I’ve been using Claude Code’s Agent Teams feature extensively and ran into what I think is a fundamental efficiency problem. I did a systematic test to confirm. The Problem Team agents and subagents cannot spawn other agents. The Agent tool simply doesn’t exist in their toolset. This means an Opus team agent that needs to explore the codebase can’t spawn a cheap Haiku Explore subagent. It has to do all exploration itself - reading files, grepping, globbing - directly in its own expensive context window. What I Tested I spawned multiple ephemeral subagents and team agents, asking each to list their tools and attempt spawning other agents. There’s no agent definition format to declare additional tools and no parameter to grant the Agent tool. It’s hardcoded: only the main session gets it. Why This Matters In the main session, you naturally delegate broad exploration to cheap Haiku subagents: “Explore the codebase and find all implementations of X” → Haiku scans 50 files, returns 5 relevant locations “Read these 20 files and summarize patterns” → Haiku batch-reads, returns a digest This keeps your expensive Opus context clean and focused on decision-making. Inside team agents, this pattern breaks completely. An Opus architect or implementer has to: Grep/glob across the codebase itself (polluting context with raw search results) Read potentially dozens of files (consuming expensive Opus tokens) Do all mechanical verification work that Haiku could handle for a fraction of the cost In my experience, roughly 40% of an agent’s work is exploration/verification that doesn’t need Opus-level intelligence. That’s all running at full Opus pricing because team agents can’t delegate downward. Workarounds (All Suboptimal) Codex/Gemini MCP: Agents can call third party models via MCP, but it’s a different model family. Not the same as spawning a Claude Haiku subagent with full tool access. Relay through main session: Team agent messages the main session to spawn an explorer and relay results. Adds latency and manual coordination overhead because messages are fully asynchronous. Pre-spawn everything: Spawn all exploration agents upfront. But you can’t predict what an agent will need mid-task. What Would Fix This Allow agent definitions to declare tool access (e.g., tools: [Agent] ) Add an allowed_tools parameter to the Agent() call Or create a scoped delegation tool that enables the cheap-model-for-exploration pattern without full Agent access Grant Agents general access to the Agent() call The core issue: Claude Code’s most powerful efficiency pattern - delegate breadth to cheap models, reserve depth for expensive ones
- stops working inside team agent contexts. Every team agent becomes a monolithic worker doing everything at full price, regardless of whether the task warrants it. Has anyone found a way around this? It seems like I’m not the only one struggling with this limitation . submitted by /u/farono
Originally posted by u/farono on r/ClaudeCode