Ever watched your AI agent’s context window balloon from a single Playwright snapshot — 56KB in one shot — and thought “there has to be a better way”? Yeah, me too. And I’ve been down this road. I covered Headroom a few weeks back on ToolGenix, and it’s genuinely good at passive compression. But here’s the thing: compression only solves half of the context problem.

So what’s the other half? But nobody was talking about it. Until Context Mode showed up on Hacker News and hit #1 with 570+ points. 17,956 stars on GitHub. Now that kind of signal doesn’t come from nothing.

So I installed it. Ran it. Broke a few things. And honestly? I think this changes how we think about agent context entirely. But that’s getting ahead of myself.

TL;DR: What Makes Context Mode Different

So here’s the key difference: Context Mode doesn’t just compress your tokens after they’ve already bloated the window. It prevents the bloat in the first place. Think of it this way:

• Headroom = a filter on your water pipe — removes impurities, but the pipe stays the same size
• tokdiet = a narrower pipe — reduces what goes through the wire
• Context Mode = a smarter plumbing system that only sends what’s needed, when it’s needed

But the headline number: 98% tool output reduction in my test. Not claimed — I saw it. A 315KB Playwright page snapshot dropped to 5.4KB. And that’s not compression tricks. That’s not dumping raw output into the context window to begin with.

What Is Context Mode?

Context Mode is an MCP-based context management system for AI agents. And it works across 17+ platforms — Claude Code, Gemini CLI, VS Code Copilot, Cursor, Codex, Aider, OpenCode, Windsurf, and plenty more.

And the project has four pillars, each one targeting a specific pain point I’ve personally dealt with:

1. Sandboxed tool execution. So tool outputs go through a sandbox layer that trims the noise before it ever hits your context window. Not after — before. The ctx_execute and ctx_batch_execute commands intercept the raw output, strip the structural fluff, and hand the model only what it actually needs.

2. Session continuity via FTS5. SQLite-backed full-text search. Restart your agent session? But your context is still there — the file you were editing, the task you were working on, the user’s last instruction. I can’t count how many times I’ve hit the “30-minute context loss” wall. And Context Mode closes that gap with actual persistence, not hacky workarounds.

3. The “code thinking” paradigm. Instead of making 47 separate Read() calls to understand a codebase, you write one batch query script. The model gets the same information in a fraction of the token cost. This one’s harder to grasp until you try it — but once you do, it’s hard to go back.

4. Non-intervention output routing. And the routing layer controls what goes into the context without modifying how the model speaks. This matters more than it sounds like. But Headroom’s proxy layer reshapes model output to save tokens — which can change tone. Context Mode leaves the output alone and just controls what gets through.

Getting Started: Installing and Testing Context Mode

I installed it on Claude Code first because that’s the path of least resistance. Two commands:

/plugin marketplace add mksglu/context-mode
/plugin install context-mode@context-mode

And it took about 30 seconds. The plugin marketplace handles everything — download, dependency check, hook injection. No config files to touch, no YAML to hand-edit.

Then I ran the diagnostic:

/context-mode:ctx-doctor

All checks returned [x]. Green across the board. That’s rare for a new tool install — usually something breaks.

The Gemini CLI path is more involved. npm install -g context-mode then manually add the MCP server and four hooks to your settings.json. I tested that too. Took about 4 minutes, mostly copying hook definitions and triple-checking the JSON syntax.

But the real moment came when I ran ctx-stats:

But that last row is the one that made me stop scrolling. 315KB to 5.4KB on a real Playwright snapshot. If you run any kind of browser automation through your agent — and I do, constantly — this alone justifies the install.

Headroom vs tokdiet vs Context Mode: The Full Picture

The Brief explicitly asked me to position these as complementary, not competitive. And I genuinely think that’s the right framing. Here’s how they stack up:

Here’s how I see the stack: Headroom handles the passive side — how Headroom handles passive compression is a solid complement. And tokdiet wraps the CLI transport layer, similar to what tokdiet wraps for transport-level savings. Context Mode operates at a completely different level — the behavior level.

They don’t overlap. They layer.

Who Should Use Context Mode

Now this isn’t for casual ChatGPT users who ask three questions and move on. This is for:

• Agent-heavy developers running Claude Code, Codex, or Cursor daily, pushing $50-500/mo in token costs
• Teams building agent workflows where context persistence across sessions is a hard requirement
• Anyone using MCP tools that dump large outputs — browser snapshots, codebase-wide searches, log analysis pipelines

If your monthly API bill is a line item someone asks about in standup, Context Mode will pay for itself in a week.

And if you’re running a team? Consider deploying a shared Context Mode gateway on a VPS. One instance serves your whole team, reducing per-developer costs and keeping context continuity across everyone’s sessions. A $6/mo DigitalOcean droplet handles this easily.

The ELv2 License — What You Need to Know

Context Mode uses Elastic License 2.0. It’s source-available with commercial restrictions. The specific restriction: you cannot offer it as a commercial SaaS product that competes with the project.

Still, for personal use, internal team use, and open-source projects, it’s fully free. No hidden gotchas.

But it’s worth being honest about: ELv2 isn’t Apache-2.0. If your org has a strict OSI-only policy, this might get flagged. I’d argue that ELv2 is actually more permissive than AGPL in practice — it only targets the specific commercial-competition scenario, not everything downstream.

The Bottom Line on Context Mode

Context Mode is the first tool I’ve seen that treats context as a system to be managed — not just a pipe to be compressed. The 98% reduction on tool outputs is real. The session persistence closes a gap nobody else has addressed. The “code thinking” paradigm shift? That’s the part that still has me thinking about how I interact with agents differently.

Is it for everyone? No. If you’re not pushing your agent to its context limits, you might not feel the pain yet. But if you are — if you’ve watched tokens vaporize on irrelevant output, if you’ve restarted a session and lost your place, if you’ve burned $200 and wondered where it went — Context Mode is the piece that’s been missing.

Run it alongside Headroom for the full picture. Passive compression from Headroom, active management from Context Mode. Together, they cover the entire context problem.

And that’s a first.