You set model: sonnet. Telemetry says a third of the calls were Haiku. That is not a conspiracy headline — it is what open telemetry and source inspection keep showing for Claude Code’s built-in Explore path. This guide explains what is actually routing, why /stats can lie by omission, and how Power Claude’s session graph, Token Tree, and analytics help you see fan-out, models, and spend without waiting for a Grafana weekend project.
TL;DR
| What you assumed | What often happens | How to see it |
|---|---|---|
| “Every turn uses my selected model” | Built-in Explore (and similar) can run on Haiku by design | External OTEL or local session projection |
“/stats is complete” | Subagent model mix is easy to miss / under-count | Per-turn JSONL + structured UI |
| “I need Grafana to care” | Useful, not required for day-to-day ops | Power Claude Flow Explorer, Token Tree, analytics |
| “Visibility fixes the routing” | No — visibility is step one; overrides are separate | Disable/override Explore + watch tokens after |
Independent third-party tooling. Not affiliated with or endorsed by Anthropic. Claude Code behavior described here follows public reports, docs, and community telemetry — verify on your install.
The story everyone is rediscovering
A detailed walkthrough on mirin.pro (Constantine Mirin) is the clearest public write-up of the pattern:
- Operator sets Sonnet/Opus in settings and works normally.
- OpenTelemetry (or equivalent) shows a large share of API calls on Haiku.
- Many Haiku calls match a cheap fingerprint (small input, exactly 32 output tokens) — classic Explore lookups.
- A non-trivial share of Haiku calls do not look like path lookups: larger inputs, non-trivial outputs, sometimes heavy cache reads.
- Claude Code’s own
/statsdoes not always surface subagent models the way operators expect (community issues track incomplete counts).
The punchline is not “Haiku is evil.” Stateless file discovery on a small model is a defensible product choice. The punchline is opacity: you optimize prompts, skills, and harnesses for the model you thought was exploring your repo.
If you only read marketing, you will miss that line. If you only read Reddit “Claude got dumber,” you may blame model quality when part of the work never hit Sonnet at all.
What Claude Code is doing under the hood (short version)
When you ask Claude Code to change code, the parent agent often does not load the whole repo into one window. It spawns subagents (Task / built-in types) with fresh contexts to search, read, and summarize. That is good for context hygiene: exploration stays off the main transcript.
Model selection is not always “inherit my settings.json.” Community inspection of Claude Code’s shipped CLI has repeatedly pointed at hardcoded Haiku for built-in agents such as Explore (file discovery / codebase search). Custom agents may inherit your model; built-ins may not. Settings like “small fast model” env knobs do not always override every code path — operators report residual Haiku even after overrides.
So you get a two-model architecture by default:
- Main conversation — your configured model (Sonnet / Opus / …).
- Explore-class work — often Haiku, sometimes with more context than “return a path.”
For API pay-as-you-go, that can be a cost win. For flat Pro/Max subscribers, the economics are different: you are not billed per Haiku token the same way, but you are spending limited rate-limit budget and trusting the wrong mental model of quality.
Token signatures: a practical field guide
You do not need the full Mirin Grafana board to start recognizing patterns in logs or dashboards:
| Fingerprint | Typical meaning |
|---|---|
| Small input (hundreds–low thousands), 0 cache, ~32 output | Stateless Explore-style lookup |
| Main turn: tiny “new” input, large cache_read, medium–large output | Parent conversation on configured model |
| Haiku with large input / large output / big cache_read | Not “just a path” — treat as real reasoning load on the small model |
Why built-in stats are not enough
Claude Code’s /stats is convenient. It is not a full observability product.
Operators and GitHub issues have reported subagent model usage missing or under-counted. Status UI may show an agent name without the model id. Docs do mention routing some work to faster models for cost control — but that is easy to miss if you only set model: sonnet and assumed “all reasoning is Sonnet.”
That gap is exactly why people bolt on OpenTelemetry → Loki/Prometheus → Grafana. It works. It is also a project. Most teams need a daily answer to:
- What subagents did this session spawn?
- How long did each branch run?
- Where did tokens go (parent vs children)?
- Which models appear in the transcript for this run?
- Did fan-out crush one account’s rate limits?
How Power Claude helps: show and track (not invent)
Power Claude is a local layer around Claude Code (VS Code + CLI). It does not claim to reverse-engineer Anthropic’s closed host or to “force Explore onto Opus” by magic. What it does well is project structure and cost signals you already have on disk into UIs and commands you can use mid-work.
1. Session Flow Explorer — the map of what ran
Session Flow Explorer turns a session into a graph: parent vs sub-agents, tools, turns, durations, evidence I/O. Fan-out is first-class, not a wall of JSONL.
Use it when the question is: “What did this agent session actually do?”
- Open Session Explorer → select session → Graph / Timeline.
- Click nodes for tool I/O when debugging bad research.
- Copy Mermaid for postmortems and design reviews.
- CLI:
pc tree --format mermaidwhen you want the same shape in a terminal or CI note.
Honest framing: the graph is only as good as the local session record. Fail-closed validation drops ghost nodes — better an empty or sparse map than a pretty fiction.
Product deep-link: Session Flow Explorer.
2. Token Tree (`pc tree`) — where tokens went across the orchestration
Token Tree attributes spend/usage across the orchestration: parent prompts, tool loops, sub-agent branches. It answers a different question from the Flow graph:
| Surface | Primary question |
|---|---|
| Flow Explorer | Structure & sequence — what ran |
Token Tree / pc tree | Cost & volume — where tokens went |
| Analytics dashboard | Trends — per session / account / day |
3. Analytics and session trail — fleet-level, not one JSONL file
Heavy subagent days are not one session. They are:
- Multiple tabs
- Parked / rewoken runs
- Rate-limit stalls mid-fan-out
Power Claude’s analytics and session trail surfaces are for that operational layer: what stalled, what recovered, what each account absorbed. Related failure mode: sub-agent fan-outs vs rate limits — visibility without capacity is still a stampede on one TPM bucket.
4. Rotation and rewake — after you can see the problem
Once you see Haiku exploration and Sonnet parents, you still need capacity for parallel Tasks. Pooling your own Claude seats and rewaking after limits is the reliability half of the story — orthogonal to model disclosure, but the reason teams stop caring about one account’s 5-hour wall mid-research. See how rotation works.
Visibility stack (local):
Claude Code JSONL / hooks
│
├─► Flow Explorer (structure: agents, tools, edges)
├─► Token Tree (attribution: tokens by branch)
├─► Analytics (trends, accounts, spend-ish views)
└─► Session trail (lifecycle: stall, rewake, recovery)External OTEL (Grafana, etc.) remains valid for org-wide API billing truth. Power Claude is the in-editor / on-machine path for coding-agent fleets.
What Power Claude does *not* claim
Be precise — SEO and trust both fail if this article oversells:
| Claim | Reality |
|---|---|
| “PC disables Haiku Explore” | No. Override/deny is a Claude Code settings/agent choice (below). |
“PC guarantees /stats is fixed” | No. We project local data; we do not patch Anthropic’s binary stats. |
| “PC is Anthropic telemetry” | No. Local product; no requirement to ship your prompts to Neural-LLM for graphs. |
| “All Haiku = silent quality downgrade” | Not always. Many Explore calls should be cheap. The issue is complex work on Haiku + lack of UI truth. |
Practical responses (routing + visibility)
A. Prefer your model for exploration (Claude Code side)
Community-proven patterns (verify against current Claude Code docs on your version):
- Deny built-in Explore via permissions so exploration stays on the main model (trade-off: more main-context pollution).
- Override Explore with a user agent definition that sets
model: sonnet(or opus) and your exploration prompt. - Re-check telemetry or local model breakdown after the change — residual Haiku can remain on other code paths.
B. Prefer seeing the truth every day (Power Claude side)
- After a heavy research session, open Flow Explorer and confirm subagent fan-out matches what you asked for.
- Run
pc tree(or Token Tree UI) and look for unexpected volume on short-lived children. - Use analytics across the day when you hit rate limits — fan-out math is often the culprit (detail).
- Export Mermaid for the postmortem if quality “felt dumb” mid-day — check whether Explore-class work dominated wall time.
C. Prefer not to reinvent Grafana on day one
OTEL + Grafana is excellent when you already run it. If you just want “show me the subagents and the token tree for this session,” start local. Add org-wide collectors when multiple developers share API keys or you need finance-grade invoices.
FAQ
Is Explore always on Haiku?
Built-in Explore has been reported as hardcoded to Haiku in shipped Claude Code builds. Always re-verify on your version; products change. Custom agents often inherit your model.
Does this mean Sonnet is a scam?
No. Your main agent may still be Sonnet/Opus. The gap is mixed routing without an honest status surface. Cost optimization for simple lookups is rational; silence is the product smell.
Can Power Claude show the exact model id for every subagent?
Where the local transcript/events record model metadata, Power Claude surfaces and aggregates it in cost/analytics views. Where the host omits fields, no honest tool invents them. Prefer fail-closed empty over fake labels.
Is this the same as “silent Haiku under rate limit pressure”?
Related but not identical. Rate-limit pressure causes stalls and recovery drama (rewake). Hardcoded Explore Haiku is a default architecture choice, not only a pressure fallback. Some public write-ups blur the two — keep them separate when debugging.
Should I disable all subagents?
Usually no. Subagents protect context. Prefer model-aware overrides + visibility + capacity (pool/rotation) over “never Task again.”
Does Flow Explorer send session graphs to Neural-LLM?
No. Graphs and Mermaid export are local. See the Flow Explorer guide.
How does this relate to LLM evaluation tools?
Offline eval suites (Promptfoo, DeepEval, …) answer “is this prompt better on my cases?” They do not replace “what did today’s Claude Code session spawn?” Map both layers in LLM quality tools for coding agents.
Where do I start if I only have ten minutes?
- Run one real research task.
- Open Flow Explorer on that session.
- Glance at Token Tree / analytics for model mix if available.
- Skim Mirin’s OTEL piece if you need org dashboards later.
Closing
Claude Code remains one of the strongest coding agents available. Setting model: sonnet still matters — for the turns that honor it. The mature operator move is:
- Know that Explore-class work may run on Haiku.
- See structure and tokens locally (Flow Explorer, Token Tree, analytics).
- Choose overrides when exploration quality matters more than cheap lookups.
- Capacity-plan fan-out so visibility is not just watching a 429.
Power Claude’s job in that stack is the middle: show and track what your machine already knows, so you are not waiting for the next outage to stand up Grafana.
Further reading (external): mirin.pro — 36% of your Claude Code subagents are running on Haiku · Claude Code docs on sub-agents (model routing / cost control language evolves — check current docs).