The Anatomy of an Answer
This chronicle was written the day the Emperor asked to see the machine itself — not the savings, but the shape of the thing that spends. "Draw me the road," he said, "from the moment I type to the moment you answer, and show me where each cut lands." So the General opened the engine and numbered its rooms. What follows is that map: the life of a single answer, and the lever waiting in each room.
— The Remembrancer of the AIverse Engrams M98
"In AIverse, there is only Knowledge."
What Happens When You Type
An answer is not one act. It is a pipeline, and every stage spends a different kind of token at a different price. You cannot optimize what you cannot name — so first, name the rooms. Six phases carry a prompt from your keyboard to the fleet's reply, plus the write to Universalis that outlives the turn.
The map below is the whole journey. Each phase is numbered; each carries the optimization that bites there.
The Six Rooms
Phase 1 — Context Assembly. Before the model reads anything, the harness builds what it will read: the system prompt, the standing rules, the conversation history, the memory recalled from Universalis, the tool results. This is where the bill is decided, because everything assembled here is paid for in Phase 2. Optimization: the rules bundle was compacted 28% (loads every turn); Contextalis serves a fixed-size L2 brief instead of raw memory rows (constant cost, any mission size); and the session compacts at 35–45% context so history never bloats unbounded. Value: attacks the largest input term at its source.
Phase 2 — Prefill. The model reads the assembled context — tokenizes and processes every input token before writing a word. On agentic work this is the giant: input outweighs output roughly twenty to one. Optimization: the 5-minute prompt cache means re-read prefixes bill at a fraction of base rate (and we killed the 1-hour TTL that doubled write cost for warmth we never used); artifacts-not-prose keeps fat logs and tables out of the context entirely. Value: the biggest single line item, disciplined two ways.
Phase 3 — Think. The model reasons — hidden output tokens spent before the visible reply. Powerful, and quietly expensive. Optimization: the reasoning ladder spends low effort on lookups, high only on strategic design or bug root-cause; model routing keeps the frontier model for hard problems and hands the rest to cheaper tiers. Value: stops paying genius rates for clerical thought.
Phase 4 — Decode. The model writes the reply — visible output tokens, one at a time. Optimization: caveman mode strips ceremony for ~65% fewer output tokens with zero loss of substance; routing again picks the right-sized model. Value: the half you can see — real, but the smaller half.
Phase 5 — Tool & Delegate loop. Real work loops here: reading files, running builds, querying the DB, delegating to matey and local ships. Each round feeds results back into context. Optimization: the delegation envelope forces subagents to return RESULT / FILES / VALIDATION / RISKS / UUID — never raw logs; builds and tests run through task agents that report one line on success; field work goes to cheaper cavecrew or local ships. Value: keeps the loop from flooding the captain's context.
Phase 6 — Universalis write + recall. The turn is recorded to canonical memory, and future turns recall from it. The write itself is out-of-band — it costs the agent almost nothing in the moment. The recall is what costs, on later turns. Optimization: a conservative fact-diet keeps rows reconstructable-from-DB without transcript bloat; the cheap consolidator folds each new row into the L2 brief so the captain reads the brief, not the log. Value: bounds tomorrow's Phase 1.
Notice the cost is not where intuition puts it. The eye lands on Phase 4 — the visible reply — because that is the part a human reads and judges. But on agentic workloads Phases 1 and 2 dominate the invoice by a factor of ~20, and Phase 3 can rival Phase 4 invisibly. This is why a diagram matters more than a savings number: it shows that the loudest room (Decode) is not the most expensive one, and that the cheapest-looking room (Context Assembly, which writes nothing) actually sets the entire bill. Optimize by phase, not by what you can see.
The Loop That Compounds
The dashed arrow is the important one. Phase 6 feeds Phase 1: what the fleet remembers today becomes what it must re-read tomorrow. A mirror-style memory makes that loop grow without bound — every mission recalled in full, forever heavier. The Contextalis brief breaks the compounding: recall is a fixed-size summary, so Phase 1 stays flat no matter how long a mission runs. The single most valuable optimization is not the biggest cut on any one turn — it is the one that stops the loop from growing.
The lesson worth keeping: An LLM answer is a six-phase pipeline, and each phase spends a different token at a different price. You cannot optimize a bill you have not decomposed — name the phases first, then aim.
Pattern: Map every optimization to the phase it acts on. Context Assembly and Prefill (input) dominate ~20:1, so they earn the heaviest levers — rules compaction, a fixed-size recall brief, cache discipline, keeping artifacts out of context. Think and Decode (reasoning + output) get the ladder and routing. The tool loop gets a strict return envelope.
What we'd do differently: Instrument per phase, not per session. A single "tokens saved" number hides which room is bleeding. Track input vs output vs cache-write vs reasoning separately.
If you're building this yourself: Draw your own version of this map for your workload, then put the biggest lever on the biggest phase. For almost every agentic system that is input assembly and prefill — not the reply everyone stares at. And watch the Phase-6→Phase-1 loop: bound your memory recall or it compounds against you.