AI Coding Agents Query 50x More Than Humans and Generate 100x More Telemetry. Your Stack Wasn't Built for That.

Autonomous agents usually don't fail because they aren't smart enough. They fail because the evidence they needed got filtered, capped, or thrown out to keep the observability bill down.

Gartner predicts that over 40% of agentic AI implementations will be abandoned by 2027, pointing to compounding costs, unclear ROI, and operational risk as the main culprits.

Most leadership teams are watching their foundation model token fees closely. Meanwhile, a quieter crisis is building underneath production: the AI telemetry explosion.

As teams roll out coding agents like Claude Code and Cursor, developer throughput climbs by roughly 34% and total code shipped more than doubles (+210%). Shipping more code, faster, means more production incidents down the line. And when those incidents happen, AI coding agents go about debugging in a way that most observability stacks simply weren't built to handle.

01. The mechanics changed

The 50+ query loop: how autonomous agents break legacy stacks

The way debugging actually happens has changed quite a bit:

• Human telemetry pattern: A human SRE gets an alert, opens a dashboard, and runs 1 to 2 targeted queries to check a single hypothesis.
• Agentic telemetry pattern: A coding agent gets a prompt (something like "Why did checkout error rates spike at 14:20 UTC?") and immediately kicks off an automated loop of roughly 50 queries. It works through logs, traces spans across microservices, correlates metric anomalies, and checks security events across the whole estate, all on its own.

Two queries from a human barely shows up on your logging bill. But a fleet of agents running 50-query loops around the clock is enough to push telemetry volume past 1 TB a day, and that's becoming the norm rather than the exception.

Your observability platform was sized for people asking occasional questions. Now it's serving machines that never stop asking.

02. The failure mode nobody budgeted for

The data deficit: it's not the reasoning that fails, it's the evidence

Most conversations about agent reliability end up being about the model itself, which one reasons better, which one writes cleaner patches. In production, though, that's rarely what actually goes wrong. What usually goes wrong is a lot simpler: the agent asks for evidence that simply isn't there anymore.

And that's really the problem. A human engineer who opens a dashboard to an empty panel knows right away there isn't enough to go on. An LLM doesn't always draw that same line. Give it a thin, sampled, or cut-down set of telemetry, and it will often produce an answer anyway instead of flagging that the evidence is incomplete. That answer can come out sounding perfectly confident, even though it's built on very little.

Missing telemetry doesn't slow an agent down. It just makes it confidently wrong.

The research backs this up pretty clearly. Chroma's Context Rot study found that model performance isn't consistent across a context window: even one distractor is enough to knock down retrieval accuracy versus a clean baseline, and four distractors make it worse. Across every model family they tested, a focused ~300-token prompt beat the same model working from the full ~113k-token haystack. The report also found that GPT-family models showed the highest rates of hallucination, generating confident but incorrect responses when distractors were present.

A sampled log stream is basically the distractor problem playing out at production scale. Drop 90% of your events and you haven't just lost 90% of the signal, you've handed the agent a partial story that it will happily finish writing on its own.

03. The economics

The retention paradox and the latency wall

Faced with $250,000-a-month bills from legacy vendors like Datadog or Splunk, SRE teams end up forced to drop data, sample logs, or cap retention at 7 days just to keep costs under control.

The trouble is, this sets off a pretty destructive feedback loop:

• 3× more outages: Teams forced to prune data see a +243% increase in incidents per PR. Code ships faster than PR reviews can keep up with (+442% review time), production breaks more often, and the telemetry needed to diagnose the failure was already deleted weeks earlier to save money.
• Agent hallucinations: AI agents lean on historical context to spot regressions. Delete the 90-day-old logs and the agent has nothing to compare current runtime metrics against, so it either gets the root cause wrong or gets stuck in retry loops.
• The latency trap: Dump logs into a standard cloud data lake and a full-text sweep can take 15 to 60 minutes. In a 50-query loop, that's more than enough to stall the investigation out or time it out completely. Storage is only useful for detection if you can query it fast enough to actually act on what you find.

04. The substrate

CtrlB: a unified substrate for humans and agents

Scaling agentic engineering without hitting the cost and risk walls Gartner is warning about means decoupling compute from storage and making full-fidelity telemetry queryable instantly.

That's the idea behind CtrlB: the fastest data lake for AI, built as a unified observability and security substrate for both humans and agents. It was built for this workload specifically: telemetry arriving at agent volume, and queries arriving at agent frequency. A 50-query investigation against a petabyte-scale lake should feel like a handful of queries against a small one. That constraint shaped the architecture: keep everything, and keep all of it fast to query.

It sits directly on top of the open object storage you already own, whether that's AWS S3, Google Cloud Storage, or Azure Blob, and stores 100% of your telemetry in open Parquet format, so nothing gets sampled away before an agent even has the chance to ask about it.

Key technical architecture highlights

• Built-in AI insight engine: CtrlB's Insight Engine continuously analyzes incoming logs to surface patterns, anomalies, and emerging risks that would otherwise slip by unnoticed, things like HTTP 5xx spikes, bursts of authentication failures, or downstream dependency timeouts. Each insight comes with a severity level, impact score, affected dataset, sample logs, a likely-cause hypothesis, and an activity timeline. That gives engineers useful context mid-incident, helps surface recurring issues afterward, and can catch emerging anomalies before they escalate, all without teams having to hand-write an alert rule for every pattern.
• Native Model Context Protocol (MCP) server: Agents can query full telemetry directly from IDEs like Claude Code or Cursor using natural language, no dashboard hopping, no manual SQL, and no per-detection vendor tax.
• $0.20 per GB, charged once at ingest: That $0.20 is CtrlB's platform fee on data as it arrives, not rent on the bytes. The data itself sits as Parquet in your own S3, GCS, or Azure bucket, and you pay your cloud provider its normal object-storage rate to keep it there. Nothing is billed again for age, so moving from 7 days of retention to 365 costs you object storage and nothing else. Totals land up to 90% below what legacy tools charge for a fraction of the window.
• Two-level indexing (~0.6% index ratio): Rather than building massive, expensive indexes, CtrlB keeps the index ratio down around 0.6%. Queries fan out across serverless workers, so a full sweep over 125 TB of logs takes about a minute instead of an hour.

Cutting total telemetry costs by up to 90% while making queries up to 10x faster removes the choice teams keep being forced into: a bill finance will kill, or a retention window too short for the agents to reason over. What's left is a substrate you can scale autonomous agents on safely, quickly, and within budget.

An agent is only as good as the evidence you kept around. Keep all of it, and keep it queryable in seconds.

Sources & further reading

1. Gartner, Over 40% of Agentic AI Projects Will Be Canceled by End of 2027 escalating costs, unclear business value, inadequate risk controls.
2. Chroma, Context Rot: How Increasing Input Tokens Impacts LLM Performance accuracy degradation with distractors and long inputs.