AI Coding Agents Write 30% More Code but Ship No More: Measure Cost per Resolved Issue at the Gateway

The number everyone shared this week

Between October 9 and 12, 2026, one chart travelled through every engineering Slack: AI coding agents make developers produce more code, and companies do not ship more software.

The source is a Harvard working paper by economists Fiona Chen and James Stratton, Artificial Intelligence in the Firm: Bottlenecks in Software Production. It pairs Jellyfish engineering telemetry with GitHub activity across more than 700 software companies and roughly 300 million work events, from 2021 through March 2026. According to the coverage of the paper:

• lines of code rose about 30% after coding-agent adoption
• commits rose about 20%, pull requests about 23%
• the resolution rate of Jira issues and completed epics, the authors' proxy for shipped features, did not change in a statistically significant way
• time from pull request submission to merge rose about 49%, revision requests nearly doubled, and comments per pull request rose about 35%
• by March 2026, 80% of firms ran AI code review tools, yet only 23% of review comments were AI-generated

Some outlets read the 49% as reviewers working harder; others, more carefully, as work waiting longer downstream. Either way the conclusion is the same: agents moved the constraint. Writing code got cheaper. Reviewing, integrating, and deciding did not.

Why most companies cannot see this in their own data

The study used years of telemetry from a specialised vendor. Most engineering organisations trying to answer the same question for themselves hit a wall within a day, because coding-agent traffic is invisible in the places that matter:

• It goes straight to providers. Terminal agents, IDE assistants, PR review bots, and CI agents each call a model provider directly, often with a shared team key or a personal card.
• It has no business context. A provider invoice says how many tokens a key used. It does not say which repository, which ticket, or which agent.
• It has no ceiling. An agent stuck in a fix-test-fix loop overnight spends until someone notices the invoice.
• It has tools. Agents now act on GitHub, Jira, and CI through MCP servers, with permissions that were scoped for humans.

You cannot compute cost per resolved issue if the cost has no issue attached. That is an infrastructure problem, and it has an infrastructure fix.

Step 1: route every coding agent through one gateway

Odock exposes native endpoints for the API shapes coding tools already speak, so the migration is a base URL and a key, not a rewrite:

• Anthropic Messages at https://api.odock.ai for Claude Code and Anthropic SDK based agents
• OpenAI Chat Completions and Responses at https://api.odock.ai/v1 for OpenAI-compatible CLIs, IDE extensions, and review bots
• Mistral, including Codestral fill-in-the-middle at /v1/mistral/fim/completions for autocomplete
• vLLM endpoints for self-hosted code models
• Gemini for Gemini-based tools

For Claude Code, that is three environment variables:

export ANTHROPIC_BASE_URL="https://api.odock.ai"
export ANTHROPIC_API_KEY="sk_dock_virtual_key_for_this_developer"
export ANTHROPIC_CUSTOM_HEADERS="x-repo: payments-api
x-ticket: PAY-1423"

Each developer, and each autonomous agent (the CI fixer, the PR reviewer, the dependency bot), gets its own virtual API key. Keys carry their owner, team, model grants, MCP grants, budgets, and quotas. Provider keys stay encrypted inside Odock and never reach a laptop.

Step 2: put budgets where the loops are

Coding agents are the clearest case of the agent cost paradox. Gartner warned in August 2026 that inference costs for agentic workflows will rise more than fivefold in two years even as token prices fall, because agents use 5 to 30 times more tokens than chatbots for equivalent tasks.

In Odock, budgets apply to an organisation, team, user, or API key, and they are enforced before the upstream call: the gateway estimates the cost, reserves it against every matching budget, and only then calls the provider. When a window is exhausted the agent receives 402 budget_exceeded, not a surprise on next month's invoice. Quotas do the same for request and token counts.

Two practical rules:

• Budget teams, not individuals. A team budget with per-key sub-limits for autonomous agents stops runaway loops without making developers ask for permission to work.
• Give autonomous agents their own keys and lower ceilings. A CI agent that retries a failing build forever is a different risk from a developer pairing with Claude Code.

For agents that run unattended, add Odock's built-in Agent identity and loop ceiling flow template. It requires x-odock-agent-id and x-odock-agent-iteration headers and stops an agent that exceeds a set number of turns, before it spends more tokens.

Step 3: tag every request with the work it serves

Here is the piece that makes cost per resolved issue possible. The developer's tool sends x-repo and x-ticket headers (or your wrapper script derives them from the branch name). A small Flow Studio flow does the rest:

• Pre-route: a Transform node copies the headers into request metadata, so they travel with the request evidence.
• Post-response: a Get Response Value node reads token usage, and a Send Webhook node posts key, team, model, tokens, status, repository, and ticket to your warehouse. Post-response runs asynchronously by default, so it adds no latency for the developer.

version: 1
name: Tag coding traffic with repo and ticket
on_error: continue
phases:
  pre_route:
    nodes:
      - {id: start, type: start}
      - id: tag
        type: transform
        config:
          target: request
          operations:
            - {op: set, path: metadata.repo, value: "{{request.headers.x-repo}}"}
            - {op: set, path: metadata.ticket, value: "{{request.headers.x-ticket}}"}
      - {id: end, type: end}
    edges:
      - {from: start, to: tag}
      - {from: tag, to: end}
  post_response:
    nodes:
      - {id: start, type: start}
      - {id: usage, type: response_get, config: {path: body.usage, var: usage}}
      - id: export
        type: webhook_send
        config:
          url: https://warehouse.example.com/hooks/ai-coding-usage
          payload:
            api_key_id: "{{request.api_key_id}}"
            model: "{{request.model}}"
            status: "{{response.status}}"
            usage: "{{vars.usage}}"
            repo: "{{request.headers.x-repo}}"
            ticket: "{{request.headers.x-ticket}}"
            at: "{{now}}"
      - {id: end, type: end}
    edges:
      - {from: start, to: usage}
      - {from: usage, to: export}
      - {from: export, to: end}

Odock's usage records already hold the principal (organisation, team, user, key), provider, model, status, latency, tokens, cost, routing trace, and plugin and safety outcomes for every call, without storing prompts or completions. The flow adds the business key you need to join it with Jira and GitHub.

Step 4: measure outcomes, not output

With spend tagged by ticket, the warehouse join is straightforward. The metrics worth putting on a dashboard are the ones the Harvard paper says actually move, or do not:

Lines of code and number of PRs belong nowhere near this dashboard. The study's whole point is that they rise while outcomes stay flat.

Step 5: spend the savings on the real bottleneck

If review is the constraint, two things follow.

Route generation to the cheapest tier that works. Odock routing lets a key define candidates, strategies, and failover, and a pre-route flow can downgrade boilerplate-shaped requests to a smaller model. A decision model such as Jev, called from Flow Studio, can classify requests as simple or complex in about 100 ms. See our article on Jev and Flow Studio.

Measure AI review as its own workload. Give PR review bots their own virtual keys and budgets. If 80% of firms run AI review but only 23% of comments come from it, you want to know what that spend buys: comments accepted, defects caught, review time saved.

Step 6: do not let agents remove the bottleneck by removing review

There is a dangerous shortcut to "fixing" merge time: let agents merge. With MCP servers for GitHub and CI in every agent's toolset, that shortcut is one tool call away.

Odock governs MCP traffic per key:

• Access grants decide which keys may call the GitHub or CI MCP server at all.
• Allowed tools keep coding agents on the work they should do: read issues, read files, create branches, open pull requests, comment.
• Blocked tools keep the irreversible actions with humans: merge, force-push, delete branch, change repository settings or secrets.
• Semantic filters inspect tool-call payloads before execution.
• Upstream auth injection keeps the GitHub token in Odock, so it never appears in an agent's environment.
• MCP usage records attribute every tool call to key, server, tool, status, and cost.

For actions that are sometimes legitimate, such as an agent merging a dependency update in a low-risk repository, use the built-in MCP external approval gate flow template: it calls your policy service before destructive tools and fails closed when approval is denied or unavailable.

What engineering leaders should do this quarter

• Inventory every coding tool and agent that calls a model provider directly, including CI.
• Issue a virtual key per developer and per autonomous agent; revoke shared provider keys.
• Set team budgets with lower ceilings for unattended agents; enable the loop ceiling template.
• Add repository and ticket headers to agent configurations and deploy the tagging flow.
• Join the export with Jira and GitHub and publish cost per resolved issue, not lines of code.
• Lock the GitHub MCP server down to read, branch, and open-PR tools; route merges through humans or an approval gate.

The Harvard result is not an argument against coding agents. It is an argument against running them as unmanaged, unmeasured traffic. Once every request carries an identity, a budget, a ticket, and a record, you can see where agents create shipped value and where they only create more code to review.

Sources

• AI Weekly, Harvard Study: AI Coding Agents Lift Code 30%, Shipped Output Flat
• Tech Insider, AI Coding Agents Add 30% More Code, Not Software
• n8nlab, AI Coding Agents Add Code, Not Software Output, Study Finds
• Superpower Daily, AI coding agents boosted code output without clear task completion gains
• Computerworld, AI inference is getting cheaper, but your agents are getting more expensive, August 17, 2026
• Odock native model endpoints
• Odock budgets
• Odock usage records
• Odock MCP security