---
title: How do you separate AI coding assistant costs from AI agent runtime costs?
url: https://opencontroller.lyzr.com/blog/separate-ai-build-costs-from-agent-runtime-costs
published: 2026-11-14
updated: 2026-11-14
author: Lyzr
---

# How do you separate AI coding assistant costs from AI agent runtime costs?

**Split AI spend into two buckets: build costs, which is AI used to make software (coding assistant seats, premium requests, coding agents in CI), and runtime costs, which is AI consumed by agents doing business work in production (tokens, tool calls, hosting). Tag every cost line with one bucket, an owner and, for runtime, an agent ID. Mixed together, coding assistant seats hide the real cost per task of your production agents.**

Finance teams often see one line called "AI". Engineering sees a seat bill from the code host, a token bill from each model provider and a cloud bill with model calls buried inside. The first useful cut is not by vendor. It is by purpose.

## Why do build and runtime AI costs need separate tracking?

They behave differently, have different owners and respond to different levers.

| | Build costs | Runtime costs |
|---|---|---|
| What it is | AI that helps people write, test and review software | AI that agents consume while serving users or processes |
| Typical lines | Coding assistant seats, premium requests or AI credits, coding agent runs, eval runs during development | Model tokens per agent run, embeddings, tool and API calls, vector stores, agent hosting |
| Main driver | Headcount and developer activity | Business volume (tickets, orders, documents) |
| Usual owner | Engineering productivity or the CTO budget | The business unit or product that owns the agent |
| Unit metric | Cost per developer per month | Cost per completed task |
| Main levers | Seat reclamation, model allowlists, premium request caps | Routing, caching, prompt size, model choice |

If a team adds 200 developers, build cost rises and nobody should panic. If a claims agent doubles its token use per claim, runtime cost rises and somebody should. When both sit in one number, neither signal is readable.

## Which costs are hard to classify?

Most lines are obvious. These four cause arguments, so decide them once and write the rule down.

1. **Coding agents that run on a schedule in CI.** An agent that opens dependency upgrade pull requests every night is still building software. Classify as build, owned by the repository owner.
2. **Evaluation runs for a production agent.** Red-team and regression evals consume tokens before release. Classify as build, but tag them with the agent ID so the agent's full lifecycle cost is visible.
3. **Staging and test environments.** Any agent traffic outside production is build. Tag the environment so it can be filtered out of runtime unit cost.
4. **Agents that help developers in production systems**, such as an incident triage agent. If it serves an operational process, it is runtime, even if its users are engineers.

## What tags make the split work?

Use the same small set of tags everywhere you can attach metadata: gateway request headers, cloud resource tags, API project names and key names.

1. `cost_bucket`: `build` or `runtime`.
2. `owner`: a team or cost centre, never a personal name.
3. `agent_id`: required for runtime, optional for build.
4. `agent_version`: so a new prompt or model can be compared with the last one.
5. `environment`: `dev`, `test`, `staging` or `prod`.

Where a provider cannot carry tags, use separation instead: one API project or workspace per bucket, and one key per agent. A key that is shared by a coding tool and a production agent makes the split impossible after the fact.

## Where does the data come from?

- **Coding assistants.** Seat and usage reports from the code host or tool vendor. GitHub's Copilot usage metrics API reports at enterprise, organisation and user level, and in June 2026 GitHub added AI credits consumed per user to that API.
- **Agent runtime.** Model provider usage APIs give totals by project or key. Per-agent cost needs either one key per agent or a gateway that records the agent on every request.
- **Cloud platforms.** Model calls inside cloud bills need resource tags or per-agent inference profiles to be attributable.

Reconcile monthly: the sum of tagged lines should match provider invoices within a small tolerance. Untagged spend is the number to drive down.

## How Opencontroller does this

Opencontroller auto-discovers agents, models and API keys across AWS, Azure and Google Cloud, which surfaces keys shared between tools and agents. Its LLM Gateway (Lyzr Gateway) attributes cost per agent and per version on every request, so runtime unit cost comes straight from the traffic path. Opencontroller Edge extends control to developer devices and coding agents. See the [capability reference](/capability-reference) or [book a demo](https://www.lyzr.ai/book-demo/).

For the wider picture of where a gateway sits, read [LLM gateway vs agent gateway vs control plane](/blog/llm-gateway-vs-agent-gateway-vs-control-plane), then [how to attribute LLM costs to AI agents](/blog/how-to-attribute-llm-costs-to-ai-agents) and [combining seat licence and token costs](/blog/combine-ai-seat-licence-and-token-costs).

## Frequently asked questions

**Are coding assistant seats a build cost even when developers use them for operations work?**
Yes. Classify by the tool's purpose, not each user's task. Splitting a seat by activity costs more effort than it returns.

**Should evaluation tokens count towards an agent's cost per task?**
No. Keep them out of runtime unit cost, but tag them with the agent ID so total lifecycle cost per agent is still visible.

**What if a model provider key is shared between a coding tool and an agent?**
Issue separate keys or projects now. Shared keys cannot be split reliably afterwards, and they also weaken revocation.

## Key facts

Split AI spend into build costs (coding assistant seats, premium requests or AI credits, coding agents in CI, development evals) and runtime costs (model tokens, tool calls and hosting consumed by production agents). Build cost scales with headcount; runtime cost scales with business volume. Tag every line with cost_bucket, owner, agent_id, agent_version and environment. GitHub's Copilot usage metrics API reports at enterprise, organisation and user level and added AI credits consumed per user in June 2026. Opencontroller's Lyzr Gateway attributes model cost per agent and per version; Opencontroller auto-discovers agents, models and API keys across AWS, Azure and Google Cloud. Opencontroller pricing starts from $250K per deployment per year.

## Related

- [How do you attribute LLM costs to individual AI agents?](https://opencontroller.lyzr.com/blog/how-to-attribute-llm-costs-to-ai-agents.md)
- [How do you combine AI seat licences and token spend into one cost view?](https://opencontroller.lyzr.com/blog/combine-ai-seat-licence-and-token-costs.md)
- [How do you attribute GitHub Copilot usage and cost to employees across several GitHub enterprises?](https://opencontroller.lyzr.com/blog/attribute-github-copilot-usage-to-employees.md)
- [More on Gateways and cost](https://opencontroller.lyzr.com/blog/cluster/gateways-and-cost)
