Token economy

Less drift. Less rework. Lower spend.

A blind agent drifts — it re-greps the tree, re-learns the architecture, and re-breaks the fragile code someone already fixed. Every wrong path is a fresh, output-heavy turn you pay for. gndctrl hands each agent a map and shared memory, so it does the right thing the first time. The token bill comes down because the work comes down.

Drift is the real token sink

The expensive part of an agent session isn't reading — it's the output: reasoning, tool calls, and edits. And the biggest source of wasted output is an agent working without context.

It explores instead of knowing

With no map, an agent greps and re-reads its way around an unfamiliar tree, burning a charged turn on every guess and wrong path.

It re-breaks solved problems

The landmine one agent already hit is invisible to the next. Without shared memory, the fragile code gets re-broken — then re-fixed — on the meter.

It drifts from the design

Never having read the architecture, an agent wanders out of its lane. The cleanup — review, revert, redo — is all charged output.

gndctrl replaces exploration with a ~1–4k-token pre-flight, and replaces re-learning with a logbook read once and shared across every agent. Fewer wrong turns is fewer charged turns.

Context load: targeted, not exhaustive

The clearest, already-measurable win is how much context an agent needs to become effective. Instead of dumping the whole codebase in to "understand" it, the agent reads a map and pulls only the zone the task touches.

40k–200k+tokens to load a raw codebase for context

~1–4ktokens for a targeted gndctrl pre-flight

onceper session — not per question

Source: gndctrl spec, pre-flight context budget. Cold memory (full zone docs, logbook entries) loads only when the task actually requires it.

"But doesn't the map itself cost tokens?"

A fair question, and the short answer is no — reading is the cheap part. Modern runtimes cache context, so the map read once is reused on later turns without counting against your budget; the meter bills the non-cached input plus output.

On the pyChisel deployment, average metered input is ~56 tokens per turn — regardless of how much the agent read. Reading more adds ~nothing to the charge.
So forcing a read-first map doesn't add cost. What it removes is the expensive behavior above — the blind exploration and rework.

Caveat kept honest: cached tokens still cost the operator a little upstream; they just don't consume your metered allowance. "Doesn't count against your budget," not "free."

You pay for what an agent writes, not what it reads.

So the lever that matters is keeping agents on-track — and that's exactly what a shared map, shared tiers, and a shared logbook do.

See how it works