Skip to main content

Agent economics

An agent estate that cannot be costed cannot be governed. Nobody approves an autonomous system whose spend is discovered at the end of the month.

Two ledgers, answering two different questions​

This separation is deliberate and worth understanding before anything else:

LedgerQuestion
Inference transparencyWhere did the model resource go, and where was it wasted?
Metered compute unitsWhat is billable, and to whom?

They are not the same quantity and are never summed. Conflating them produces a bill that looks like an efficiency report and an efficiency report that looks like a bill.

Inference transparency: per call, attributed to lineage​

Every model call produces an event carrying the lineage that made it, the provider and model, whether it ran locally, the outcome, and input and output tokens, which are the two dimensions always present.

Optionally, when the provider reports them: cache reads and writes, thinking tokens, cost, processor and wall time, and an energy estimate.

Two properties make this trustworthy rather than merely detailed.

Absent is not zero. A field the provider did not report is recorded as absent, not as 0. One provider reports cache statistics and another does not, and a dashboard that renders the second as "zero cache usage" is lying with a number. Each measurement is additionally flagged as reported by the provider or estimated locally.

Local inference is comparable to paid inference. A locally-served model has no monetary cost but real processor, wall-clock and energy cost, so both appear on the same axis and a "free" local model is not free in the view.

The waste taxonomy​

The outcome field is the interesting one, because it is a waste taxonomy rather than a success flag:

OutcomeWhat it means
AcceptedThe result was used
RetriedSpent, then repeated
FailedSpent, no result
DiscardedProduced and thrown away
Speculative loserRaced, and lost the race
AbandonedA worker killed by budget or cancellation before producing anything. Sunk tokens

Most platforms can tell you what you spent. This tells you which of your spend bought nothing, which is the number that actually changes behaviour.

Capture happens at the provider-normalization boundary, so it is provider-agnostic by construction rather than implemented once per vendor. Writes are fail-soft, telemetry must never break an inference, while reads are honest about errors rather than returning a silently empty list.

Metered compute units: who is charged​

The billing sample carries the agent as a first-class field, inside the tamper-evident canonical bytes rather than as a loose dimension, along with the sub-agent lineage, the run, the workspace, the clean room and the cell.

The mechanism that makes this reliable is ambient attribution: any operation occurring inside an agent run resolves the acting agent from the ambient lineage, so a caller does not have to remember to thread it through. An explicit attribution always wins over the ambient one.

That is the difference between "most agent activity is attributed" and "agent activity is attributed."

Four layers of budget, all checked before execution​

LayerScopeWhen
Grant budgetOne sub-agent, attenuated at mintStructurally, when the child is created
Live ledgerOne agent's runOn every reservation, before the work
Organization capsContractual ceilingsOn the service hot path, before work
Cost-fused gateOne decisionAt the decision, folding cost into the verdict

The grant budget is split out of the parent's remaining allocation at mint, so the subtree total can never exceed the root. It is not enforced afterwards; it is arithmetically impossible to exceed.

The live ledger issues time-limited reservations. An exhausted dimension raises with the dimension, what was asked and what was available, rather than a generic failure. Crashed work returns its budget on expiry. And an agent with no registered ledger cannot spawn at all, which is the fail-closed default that prevents an unbudgeted agent being an unbounded one.

Organization caps come from the licence. No cap means the work is allowed and billed as overage, consistent with the platform's overage is billed, never blocked rule. A contractual ceiling produces a structured refusal. Budgets throttle before they block, and the enforcement state is persisted so the decision is consistent across processes rather than re-derived per node.

The cost-fused gate folds metered cost into the net-potential-gain verdict, so work whose cost exceeds its value is refused before a token is spent rather than reported afterwards.

Sub-agent spend rolls up​

Because every metered row carries the run and the lineage, spend folds into the sub-agent tree directly, ordered so the most expensive worker reads first.

The roll-up is structural rather than reconstructed: a child's budget was carved out of its parent's, so the tree sums by construction, and unspent budget flows back when a lease expires.

Spend also rolls up across cells​

A crew does not necessarily run in one place. Members can be pinned to peer cells, and an ephemeral cell can be stood up for part of a run, which creates a counting problem: a cost view assembled from the cell you happen to be asking would show only that cell's share and look complete.

The fix keeps the platform's standing rule about telemetry intact:

Raw inference events stay local. Only the derived aggregate converges.

Per-event telemetry never leaves the cell that recorded it, under the same exception that keeps each cell's hash-chained ledgers its own. What converges is a small per-cell cost aggregate, keyed so each cell's contribution stays distinct, and the cost view sums those contributions across the node rather than reading one cell's sink.

Two details make the sum trustworthy:

  • Waste is re-derived, not re-added. The waste figure is carried as additive pieces rather than a finished number, so summing across cells produces the right total instead of compounding per-cell roundings.
  • A clean-room run is counted the same way. The aggregate carries the clean-room coordinate alongside the workspace one, so a compartmented run is not a blind spot in the cost view.

The rollup itself is watermark-driven and best-effort: it advances as events accumulate, and a cell that has not yet rolled up contributes its share when it does. A cost view is therefore current rather than instantaneous, which is the honest property for an aggregate assembled from many cells.

Agent-level financial views​

Three views, each careful about what it does not know:

Estate cohorts answer "which of my agents are idle, runaway, or expensive?" The idle cohort is computed from the registry minus the active set, not from the usage rows, because an agent that did nothing has no rows at all: it is absent, not zero. Activity that cannot be read is reported as unknown, never as idle.

Per-agent baselines compare an agent against its own history rather than against its peers. The quantity is named first: hour-over-hour cost change is growth, so it is judged against a growth step. Repeated growth without consolidation raises a runaway signal; an agent that grows and then holds is fine at any size. Under a minimum number of observations the answer is nothing at all, never "nominal."

Behavioural composites are built from observed facts only: looping without progress, abandonment, retry burn, refusals. There is a deliberate refusal here worth repeating: the platform does not ship psycholinguistic "tells" about agent intent. They are unfalsifiable accusations, and no peer platform ships one either. No signals and no observations yields unknown, never "healthy."

Reporting "healthy" when the truth is "I could not tell" is the failure mode all three of these are built to avoid.