Solomon exhausted 95% of my Claude Max session allowance while using only 27% of the weekly allowance. I traced the Claude sessions to determine whether a skill, hook, or repeated command caused the spike. None did. The main cost was hundreds of model calls against long, uncompressed conversations.
What happened
Across Solomon’s Claude sessions during an eight-hour sample:
| Measure | Total |
|---|---|
| Sessions | 27 |
| Model calls | 2,156 |
| Output tokens | 1.77 million |
| Cached input tokens | 469.7 million |
| Shell calls | 1,401 |
| Subagent launches | 35 |
| Skill calls | 35 |
The largest session made 335 model calls, including 242 shell calls. It produced 261,904 output tokens and read 108.5 million cached input tokens.
I compared all 332 tool calls in that session. Every call had a distinct payload. This was not a loop issuing the same command repeatedly. Tool results contained about 254,000 characters in total, which is also too small to explain 108.5 million input tokens by itself.
Why usage grows
A Claude coding agent alternates between the model and tools:
flowchart LR
P[Prompt and history] --> M[Claude]
M --> T[Run tool]
T --> R[Append result]
R --> M
Each tool result becomes part of the conversation. The next model call receives that result plus the earlier messages, file reads, patches, and command output. The work may be different on every step while the input remains mostly the same.
If a conversation contains 150,000 tokens and the agent makes 50 more tool-driven calls, Claude may process much of that 150,000-token history 50 more times. Prompt caching reduces the cost of repeated input, but cached input still counts toward plan usage.
Solomon currently resumes Claude’s complete provider transcript. That preserves context accurately, but it also preserves every intermediate command and result. The audited sessions had no compaction boundaries.
Three settings amplify the effect:
- Most calls used Opus.
- Claude’s global effort level was
xhigh. - Several agents ran at the same time against one shared plan allowance.
Skills were not the main cause. There were 35 skill calls among 2,156 model calls. Solomon’s hooks add some context and one end-of-session memory step, but their volume is small compared with the repeated conversation history.
Why a translation layer is the wrong fix
A translation layer could rewrite every prompt and tool result into shorter text before Claude sees it. That sounds efficient, but the translation itself needs another model call. It also creates a second representation of the task that can omit a condition, path, error, or measurement.
The measured problem is not verbose user prompts. It is the lifetime of the working conversation. Compressing every message attacks the smaller term while adding cost and failure modes.
The proposed fix: bounded sessions
Solomon should treat a provider conversation as temporary working memory, not permanent agent identity.
flowchart LR
A[Task session] --> H[Structured handoff]
H --> N[Fresh session]
N --> W[Continue work]
D[Files and shared memory] --> N
At a task boundary—or after a fixed call or context budget—Solomon should create a compact handoff containing:
- Current objective
- Decisions and constraints
- Files changed
- Verification completed
- Failures and open questions
- Exact next action
It should then start a new Claude conversation, inject the handoff, and keep the same Solomon agent identity. Files, Git history, and shared memory remain the durable record. The discarded data is the sequence of intermediate tool calls that produced that state.
Implementation plan
1. Fix usage accounting
Claude’s Agent SDK reports cumulative usage for a streaming session. Solomon currently records each cumulative result as a new amount. This inflates Solomon’s local dashboard by about 6.7 times. It does not affect Anthropic’s plan meter, but it hides the real pattern. Solomon must record the difference between consecutive usage reports and handle resets after resume or clear.
2. Add session budgets
Track model calls, tool calls, output, and cached input per provider session. Initially rotate after 50 model calls or when cached-input growth crosses a measured threshold. Record which limit caused the rotation.
3. Rotate only at safe points
Do not replace a conversation during a file edit, test run, permission request, or unresolved question. Rotate after a completed task or before the next user prompt. If the agent is still working when it reaches a limit, require it to write the handoff before continuing.
4. Route models by work type
Use Opus at high effort for architecture, planning, and difficult debugging. Use Sonnet at medium or high effort for implementation, file inspection, and test repair. Do not make xhigh the global default.
5. Bound tool output
Prefer targeted searches, line ranges, test summaries, and error tails. Store full logs on disk and return their paths with a short failure summary. This reduces new context before it becomes repeated context.
6. Limit concurrent expensive agents
Set a workspace budget for concurrent Opus sessions. Additional agents should use Sonnet or wait. Parallel work remains useful only when the tasks are independent enough to offset the added usage.
How we will test it
Run the same class of multi-file task before and after the change. Compare:
- Model calls per completed task
- Cached input per model call
- Output tokens per completed task
- Number of session rotations
- Rework caused by missing handoff information
- Claude plan usage over the same wall-clock period
The target is not the fewest tokens. It is the lowest token use that preserves correctness. A useful first result would cut cached input per completed task by half without increasing failed tests, reverted edits, or user corrections.
Conclusion
Solomon’s agents are not burning tokens because one skill repeats work. They are burning tokens because useful work is split into hundreds of model calls inside conversations that remain alive for hours. Each call carries the accumulated history again.
The fix is to bound conversation lifetime, preserve state in a compact handoff, and continue in a fresh session. Translation belongs at that boundary, once—not between every tool call.