Cost, Budgets & Auditing

A coding session is not a special case for governance. Every request the extension makes is a recorded invocation with its own token counts and cost, exactly like a message in a chat conversation — costed against the same per-model rates, counted in the same reports and stopped by the same budgets.

Nothing new needs to be switched on for this. If you already govern agents in AETHER, you already govern what your developers do in the editor.

Every request is recorded

Each turn of a coding task is one invocation: the extension sends the transcript, the agent answers, and the platform records the input and output tokens together with the cost derived from the agent's model rates. When the agent searches your knowledge base during a task, that search is recorded too, as embedding usage.

The rates come from the models directory, so a coding invocation is priced exactly as any other use of that model — see Configuring Models and Invocation Logs, Tokens & Cost.

Budgets stop a runaway task

Budgets are checked server-side, before every request, and the check walks the agent's whole chain: the agent's own budget, then its owner's, its team's, its business unit's and finally the organisation's. The organisation-level budget doubles as your prepaid credit, so exhausting it stops every agent at once.

A Hard Stop breach anywhere in that chain refuses the request outright. The developer sees an error telling them the agent's budget has been exceeded and to contact their administrator; the task stops where it stands. A Soft Warning breach records the breach and lets the work continue. See Setting & Monitoring Budgets for the full model.

Note: a hard stop ends the run rather than corrupting it. Files already written to the workspace stay written and nothing is corrupted — the agent simply stops replying until the budget resets or you raise it.

An agent-level budget is the most useful control here. It caps what the coding agent can spend without touching anything else your organisation runs, which means an experiment, a new team or a badly-scoped task can be contained rather than argued about afterwards.

Auditing who did what

Coding sessions appear in the Conversation Explorer alongside chat conversations, and each one is attributed to the owner of the access token that made the request — not to the agent's API key, and not to a shared machine account. That attribution is the whole reason personal tokens are mandatory; see Access Tokens.

The turns of a single coding task are grouped into one conversation, so a session reads as the piece of work it was. Opening it shows the messages exchanged, the knowledge the agent cited, the platform tools it called, and the editing actions it asked the developer's editor to perform. It is the record you need when someone asks what an agent changed, on whose instruction, and on what basis.

Reports

Coding usage rolls up into the standard reports with everything else:

Filter either report to the coding agent, or to the team that uses it, to separate coding spend from the rest of your platform. The per-agent analytics panel on the agent's published page gives the same picture at a glance for a single agent.

Note: the cost figure the extension shows next to a task is the same billable, marked-up price recorded on each request, but it only sums chat-completion requests — embedding calls the agent makes while searching your knowledge base are billed but not included. On a retry the platform bills every attempt while the badge keeps only the last one, and older messages saved before this behaviour shipped keep the $0.0000 they were saved with. The Cost Report remains the authoritative number for reconciliation — see Limits & Known Behaviour.

What drives the cost

Coding tasks cost more per message than chat does, for one structural reason: the extension holds the transcript and sends it back with every request. A task that has read ten files and run four commands carries all of that on its next turn, so cost per turn rises as a task goes on.

That makes task hygiene the lever that matters, and it is worth telling your developers so:

• Scope tasks to one outcome. Three focused tasks are consistently cheaper than one sprawling one, because each starts with a small transcript.
• Switch Auto Compact on. It is off by default, but once enabled the extension condenses long conversations automatically, keeping decisions and dropping noise. Turning it on is free money.
• Hand over context instead of making the agent hunt for it. Naming the relevant files costs a sentence; letting the agent discover them costs several round trips.
• Prefer a plan before a long run. Agreeing an approach cheaply beats paying for a long autonomous run in the wrong direction.

See Context: Mentions, Images & Focus for the developer-facing version of this advice.

If your coding spend looks wrong, the Cost Report's daily breakdown is the fastest diagnosis: a single developer with a runaway task shows up as one enormous day, while genuine adoption shows up as a gentle slope across many users in the Usage Report.

A sensible governance starting point

If you are rolling AETHER Coder out for the first time:

1. Give the coding agent its own agent-level budget, set as Soft Warning, for the first few weeks.
2. Watch the Cost Report to learn what real usage costs your team, rather than guessing.
3. Convert the budget to Hard Stop at a level informed by that data.
4. Spot-check a few sessions in the Conversation Explorer, so you know what the audit trail looks like before you ever need it.

Next steps

• Setting & Monitoring Budgets — caps, periods and enforcement modes.
• Cost Report — where coding spend shows up.
• Limits & Known Behaviour — why the in-editor cost figure differs.