Four ways into every tool
- See and click. Every calculator is an ordinary form and stays one.
- Type a sentence. “I paid 12, selling at 40, shipping label 5.” The assistant matches each number to a field and lists what it changed.
- Speak. Press the microphone, or turn on Voice mode to keep going hands-free: it listens, fills, reads the result aloud and listens again until you say “stop”.
- Let an agent do it. On browsers with WebMCP, every page offers tools to search the site, fill the form and read the result. See For AI agents.
How it works, and where your words go
You choose the engine in the panel’s Settings. The default is the first row. Nothing below the first row downloads or connects until you click to turn it on.
| Engine | Downloads | What you type or say goes to | Good at |
|---|---|---|---|
| No model (default) | Nothing (the assistant code is about 40 KB, fetched when you first open it) | Nowhere | Filling forms from clear sentences; finding tools; quoting the paragraph on this page that answers you |
| Your browser’s built-in model | Nothing from this site. Chrome downloads and manages its own model | Nowhere: it runs on your device | Looser sentences, short answers |
| On-device model (Qwen2.5 0.5B or 1.5B, through WebLLM on the GPU, or llama.cpp compiled to WebAssembly on the CPU where there is no WebGPU) | 290 MB or 880 MB with WebGPU, 430 MB or 1.1 GB on the CPU, once, from huggingface.co (the engine from cdn.jsdelivr.net), then kept in your browser’s storage | Nowhere: it runs in a background worker on your device | The same, offline. On the CPU it is several times slower |
| Your own key or local server | Nothing | The provider you choose (Anthropic, OpenAI, Gemini, any OpenAI-compatible URL) or Ollama, LM Studio or llama.cpp on your computer. The key stays in your browser | The strongest answers, depending on your model |
Voice in uses your browser’s on-device speech recognition where it has one. Otherwise it uses Whisper tiny.en (96 MB, once, from huggingface.co), which runs in your browser: an 11-second clip took about 4 seconds to transcribe on a laptop-class CPU in our test, word for word. Cloud speech recognition is never used, because it would send your audio to a company this page cannot name. Voice out uses your device’s own voices.
A model never writes into a form directly. It proposes values as JSON, constrained to the form’s own fields where the engine supports it. Every value is checked against the field’s type, range and choices before it is written, and anything refused is listed. The rule-based reader comes first: its values stand, and a model may only add fields the rules did not fill. A model’s number is dropped unless you said it, each number you said fills one field, and a model may set a choice or checkbox only if you used one of its words. Without those checks the 0.5B model wrote 337 wrong values on our 52 test sentences, mostly zeros in fields nobody mentioned (docs/reports/2026-10-21-wasm-on-the-site.md).
How well it is measured to work
The rule-based reader is tested on 52 sentences against 5 real calculator forms. The sentences are in platform/pages/assistant/evals.json and the test is platform/pages/assistant.test.mjs. Today it gets 52 of 52 fully right. That number is not an estimate of how it does on your sentences, because every mistake found was fixed. The estimate is the blind rounds: new sentences written before the rules were run on them, scored once, and recorded with the commit that produced the score, so anyone can reproduce it.
| Blind round | Sentences | Fully right | Wrong value written | Reproduce at |
|---|---|---|---|---|
| 1 (2026-10-20): eBay fees, roofing bid, Amazon FBA (the forms the rules were written on) | 12 | 6 | 1 | 0a350c26 |
| 2 (2026-10-20): the same three, plus house cleaning and mileage, which the rules had never seen | 16 | 10 | 4 | 1eec78c2 |
The samples are small, and a wrong value written is the mistake that matters most, which is why every change the assistant makes is listed with an Undo. The on-device models were scored on the same 52 sentences on 2026-10-21: on their own, Qwen2.5 0.5B wrote 337 wrong values and 1.5B wrote 87, and with the checks above the panel wrote none for either. The rules already pass all 52, so this shows the checks stop a model doing harm, not that a model helps; that needs new sentences the rules get wrong (platform/pages/assistant/model-bench/score.mjs).
Limitations
- Check every value. The panel lists each field it changed and offers Undo. The calculator’s own result is the answer, not the assistant’s summary of it.
- The rule-based reader needs the field’s name near the number (“waste 10 percent”). It skips rather than guesses when two fields match equally, and when a value is outside a field’s range. It cannot fill text fields or dates; a model can.
- Small on-device models make things up. They are told to answer only from the page and the site’s tool list, but they can still be wrong. Nothing here is legal, tax, financial or professional advice.
- The on-device model is fastest with WebGPU (recent Chrome or Edge on desktop; support elsewhere varies) and about 1–1.7 GB of GPU memory. Without it the same model runs on the CPU on one thread: in our test (a 4-core cloud machine, Qwen2.5 0.5B) a form fill took 11 to 107 seconds and a 100-word answer about 40 seconds. Phones may not have enough memory for either.
- Speech recognition gets numbers wrong in noise and with unusual words; what it heard is shown before anything is filled.
- Some calculators build their fields in ways the reader cannot see. It tells you when it finds no field to fill.
For AI agents
On browsers with WebMCP (navigator.modelContext), each page registers:
search_site_tools: search every tool and research project by keywords.fill_form(calculators only): a JSON Schema of the page’s fields, built from the live form. Values outside a field’s range are refused, not clamped. Returns what was filled, what was refused, and the page’s result text.read_page_results: the page’s current result text.
Without WebMCP, agents can read llms.txt and catalog.json. Every calculator is a plain HTML form an agent can fill directly.
Source
Everything here is open source, MIT licensed: platform/pages/assistant/client.js (the panel), platform/pages/assistant/fill.mjs (the rule-based reader), platform/pages/assistant/worker.js (on-device model and speech), platform/llm/byok.mjs (bring your own key), and platform/pages/assistant.mjs (how pages load it).
Questions
Can I fill in a calculator by voice?
Yes. On any calculator press "Speak or type" (or "Ask" in the header) and say your numbers, for example "2,400 square feet, 8/12 pitch, waste ten percent". The assistant writes them into the matching fields, lists every change with an Undo, and can read the result back. Voice mode keeps listening, filling and speaking until you say "stop".
Does what I say or type leave my device?
Not unless you choose a provider that runs elsewhere. With no model (the default), the built-in browser model or the on-device model, everything runs in your browser. Speech recognition is the browser's on-device recogniser or Whisper running in your browser; cloud speech recognition is never used. If you enter your own API key, what you type goes from your browser to that provider and nowhere else.
Do I need an AI model or an API key?
No. Without any model, a rule-based reader fills forms and the site search finds tools. A model adds open-ended answers and reads looser sentences; you can use your browser's built-in one, download one that runs on your device, or bring your own key.
How accurate is it?
The rule-based reader is scored on every build against real sentences and real calculator forms. In its latest blind test (sentences written before the rules were run on them, on the same three, plus house cleaning and mileage, which the rules had never seen) it got 10 of 16 fully right and wrote a wrong value 4 times; those mistakes were then fixed, and the next blind round will measure the fixes. Always check the fields: every value it writes is listed with an Undo.
Can an AI agent use these tools?
Yes. In a browser that supports WebMCP, every page offers search_site_tools, read_page_results and, on calculators, fill_form with a JSON Schema of its fields, so an agent fills the same form a person sees and every value is checked against the field first.