Open-source AI browser agent for Chrome and Firefox (monorepo) ðŸ§
title: >
WebBrain Compass is live, and these are the local models we are benchmarking next
slug: webbrain-cloud-local-model-benchmarks
sortOrder: 1
date: 2026-06-19
readTime: 5 min read
description: >
WebBrain Compass is now live in the latest main branch, so you can try WebBrain without running a local LLM or bringing your own API key. The hosted route is request-limited, but it is enough to see how the browser agent feels. Next up: benchmarks for VibeThinker-3B, Gemma 4 12B Coder, DiffusionGemma 26B, and Cohere North-Mini-Code 30B across practical local-VRAM bands.
excerpt: >
WebBrain Compass is live in the latest main branch, which means you can try WebBrain without a local LLM or API access. It is request-limited, but useful for a first look. We are also lining up the next local-model benchmark set by hardware band: 4-12GB, 12-24GB, and 24-64GB VRAM.
titleTag: >
WebBrain Compass is live, plus the next local model benchmark list - WebBrain Blog
ogTitle: >
WebBrain Compass is live, plus the next local model benchmark list
ogDescription: >
Try WebBrain from the latest main branch without a local LLM or API key, then follow our next benchmarks for practical local models by VRAM tier.
twitterTitle: >
WebBrain Compass is live
twitterDescription: >
No local LLM or API key needed for a limited first look. Next: local model benchmarks by VRAM tier.
keywords:
- WebBrain Compass
- WebBrain
- local LLM
- browser agent
- VibeThinker-3B
- Gemma 4 12B Coder
- DiffusionGemma
- Cohere North-Mini-Code
- local model benchmark
- VRAM
html: true
lede: >
Two updates. First: WebBrain Compass 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 Compass 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 Compass 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 Compass 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?