The demo looked perfect. A software engineering agent, powered by Claude, working through a GitHub issue—reading code, running tests, proposing a fix. Then it looped. Same dead-end reasoning, five times in a row, burning through tokens like a taxi with the meter running and nowhere to go.
This isn't an edge case anymore. It's the central problem facing companies trying to move AI agents from proof-of-concept to production in 2026, and it's one that better prompts alone won't fix. Gartner projected in June 2025 that more than 40% of agentic AI projects would be canceled by the end of 2027, undone by runaway costs, murky ROI, and inadequate risk controls. Six months in, that forecast is looking less like pessimism and more like pattern recognition.
The paradox is that spending hasn't slowed. AI infrastructure investment is barreling toward $2.59 trillion in 2026, up 47% year-over-year by Gartner's count. But deployment? As of April, just 17% of organizations had actually put agents into production, even though more than 60% say they plan to within two years. That gap—between boardroom enthusiasm and operational reality—has created an opening for a new breed of startups building what they call the "runtime layer," infrastructure designed to catch and correct agent failures as they happen, not in post-mortems.
The Enterprise Pilot Graveyard
Most companies running agents in 2026 remain stuck in what one investor described as "extended pilot purgatory." The blockers are predictable: trust, security, governance. Industry observers from April through June noted a recurring pattern—impressive demos, then long pilots, then deployment stalls when the costs become clear or the agent's reasoning unravels in ways no one anticipated.
The big model providers saw this coming, or at least saw an opportunity. Anthropic launched Claude Managed Agents on April 8, offering what amounts to a hardened runtime: sandboxed code execution, checkpointing, credential management, scoped permissions. Early customers include Notion, Rakuten, Asana, and Sentry. OpenAI countered a week later with the next evolution of its Agents SDK—native sandboxes, a standardized AGENTS.md spec, and new primitives for managing sessions. By June, Microsoft's Foundry Agent Service, AWS's AgentCore, and Google's Vertex Agent Engine had all reached general availability, each racing to own the managed runtime layer.
Yet managed platforms solve orchestration and security. They don't necessarily make individual agent runs smarter or cheaper, and that's where the real friction lives.
The Token Economics Problem
Agents fail in ways that static evaluations don't catch. They loop, second-guess themselves, carry stale tool outputs through dozens of reasoning steps. Traditional prompt compression techniques—semantic pruning, methods like LLMLingua-2—can shrink context windows but don't address the structural waste baked into how agents reason through multi-turn tasks.
Token pricing makes this painful. OpenAI, as of mid-June, charges $5 per million input tokens and $30 per million output tokens for GPT-5.5. Anthropic's May 27 pricing for Claude 3.7 Sonnet includes cache incentives that reward efficiency but penalize bloat. When GitHub Copilot switched to usage-based billing on June 1, some engineering teams experienced what industry watchers called "AI sticker shock"—suddenly visible costs for long agent sessions that had been bundled into flat subscriptions.
Regulatory pressure is converging on a similar timeline. The EU AI Act, which entered force in August 2024, saw key obligations for general-purpose AI providers take effect this past August. A June executive order from the White House emphasized restrictions on unlawful AI agent use, framing runtime controls as a national security issue. NIST's April concept note on an AI Risk Management Framework for critical infrastructure underscored the shift from static guardrails to execution-time policies.
The benchmarking infrastructure itself is cracking under pressure. OpenAI retired SWE-bench Verified on February 23, citing saturation and contamination—models were memorizing solutions. The industry pivoted to SWE-bench Pro, launched by Scale AI last September, which proved harder to game but still reports top-model scores below 25% on initial attempts. Static benchmarks, it turns out, are poor predictors of how agents behave in production, where variance and multi-turn complexity dominate.
The Runtime Intelligence Bet
Enter a cohort of startups betting that many agent failures are fixable in real time if you instrument the loop itself. ReasonBlocks, a two-person team out of Y Combinator's Spring 2026 batch, exemplifies the pitch. The San Francisco outfit launched around April with what sounds more like middleware than traditional observability: a runtime layer that corrects agent reasoning mid-run, compresses low-value context, and builds a private library of reusable reasoning patterns from successful traces.
The company's marketing claims are aggressive—42% accuracy gains and 52% token reductions on SWE-bench Pro across 75 problems using Claude Sonnet 4.6, with 70% fewer budget cap hits. A technical whitepaper (version 2.0, published in mid-June) details a pattern library built from more than 190,000 distilled traces, evaluated on a curated subset of the now-retired SWE-bench Verified. It reports model-specific lifts under a "high-confidence gate": Haiku improving from 60% to 75% accuracy, Sonnet from 75% to 80%, Opus from 70% to 90%. Token savings range from 21% to 25%, spiking as high as 62% in some runs.
There's a discrepancy worth noting. The marketing highlights Pro benchmarks; the whitepaper methodology references Verified, which OpenAI discontinued in February. That's not unusual for early-stage companies iterating between benchmark versions—but it illustrates the challenge of establishing credible performance metrics when the goalposts keep moving.
ReasonBlocks' SDK integrates with several popular AI frameworks including LangChain and tools by OpenAI and Anthropic (Claude), exposing monitors that flag loops, duplicate work, and second-guessing. The system injects corrections mid-run and uses what the documentation calls "reasoning-aware compression"—stripping out stale tool outputs and redundant context while preserving the logic chains that matter. A "reasoning reuse" component builds distilled patterns (situation, dead-end, unlock) into a customer-controlled library that gets injected into future runs.
Founders Sajeev Magesh (CEO, ex-Stanford CS) and Rohan Vij (ex-CMU) position the tool for teams running production agents in high-stakes domains: legal, finance, healthcare, security, software engineering. No seed round beyond YC backing had been announced as of late June.
The broader observability and evaluation infrastructure has attracted far more capital. Braintrust raised an $80 million Series B in mid-February at around $800 million valuation, joining LangSmith, Arize Phoenix, and Patronus AI in the race to become "Datadog for AI agents." LangChain added context management and checkpointing primitives to its Deep Agents offering between January and March. Langfuse shipped code evaluators, MCP support, and CI/CD experiments in its May 31 update—all agent-first workflows.
Those platforms focus on post-run analysis and multi-run variance. ReasonBlocks and others in the runtime category are making a different bet: that the gap between "agent runs" and "agent runs well" is solvable with architectural patterns and execution-time intelligence, not just better prompts or bigger models.
The Next Question
The consensus from Gartner, Forrester, and IDC through mid-2026 is that enterprise enthusiasm for agents is real, but operational maturity lags badly. Forrester's 2026 predictions suggested 25% of planned AI spending could slip to 2027 as governance concerns outpace deployment readiness. IDC forecast $487 billion in AI infrastructure spending this year, up 53% year-over-year, calling it the start of a multi-year "AI supercycle."
What's murkier is where the value ultimately accrues. Model providers are racing to own the runtime with managed platforms and native SDK features—sandboxes, sessions, permissions, tracing. Hyperscalers are building framework-agnostic serverless runtimes with memory, policies, and evals baked in. Third-party observability vendors raised hundreds of millions in 2026 to instrument agent traces and taxonomize failures.
Startups building runtime correction and reasoning reuse are making a narrower wager: that the gap between running agents and running them reliably is an infrastructure problem, solvable with execution-time intelligence rather than incremental prompt tuning. If token compression, mid-run failure recovery, and pattern libraries become table stakes for production deployments, the runtime layer could be a wedge into deeper parts of the stack. If managed platforms absorb those capabilities—or if teams decide the added complexity isn't worth it—the window closes fast.
The migration from Verified to Pro benchmarks, and the research community's broader shift toward multi-run, variance-aware evaluations, suggests the industry is getting more sophisticated about what "works" actually means for agents. So does the move from flat subscriptions to metered, per-token or per-session pricing. Both trends favor infrastructure that makes agents predictably cheaper and more reliable—exactly the pitch runtime-layer startups are making.
Whether that infrastructure becomes a category or a feature set that gets subsumed is the next question. For now, with 40% of projects reportedly at risk of cancellation and billions in AI infrastructure spend searching for a home, there's room to try. Perhaps more room than the founders expected.
