ActiveContext sits between your agent and the model and actively manages session history and context. Your agents stay focused and avoid compaction. 20–70% savings and increased performance.
They fail because the context fills up with noise — old tool calls, stale file reads, abandoned reasoning — and the model stops paying attention to what matters now. Then compaction hits and your agent totally goes off the rails.
ActiveContext prunes dead context between tasks, preserves what's still driving decisions, and hands the model a clean working set every time. Same model. Better outcomes. One environment variable to install.
Agent loops are stuck with an append-only design. What was added 35 turns ago becomes completely irrelevant to the current goal. With task aware history restructuring, we ensure the LLM is given the most relevant context.
Encoder compression and cheap-model summarization strip out what the agent needed and leave in what it didn't. Past attempts have been one-shot and task-blind. The agent loses the thread.
ActiveContext is dual-core. A second intelligence layer reads the session as it unfolds, identifies what your primary agent is actually trying to accomplish, and curates context around that goal. When a task completes and the next one begins, we restore exactly the context the new task needs.
It's not compression. It's understanding.
ActiveContext works best with providers that offer explicit prompt caching — Anthropic and Alibaba Cloud today. Because we control where the cache breakpoints land, we maintain a very high cache hit ratio despite history restructuring. If your session pauses for 5 minutes? Cache falls off anyway and we take advantage of the free opportunity to curate. That's a meaningful chunk of the savings.
Our curator core adds inference of its own. Those calls run async between turns, use short prompts on optimized models, and never block your agent. Net: no noticeable latency, and the savings on your primary model dwarf the cost of the curator driving them.
Every agent uses context differently. A coding agent, a research agent, an open-ended exploratory agent — each one needs context managed differently to perform its best.
ActiveContext puts you in control. Tune the aggressiveness per agent, per model, per workflow. See exactly where your tokens are going through built-in analytics — which sessions, which agents, which patterns are driving spend.
The defaults are good. When you know your workload, you decide how it runs.
See how much ActiveContext can save over long sessions
Every long session, every redundant file read, every blown-out context window — that's revenue on their side and a bill on yours. They aren't incentivized to make your agent more token-efficient. They're incentivized to charge you for the compaction event that erased the work you already paid them to do.
ActiveContext is built by people who don't supply tokens. We sit on your side of the meter.
Every claim here is reproducible. Full methodology and code published.
Read the full report →Short single-turn requests. Tightly scoped RAG. Workflows that don't accumulate tool history. We publish those too.
Your best engineer figures out a prompt pattern. Someone else cracks a tricky tool sequence. A third teammate finds the rule that keeps the agent from going off the rails. Today, none of that propagates.
ActiveContext surfaces what's working across your team's sessions so managers can see how their developers are actually using agents, learn what's driving results, and roll out shared rules every teammate runs against — consistently, every session.
Swap models without changing code. Mix providers in the same workflow.
Every session is logged. Every dollar of savings is calculated against what your provider would have charged for the same work. You see the math.
One line in your environment. The rest of your stack stays the same.