Tejas Chopra: how Headroom cuts AI agent token costs

Interview by Tim Mitchell.

Every long agent session leaves behind a token trail nobody asked for: restated file contents, duplicate tool outputs, an entire log file read end to end for the one line that mattered. Tejas Chopra found that trail while burning through his own API credits on side projects.

Six months later, the compression layer he built to fix it has become one of the fastest-growing tools in agentic AI.

Headroom picked up a mention in The Register in June 2026 and gained enough momentum to pull Chopra out of Netflix and into building Headroom Labs full time. The pitch is simple to state and hard to build: compress an agent's context aggressively, but keep the original in reserve so the model can always ask for it back.

Before the full conversation:

The origin: built out of frustration with his own token bills while running Claude and Codex side projects on a personal API key.
The mechanism: reversible compression, meaning the model gets a compressed context plus a tool call it can use to retrieve the original if the compression left something out.
The moment: a Register writeup landed in the same week GitHub Copilot's pricing change pushed some users from around $1,000 to $4,000 for the same usage, spiking token cost anxiety right when Headroom got visibility.
The scale: somewhere between 200 and 300 billion tokens saved by Chopra's own count, a number he stopped tracking once usage took off, because Headroom runs entirely on the user's machine by design.

We spoke with Tejas about how reversible compression actually holds up under load, where it has failed in production, and what he is building next for a world where agents hand context to other agents instead of writing it all down first.

Where Headroom came from

Tim Mitchell: "For people who haven't come across Headroom, what was the origin here? Was there a specific moment you thought "context needs a compression layer," or did it build up gradually?"

Tejas Chopra: "I run a lot of side projects on my own API key, and I kept burning through my subscription tokens and falling back to pay-as-you-go. That's when I started looking at where the tokens were actually going. I use Claude primarily, and Codex, and their dashboards will tell you that you spent X dollars in a session, but they don't tell you what drove it. Was the prompt bad? Was the data I queried too large? None of that was visible.

The moment it really broke was asking a GPU usage question against a log file and running out of context window within two questions. One line in that log file mattered. Why did the model need to read the whole thing? That's where it started. I built a way to intercept traffic between Claude Code and the Claude models, which turned out to be a genuinely hard proxy to build, but once I had it, I could see how much was flowing through that had nothing to do with what I'd actually asked.

That first version only worked for API keys. Most people run on subscription-based Claude, which uses a different endpoint, so I had to build separate paths for API keys, subscriptions, streaming, non-streaming, Vertex, and Bedrock. Even for one provider, that's a lot of combinations, and everyone's setup is a little different. Headroom started as a way to collapse all of that into one integration layer.

It began as my own Claude problem and expanded into Codex, then into other people who wanted the same compression approach. The hard part was proving accuracy, because LLMs are non-deterministic. The core idea that separates Headroom from most of what's out there is reversible compression: we compress the context but keep the original in reserve, and we tell the model, if you need the source, here's the tool call to get it. In the overwhelming majority of cases the model asks for that source rarely. But the option is always there, and that's what lets us stand behind accuracy. Most compressors on the market are lossy. They strip data and give you a way back to it only when you rebuild it yourself. We integrate directly into the Claude Code and Codex harness itself, and getting that integration right takes more engineering effort than the compression logic does."

The traction spike

Tim Mitchell: "You started building this last December, so six or seven months ago. The last few weeks in particular have been a real moment of recognition. What changed?"

Tejas Chopra: "Honestly, fundamentally little changed on our end. Most of the core product was built five months ago. I've spent the time since fixing bugs. It took off because several things landed in the same week: The Register wrote about us, and within three or four days, GitHub Copilot changed its pricing model and people went from paying around $1,000 to $4,000 for the same usage. Token cost anxiety spiked at exactly the moment we got visibility, and that combination is what drove it.

Stars and adoption are still growing, but we genuinely don't know by how much, because we don't track any usage metrics. Headroom runs entirely locally, by design. Before this wave hit, we'd measured somewhere between 200 and 300 billion tokens saved. Since then, we haven't checked. It could be a trillion tokens saved, it could be less. We want people to trust that it's running on their own machine, so we skip collecting data through the open-source product entirely.

The reason we open-sourced it goes back to the mission: making AI sustainable and scalable for a future where 100 million agents might be operating on data concurrently. Getting there means increasing the amount of intelligence per token. Compression is one lever. We're working on others."

Tim Mitchell: "And the plan from here? Staying open source, or is there a company forming around this?"

Tejas Chopra: "I've started Headroom Labs and left Netflix to build this full time. We're extending Headroom for enterprise use cases and are already in conversations with a few enterprises. I have a CTO with me, also ex-Netflix, and a group of open-source contributors, some of whom we're planning to bring on full time.

We've also raised a small pre-seed round, which we're announcing this week.

I'm excited and scared in equal measure, which is a good sign. This is why you pick a profession like this: you want to wake up wanting to do the work, and get paid for it. I'm chasing my own version of IKIGAI, like everyone else."

Reversible compression, and why the eval matters

Tim Mitchell: "The architecture is interesting, and reversible compression feels like the hardest part of the promise to keep. How do you guarantee an agent can always get back to the original data without defeating the point of compressing it in the first place?"

Tejas Chopra: "That's the right question, and it's why we're working with a few companies on a neutral eval and benchmark strategy for compression and token intelligence more broadly. Models are aggressive about using tool calls when you give them one, so the mechanic is: compress the data, and leave a marker in the compressed text saying, if this isn't enough, here's the tool call to get the original. In about 99% of cases, the model answers from the compressed context and skips the tool call entirely. When it does need the original, that's one extra hop and some extra tokens, but the expectation is that it amortizes across a session.

A concrete example: Snowflake's inference lead tested Headroom against Cortex Cocoa, their agent platform, for data queries, and saw 65 to 70% token compression, in some cases up to 90%, while getting back the same data. Data-intensive pipelines tend to see the biggest gains from Headroom, often without the model ever needing to invoke reversibility. But we still think a proper eval and benchmark is the right way to prove that out, which is what we're building with a few enterprises and companies working on token and context intelligence."

Where compression has actually broken things

Tim Mitchell: "What's the worst failure mode you've seen, a case where compression cost correctness instead of just saving tokens?"

Tejas Chopra: "We've seen it with some of the non-reversible techniques we ship as defaults, like RTK and LeanCTX. They've dropped tokens the model actually needed, forcing it to retry the same command with those techniques turned off. So you've compressed the turn, but if it now takes two turns to do what one turn used to do, the net saving is close to zero. That's rare, but it's the worst case we've hit.

The bigger, more constant challenge is that if Claude changes its response structure for any reason, we have to adapt our integration to match. That's an integration tax we're happy to carry, because it keeps things simple on the user's end, and at least those failures fail fast and visibly."

What's hiding in the model's output

Tim Mitchell: "The output-side reduction is a newer addition. What surprised you about what's actually sitting in model outputs?"

Tejas Chopra: "Output tokens are billed at roughly five times the rate of input tokens, so a dial on the output side is worth more than the equivalent dial on the input side. Right now, the only real lever is the system prompt, telling the model directly to keep it brief. But developers differ a lot: some want an explanation, some want it crisp, some skip reading the model's prose entirely. That mismatch is a hidden cost that nobody's pricing in.

What we do is learn a developer's style from their own conversation history and use that to tune how the model responds, which should unlock better savings without every engineer having to hand-tune their own prompt.

This overlaps with a couple of other open-source tools working the same problem, including Caveman and a newer one called Ponytail. Since Headroom, Caveman, and Ponytail are all open source, the plan is to see which pieces are best in their category and stitch the best of them together under one context-intelligence harness inside Headroom."

The roadmap: from single agents to millions of them

Tim Mitchell: "Looking ahead, what's the roadmap for Headroom, and what are you most excited about?"

Tejas Chopra: "Headroom today solves the problem for agents running on your laptop. The next problem is agent-to-agent context transfer. Right now, if one agent needs to hand context to another, the first agent has to use an LLM call to write it out to a markdown file, and the second agent has to use another LLM call to read and interpret that file before it can act.

With more agents in the loop, everyone ends up burning a model call just to understand context they could have exchanged directly. Markdown is also lossy: it's flat text, and it only captures a fraction of what the first agent actually understood.

We're building a context exchange protocol to solve that with a richer interface between agents, and extending it to enterprises running many agents against their data. That's the split going forward: Headroom, the open-source project, keeps its own roadmap and stays free for individual developers, because staying open source is core to the sustainability mission. Headroom Labs is the broader bet, currently in stealth, building infrastructure for a future where many agents are operating on and mutating data concurrently, approached from an enterprise angle. Over time we expect to open source more from Headroom Labs too, including work on observability and data mutation."

What this means for your own agent stack

Tejas' numbers are self-reported and the eval work he mentions is still in progress, so treat the compression percentages as a starting point rather than a benchmark you can cite blind.

What's harder to dispute is the shape of the problem: token bills are becoming a line item people actually scrutinize, and most teams still have limited visibility into what's driving theirs.

A few things worth taking from this conversation into your own setup:

Check your reversibility story before you compress anything. Lossy compression that drops a needed token still costs you a retry, and a retry can erase the saving entirely.
Output tokens deserve as much attention as input tokens. At roughly five times the cost, a verbose system prompt is a more expensive habit than a bloated context window.
Agent-to-agent handoffs are the next bottleneck. If your architecture already routes context through markdown files between agents, that's the pattern Chopra is building an alternative to.

Headroom stays free and open source for individual developers. Headroom Labs, still in stealth, is where the enterprise version of this problem gets solved next, and Tejas' roadmap suggests context exchange between agents will matter as much as compression did in this first act. Find Tejas Chopra on LinkedIn.

Q&A: How Headroom went from side project to enterprise infrastructure.