The Best New Coding Agent Runs on One GPU. It Gets 131K of Context, Not a Million.
Meta's Muse Glimmer puts a real agentic coding model on a single consumer GPU—Apache 2.0, 131K context. When tokens are free, the window becomes the meter. Context efficiency stops being cost control and becomes fit.
On Monday, Meta returned to open source with Muse Glimmer: a 30B-parameter model under Apache 2.0, trained specifically for agentic work—multi-step tool use, coding, scaffold compatibility, and recovery from failed tool calls. The reported specs are the story: 4-bit quantization fits it under 20GB, on a single consumer GPU, with one quant running the full 131K context in 15.6GB of VRAM. The same week, Alibaba began releasing open weights for Qwen3.8—including the ~2.4T-parameter flagship. The open-model wave that has defined 2026 just reached the point where a genuinely capable coding agent runs on the machine under your desk.
No API bill. No usage credits. No weekly cap. If you’ve followed our running series on AI cost meters, this looks like the ending: the meter is gone.
It isn’t. It moved again—into the context window.
Free Tokens, Three Constraints
Run the model locally and the per-token price drops to zero. Three things don’t:
The window is 131K, not a million. Cloud frontier models spent 2026 racing to 1M-token contexts—big enough to absorb sloppy retrieval. Local models live an order of magnitude smaller. 131K is a real budget: system prompt, tool definitions, conversation history, tool outputs, and every file the agent decides to read, all competing for the same space. There is no overflow valve. When the window fills, the agent forgets or fails.
Wall-clock is the new invoice. A local GPU processes tokens at local speeds—Muse Glimmer’s launch coverage touts a 3.1× speculative-decoding speedup on an RTX 5090 precisely because throughput is the pain point. Every needless file the agent ingests is seconds you personally wait, on every turn, for the model to re-attend to noise it never needed.
Attention doesn’t scale for free. Models reason worse over stuffed windows—the more loosely-related code in context, the more the model’s answer quality erodes. That’s true in the cloud too, but a 30B local model has less headroom to waste than a frontier one.
The pattern from our cost series holds with the labels swapped: the meter keeps changing shape—quota, dollars, caps, and now fit—and the lever stays the same. Tokens-per-task was your cost control in the cloud. Locally, it’s whether the agent works at all.
The Window-Fit Math
How fast does retrieval waste eat 131K? Our committed benchmark (three fixed tasks, two fixtures, counted with a real tokenizer—everything checked into the repo, rerunnable) gives the shape. On the caching task, keyword retrieval reads 20 files (~4,313 input tokens, 21 tool calls) where the dependency graph reads 4 files (~935 tokens, 5 calls).
Now put that inside an agent loop. A real session isn’t one retrieval round—it’s one per subtask: explore, patch, run tests, read failures, patch again. At ~4,300 tokens of context per round plus accumulating tool outputs and history, a handful of subtasks pushes deep into a 131K budget, and the agent starts evicting or truncating exactly when the task gets interesting. At ~900 tokens per round, the same window holds several times more working history—the difference between an agent that finishes a multi-step task and one that loses the plot halfway.
Across all three benchmark tasks the median is 67.9% fewer input tokens and 2.75× fewer tool calls (per-task spread: 78.3%, 67.9%, 67.0%; 4.2×, 2.75×, 1.67×). Median of three fixed tasks, not a universal constant—your repo sets the real number. But locally, every one of those saved tokens pays out twice: once in window headroom, once in seconds not spent decoding noise.
The Fully Local Stack
There’s a second thing the local wave unlocks, and for some teams it matters more than the free tokens: the whole loop can now run without your code touching a cloud.
Muse Glimmer is Apache 2.0, on your GPU. Coograph is MIT, and was local from day one: it parses your codebase with tree-sitter (Python, TypeScript, JavaScript, Go, Rust, Java, C#, Ruby, and more, with a regex fallback) into a single SQLite file—.code-graph/graph.db—on your disk. Your agent queries it over MCP (get_minimal_context, query_graph) and gets the dependency chain in one pass. A git hook re-parses only changed files per commit. No embedding service, no API key, no third party seeing a line of your source.
Model on your GPU, graph on your disk, code in your repo. For teams whose compliance posture—or customers—rule out shipping source to a cloud model, “capable local agent” was the missing piece. It just arrived, and it arrived with a small window: the context layer isn’t optional equipment for this stack. It’s what makes the 131K feel like enough.
Setup is minutes: clone Coograph as a sibling directory, run /coograph-init from your tool (Claude Code, Copilot, Cursor, Windsurf, Codex CLI, OpenCode, Aider, Cline—anything that speaks MCP), and build the graph. The graph doesn’t care which model reads from it—Fable 5 in the cloud today, Muse Glimmer under the desk tomorrow.
Is a 30B local model actually good enough for coding-agent work?
Meta trained Glimmer specifically for tool use, coding agents, scaffold compatibility, and recovery from failed tool calls, and reports it runs the full 131K context in under 16GB of VRAM (as reported at launch). It won’t match Fable 5 on the hardest problems—but for the bulk work agents actually do, “capable, free, and private” is a serious proposition. The context layer decides how much of that capability survives contact with your repo.
Tokens are free locally—why care about token efficiency?
Because three costs survive: the 131K window (waste fills it and the agent degrades), wall-clock (a local GPU decodes every noise token while you wait), and reasoning quality over stuffed context. On the committed benchmark the graph cuts input tokens by a median 67.9% and tool calls 2.75×—locally that buys window headroom and speed, not just money.
Does Coograph work with local models?
Yes. Coograph is an MCP server over a local SQLite graph—any agent scaffold that speaks MCP can query it, whatever model is behind it. It’s already fully local, so a local model completes the no-cloud loop rather than requiring anything new.
Where do these benchmark numbers come from?
Harness v0.2.0: three fixed tasks across two committed fixtures, tokens counted with tiktoken (cl100k_base), headline reported as the median (67.9% tokens, 2.75× calls; spread 67.0–78.3% and 1.67–4.2×). We lowered our own headline when we upgraded the measurement. Everything is committed—rerun it.
Open source or paid?
The whole repo is MIT-licensed and free forever—no gated features. Coograph Pro is bespoke services (integration, custom parsers, benchmarking against your workload), not a locked tier.
The cloud spent 2026 teaching everyone that context waste costs money. The local wave teaches the sharper lesson: context waste costs capability. A 131K window with a disciplined context layer beats a million-token window full of noise—and now the whole stack that proves it fits under your desk. Generate your first graph with the getting-started guide, see what’s inside it on the code-graph page, or talk to us about Coograph Pro if you’re building the no-cloud loop. The benchmark is committed. Rerun it on the machine your code never has to leave.
Cut your AI coding bill 67–78%. Coograph is MIT-licensed and free forever. Pro is bespoke services.