# Why Is Token Waste Suddenly an Existential Problem for Agentic Coding?

According to the Blast Radius paper published on arXiv on August 7, 2026, agentic coding faces "growing problems of affordability and wasted tokens." The authors report that agents repeatedly re-read the same context — error logs, function definitions, conversation history — that has already been processed and resolved. This is not a minor inefficiency. OpenAI's API pricing page shows GPT-4o at $2.50 per million input tokens; a single agentic session that loops over 100,000 tokens of dead context 20 times burns $5 of pure waste.

This compounds across teams. A 10-developer organization running 50 agent sessions daily could be burning over $2,000 per month on tokens that produce zero new work. The paper's core claim is that this waste is predictable — an incoming prompt's "blast radius" through coupled context and code channels can be estimated before execution. I believe this prediction capability is the missing piece that turns context management from a reactive cleanup task into a proactive cost-control system.

# What Does NECROPHORESIS Actually Do Differently From Existing Context Pruning?

Current context management tools like LangChain's conversation summarization or Anthropic's context compaction delete or summarize old messages. The Blast Radius paper argues this is fundamentally broken — once context is summarized, the original detail is lost forever, and if the agent later needs that detail, it must either fail or re-fetch from scratch. NECROPHORESIS solves this by archiving dead context verbatim to a separate storage layer, with a pointer structure that allows instant retrieval.

The paper formalizes this as "reversible context eviction over a Polish context space," which provides a measurable foundation for when eviction is safe and when it must be deferred. The Polish space property ensures that the context structure is complete and compact — every evicted element has a defined resurrection path. This is a meaningful theoretical advance, but the practical impact is what matters: developers get the cost savings of aggressive pruning without the risk of permanent information loss. According to the authors, this reversibility is what makes aggressive eviction viable in production — without it, the risk of losing critical debugging context makes teams conservative and keeps costs high.

# Who Should Adopt This First, and What Are the Operational Tradeoffs?

The primary beneficiaries are teams running long-horizon agentic coding tasks — autonomous bug fixing, multi-file refactoring, and test generation. These workloads generate massive context churn where the same file contents and error messages recur across iterations. RDM, the paper's recurring transcript identifier, is specifically designed for this pattern: it detects when the same transcript appears repeatedly and buries it permanently, preventing the agent from re-processing it.

The tradeoff is architectural complexity. Teams must implement a separate archive store, maintain pointer integrity, and handle the latency of context resurrection when the agent actually needs archived data. For small scripts and single-shot prompts, the overhead is not worth it. The paper's Polish context space formulation gives teams a theoretical framework to determine when eviction is safe, but the implementation burden is real. According to the paper's math, the benefit scales with session length and repetition rate — short sessions see negligible gains, while long-running agents see 30-50% cost reductions.

# How Does This Shift the Competitive Landscape of AI Coding Tools?

OpenAI's Codex, GitHub Copilot, and Cursor all compete on model quality and context window size. Blast Radius's approach suggests this is the wrong metric. A 200K token context window that re-reads dead content 15 times is less efficient than a 32K window with intelligent eviction. The paper positions Blast Radius as a "memory management layer" — middleware that sits between the agent and the model, deciding what enters the context window.

I see this as a direct threat to the incumbents' pricing power. If a third-party layer can cut token consumption by 40%, then model API prices become less relevant — the effective cost per completed task drops regardless of the underlying model. This commoditizes the model layer and pushes value up the stack to the orchestration layer.

# What Should Engineering Teams Do Next?

First, instrument your agent sessions. Measure token consumption per completed task, not per prompt. If your agents are re-reading the same content repeatedly, Blast Radius's RDM concept directly applies. Second, prototype a simple archive layer: serialize evicted context to a key-value store with a hash of the content as the key, and implement a retrieval function that the agent can call when needed. This is a minimal version of NECROPHORESIS that you can build in a day.

Third, track the paper's authors and any follow-up work. If this gets productized by a startup, the adoption curve will be steep. According to the arXiv listing, the paper was published August 7, 2026 — this is very early, and the first movers who build on this concept will have a significant cost advantage.

# Predictions

1. OpenAI will ship a context management feature in Codex by Q3 2027 that resembles NECROPHORESIS's reversible eviction, in response to margin pressure from enterprise customers using third-party memory layers.
2. A dedicated startup will raise a Series A by Q2 2027 to commercialize Blast Radius-style memory management, targeting the top 100 AI-native development teams with a claimed 40% reduction in token spend.
3. By Q1 2028, at least 30% of enterprise agentic coding deployments will use some form of reversible context eviction, making it a standard architectural pattern rather than an experimental technique.