Skip to content

Open-source AI browser agent for Chrome and Firefox (monorepo) 🧠

Add Compass Tiny benchmark and blog post

Barack Sokullu0bc6cd2b18eb
diff --git a/scripts/serve-web-preview-v1.mjs b/scripts/serve-web-preview-v1.mjs
new file mode 100644
index 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.mjs
new file mode 100644
index 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.mjs
new file mode 100644
index 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.mjs
new file mode 100644
index 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.json
new file mode 100644
index 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.json
new file mode 100644
index 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.mjs
index 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.mjs
index 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.html
index 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 &middot; 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 &middot; 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.md
new file mode 100644
index 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 #OpenWeights
diff --git a/web/blog/webbrain-compass-tiny-v1/index.html b/web/blog/webbrain-compass-tiny-v1/index.html
new file mode 100644
index 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&#39;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 &middot; 6 min read &middot; <a href="/blog">&larr; 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>&copy; 2026 WebBrain &middot; <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>