McKinsey: 30% of Firms Lose Productivity With Agentic AI. Why?

Agentic AI spend is climbing while output flatlines. The usual culprit isn't the model — it's how much irrelevant code the agent reads before it does anything useful.

A recent McKinsey report found that productivity actually fell in 30% of companies deploying agentic AI. Not plateaued. Fell. Meanwhile budgets for those same tools keep climbing.

The most telling data point isn’t from McKinsey at all. One study of AI-assisted teams measured a 180% jump in coding activity against just a 30% increase in shipped releases. More commits, more branches, more diffs, roughly the same amount of product reaching customers.

The Paradox of Agentic AI: Soaring Spend, Stagnant Results

McKinsey’s surprising findings on AI adoption

The uncomfortable part of the McKinsey number is that these are not failed pilots. These are companies that bought the tools, rolled them out, and measured the result — and the result was negative. Spend went up, output went sideways or down.

That pattern shows up in finance reviews before it shows up in engineering retros. An agent API line item that was $800 last quarter is $6,000 this quarter, and nobody can point to the feature it bought.

Why more code doesn’t equal more shipped product

A 180% increase in coding activity with a 30% increase in releases means the extra work is being absorbed somewhere. It gets absorbed in review queues, in rework, in the half-finished attempts a developer abandons because the agent wandered into the wrong module.

Generated code is cheap to produce and expensive to verify. When production outpaces verification capacity, the bottleneck just moves to your senior engineers, who are now the most expensive code reviewers in the company.

The developer trust gap is a business problem

Once a developer has watched an agent confidently patch the wrong service twice, they stop delegating the tasks where the agent would have saved real time. They keep using it for boilerplate and stop using it for anything structural.

That is the quiet killer of ROI. You are paying platform pricing for autocomplete, and the trust curve for AI coding agents only goes down from there unless something changes in how the agent gets its information.

The Root Cause: Your AI Agent’s ‘Context Diet’ Is Bloated

Defining the cost-per-task of an AI agent

Every agentic task has a unit cost: input tokens, output tokens, and the number of round trips before the agent produces a usable diff. Input tokens dominate, because the agent re-reads context on nearly every step.

Think of it as cost-per-task rather than cost-per-seat. A task that takes 14 tool calls and 300,000 input tokens costs several dollars. Multiply by a few hundred tasks a week across the team and you have your surprise invoice.

How naive context retrieval drives up token consumption

Without a map of the repository, an agent does what you would do on your first day: grep for a string, open whatever comes back, open the neighbors, and keep going. On a large monorepo that means reading dozens of files to find the four that matter.

The agent isn’t being wasteful on purpose. It genuinely does not know which of your 3,000 files touch the function it was asked to change, so it guesses broadly and pays for the guess in tokens.

The high price of asking an LLM to find a needle in a haystack

Long, noisy context also degrades output quality. Bury the relevant file among twenty irrelevant ones and the model’s attention gets split; you get plausible code written against the wrong interface.

So you pay three times: a bigger bill, slower turnaround, and a diff your engineer has to unpick. The cost driver and the accuracy driver are the same variable.

Code Intelligence: The Missing Link for Agentic ROI

Moving from keyword search to dependency awareness

Keyword and vector search answer “what looks similar to this?” Dependency analysis answers “what actually breaks if I change this?” Those are different questions, and agents almost always need the second one.

JetBrains made this the centerpiece of its recent “Air” announcement — deterministic code intelligence as the layer underneath the agent, not a nicer prompt on top of it. When a tools vendor with decades of static analysis rebuilds around that idea, it is worth noticing.

What is a code graph and why does it matter for AI?

A code graph maps real relationships: imports, calls, type references, module boundaries. Ask it for the context needed to change a function and it returns the files that are genuinely connected, not the files that happened to share vocabulary. Here’s what is a code graph in more detail.

The output is deterministic. The same question returns the same file set every time, which matters when you’re trying to explain a cost number to a CFO.

Making agents cheaper, faster, and more accurate

Hand the agent four relevant files instead of forty and three things move at once: the input token count drops, the number of exploratory tool calls drops, and the model stops hallucinating interfaces it never actually read.

How Coograph Delivers Actionable Code Intelligence

Reducing token costs with a reproducible benchmark

Coograph builds a dependency graph of your repository and serves the agent only the files that task requires. On the committed benchmark, that cuts input tokens by a median of 67.9%.

Run the illustrative arithmetic. Suppose a 25-engineer team spends about $200 per engineer per month on agent APIs, so $5,000 a month. A 67.9% reduction in input tokens brings the input-driven portion to roughly $1,600 — call it $40,000 a year, from a configuration change rather than a headcount change.

Fewer tool calls means faster task completion

The same benchmark shows a median 2.75x reduction in tool calls. That is the latency number, and latency is what determines whether a developer waits for the agent or switches tabs and loses the thread.

An agent that answers in 40 seconds instead of two minutes gets used for real work. That behavioral shift is worth more than the token savings, though it is harder to put on an invoice.

An open-source foundation for your AI strategy

Coograph is MIT-licensed and works with the tools your team already uses — Claude Code, Cursor, VS Code Copilot, Aider. You are not betting your context layer on a single vendor’s roadmap.

The Build-vs-Buy Decision for Your Code Intelligence Layer

The engineering cost of a homegrown solution

Plenty of teams start building this. It looks like a two-week project until you hit incremental re-indexing, monorepo scale, and four more languages than you planned for.

Illustratively: two strong engineers for two quarters, at roughly $200,000 fully loaded per engineer per year, is about $200,000 of payroll — plus the opportunity cost of whatever those two would have shipped instead. Then you own it forever, including the day a language server upgrade breaks parsing.

De-risking your AI investment with an open-source core

The MIT license is the risk answer. You can read the code, fork it, run it in your own infrastructure, and you are not exposed to a pricing change on a component that sits in the critical path of every agent task.

Getting the benefits of agentic AI without the budget overruns

If your agent spend is growing faster than your shipped output, start by measuring cost-per-task rather than negotiating seat pricing. Teams that need SSO, hosted indexing, and support get that from Coograph Pro; everyone else should clone the repo, follow getting started, and compare token counts on a real ticket before and after.