WebBrain Cloud is live, and these are the local models we are benchmarking next
Two updates. First: WebBrain Cloud is now live in the latest main branch, so you can start using WebBrain without a local LLM and without bringing your own API access. It is limited to a small number of hosted requests, but that is enough to see the product loop, test the browser-agent flow, and decide whether you want to wire in your own local or API-backed model. Second: our next benchmark pass will focus on the best local models for the hardware people actually have, grouped by VRAM.
WebBrain Cloud is live
Until now, trying WebBrain seriously meant having one of two things ready: a local model server, or an API key for a hosted model provider. That is still the best setup for sustained use, but it is too much friction for a first look.
The new cloud path removes that first-run blocker. Download and install the latest main branch from the WebBrain GitHub repo, then run WebBrain as usual. You can use the built-in WebBrain Cloud route for a limited number of requests without configuring a local LLM or external API provider.
This is not meant to be an unlimited hosted tier. The point is simpler: you should be able to install WebBrain, try the browser agent, and see whether the workflow makes sense before spending time on model setup.
main branch, try the limited WebBrain Cloud requests first, then switch to a local or API-backed model when you are ready for heavier usage.
What we are benchmarking next
The next benchmark set is about practical local deployment. "Best model" is not one category. A model that is excellent on a 48GB card may be irrelevant to someone with a laptop GPU, and a tiny model that is fast enough to be delightful may be too weak for harder browser-agent planning.
So we are grouping the next candidates by approximate VRAM band.
4GB to 12GB VRAM
| Model | Why it is on the list |
|---|---|
| VibeThinker-3B | This is the small-model candidate that looks most likely to punch above its weight. The claim from the community is simple: it is beating models near its size class and challenging much larger ones, with the previous version already showing strong math-benchmark performance. For WebBrain, the question is whether that reasoning transfers into tool selection and browser control. |
The useful thing about a 3B model is not just that it fits. It can be fast enough to keep the browser-agent loop feeling interactive on hardware that would make 12B+ models annoying. If VibeThinker-3B holds up on tool calling, it becomes a serious default candidate for entry-level local use.
12GB to 24GB VRAM
| Model | Why it is on the list |
|---|---|
| Gemma 4 12B Coder Fable5 Composer 2.5 GGUF | Built on top of an already strong base, tuned toward coding, reduced refusals, and published with a 262k context-window target. The Fable traces make it especially interesting for agent-style work where the model has to keep long task state and edit intent in memory. |
This is probably the most important tier for WebBrain users with a single consumer GPU. A good 12B coder can be large enough to reason about messy pages and small enough to run locally without turning every action into a wait.
24GB to 64GB VRAM
| Model | Why it is on the list |
|---|---|
| DiffusionGemma-26B-A4B-it | Gemma 4 26B was already one of the most functional open local-model families for our use case. The diffusion variant is interesting because people are reporting extremely high throughput on consumer hardware. If that speed holds while preserving tool quality, it could change the local-agent tradeoff. |
| Cohere North-Mini-Code 1.0 | A new 30B coding model from a lab that has consistently taken code and retrieval seriously. This is the "push the local coding ceiling" candidate: not for the smallest setup, but very worth testing for users who want stronger local planning and code-edit behavior. |
This tier is where local starts competing with small hosted-model routes on quality while keeping the privacy and latency profile of your own hardware. The benchmark question is not only "which model scores highest?" It is also "which model gives the best action quality per second?"
What we are not testing first
0xSero's broader recommendation list also called out GLM-5.2-REAP for very large multi-GPU setups. We are intentionally leaving that out of this first WebBrain local benchmark pass.
That is not a judgment on the model. It is a scope decision. Once a setup needs something like multiple workstation GPUs or clustered small systems, it stops answering the question most WebBrain users are asking: what should I run locally on the hardware I already have?
How we will score them
The first pass will use the same basic standard as our recent browser-agent posts: frozen prompts and tool schemas, first-action tool selection, parseability, latency, and failure modes. We care about model behavior that survives contact with the actual browser loop, not just leaderboard claims.
For each model, the main questions are:
- Does it call tools reliably, or does it fall back into chat-assistant prose?
- Does it pick the right first browser action?
- Does it emit parseable arguments every time?
- Does it stay fast enough that the agent still feels usable?
- Does it refuse normal browser work more often than it should?
The cloud path gives everyone a low-friction way to try WebBrain today. The local benchmark pass should make the next decision clearer: when you are ready to move beyond the limited hosted requests, which model should you run on your own hardware?