Per-run agent cost attribution for engineering teams

Once coding agents move from a few engineers' laptops to a whole team in the cloud, the finance question arrives fast: what are we spending, on what, and is it working?

Most teams can't answer it. Model usage sits on one invoice, seats on another, compute on a third, and none of them say which run produced which pull request. Per-run attribution fixes that.

What to attribute, per run

A useful record for every agent run has:

• Source: Slack, Linear, GitHub, GitLab, the dashboard, the API, or an automation.
• Person: who started it, or which automation did.
• Harness and model: Claude Code on one model, Codex on another, and the effort level.
• Credential: which plan or API key paid for the model usage.
• Compute: minutes the workspace was awake, and on what machine size.
• Tools: which skills and MCP servers the agent used.
• Outcome: the pull request it opened, and whether it merged.

With that, "cost per merged PR by source and agent" becomes a query instead of a guess.

Two bills, kept separate

Agent cost has two parts, and it's easier to reason about when they stay separate:

Compute. The machine the agent runs on. On Replicas this is billed per workspace minute by VM size, at $0.004, $0.008 or $0.016 a minute within your plan's included usage for small, large and ultra machines (higher after that), and a sleeping or archived workspace costs nothing. A 20-minute task on the default large size is about 16 cents of compute. Check replicas.dev/pricing for current rates.

Models. The tokens. When agents run on your own API keys or plans, this lands on your Anthropic, OpenAI, Bedrock or Foundry bill, where you already have usage reporting, budgets and committed-spend discounts.

Bundled pricing (where the vendor resells tokens inside credits or units) is simpler to buy, but harder to attribute: you see units consumed, not which model or which credential, and you can't apply your own provider discounts.

Why seats make attribution worse

Per-seat pricing charges for people, not work. A team where five engineers run agents constantly and twenty run them weekly pays the same per head for both groups, and the bill says nothing about which runs produced value. Usage-based compute with free seats lets you add everyone, then see who and what actually drives cost.

What good reporting looks like

Look for a platform that can show, without exporting to a spreadsheet:

• Minutes and token spend by source, person, agent, model and credential.
• Pull requests by source and engineer, so you can see which channels produce merged work.
• Usage by skills and MCP servers, so you know which integrations earn their keep.
• A way to put shared channels and automations on a team credential while individuals use their own.

Replicas attributes every minute to a source, a person, a harness, a model, the credential that paid for it, and the skills and MCP servers the agent used, and shows pull requests by source and engineer. That's a large part of why it scores well on governance for teams in the chooser.

A simple monthly review

1. Total compute minutes and model spend, split by team.
2. Cost per merged pull request, by source (Slack, Linear, automation) and by agent.
3. The ten most expensive runs: were they worth it, or did an agent loop?
4. Automations that run often but rarely merge: tune them or turn them off.
5. Engineers not using agents at all: is it access, environment setup or habit?

Do that for three months and you'll know which agents, models and workflows to standardise on, with numbers rather than anecdotes.