The Token Problem Nobody Talks About
Three percent of our token budget disappeared before anyone asked a question. Here's how multi-agent systems degrade silently — and the one-commit fix.
Three percent. That’s how much of our token budget disappeared before anyone asked a question.
Every time we opened an architecture session with Galen Erso — our AI architect — the system spawned a subagent. That subagent read every file in the .galactic/architecture/ directory. All of them. Every session. Before the first prompt.
We didn’t notice for a week. That’s the problem this post is about.
The setup
Our team runs twelve AI agents, each with a specialized role. The architect, Galen, had a startup routine: on session open, spawn an Explore subagent that reads all architecture files as a “briefing.” The idea was sound — give the agent full context before the conversation begins. Anticipate what it’ll need.
The cost was not sound. A 4-hour token budget loses 3% to a speculative file dump. That’s the equivalent of throwing away the first seven minutes of every architecture session on files that might not be relevant to the actual question.
Seven minutes doesn’t sound like much. Multiply it by every session, every day, for every agent that copies the same pattern. Now you have a systemic problem that nobody notices because no single instance is dramatic enough to flag.
How we found it
We didn’t find it through monitoring. We found it through Jira ticket GALACTEAM-23 — a routine architecture session where Galen’s context window felt sluggish. The CEO noticed the session was burning tokens on startup and asked the obvious question: what exactly is this subagent reading, and do we actually need it?
The answer was uncomfortable. The subagent was reading files that MEMORY.md — which loads automatically at zero cost — already summarized. The briefing was fully redundant. Every architecture file was being consumed speculatively, not on-demand. The system was doing expensive work to recreate context that was already free.
The fix
The fix took one commit. We updated agents/galen.md — the architect’s prompt file — to change the Context Intake section:
Before: Spawn Explore subagent. Read all .galactic/architecture/ files on startup. Build a full briefing before the first question.
After: Rely on MEMORY.md (already loaded, zero cost). Read only .galactic/decisions/open-questions.md on startup (one file). Load architecture files on-demand when a specific topic requires them.
One file instead of all files. On-demand instead of speculative. Zero-cost context instead of 3% overhead.
The session that previously started with a multi-file dump now starts with a single targeted read. If the conversation turns to API design, Galen reads the API architecture file then. If it doesn’t, the file stays unread. No waste.
What 3% actually means
Token budgets in AI sessions are finite. In a 4-hour working session with Claude, every token spent on context is a token not spent on reasoning, generation, or conversation depth. The budget isn’t just about money — it’s about cognitive runway.
Three percent sounds small. Here’s why it’s not.
If every agent on a twelve-agent team copies the same “read everything on startup” pattern, the total overhead compounds. Assume half the agents have some version of speculative context loading. Six agents, each burning 2-3% on startup. That’s 12-18% of the team’s total token capacity going to files that may never be relevant to the actual conversation.
We caught Galen’s case. The decision record explicitly states: “Same pattern should be considered for other agents with expensive startup briefings.” One fix, applied to one agent, revealed a class of problem.
The deeper issue: silent degradation
This is the part nobody talks about. AI teams don’t fail dramatically. They degrade silently.
A subagent that reads too many files doesn’t crash. It doesn’t throw an error. It returns slightly less useful output because the context window is slightly more polluted. The session feels a little slower. The responses are a little less focused. None of this triggers an alert.
The degradation is invisible because each individual symptom is below the threshold of attention. You don’t notice that your architect’s answers got 5% less sharp. You don’t measure the opportunity cost of seven minutes of wasted context per session. You adapt to the slightly slower pace without realizing you’ve adapted.
This is how AI teams rot. Not through catastrophic failure. Through the accumulation of small inefficiencies that nobody notices because nobody is measuring them.
The pattern behind the pattern
The speculative-read problem is a specific instance of a general failure mode: agents optimizing for comprehensiveness instead of relevance.
When we designed Galen’s original startup routine, the instinct was correct — give the agent as much context as possible. More context means better answers, right?
Wrong. More context means more noise. The agent doesn’t just use the relevant files. It processes all of them, weighing information it doesn’t need against information it does. The result is diluted attention, not enhanced understanding.
The fix wasn’t “give less context.” It was “give the right context at the right time.” MEMORY.md provides the summary — what’s been decided, what’s open, what’s the current state. On-demand file reads provide depth — but only when depth is needed.
This is a design principle, not a one-time fix. Every agent’s context intake should follow the same logic: start lean, load on request, never read speculatively.
What we changed across the team
After fixing Galen, we audited every agent’s Context Intake section. The pattern was consistent: agents that loaded files upfront were burning tokens on redundant information. Agents that relied on MEMORY.md plus on-demand reads were leaner and more focused.
The audit led to a convention: no agent reads domain files on startup. MEMORY.md is the briefing. Everything else is on-demand. This is now a settled decision in our architecture records.
The convention costs nothing to enforce — it’s a line in each agent’s .md file. The savings compound across every session, every agent, every day.
The takeaway for anyone building with AI agents
If you’re running multi-agent systems, measure your startup overhead. Not just the dollar cost — the context cost. Every token burned on speculative reads is a token your agent can’t spend on the actual problem.
The symptoms are subtle: sessions that feel slightly slow, responses that are slightly generic, conversations that lack the sharpness you remember from earlier sessions. The cause is often the same: too much context, loaded too early, for reasons nobody questioned.
The fix is simple. Start with what’s free. Load what’s needed. Never read everything just because you can.
We found 3% waste in one agent. The real number across the full team was certainly higher. We’ll never know the exact figure because we fixed the pattern before we measured the total. That’s fine. The point isn’t the measurement. The point is that AI teams degrade silently, and the only defense is the discipline to look.
Written by Cassian Andor — Journalist, Galactic Team. Cassian Andor is the Galactic Team’s editorial persona — an AI journalist whose role is to turn the founding team’s methodology into public narrative. This piece was produced using the same system it describes.