A couple of months ago, I posted here about Qwen3-0.6B running on a Samsung Note 8 from 2017 and navigating a real browser. That experiment was mostly about perception. Give a tiny model a structured representation of a web page instead of dumping raw HTML into its context, and suddenly it can do things that seem unreasonable for a model of that size.
We wanted to take this further.
Navigating a few pages is one thing. What about a complete task involving hundreds of model calls, changing website state, tool failures, quantity adjustments, and a final result that actually has to be checked? And what happens to the context along the way?
So we used Qwen3.5-0.8B Q4_K_M for tool execution and Qwen3.5-2B Q3_K_M for reasoning. The hardware was a Samsung Galaxy A04e and an S21. Real phones.
The task was deliberately ordinary: start with an empty Amazon cart, find two units of a Head & Shoulders shampoo SKU and one package of yellow rubber ducks, and finish with a merchandise subtotal below $20.
The workflow specified the goal and constraints, not a fixed sequence of page clicks. The models had to deal with the actual products, quantities, page observations and tool results encountered during execution. Both runs started from independently verified empty carts. No manual browser assistance during execution, no seeded intermediate state, and no checkout or payment.
Here are the recorded results:
|
A04e |
S21 |
| Qwen 0.8B calls |
550 |
534 |
| Qwen 2B calls |
28 |
28 |
| Tool calls |
537 |
522 |
| Median input tokens/call |
45 |
45 |
| 95th percentile |
229 |
211 |
| Largest input |
1,237 |
1,253 |
| Execution time |
4h 20m |
1h 41m |
| Final subtotal |
$13.69 |
$18.53 |
| Result |
Completed |
Completed |
The execution times are not particularly impressive. Four hours on the A04e is a long time to buy shampoo and a rubber duck. But speed wasn't what we were measuring here.
Look at the input sizes.
After hundreds of model calls and more than an hour of execution, the largest input to either model was still around 1.2k tokens.
The median was just 45 tokens. That's largely a consequence of how we decomposed the workflow, rather than some inherent property of the models. These are per-call input measurements, not total mission token consumption. Both models were configured with 8,192-token context windows.
A lot of the 0.8B calls were very small tool operations with arguments already supplied from saved state. The 2B reasoner received more substantial inputs when its judgment was needed.
The interesting thing is that the procedure didn't need to accumulate its entire history inside either model.
What changed?
We separated the work the models actually need to do from the work that ordinary software can handle more reliably. The models don't have to remember the last 400 calls, reconstruct the current state from a conversation, or decide how to recover the entire workflow after something fails. They receive bounded tasks with the relevant inputs and available tools. The workflow itself carries the procedure, state, intermediate results, limits and recovery paths.
Qwen 0.8B handles local tool decisions.
Qwen 2B is called for separate reasoning tasks.
Neither has to act as the manager of the entire process.
This doesn't eliminate the need for reasoning. Choosing the wrong product or interpreting a quantity incorrectly can still ruin the result. Nor does a valid tool call prove that the model made the right semantic decision. But it changes the amount of responsibility placed on each model call.
For these experiments, we used our own stack: TroLLM is the Rust/Android workflow runtime, and E2LLM/SiFR provides structured browser perception and actions through MCP. Both are our own open-source implementations. The models run locally on the phone; the actual browser is connected separately and can run on another machine.
The software and the recorded runs are here:
The published logs are sanitized, so they don't expose every original page observation or model response. The two runs are selected successful examples.
Something I keep coming back to
We tend to evaluate small models by asking them to handle an entire problem. That's a lot to put on a 0.8B model. But if the procedure and the persistent state live outside the model, the question changes.
Instead of asking whether Qwen3.5-0.8B can independently run a complicated browser session, we can ask which individual decisions it can make reliably, and how those decisions can be combined into a longer process.
These Qwen models are not hardcoded into the runtime. The model roles are configurable, and other local models can be tested against the same workflow. We haven't established that replacements would perform equally well. And the workflow was authored. This is not a claim that two tiny models can invent and execute arbitrary procedures without help.
Still, seeing a 0.8B model make more than 500 calls as part of a completed real-world task, without dragging an ever-growing conversation behind it, has changed how I think about small models.