Open-source AI browser agent for Chrome and Firefox (monorepo) 🧠
JavaScript ai-agentai-agentsai-toolsbrowser-aibrowser-automationbrowser-extensionchrome-aichrome-devtoolschrome-extensionchrome-extensionsfirefox-addonfirefox-addonsfirefox-extensionfirefox-extensionsgemmagemma4minimaxoffline-aioffline-llmqwen
Add Compass Tiny benchmark and blog post
Barack Sokullu0bc6cd2b18eb
diff --git a/scripts/serve-web-preview-v1.mjs b/scripts/serve-web-preview-v1.mjsnew file mode 100644index 000000000..5bcbcdefc--- /dev/null+++ b/scripts/serve-web-preview-v1.mjs@@ -0,0 +1,60 @@+#!/usr/bin/env node+// Small, dependency-free static preview server. It deliberately performs no+// per-request console logging so it remains healthy when launched detached.+import http from 'node:http';+import { createReadStream, statSync } from 'node:fs';+import path from 'node:path';++const args = process.argv.slice(2);+const option = (name, fallback) => {+ const index = args.indexOf(name);+ return index >= 0 && args[index + 1] ? args[index + 1] : fallback;+};+const port = Number(option('--port', '8125'));+const root = path.resolve(option('--root', path.resolve('web')));+const types = new Map([+ ['.css', 'text/css; charset=utf-8'],+ ['.html', 'text/html; charset=utf-8'],+ ['.ico', 'image/x-icon'],+ ['.js', 'text/javascript; charset=utf-8'],+ ['.json', 'application/json; charset=utf-8'],+ ['.png', 'image/png'],+ ['.svg', 'image/svg+xml'],+ ['.txt', 'text/plain; charset=utf-8'],+ ['.webp', 'image/webp'],+]);++function resolveRequest(url) {+ const pathname = decodeURIComponent(new URL(url, 'http://localhost').pathname);+ const requested = path.resolve(root, `.${pathname}`);+ if (requested !== root && !requested.startsWith(`${root}${path.sep}`)) return null;+ try {+ return statSync(requested).isDirectory() ? path.join(requested, 'index.html') : requested;+ } catch {+ return pathname.endsWith('/') ? path.join(requested, 'index.html') : requested;+ }+}++http.createServer((request, response) => {+ if (!['GET', 'HEAD'].includes(request.method || '')) {+ response.writeHead(405, { Allow: 'GET, HEAD' });+ response.end();+ return;+ }+ const file = resolveRequest(request.url || '/');+ if (!file) { response.writeHead(400); response.end(); return; }+ try {+ const info = statSync(file);+ if (!info.isFile()) throw new Error('not a file');+ response.writeHead(200, {+ 'Content-Length': info.size,+ 'Content-Type': types.get(path.extname(file).toLowerCase()) || 'application/octet-stream',+ 'Cache-Control': 'no-store',+ });+ if (request.method === 'HEAD') response.end();+ else createReadStream(file).pipe(response);+ } catch {+ response.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });+ response.end('Not found');+ }+}).listen(port, '127.0.0.1');diff --git a/test/llm/lib/content-tool-call-parser.mjs b/test/llm/lib/content-tool-call-parser.mjsnew file mode 100644index 000000000..a4dcfbbf6--- /dev/null+++ b/test/llm/lib/content-tool-call-parser.mjs@@ -0,0 +1,197 @@+// Safe fallback extraction for servers that leave structured calls in content.+// Supports JSON wrappers plus native LFM2/Python-literal calls. It never uses+// eval/Function and accepts keyword-only literal arguments only.++const LFM2_START = '<|tool_call_start|>';+const LFM2_END = '<|tool_call_end|>';++class ParseError extends Error {}++class PythonLiteralCallParser {+ constructor(text) { this.text = text; this.i = 0; }+ ws() { while (/\s/u.test(this.text[this.i] || '')) this.i += 1; }+ peek() { this.ws(); return this.text[this.i]; }+ take(ch) {+ this.ws();+ if (this.text[this.i] !== ch) throw new ParseError(`expected ${ch}`);+ this.i += 1;+ }+ identifier({ dotted = false } = {}) {+ this.ws();+ const rest = this.text.slice(this.i);+ const match = rest.match(dotted+ ? /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*/u+ : /^[A-Za-z_][A-Za-z0-9_]*/u);+ if (!match) throw new ParseError('expected identifier');+ this.i += match[0].length;+ return match[0];+ }+ string() {+ this.ws();+ const quote = this.text[this.i++];+ if (quote !== "'" && quote !== '"') throw new ParseError('expected string');+ let out = '';+ while (this.i < this.text.length) {+ const ch = this.text[this.i++];+ if (ch === quote) return out;+ if (ch !== '\\') { out += ch; continue; }+ if (this.i >= this.text.length) throw new ParseError('dangling escape');+ const esc = this.text[this.i++];+ const simple = { '\\': '\\', "'": "'", '"': '"', n: '\n', r: '\r', t: '\t', b: '\b', f: '\f' };+ if (Object.hasOwn(simple, esc)) { out += simple[esc]; continue; }+ if (esc === 'u') {+ const hex = this.text.slice(this.i, this.i + 4);+ if (!/^[0-9A-Fa-f]{4}$/u.test(hex)) throw new ParseError('bad unicode escape');+ out += String.fromCharCode(Number.parseInt(hex, 16)); this.i += 4; continue;+ }+ throw new ParseError('unsupported escape');+ }+ throw new ParseError('unterminated string');+ }+ number() {+ this.ws();+ const match = this.text.slice(this.i).match(/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u);+ if (!match) throw new ParseError('expected number');+ this.i += match[0].length;+ const value = Number(match[0]);+ if (!Number.isFinite(value)) throw new ParseError('non-finite number');+ return value;+ }+ list() {+ this.take('['); const out = [];+ if (this.peek() === ']') { this.take(']'); return out; }+ while (true) {+ out.push(this.value());+ if (this.peek() === ']') { this.take(']'); return out; }+ this.take(',');+ if (this.peek() === ']') { this.take(']'); return out; }+ }+ }+ object() {+ this.take('{'); const out = Object.create(null);+ if (this.peek() === '}') { this.take('}'); return { ...out }; }+ while (true) {+ if (this.peek() !== "'" && this.peek() !== '"') throw new ParseError('dict keys must be strings');+ const key = this.string();+ if (Object.hasOwn(out, key)) throw new ParseError('duplicate dict key');+ this.take(':'); out[key] = this.value();+ if (this.peek() === '}') { this.take('}'); return { ...out }; }+ this.take(',');+ if (this.peek() === '}') { this.take('}'); return out; }+ }+ }+ value() {+ const ch = this.peek();+ if (ch === "'" || ch === '"') return this.string();+ if (ch === '[') return this.list();+ if (ch === '{') return this.object();+ if (ch === '-' || /\d/u.test(ch || '')) return this.number();+ const name = this.identifier();+ if (name === 'True') return true;+ if (name === 'False') return false;+ if (name === 'None') return null;+ throw new ParseError('non-literal value');+ }+ call() {+ const name = this.identifier({ dotted: true });+ this.take('('); const args = Object.create(null);+ if (this.peek() === ')') { this.take(')'); return { name, args: { ...args } }; }+ while (true) {+ const key = this.identifier();+ if (Object.hasOwn(args, key)) throw new ParseError('duplicate keyword');+ this.take('='); args[key] = this.value();+ if (this.peek() === ')') { this.take(')'); return { name, args: { ...args } }; }+ this.take(',');+ if (this.peek() === ')') { this.take(')'); return { name, args: { ...args } }; }+ }+ }+ callList() {+ this.take('['); const calls = [];+ if (this.peek() === ']') throw new ParseError('empty call list');+ while (true) {+ calls.push(this.call());+ if (this.peek() === ']') { this.take(']'); break; }+ this.take(',');+ }+ this.ws();+ if (this.i !== this.text.length) throw new ParseError('trailing syntax');+ return calls;+ }+ singleCall() {+ const call = this.call(); this.ws();+ if (this.i !== this.text.length) throw new ParseError('trailing syntax');+ return call;+ }+}++function allowedNames(tools) {+ if (!Array.isArray(tools)) return null;+ return new Set(tools.map((tool) => tool?.function?.name).filter((name) => typeof name === 'string'));+}++function validateCall(call, allowed) {+ if (!call || typeof call.name !== 'string' || !call.name) return null;+ if (allowed && !allowed.has(call.name)) return null;+ if (!call.args || typeof call.args !== 'object' || Array.isArray(call.args)) return null;+ return call;+}++function safeJsonArguments(value) {+ if (value && typeof value === 'object' && !Array.isArray(value)) return value;+ if (typeof value !== 'string') return {};+ try {+ const parsed = JSON.parse(value);+ return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};+ } catch { return {}; }+}++function normalizeJsonCall(value) {+ if (!value || typeof value !== 'object') return null;+ if (Array.isArray(value)) return value[0] ? normalizeJsonCall(value[0]) : null;+ if (Array.isArray(value.tool_calls)) return value.tool_calls[0] ? normalizeJsonCall(value.tool_calls[0]) : null;+ if (value.function && typeof value.function.name === 'string') {+ return { name: value.function.name, args: safeJsonArguments(value.function.arguments ?? value.function.args ?? {}) };+ }+ const name = typeof value.name === 'string' ? value.name+ : typeof value.tool_name === 'string' ? value.tool_name : null;+ if (!name) return null;+ return { name, args: safeJsonArguments(value.arguments ?? value.args ?? value.parameters ?? {}) };+}++export function extractToolCallFromContent(text, { tools = null } = {}) {+ if (!text || typeof text !== 'string') return null;+ const allowed = allowedNames(tools);+ const candidates = [];+ for (const match of text.matchAll(/<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/gu)) candidates.push({ kind: 'json', raw: match[1] });+ for (const match of text.matchAll(/<\|START_ACTION\|>\s*([\s\S]*?)\s*<\|END_ACTION\|>/gu)) candidates.push({ kind: 'json', raw: match[1] });+ for (const match of text.matchAll(/```(?:json)?\s*([\s\S]*?)\s*```/gu)) candidates.push({ kind: 'json', raw: match[1] });++ const lfmStart = text.indexOf(LFM2_START);+ if (lfmStart >= 0) {+ const lfmEnd = text.indexOf(LFM2_END, lfmStart + LFM2_START.length);+ if (lfmEnd < 0) return null;+ candidates.unshift({ kind: 'python-list', raw: text.slice(lfmStart + LFM2_START.length, lfmEnd).trim() });+ }++ const trimmed = text.trim();+ if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {+ candidates.push({ kind: 'json', raw: trimmed });+ }+ const trailingJson = trimmed.match(/(\[\s*\{[\s\S]*\}\s*\]|\{[\s\S]*\})\s*$/u);+ if (trailingJson) candidates.push({ kind: 'json', raw: trailingJson[1] });+ if (/^[A-Za-z_][\w.]*(?:\s*)\(/u.test(trimmed)) candidates.push({ kind: 'python-call', raw: trimmed.replace(/;\s*$/u, '') });++ for (const candidate of candidates) {+ try {+ let call = null;+ if (candidate.kind === 'python-list') call = new PythonLiteralCallParser(candidate.raw).callList()[0] || null;+ else if (candidate.kind === 'python-call') call = new PythonLiteralCallParser(candidate.raw).singleCall();+ else call = normalizeJsonCall(JSON.parse(candidate.raw));+ const valid = validateCall(call, allowed);+ if (valid) return valid;+ } catch { /* fail closed and try the next non-executable representation */ }+ }+ return null;+}++export const _test = { PythonLiteralCallParser };diff --git a/test/llm/lib/content-tool-call-parser.test.mjs b/test/llm/lib/content-tool-call-parser.test.mjsnew file mode 100644index 000000000..f8c824264--- /dev/null+++ b/test/llm/lib/content-tool-call-parser.test.mjs@@ -0,0 +1,39 @@+import test from 'node:test';+import assert from 'node:assert/strict';+import { extractToolCallFromContent } from './content-tool-call-parser.mjs';++const tools = ['navigate', 'click_ax', 'clarify', 'read_page'].map((name) => ({+ type: 'function', function: { name, parameters: { type: 'object' } },+}));++test('parses native LFM2 wrapper after reasoning', () => {+ const raw = "reasoning</think><|tool_call_start|>[navigate(url='https://example.com', force=False)]<|tool_call_end|>";+ assert.deepEqual(extractToolCallFromContent(raw, { tools }), {+ name: 'navigate', args: { url: 'https://example.com', force: false },+ });+});++test('parses nested literal lists and dictionaries without evaluation', () => {+ const raw = "<|tool_call_start|>[clarify(question='More?', options=['A','B'], meta={'safe': True}, require_explicit_answer=True)]<|tool_call_end|>";+ assert.deepEqual(extractToolCallFromContent(raw, { tools }), {+ name: 'clarify',+ args: { question: 'More?', options: ['A', 'B'], meta: { safe: true }, require_explicit_answer: true },+ });+});++test('keeps legacy JSON fallback support', () => {+ assert.deepEqual(extractToolCallFromContent('<tool_call>{"name":"click_ax","arguments":{"ref_id":"r1"}}</tool_call>', { tools }), {+ name: 'click_ax', args: { ref_id: 'r1' },+ });+});++for (const [name, raw] of [+ ['unknown tool', "<|tool_call_start|>[unknown(value='x')]<|tool_call_end|>"],+ ['nested call', "<|tool_call_start|>[navigate(url=open('secret'))]<|tool_call_end|>"],+ ['positional argument', "<|tool_call_start|>[navigate('https://example.com')]<|tool_call_end|>"],+ ['malformed nested helper', "<|tool_call_start|>[read_page(continuationArgs=set_continuationArgs({'offset': 0}))]<|tool_call_end|>"],+ ['unclosed wrapper', "<|tool_call_start|>[navigate(url='https://example.com')]"],+ ['duplicate keyword', "<|tool_call_start|>[navigate(url='a', url='b')]<|tool_call_end|>"],+]) {+ test(`fails closed: ${name}`, () => assert.equal(extractToolCallFromContent(raw, { tools }), null));+}diff --git a/test/llm/regrade-compact-parser-v2.mjs b/test/llm/regrade-compact-parser-v2.mjsnew file mode 100644index 000000000..40a592d1e--- /dev/null+++ b/test/llm/regrade-compact-parser-v2.mjs@@ -0,0 +1,175 @@+#!/usr/bin/env node+// Inference-free, non-destructive regrade of stored Compact outputs after the+// LFM2 content-parser fix. Writes only a new content-addressed analysis tree.++import { createHash } from 'node:crypto';+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';+import { basename, dirname, join, resolve } from 'node:path';+import { fileURLToPath } from 'node:url';+import { buildPayload } from './lib/build-payload.mjs';+import { buildScenarioPayload } from './lib/scenario-payload.mjs';+import { extractToolCallFromContent } from './lib/content-tool-call-parser.mjs';+import { scoreVerdict } from './lib/score.mjs';++const HERE = dirname(fileURLToPath(import.meta.url));+const SCRIPT = fileURLToPath(import.meta.url);++function sha256(data) { return createHash('sha256').update(data).digest('hex'); }+function fileSha(path) { return sha256(readFileSync(path)); }+function stable(value) {+ if (Array.isArray(value)) return `[${value.map(stable).join(',')}]`;+ if (value && typeof value === 'object') return `{${Object.keys(value).sort().map((k) => `${JSON.stringify(k)}:${stable(value[k])}`).join(',')}}`;+ return JSON.stringify(value);+}++function parseArgs(argv) {+ const pairs = [];+ for (let i = 0; i < argv.length; i += 1) {+ if (argv[i] !== '--pair') throw new Error(`unknown argument: ${argv[i]}`);+ const value = argv[++i];+ const [label, first, scenarios] = value.split('::');+ if (!label || !first || !scenarios) throw new Error(`bad --pair: ${value}`);+ pairs.push({ label, first: resolve(first), scenarios: resolve(scenarios) });+ }+ if (!pairs.length) throw new Error('at least one --pair is required');+ return pairs;+}++function jsonFiles(dir) {+ return readdirSync(dir).filter((name) => /^\d{3}\.json$/u.test(name)).sort();+}++function availableTools(kind, id, row, summary) {+ try {+ if (kind === 'first-turn') {+ const question = JSON.parse(readFileSync(join(HERE, 'questions', `${id}.json`), 'utf8'));+ return buildPayload({ ...question, mode: row.mode }, {+ browser: summary.browser || 'chrome', tier: summary.tier || 'compact',+ }).tools;+ }+ const scenario = JSON.parse(readFileSync(join(HERE, 'scenarios', `${id}.json`), 'utf8'));+ return buildScenarioPayload({+ ...scenario, browser: row.browser || summary.browser || 'chrome', mode: row.mode,+ }, { tier: summary.tier || 'compact', unprotected: !!summary.unprotected }).tools;+ } catch {+ return null;+ }+}++function expectedFor(kind, id, row) {+ if (kind === 'scenarios') return row.expected;+ const source = JSON.parse(readFileSync(join(HERE, 'expected', `${id}.json`), 'utf8'));+ return { idealNextToolCall: source.idealFirstToolCall, antiPatterns: [] };+}++function emptyCounts() {+ return { exact: 0, name_only: 0, other: 0, no_tool: 0, anti: 0, empty: 0, error: 0, skipped: 0 };+}++function bucket(verdict) {+ return ({ ideal: 'exact', ideal_name: 'name_only' })[verdict] || verdict;+}++function gradeDir(kind, dir) {+ if (!existsSync(dir)) throw new Error(`missing run dir: ${dir}`);+ const summaryPath = join(dir, 'summary.json');+ const summary = JSON.parse(readFileSync(summaryPath, 'utf8'));+ const counts = emptyCounts();+ const rows = [];+ let structured = 0; let fallback = 0;+ for (const name of jsonFiles(dir)) {+ const path = join(dir, name);+ const row = JSON.parse(readFileSync(path, 'utf8'));+ const id = name.slice(0, 3);+ const tools = availableTools(kind, id, row, summary);+ let call = row.firstToolCall || null;+ let source = row.toolCallSource || (call ? 'stored_structured' : null);+ if (!call && row.content) {+ call = extractToolCallFromContent(row.content, { tools });+ if (call) source = 'content_fallback_lfm2_v2';+ }+ if (source === 'content_fallback_lfm2_v2') fallback += 1;+ else if (call) structured += 1;+ const expected = expectedFor(kind, id, row);+ const scored = scoreVerdict({+ skipped: row.skipped,+ error: row.error,+ firstToolCall: call,+ content: row.content,+ expected,+ });+ counts[bucket(scored.verdict)] += 1;+ rows.push({+ id,+ inputSha256: fileSha(path),+ source,+ firstToolCall: call,+ verdict: bucket(scored.verdict),+ originalVerdict: row.verdict || null,+ matchedAntiPattern: scored.matchedAntiPattern || null,+ contentSha256: row.content ? sha256(row.content) : null,+ });+ }+ return {+ kind, sourceDir: dir, sourceSummarySha256: fileSha(summaryPath),+ rows: rows.length, structured, fallback, toolCalls: structured + fallback,+ toolCallRate: rows.length ? (structured + fallback) / rows.length : 0,+ counts, decisions: rows,+ };+}++const pairs = parseArgs(process.argv.slice(2));+const implementation = {+ regrader: { path: SCRIPT, sha256: fileSha(SCRIPT) },+ contentParser: { path: join(HERE, 'lib', 'content-tool-call-parser.mjs'), sha256: fileSha(join(HERE, 'lib', 'content-tool-call-parser.mjs')) },+ grader: { path: join(HERE, 'lib', 'score.mjs'), sha256: fileSha(join(HERE, 'lib', 'score.mjs')) },+};+const graded = pairs.map((pair) => {+ const firstTurn = gradeDir('first-turn', pair.first);+ const scenarios = gradeDir('scenarios', pair.scenarios);+ const combined = emptyCounts();+ for (const key of Object.keys(combined)) combined[key] = firstTurn.counts[key] + scenarios.counts[key];+ return {+ label: pair.label,+ firstTurn,+ scenarios,+ combined: {+ rows: firstTurn.rows + scenarios.rows,+ toolCalls: firstTurn.toolCalls + scenarios.toolCalls,+ toolCallRate: (firstTurn.toolCalls + scenarios.toolCalls) / (firstTurn.rows + scenarios.rows),+ counts: combined,+ },+ };+});++const signature = sha256(stable({+ implementation,+ inputs: graded.map(({ label, firstTurn, scenarios }) => ({+ label,+ firstTurn: { sourceDir: firstTurn.sourceDir, sourceSummarySha256: firstTurn.sourceSummarySha256, decisions: firstTurn.decisions.map((r) => r.inputSha256) },+ scenarios: { sourceDir: scenarios.sourceDir, sourceSummarySha256: scenarios.sourceSummarySha256, decisions: scenarios.decisions.map((r) => r.inputSha256) },+ })),+}));+const outputDir = join(HERE, 'analysis', `compact-parser-regrade-v2-${signature.slice(0, 16)}`);+mkdirSync(outputDir, { recursive: false });++for (const model of graded) {+ writeFileSync(join(outputDir, `${model.label}.rows.json`), `${JSON.stringify(model, null, 2)}\n`, { flag: 'wx' });+}+const summaryBody = {+ schema: 'webbrain-compact-parser-regrade-v2',+ createdAt: new Date().toISOString(),+ inferenceRequests: 0,+ inputSignatureSha256: signature,+ implementation,+ models: graded.map(({ label, firstTurn, scenarios, combined }) => ({+ label,+ firstTurn: { rows: firstTurn.rows, toolCalls: firstTurn.toolCalls, toolCallRate: firstTurn.toolCallRate, counts: firstTurn.counts },+ scenarios: { rows: scenarios.rows, toolCalls: scenarios.toolCalls, toolCallRate: scenarios.toolCallRate, counts: scenarios.counts },+ combined,+ })),+};+const reportSha = sha256(stable(summaryBody));+const report = join(outputDir, `summary-${reportSha}.json`);+writeFileSync(report, `${JSON.stringify({ ...summaryBody, reportSha256: reportSha }, null, 2)}\n`, { flag: 'wx' });+console.log(JSON.stringify({ status: 'regraded', outputDir, report, reportSha256: reportSha, models: summaryBody.models }, null, 2));diff --git a/test/llm/regrades/compass-lfm2-native-regrade-v1-468f8f18cb3a8db985d2dc00910f839e6cf1836daa2fd0397269acf1f2533f71.json b/test/llm/regrades/compass-lfm2-native-regrade-v1-468f8f18cb3a8db985d2dc00910f839e6cf1836daa2fd0397269acf1f2533f71.jsonnew file mode 100644index 000000000..dcc320da0--- /dev/null+++ b/test/llm/regrades/compass-lfm2-native-regrade-v1-468f8f18cb3a8db985d2dc00910f839e6cf1836daa2fd0397269acf1f2533f71.json@@ -0,0 +1,56 @@+{+ "schema": "webbrain-compass-lfm2-native-regrade-v1",+ "createdAt": "2026-09-05T16:24:24.483716Z",+ "regraderSha256": "00364a695dae638b9630b406515c033b9d5bd772797a8bd3d7c82d0120d40f4c",+ "inputs": {+ "firstTurnDirectory": "/mnt/g/esoku/Documents/webbrain2/test/llm/results/compact-benchmark-v1-webbrain-compass-tiny-v1-20260905T184439-first-turn-100_chrome_webbrain-compass-tiny-v1_compact",+ "firstTurnSummarySha256": "18f3c798f5a6693cb368dd99178da7a0ad809f02875a344aea8473d02564131b",+ "scenarioDirectory": "/mnt/g/esoku/Documents/webbrain2/test/llm/results-scenarios/compact-benchmark-v1-webbrain-compass-tiny-v1-20260905T184439-scenarios-compact_chrome_webbrain-compass-tiny-v1_compact",+ "scenarioSummarySha256": "6747c4d4bb3e839b4ee599763dd562043ace9441155911ead88e2220d9b2cc4e"+ },+ "parser": {+ "format": "LFM2 native pythonic wrappers",+ "startToken": "<|tool_call_start|>",+ "endToken": "<|tool_call_end|>",+ "execution": "AST parse and literal evaluation only; no eval"+ },+ "coverage": {+ "firstTurnRows": 100,+ "scenarioRows": 100,+ "parseCounts": {+ "first_turn_native_parsed": 81,+ "first_turn_unparsed": 19,+ "scenarios_native_parsed": 72,+ "scenarios_skipped": 11,+ "scenarios_unparsed": 17+ },+ "malformedNativeCallIds": [+ "first-turn:029",+ "first-turn:037",+ "first-turn:060",+ "first-turn:074",+ "first-turn:075",+ "first-turn:098",+ "first-turn:099",+ "scenario:006",+ "scenario:017",+ "scenario:049",+ "scenario:096"+ ]+ },+ "firstTurnVerdicts": {+ "ideal": 5,+ "ideal_name": 17,+ "no_tool": 19,+ "other": 59+ },+ "scenarioVerdicts": {+ "anti": 1,+ "ideal": 5,+ "ideal_name": 42,+ "no_tool": 3,+ "other": 38,+ "skipped": 11+ },+ "contentSha256": "468f8f18cb3a8db985d2dc00910f839e6cf1836daa2fd0397269acf1f2533f71"+}diff --git a/test/llm/regrades/compass-lfm2-native-regrade-v1-d3cbb4cc2ab03acac94e462725c04c71474063a09a106a83874144fd64921f13.json b/test/llm/regrades/compass-lfm2-native-regrade-v1-d3cbb4cc2ab03acac94e462725c04c71474063a09a106a83874144fd64921f13.jsonnew file mode 100644index 000000000..75d58282f--- /dev/null+++ b/test/llm/regrades/compass-lfm2-native-regrade-v1-d3cbb4cc2ab03acac94e462725c04c71474063a09a106a83874144fd64921f13.json@@ -0,0 +1,56 @@+{+ "schema": "webbrain-compass-lfm2-native-regrade-v1",+ "createdAt": "2026-09-05T16:25:57.810228Z",+ "regraderSha256": "229e846b871e07afdb4ea8f37bd31c30fa60d4817d8a1cb10e1170379baa4850",+ "inputs": {+ "firstTurnDirectory": "/mnt/g/esoku/Documents/webbrain2/test/llm/results/compact-benchmark-v1-webbrain-compass-tiny-v1-20260905T184439-first-turn-100_chrome_webbrain-compass-tiny-v1_compact",+ "firstTurnSummarySha256": "18f3c798f5a6693cb368dd99178da7a0ad809f02875a344aea8473d02564131b",+ "scenarioDirectory": "/mnt/g/esoku/Documents/webbrain2/test/llm/results-scenarios/compact-benchmark-v1-webbrain-compass-tiny-v1-20260905T184439-scenarios-compact_chrome_webbrain-compass-tiny-v1_compact",+ "scenarioSummarySha256": "6747c4d4bb3e839b4ee599763dd562043ace9441155911ead88e2220d9b2cc4e"+ },+ "parser": {+ "format": "LFM2 native pythonic wrappers",+ "startToken": "<|tool_call_start|>",+ "endToken": "<|tool_call_end|>",+ "execution": "AST parse and literal evaluation only; no eval"+ },+ "coverage": {+ "firstTurnRows": 100,+ "scenarioRows": 100,+ "parseCounts": {+ "first_turn_native_parsed": 81,+ "first_turn_unparsed": 19,+ "scenarios_native_parsed": 72,+ "scenarios_skipped": 11,+ "scenarios_unparsed": 17+ },+ "malformedNativeCallIds": [+ "first-turn:029",+ "first-turn:037",+ "first-turn:060",+ "first-turn:074",+ "first-turn:075",+ "first-turn:098",+ "first-turn:099",+ "scenario:006",+ "scenario:017",+ "scenario:049",+ "scenario:096"+ ]+ },+ "firstTurnVerdicts": {+ "ideal": 5,+ "ideal_name": 17,+ "no_tool": 19,+ "other": 59+ },+ "scenarioVerdicts": {+ "anti": 1,+ "ideal": 5,+ "ideal_name": 42,+ "no_tool": 3,+ "other": 38,+ "skipped": 11+ },+ "contentSha256": "d3cbb4cc2ab03acac94e462725c04c71474063a09a106a83874144fd64921f13"+}diff --git a/test/llm/run-llamacpp.mjs b/test/llm/run-llamacpp.mjsindex a023d3ccf..61ac169e3 100644--- a/test/llm/run-llamacpp.mjs+++ b/test/llm/run-llamacpp.mjs@@ -64,6 +64,7 @@ import {prepareMessagesForChatTemplate,prepareToolsForChatTemplate,} from './lib/chat-template-compat.mjs';+import { extractToolCallFromContent as extractLfm2AwareToolCallFromContent } from './lib/content-tool-call-parser.mjs';const HERE = dirname(fileURLToPath(import.meta.url));const Q_DIR = join(HERE, 'questions');@@ -392,7 +393,7 @@ async function runOne(id) {firstToolCall = { name: tc.function.name, args: parsedArgs };toolCallSource = 'tool_calls';} else if (msg?.content) {- const fallback = extractToolCallFromContent(msg.content);+ const fallback = extractLfm2AwareToolCallFromContent(msg.content, { tools });if (fallback) {firstToolCall = fallback;toolCallSource = 'content_fallback';diff --git a/test/llm/run-scenarios.mjs b/test/llm/run-scenarios.mjsindex ea7a1499e..17adcebdb 100644--- a/test/llm/run-scenarios.mjs+++ b/test/llm/run-scenarios.mjs@@ -55,6 +55,7 @@ import {normalizeTier,} from './lib/build-payload.mjs';import { scoreVerdict } from './lib/score.mjs';+import { extractToolCallFromContent as extractLfm2AwareToolCallFromContent } from './lib/content-tool-call-parser.mjs';import {chatTemplateCompatLabel,getChatTemplateCompat,@@ -333,7 +334,7 @@ async function runOne(scenario) {firstToolCall = { name: tc.function.name, args: pa };toolCallSource = 'tool_calls';} else if (msg?.content) {- const fb = extractToolCallFromContent(msg.content);+ const fb = extractLfm2AwareToolCallFromContent(msg.content, { tools });if (fb) { firstToolCall = fb; toolCallSource = 'content_fallback'; }}diff --git a/web/blog/index.html b/web/blog/index.htmlindex 14aaf4ed8..6d47abd05 100644--- a/web/blog/index.html+++ b/web/blog/index.html@@ -669,6 +669,18 @@"url": "https://webbrain.one/blog","image": "https://webbrain.one/og-image.png","blogPost": [+ {+ "@type": "BlogPosting",+ "headline": "Introducing WebBrain Compass Tiny: edge-sized Compact tool routing for WebBrain",+ "url": "https://webbrain.one/blog/webbrain-compass-tiny-v1",+ "datePublished": "2026-09-05",+ "description": "WebBrain Compass Tiny v1 is a private 2.6B WebBrain Compact-model preview. In our first routing suite it ties Qwen3.6-35B-A3B on tool-name conformity, improves the same local LFM2.5 base model by eight routing outcomes, and keeps the model small enough for edge-oriented deployment.",+ "author": {+ "@type": "Person",+ "name": "Emre Sokullu",+ "url": "https://emresokullu.com"+ }+ },{"@type": "BlogPosting","headline": "DeepSeek V4 Flash Vision Exp tested: a great planner with experimental eyes",@@ -1300,14 +1312,19 @@<kbd class="search-key" aria-hidden="true">/</kbd></div><div class="archive-status" role="status" aria-live="polite" aria-atomic="true">- <span id="results-count">49 notes</span>+ <span id="results-count">50 notes</span><span class="archive-status-rule" aria-hidden="true"></span><span id="page-status"></span></div></section><div class="post-list" id="post-list">- <a href="/blog/deepseek-v4-flash-vision-openrouter" class="post-card" data-search="DeepSeek V4 Flash Vision Exp tested: a great planner with experimental eyes DeepSeek V4 Flash Vision Exp tested: a great planner with experimental eyes DeepSeek V4 Flash Vision Exp delivers the best first-action routing of our three new Flash models and a 2.60-second planner median. Its vision side is fast, but only 68 of 100 screenshots pass the strict rubric. We tested DeepSeek V4 Flash Vision Exp on 200 WebBrain browser-agent cases. Its text planning beats Qwen3.8 Flash and GLM-5.3 Flash, but its experimental vision route trails both. August 27, 2026 2026-08-27 DeepSeek V4 Flash Vision Exp DeepSeek V4 Flash 0731 OpenRouter multimodal model benchmark browser agent mixture of experts vision language model tool calling AI API pricing WebBrain">+ <a href="/blog/webbrain-compass-tiny-v1" class="post-card" data-search="Introducing WebBrain Compass Tiny: edge-sized Compact tool routing for WebBrain Introducing WebBrain Compass Tiny: edge-sized Compact tool routing for WebBrain A 2.6B model is not a 35B general-reasoning replacement. But in the narrow, production-shaped WebBrain Compact routing loop, Compass Tiny v1 reaches the same tool-name conformity as Qwen3.6-35B-A3B and improves its matched local base model by eight routing outcomes. WebBrain Compass Tiny v1 is a private 2.6B WebBrain Compact-model preview. In our first routing suite it ties Qwen3.6-35B-A3B on tool-name conformity, improves the same local LFM2.5 base model by eight routing outcomes, and keeps the model small enough for edge-oriented deployment. September 5, 2026 2026-09-05 WebBrain Compass Tiny browser agent tool calling compact mode edge AI LFM2.5 Qwen">+ <div class="post-meta">September 5, 2026 · 6 min read</div>+ <div class="post-title">Introducing WebBrain Compass Tiny: edge-sized Compact tool routing for WebBrain</div>+ <div class="post-excerpt">A 2.6B model is not a 35B general-reasoning replacement. But in the narrow, production-shaped WebBrain Compact routing loop, Compass Tiny v1 reaches the same tool-name conformity as Qwen3.6-35B-A3B and improves its matched local base model by eight routing outcomes.</div>+ </a>+<a href="/blog/deepseek-v4-flash-vision-openrouter" class="post-card" data-search="DeepSeek V4 Flash Vision Exp tested: a great planner with experimental eyes DeepSeek V4 Flash Vision Exp tested: a great planner with experimental eyes DeepSeek V4 Flash Vision Exp delivers the best first-action routing of our three new Flash models and a 2.60-second planner median. Its vision side is fast, but only 68 of 100 screenshots pass the strict rubric. We tested DeepSeek V4 Flash Vision Exp on 200 WebBrain browser-agent cases. Its text planning beats Qwen3.8 Flash and GLM-5.3 Flash, but its experimental vision route trails both. August 27, 2026 2026-08-27 DeepSeek V4 Flash Vision Exp DeepSeek V4 Flash 0731 OpenRouter multimodal model benchmark browser agent mixture of experts vision language model tool calling AI API pricing WebBrain"><div class="post-meta">August 27, 2026 · 9 min read</div><div class="post-title">DeepSeek V4 Flash Vision Exp tested: a great planner with experimental eyes</div><div class="post-excerpt">DeepSeek V4 Flash Vision Exp delivers the best first-action routing of our three new Flash models and a 2.60-second planner median. Its vision side is fast, but only 68 of 100 screenshots pass the strict rubric.</div>diff --git a/web/blog/posts/webbrain-compass-tiny-v1.md b/web/blog/posts/webbrain-compass-tiny-v1.mdnew file mode 100644index 000000000..9313147c3--- /dev/null+++ b/web/blog/posts/webbrain-compass-tiny-v1.md@@ -0,0 +1,101 @@+---+title: >+ Introducing WebBrain Compass Tiny: edge-sized Compact tool routing for WebBrain+slug: webbrain-compass-tiny-v1+sortOrder: -281+date: 2026-09-05+readTime: 6 min read+description: >+ WebBrain Compass Tiny v1 is a private 2.6B WebBrain Compact-model preview. In our first routing suite it ties Qwen3.6-35B-A3B on tool-name conformity, improves the same local LFM2.5 base model by eight routing outcomes, and keeps the model small enough for edge-oriented deployment.+excerpt: >+ A 2.6B model is not a 35B general-reasoning replacement. But in the narrow, production-shaped WebBrain Compact routing loop, Compass Tiny v1 reaches the same tool-name conformity as Qwen3.6-35B-A3B and improves its matched local base model by eight routing outcomes.+titleTag: >+ Introducing WebBrain Compass Tiny v1 - WebBrain Blog+ogTitle: >+ WebBrain Compass Tiny v1: Compact browser-tool routing at the edge+ogDescription: >+ A first look at WebBrain's 2.6B Compact model preview, its tool-routing benchmark, and the road toward open weights.+twitterTitle: >+ WebBrain Compass Tiny v1: an edge-sized Compact model+twitterDescription: >+ Compass Tiny v1 ties a 35B Qwen model on WebBrain Compact tool-name routing. More tests and v1.1/v2 work are coming.+keywords:+ - WebBrain Compass Tiny+ - browser agent+ - tool calling+ - compact mode+ - edge AI+ - LFM2.5+ - Qwen+author: Emre Sokullu+authorUrl: https://emresokullu.com+lede: >+ **WebBrain Compass Tiny v1 is our first edge-sized model built specifically for the Compact browser-tool loop.** It is not a claim that 2.6B parameters equal a 35B model at general reasoning. It is evidence that a focused, grounded routing policy can make a small model useful inside a real browser agent: in this first suite, Compass ties Qwen3.6-35B-A3B on the expected tool name and improves the matched local LFM2.5-2.6B base model by eight routing outcomes. Qwen3.8-27B remains the quality leader when its cost and footprint fit the deployment.+---++## The short version++Compass Tiny v1 is a **private preview** today. We are preparing an open-weights release so it can be downloaded and run locally, subject to the remaining release, provenance, and packaging checks. Until that work is complete, it is not a public download and this article should not be read as a release announcement.++The model is tuned for three Compact behaviors in WebBrain:++1. Answer or ask a clarifying question when that is the justified next step.+2. Emit a grounded Compact tool call when the page context supports it.+3. Abstain or escalate when direct execution would be unjustified.++That is deliberately narrower than “be a universally smarter model.” It is the right narrowness for a browser agent that must choose a next action from a constrained toolset.++## What we measured++We ran the current Compact Chrome suite: 100 first-action cases and 100 stateful scenarios. Eleven scenarios are intentionally out of scope for Compact and are excluded from the scenario-quality denominator, leaving 89 scored scenarios.++The table uses two different signals:++- **Exact reference action** means the tool and arguments matched the canonical next action.+- **Expected tool name** credits the expected tool even when arguments differ. It is useful for measuring routing, but it is not a completed browser task.++The exact reference is a Sonnet-authored canonical next action. It is a regression-oriented reference, not an oracle for every reasonable live-browser strategy: a careful model may inspect before a direct click, for example. That distinction matters here.++| Model | Parameters | First-turn structured calls | Exact reference action (of 89) | Expected tool name (of 89) |+| --- | ---: | ---: | ---: | ---: |+| Qwen3.8-27B | 27B | **99 / 100** | **17** | 39 |+| Qwen3.6-35B-A3B | 35B A3B | 89 / 100 | 15 | **42** |+| **WebBrain Compass Tiny v1** | **2.6B** | **81 / 100** | 4 | **42** |+| LFM2.5-2.6B base (local) | 2.6B | 80 / 100 | 4 | 34 |+| Qwen3.5-9B | 9B | 84 / 100 | 2 | 12 |++Compass therefore does not beat the 35B model on the strict reference. It **matches it on tool-name routing** in this Compact suite. It also exceeds the 9B Qwen result by 30 expected-tool-name outcomes and the matched local LFM base model by eight. Those are promising results for a model intended to live near the edge of the product, where size, VRAM, latency, and controllability matter as much as raw general capability.++## The controlled base-model comparison++The base-model row is the comparison we care about most. We served the pinned `LiquidAI/LFM2.5-2.6B` base revision locally through the same vLLM version, LFM2 parser, tokenizer, BF16 precision, 32K context window, Compact prompt, tools, and benchmark harness used for Compass.++The base model produced 80 first-turn structured calls, four exact-reference scenario actions, and 34 expected-tool-name outcomes. Compass produced 81, four, and **42** respectively. In this deliberately narrow measurement, the fine-tune does not change the exact-reference count, but it adds **eight** expected Compact routing outcomes.++That is a useful, bounded result: Compass is not claiming a broad general-intelligence jump over its base. It is demonstrating that WebBrain-specific training can move the next-action routing policy in the desired direction without making the model larger.++## Why Qwen3.8 is still the default quality choice++Qwen3.8-27B remains the best model in this comparison if the budget and deployment footprint are acceptable. It has the highest exact-reference score, almost universal first-turn tool-call emission, and fast scenario completion in this run.++Compass is not positioned as a replacement for that class. The point is different: **a 2.6B specialist can already be useful for a well-scoped WebBrain Compact decision**, rather than forcing every low-risk browser step through a much larger planner.++Qwen3.6-35B-A3B remains an important reference point too. Its tie with Compass on expected tool name should not be over-read as equal general intelligence. It is evidence of task specialization, not a claim about broad reasoning, coding, knowledge, multilingual breadth, or long-horizon browser reliability.++## A note on the public free route++We also exercised the public `liquid/lfm-2.5-2.6b:free` route on OpenRouter as an availability probe. Its scenario service was not stable enough to rank: it returned intermittent provider errors even when requests were serialized. It is therefore excluded from the table above. The local, pinned base comparison is the relevant fine-tune baseline.++## What happens next++This is the beginning of the evaluation, not the end of it. We are adding more browser surfaces, longer trajectories, tool-result recovery, calibrated escalation behavior, and broader multilingual cases. We also want to measure locally hosted base LFM under the same serving stack before publishing a fine-tune-versus-base headline.++The working roadmap includes Compass **v1.1** and eventually **v2**, with more data, more targeted evaluations, and clearer release artifacts. We hope that work turns this private preview into a useful open-weights option for teams that want WebBrain-native Compact behavior without making a large cloud model the only route for every action.++## Reproducibility notes++The comparison used the same Compact Chrome harness and structured tool schemas for every listed model. The runner captures the next response; it does not execute the browser action, so these figures are routing metrics rather than end-to-end success rates. Provider routes, sampling behavior, and model revisions can change, so these results should be read as a dated benchmark snapshot rather than a permanent leaderboard.++More evaluation results will follow as the suite grows.++Tags: #WebBrain #CompassTiny #BrowserAgent #ToolCalling #EdgeAI #CompactMode #LFM25 #OpenWeightsdiff --git a/web/blog/webbrain-compass-tiny-v1/index.html b/web/blog/webbrain-compass-tiny-v1/index.htmlnew file mode 100644index 000000000..48d8141c5--- /dev/null+++ b/web/blog/webbrain-compass-tiny-v1/index.html@@ -0,0 +1,611 @@+<!DOCTYPE html>+<html lang="en">+<head>+ <meta charset="UTF-8">+ <meta name="viewport" content="width=device-width, initial-scale=1.0">+ <title>Introducing WebBrain Compass Tiny v1 - WebBrain Blog</title>+ <meta name="description" content="WebBrain Compass Tiny v1 is a private 2.6B WebBrain Compact-model preview. In our first routing suite it ties Qwen3.6-35B-A3B on tool-name conformity, improves the same local LFM2.5 base model by eight routing outcomes, and keeps the model small enough for edge-oriented deployment.">+ <meta name="keywords" content="WebBrain Compass Tiny, browser agent, tool calling, compact mode, edge AI, LFM2.5, Qwen">+ <meta property="og:title" content="WebBrain Compass Tiny v1: Compact browser-tool routing at the edge">+ <meta property="og:description" content="A first look at WebBrain's 2.6B Compact model preview, its tool-routing benchmark, and the road toward open weights.">+ <meta property="og:type" content="article">+ <meta property="og:url" content="https://webbrain.one/blog/webbrain-compass-tiny-v1">+ <meta property="og:image" content="https://webbrain.one/og-image.png">+ <meta property="og:image:secure_url" content="https://webbrain.one/og-image.png">+ <meta property="og:image:type" content="image/png">+ <meta property="og:image:width" content="1200">+ <meta property="og:image:height" content="630">+ <meta property="og:image:alt" content="WebBrain — Open-source AI browser agent">+ <meta name="twitter:card" content="summary_large_image">+ <meta name="twitter:title" content="WebBrain Compass Tiny v1: an edge-sized Compact model">+ <meta name="twitter:description" content="Compass Tiny v1 ties a 35B Qwen model on WebBrain Compact tool-name routing. More tests and v1.1/v2 work are coming.">+ <meta name="twitter:image" content="https://webbrain.one/twitter-image.png">+ <meta name="twitter:image:alt" content="WebBrain — Open-source AI browser agent">+ <link rel="icon" type="image/png" href="/favicon.png">+ <link rel="canonical" href="https://webbrain.one/blog/webbrain-compass-tiny-v1">+ <!-- Blog is English-only; alternates point to locale homepages. -->+ <link rel="alternate" hreflang="en" href="https://webbrain.one/">+ <link rel="alternate" hreflang="es" href="https://webbrain.one/es/">+ <link rel="alternate" hreflang="fr" href="https://webbrain.one/fr/">+ <link rel="alternate" hreflang="tr" href="https://webbrain.one/tr/">+ <link rel="alternate" hreflang="zh" href="https://webbrain.one/zh/">+ <link rel="alternate" hreflang="ru" href="https://webbrain.one/ru/">+ <link rel="alternate" hreflang="uk" href="https://webbrain.one/uk/">+ <link rel="alternate" hreflang="ar" href="https://webbrain.one/ar/">+ <link rel="alternate" hreflang="ja" href="https://webbrain.one/ja/">+ <link rel="alternate" hreflang="ko" href="https://webbrain.one/ko/">+ <link rel="alternate" hreflang="id" href="https://webbrain.one/id/">+ <link rel="alternate" hreflang="th" href="https://webbrain.one/th/">+ <link rel="alternate" hreflang="ms" href="https://webbrain.one/ms/">+ <link rel="alternate" hreflang="tl" href="https://webbrain.one/tl/">+ <link rel="alternate" hreflang="he" href="https://webbrain.one/he/">+ <link rel="alternate" hreflang="x-default" href="https://webbrain.one/">+ <style>+ *, *::before, *::after { margin: 0; padding: 0; box-sizing: border-box; }+ :root {+ --bg: #0b0e17;+ --bg-card: #111827;+ --bg-card-hover: #1a2233;+ --surface: #161d2e;+ --border: rgba(255,255,255,0.07);+ --text: #e4e4ec;+ --text-dim: #8b8fa4;+ --accent: #6c63ff;+ --accent-glow: rgba(108,99,255,0.25);+ --accent2: #a78bfa;+ --success: #34d399;+ --warning: #fbbf24;+ --danger: #f87171;+ --tint-soft: rgba(255,255,255,0.05);+ --tint-soft-2: rgba(255,255,255,0.04);+ --tint-medium: rgba(255,255,255,0.08);+ --nav-bg: rgba(11,14,23,0.85);+ --code-bg: #0a0e17;+ --inline-code-bg: rgba(255,255,255,0.06);+ --shadow-strong: rgba(0,0,0,0.40);+ --radius: 12px;+ --radius-lg: 16px;+ --max-w: 760px;+ color-scheme: dark;+ }+ :root[data-theme="light"] {+ --bg: #f7f1e6;+ --bg-card: #fffdf8;+ --bg-card-hover: #f2e9d4;+ --surface: #ede2cb;+ --border: rgba(89,55,25,0.15);+ --text: #2c1810;+ --text-dim: #6b5b47;+ --accent: #5b52e8;+ --accent-glow: rgba(91,82,232,0.20);+ --accent2: #7c6ce6;+ --success: #2d8866;+ --warning: #9a6500;+ --danger: #b74747;+ --tint-soft: rgba(89,55,25,0.05);+ --tint-soft-2: rgba(89,55,25,0.07);+ --tint-medium: rgba(89,55,25,0.10);+ --nav-bg: rgba(247,241,230,0.85);+ --code-bg: #fff7e6;+ --inline-code-bg: rgba(89,55,25,0.08);+ --shadow-strong: rgba(89,55,25,0.18);+ color-scheme: light;+ }+ html { scroll-behavior: smooth; }+ body {+ font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Inter, Roboto, sans-serif;+ background: var(--bg);+ color: var(--text);+ line-height: 1.75;+ font-size: 17px;+ overflow-x: hidden;+ }+ a { color: var(--accent2); text-decoration: none; }+ a:hover { text-decoration: underline; }+ .glow-bg {+ position: fixed;+ inset: 0;+ z-index: -1;+ pointer-events: none;+ overflow: hidden;+ }+ .glow-bg::before,+ .glow-bg::after {+ content: '';+ position: absolute;+ border-radius: 50%;+ filter: blur(120px);+ opacity: 0.26;+ }+ .glow-bg::before {+ width: 500px;+ height: 500px;+ background: var(--accent);+ top: -220px;+ left: -160px;+ }+ .glow-bg::after {+ width: 500px;+ height: 500px;+ background: var(--accent2);+ right: -180px;+ bottom: -230px;+ opacity: 0.18;+ }+ nav {+ position: sticky;+ top: 0;+ z-index: 100;+ background: var(--nav-bg);+ backdrop-filter: saturate(160%) blur(12px);+ -webkit-backdrop-filter: saturate(160%) blur(12px);+ border-bottom: 1px solid var(--border);+ }+ .nav-inner {+ max-width: var(--max-w);+ margin: 0 auto;+ padding: 14px 24px;+ display: flex;+ align-items: center;+ justify-content: space-between;+ gap: 20px;+ }+ .nav-brand {+ display: inline-flex;+ align-items: center;+ gap: 6px;+ flex-shrink: 0;+ color: var(--text);+ font-size: 18px;+ font-weight: 700;+ text-decoration: none;+ }+ .nav-brand:hover { text-decoration: none; }+ .nav-brand .brand-logo { width: 26px; height: 26px; border-radius: 7px; flex: 0 0 auto; }+ .nav-brand .domain { opacity: 0.5; font-weight: 400; }+ .nav-links {+ display: flex;+ align-items: center;+ justify-content: flex-end;+ gap: 16px;+ min-width: 0;+ }+ .nav-links a {+ position: relative;+ color: var(--text-dim);+ font-size: 14px;+ font-weight: 500;+ white-space: nowrap;+ }+ .nav-links a:hover { color: var(--text); text-decoration: none; }+ .nav-links a[aria-current="page"] { color: var(--text); }+ .nav-links a[aria-current="page"]::after {+ content: '';+ position: absolute;+ left: 1px;+ right: 1px;+ bottom: -7px;+ height: 3px;+ border-radius: 999px;+ background: linear-gradient(90deg, var(--accent2), var(--accent));+ box-shadow: 0 2px 12px var(--accent-glow);+ }+ .lang-dropdown {+ background: var(--tint-soft);+ color: var(--text);+ border: 1px solid var(--border);+ border-radius: 8px;+ padding: 6px 10px;+ font-size: 13px;+ max-width: 120px;+ }+ .lang-dropdown:focus { outline: 2px solid var(--accent-glow); outline-offset: 1px; }+ .lang-dropdown option { background-color: var(--bg-card-hover); color: var(--text); }+ .theme-toggle {+ appearance: none;+ -webkit-appearance: none;+ background: var(--tint-soft-2);+ border: 1px solid var(--border);+ border-radius: 999px;+ width: 30px;+ height: 30px;+ padding: 0;+ display: inline-flex;+ align-items: center;+ justify-content: center;+ flex-shrink: 0;+ cursor: pointer;+ color: var(--text-dim);+ transition: background 0.2s, color 0.2s, border-color 0.2s, transform 0.1s;+ }+ .theme-toggle:hover {+ background: var(--tint-medium);+ border-color: var(--accent);+ color: var(--text);+ transform: translateY(-1px);+ }+ .theme-toggle:focus-visible {+ outline: 2px solid var(--accent2);+ outline-offset: 2px;+ }+ .theme-toggle svg { width: 16px; height: 16px; display: block; }+ .theme-toggle .icon-sun { display: block; }+ .theme-toggle .icon-moon { display: none; }+ :root[data-theme="light"] .theme-toggle .icon-sun { display: none; }+ :root[data-theme="light"] .theme-toggle .icon-moon { display: block; }+ main,+ article {+ max-width: var(--max-w);+ margin: 0 auto;+ padding: 64px 24px 80px;+ }+ .sr-only {+ position: absolute;+ width: 1px;+ height: 1px;+ padding: 0;+ margin: -1px;+ overflow: hidden;+ clip: rect(0, 0, 0, 0);+ white-space: nowrap;+ border: 0;+ }+ h1 {+ font-size: 38px;+ line-height: 1.2;+ font-weight: 700;+ letter-spacing: 0;+ margin-bottom: 16px;+ }+ .lede {+ color: var(--text-dim);+ line-height: 1.6;+ }+ .lede {+ font-size: 19px;+ margin-bottom: 40px;+ }+ .meta {+ font-size: 13px;+ color: var(--text-dim);+ margin-bottom: 12px;+ letter-spacing: 0;+ }+ h2 {+ font-size: 24px;+ font-weight: 700;+ margin-top: 48px;+ margin-bottom: 14px;+ letter-spacing: 0;+ }+ h3 {+ font-size: 18px;+ font-weight: 600;+ margin-top: 32px;+ margin-bottom: 10px;+ color: var(--text);+ }+ h4, h5, h6 {+ color: var(--text);+ margin-top: 28px;+ margin-bottom: 10px;+ line-height: 1.35;+ }+ p { margin-bottom: 16px; }+ ul, ol { margin: 0 0 16px 20px; }+ li { margin-bottom: 6px; }+ code {+ font-family: 'SF Mono', 'Menlo', 'Consolas', monospace;+ font-size: 0.88em;+ background: var(--inline-code-bg);+ padding: 2px 6px;+ border-radius: 4px;+ color: color-mix(in srgb, var(--accent2) 80%, var(--text));+ }+ pre {+ background: var(--code-bg);+ border: 1px solid var(--border);+ border-radius: var(--radius);+ padding: 18px 20px;+ overflow-x: auto;+ margin: 20px 0;+ font-size: 14px;+ line-height: 1.55;+ box-shadow: 0 18px 60px var(--shadow-strong);+ }+ pre code {+ background: transparent;+ padding: 0;+ color: inherit;+ font-size: inherit;+ }+ blockquote {+ border-left: 3px solid var(--accent);+ padding: 4px 0 4px 18px;+ margin: 20px 0;+ color: var(--text-dim);+ font-style: italic;+ }+ blockquote p:last-child { margin-bottom: 0; }+ hr {+ border: 0;+ border-top: 1px solid var(--border);+ margin: 36px 0;+ }+ article img {+ max-width: 100%;+ height: auto;+ display: block;+ border-radius: var(--radius);+ border: 1px solid var(--border);+ margin: 24px 0;+ }+ .table-wrap { overflow-x: auto; margin: 24px 0; }+ table {+ width: 100%;+ min-width: 560px;+ border-collapse: collapse;+ font-size: 14px;+ }+ th, td {+ text-align: left;+ padding: 10px 12px;+ border-bottom: 1px solid var(--border);+ vertical-align: top;+ }+ th {+ color: var(--text-dim);+ font-weight: 600;+ font-size: 12px;+ text-transform: uppercase;+ letter-spacing: 0;+ background: var(--tint-soft-2);+ }+ td code { font-size: 12px; }+ .win { color: var(--success); font-weight: 600; }+ .lose { color: var(--danger); }+ .meh { color: var(--warning); }+ .callout {+ background: color-mix(in srgb, var(--accent) 10%, transparent);+ border: 1px solid color-mix(in srgb, var(--accent) 24%, transparent);+ border-radius: var(--radius);+ padding: 16px 20px;+ margin: 24px 0;+ font-size: 15px;+ line-height: 1.65;+ color: var(--text-dim);+ }+ .callout strong { color: var(--text); }+ .author-box {+ margin-top: 64px;+ padding-top: 32px;+ border-top: 1px solid var(--border);+ color: var(--text-dim);+ font-size: 14px;+ }+ .post-list { display: flex; flex-direction: column; gap: 18px; }+ .post-card {+ display: block;+ background: var(--bg-card);+ border: 1px solid var(--border);+ border-radius: var(--radius-lg);+ padding: 24px 26px;+ transition: background 0.18s, border-color 0.18s, transform 0.18s;+ }+ .post-card:hover {+ background: var(--bg-card-hover);+ border-color: color-mix(in srgb, var(--accent) 30%, transparent);+ transform: translateY(-1px);+ text-decoration: none;+ }+ .post-meta {+ font-size: 12px;+ color: var(--text-dim);+ letter-spacing: 0;+ margin-bottom: 8px;+ }+ .post-title {+ font-size: 21px;+ font-weight: 600;+ color: var(--text);+ margin-bottom: 6px;+ letter-spacing: 0;+ line-height: 1.35;+ }+ .post-excerpt {+ color: var(--text-dim);+ font-size: 15px;+ line-height: 1.6;+ }+ footer {+ max-width: var(--max-w);+ margin: 0 auto;+ padding: 40px 24px;+ border-top: 1px solid var(--border);+ display: flex;+ justify-content: space-between;+ gap: 24px;+ color: var(--text-dim);+ font-size: 13px;+ }+ footer a { color: var(--text-dim); }+ footer a:hover { color: var(--text); }+ @media (max-width: 700px) {+ body { font-size: 16px; }+ .nav-inner { padding: 14px 20px; align-items: flex-start; }+ .nav-links { gap: 12px; flex-wrap: wrap; }+ .lang-dropdown { display: none; }+ h1 { font-size: 28px; }+ .lede { font-size: 16px; }+ main, article { padding: 48px 20px 64px; }+ h2 { font-size: 20px; margin-top: 36px; }+ .post-card { padding: 20px; }+ .post-title { font-size: 19px; }+ footer { flex-direction: column; padding: 32px 20px; }+ }+ @media (max-width: 420px) {+ .nav-inner { gap: 12px; }+ .nav-links a[href="https://github.com/webbrain-one/webbrain"] { display: none; }+ .theme-toggle { width: 28px; height: 28px; }+ }+ </style>+ <script>+ (function () {+ try {+ var saved = localStorage.getItem('webbrain-theme');+ var theme = (saved === 'light' || saved === 'dark')+ ? saved+ : (window.matchMedia('(prefers-color-scheme: light)').matches ? 'light' : 'dark');+ document.documentElement.setAttribute('data-theme', theme);+ } catch (_) {+ document.documentElement.setAttribute('data-theme', 'dark');+ }+ })();+ </script>+ <!-- Plausible analytics: start -->+ <!-- Privacy-friendly analytics by Plausible -->+ <script async src="https://plausible.io/js/pa-yWGfwxkkKSVs-eTuaKYpy.js"></script>+ <script>+ window.plausible=window.plausible||function(){(plausible.q=plausible.q||[]).push(arguments)},plausible.init=plausible.init||function(i){plausible.o=i||{}};+ plausible.init()+ </script>+ <!-- Plausible analytics: end -->+ <script type="application/ld+json">+{+ "@context": "https://schema.org",+ "@type": "BlogPosting",+ "headline": "Introducing WebBrain Compass Tiny: edge-sized Compact tool routing for WebBrain",+ "description": "WebBrain Compass Tiny v1 is a private 2.6B WebBrain Compact-model preview. In our first routing suite it ties Qwen3.6-35B-A3B on tool-name conformity, improves the same local LFM2.5 base model by eight routing outcomes, and keeps the model small enough for edge-oriented deployment.",+ "author": {+ "@type": "Person",+ "name": "Emre Sokullu",+ "url": "https://emresokullu.com"+ },+ "datePublished": "2026-09-05",+ "image": "https://webbrain.one/og-image.png",+ "publisher": {+ "@type": "Organization",+ "name": "WebBrain",+ "logo": {+ "@type": "ImageObject",+ "url": "https://webbrain.one/logo-github.png"+ }+ },+ "mainEntityOfPage": {+ "@type": "WebPage",+ "@id": "https://webbrain.one/blog/webbrain-compass-tiny-v1"+ }+}+ </script>+</head>+<body>+ <div class="glow-bg"></div>+ <nav>+ <div class="nav-inner">+ <a href="/" class="nav-brand"><img class="brand-logo" src="/logo-github.png" alt="" aria-hidden="true"> WebBrain<span class="domain">.one</span></a>+ <div class="nav-links">+ <a href="/">Home</a>+ <a href="/docs/">Docs</a>+ <a href="/blog" aria-current="page">Blog</a>+ <select class="lang-dropdown" id="lang-dropdown" aria-label="Select language" data-current="en"><option value="en">English</option><option value="es">Español</option><option value="fr">Français</option><option value="tr">Türkçe</option><option value="zh">中文</option><option value="ru">Русский</option><option value="uk">Українська</option><option value="ar">العربية</option><option value="ja">日本語</option><option value="ko">한국어</option><option value="id">Bahasa Indonesia</option><option value="th">ไทย</option><option value="ms">Bahasa Melayu</option><option value="tl">Filipino</option><option value="he">עברית</option></select>+ <button class="theme-toggle" type="button" id="theme-toggle" aria-label="Toggle light / dark theme" title="Toggle light / dark theme">+ <svg class="icon-sun" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">+ <circle cx="12" cy="12" r="4"/>+ <path d="M12 2v2M12 20v2M4.93 4.93l1.41 1.41M17.66 17.66l1.41 1.41M2 12h2M20 12h2M4.93 19.07l1.41-1.41M17.66 6.34l1.41-1.41"/>+ </svg>+ <svg class="icon-moon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">+ <path d="M21 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 21 12.79z"/>+ </svg>+ </button>+ <a href="https://github.com/webbrain-one/webbrain" target="_blank" rel="noopener">GitHub</a>+ </div>+ </div>+ </nav>++ <article>+ <div class="meta">September 5, 2026 · 6 min read · <a href="/blog">← All posts</a></div>+ <h1>Introducing WebBrain Compass Tiny: edge-sized Compact tool routing for WebBrain</h1>+ <p class="lede"><strong>WebBrain Compass Tiny v1 is our first edge-sized model built specifically for the Compact browser-tool loop.</strong> It is not a claim that 2.6B parameters equal a 35B model at general reasoning. It is evidence that a focused, grounded routing policy can make a small model useful inside a real browser agent: in this first suite, Compass ties Qwen3.6-35B-A3B on the expected tool name and improves the matched local LFM2.5-2.6B base model by eight routing outcomes. Qwen3.8-27B remains the quality leader when its cost and footprint fit the deployment.</p>+<h2 id="the-short-version">The short version</h2>+<p>Compass Tiny v1 is a <strong>private preview</strong> today. We are preparing an open-weights release so it can be downloaded and run locally, subject to the remaining release, provenance, and packaging checks. Until that work is complete, it is not a public download and this article should not be read as a release announcement.</p>+<p>The model is tuned for three Compact behaviors in WebBrain:</p>+<ol><li>Answer or ask a clarifying question when that is the justified next step.</li><li>Emit a grounded Compact tool call when the page context supports it.</li><li>Abstain or escalate when direct execution would be unjustified.</li></ol>+<p>That is deliberately narrower than “be a universally smarter model.” It is the right narrowness for a browser agent that must choose a next action from a constrained toolset.</p>+<h2 id="what-we-measured">What we measured</h2>+<p>We ran the current Compact Chrome suite: 100 first-action cases and 100 stateful scenarios. Eleven scenarios are intentionally out of scope for Compact and are excluded from the scenario-quality denominator, leaving 89 scored scenarios.</p>+<p>The table uses two different signals:</p>+<ul><li><strong>Exact reference action</strong> means the tool and arguments matched the canonical next action.</li><li><strong>Expected tool name</strong> credits the expected tool even when arguments differ. It is useful for measuring routing, but it is not a completed browser task.</li></ul>+<p>The exact reference is a Sonnet-authored canonical next action. It is a regression-oriented reference, not an oracle for every reasonable live-browser strategy: a careful model may inspect before a direct click, for example. That distinction matters here.</p>+<div class="table-wrap"><table><thead><tr><th>Model</th><th>Parameters</th><th>First-turn structured calls</th><th>Exact reference action (of 89)</th><th>Expected tool name (of 89)</th></tr></thead><tbody><tr><td>Qwen3.8-27B</td><td>27B</td><td><strong>99 / 100</strong></td><td><strong>17</strong></td><td>39</td></tr><tr><td>Qwen3.6-35B-A3B</td><td>35B A3B</td><td>89 / 100</td><td>15</td><td><strong>42</strong></td></tr><tr><td><strong>WebBrain Compass Tiny v1</strong></td><td><strong>2.6B</strong></td><td><strong>81 / 100</strong></td><td>4</td><td><strong>42</strong></td></tr><tr><td>LFM2.5-2.6B base (local)</td><td>2.6B</td><td>80 / 100</td><td>4</td><td>34</td></tr><tr><td>Qwen3.5-9B</td><td>9B</td><td>84 / 100</td><td>2</td><td>12</td></tr></tbody></table></div>+<p>Compass therefore does not beat the 35B model on the strict reference. It <strong>matches it on tool-name routing</strong> in this Compact suite. It also exceeds the 9B Qwen result by 30 expected-tool-name outcomes and the matched local LFM base model by eight. Those are promising results for a model intended to live near the edge of the product, where size, VRAM, latency, and controllability matter as much as raw general capability.</p>+<h2 id="the-controlled-basemodel-comparison">The controlled base-model comparison</h2>+<p>The base-model row is the comparison we care about most. We served the pinned <code>LiquidAI/LFM2.5-2.6B</code> base revision locally through the same vLLM version, LFM2 parser, tokenizer, BF16 precision, 32K context window, Compact prompt, tools, and benchmark harness used for Compass.</p>+<p>The base model produced 80 first-turn structured calls, four exact-reference scenario actions, and 34 expected-tool-name outcomes. Compass produced 81, four, and <strong>42</strong> respectively. In this deliberately narrow measurement, the fine-tune does not change the exact-reference count, but it adds <strong>eight</strong> expected Compact routing outcomes.</p>+<p>That is a useful, bounded result: Compass is not claiming a broad general-intelligence jump over its base. It is demonstrating that WebBrain-specific training can move the next-action routing policy in the desired direction without making the model larger.</p>+<h2 id="why-qwen3-8-is-still-the-default-quality-choice">Why Qwen3.8 is still the default quality choice</h2>+<p>Qwen3.8-27B remains the best model in this comparison if the budget and deployment footprint are acceptable. It has the highest exact-reference score, almost universal first-turn tool-call emission, and fast scenario completion in this run.</p>+<p>Compass is not positioned as a replacement for that class. The point is different: <strong>a 2.6B specialist can already be useful for a well-scoped WebBrain Compact decision</strong>, rather than forcing every low-risk browser step through a much larger planner.</p>+<p>Qwen3.6-35B-A3B remains an important reference point too. Its tie with Compass on expected tool name should not be over-read as equal general intelligence. It is evidence of task specialization, not a claim about broad reasoning, coding, knowledge, multilingual breadth, or long-horizon browser reliability.</p>+<h2 id="a-note-on-the-public-free-route">A note on the public free route</h2>+<p>We also exercised the public <code>liquid/lfm-2.5-2.6b:free</code> route on OpenRouter as an availability probe. Its scenario service was not stable enough to rank: it returned intermittent provider errors even when requests were serialized. It is therefore excluded from the table above. The local, pinned base comparison is the relevant fine-tune baseline.</p>+<h2 id="what-happens-next">What happens next</h2>+<p>This is the beginning of the evaluation, not the end of it. We are adding more browser surfaces, longer trajectories, tool-result recovery, calibrated escalation behavior, and broader multilingual cases. We also want to measure locally hosted base LFM under the same serving stack before publishing a fine-tune-versus-base headline.</p>+<p>The working roadmap includes Compass <strong>v1.1</strong> and eventually <strong>v2</strong>, with more data, more targeted evaluations, and clearer release artifacts. We hope that work turns this private preview into a useful open-weights option for teams that want WebBrain-native Compact behavior without making a large cloud model the only route for every action.</p>+<h2 id="reproducibility-notes">Reproducibility notes</h2>+<p>The comparison used the same Compact Chrome harness and structured tool schemas for every listed model. The runner captures the next response; it does not execute the browser action, so these figures are routing metrics rather than end-to-end success rates. Provider routes, sampling behavior, and model revisions can change, so these results should be read as a dated benchmark snapshot rather than a permanent leaderboard.</p>+<p>More evaluation results will follow as the suite grows.</p>+<p>Tags: #WebBrain #CompassTiny #BrowserAgent #ToolCalling #EdgeAI #CompactMode #LFM25 #OpenWeights</p>++ <div class="author-box">+ Written by <a href="https://emresokullu.com" target="_blank" rel="noopener">Emre Sokullu</a>. WebBrain 33.0.0 and later is GPL-3.0-or-later and open on <a href="https://github.com/webbrain-one/webbrain" target="_blank" rel="noopener">GitHub</a>.+ </div>+ </article>++ <footer>+ <div>© 2026 WebBrain · <a href="/privacy">Privacy</a></div>+ <div><a href="https://github.com/webbrain-one/webbrain" target="_blank" rel="noopener">GitHub</a></div>+ </footer>+ <script>+ (function () {+ const btn = document.getElementById('theme-toggle');+ if (!btn) return;+ const root = document.documentElement;++ function setTheme(theme, persist) {+ root.setAttribute('data-theme', theme);+ if (persist) {+ try { localStorage.setItem('webbrain-theme', theme); } catch (_) {}+ }+ }++ btn.addEventListener('click', function () {+ const next = root.getAttribute('data-theme') === 'light' ? 'dark' : 'light';+ setTheme(next, true);+ });++ const mq = window.matchMedia('(prefers-color-scheme: light)');+ function onMQ(e) {+ try {+ if (localStorage.getItem('webbrain-theme')) return;+ } catch (_) {}+ setTheme(e.matches ? 'light' : 'dark', false);+ }+ if (typeof mq.addEventListener === 'function') mq.addEventListener('change', onMQ);+ else if (typeof mq.addListener === 'function') mq.addListener(onMQ);+ })();+ </script>+ <script>+ (function () {+ const LOCALES = ["en","es","fr","tr","zh","ru","uk","ar","ja","ko","id","th","ms","tl","he"];+ const sel = document.getElementById('lang-dropdown');+ if (!sel) return;+ sel.value = sel.dataset.current || 'en';+ sel.addEventListener('change', function () {+ const target = sel.value;+ if (!LOCALES.includes(target)) return;+ window.location.href = target === 'en' ? '/' : '/' + target + '/';+ });+ })();+ </script>+</body>+</html>