Why Your AI Agent Should Stop Playing Telephone With Itself

Imagine you ask Copilot CLI to rename a variable. Instead of doing it, it spawns a helper agent that searches the codebase, waits around, then comes back confused. What should have been one step became three. This is the dark side of delegation: when your AI is too eager to hand off work, the handoff itself becomes the bottleneck.

GitHub recently shipped a fix for exactly this problem. It is called “smarter subagent delegation,” and it is already live for every Copilot CLI user. The results from their production A/B test are real: a 23% drop in tool failures, 27% fewer search misfires, and noticeably less waiting during long sessions. There are no new settings to flip and no commands to memorize. The tool simply got better at deciding when to delegate and when to just get the work done itself.

Here is what changed, and why it matters.

Delegation is powerful until it becomes friction

Subagents are genuinely useful. When Copilot needs to explore an unfamiliar repo, check a completely separate area of code, or run a long command while keeping the main thread moving, spinning up a specialist makes sense. The problem is that delegation is not free. Every handoff adds coordination overhead, extra tool calls, and wait time.

GitHub identified four failure patterns that were making things worse than they needed to be. First, simple tasks that the main agent could knock out quickly were getting passed off anyway. Second, exploration subagents were being called in when the handoff already contained enough context to act. Third, multiple agents were running the same searches independently, duplicating work. Fourth, and maybe most annoyingly, sequential delegation meant the main agent just sat there waiting instead of parallelizing anything.

Think of it like hiring a contractor to hang a picture. If you already own a hammer and the nail is right there, the paperwork alone takes longer than the job. GitHub realized Copilot was doing this constantly: calling in specialists for errands.

Concrete symptoms I have hit in long sessions:

• Unnecessary handoffs for trivial edits that take one tool call
• Overusing exploration agents when the context was already in the prompt
• Repeated searches across main and subagents running the same query
• Sequential delegation where the main agent waits instead of working
• Failure-prone paths: stale files, moved paths, workspace mismatches

The fix came from watching how the agent actually behaves

Instead of guessing, GitHub used LLMs to analyze full agent trajectories (the complete log of decisions, tool calls, and intermediate results produced by an agent during one session). They fed complete session logs into a model and asked a simple question: where is the orchestration helping, and where is it adding overhead?

The pattern was consistent. Subagents were being invoked for tasks that were already narrow, obvious, or fully described in the original handoff. In those cases, the subagent would re-search the repo even though the main agent already had everything it needed to act. That made the improvement target clear: keep focused discovery-and-edit tasks in the main agent, and reserve subagents for work that is broad, cross-cutting, or genuinely parallelizable.

They then turned that diagnosis into a tighter orchestration policy. Copilot CLI now handles focused work directly: find a file, read it, make a targeted change, verify it. It escalates to a subagent only when the work requires independent context, broad exploration, or parallel execution. And when it does delegate, the handoff is specific: what the user asked, what is already known, what the subagent owns, and what result the main agent needs back.

The principles that seem to drive the new policy:

• Start with the narrowest effective path
• Escalate only when complexity creates real value
• Step back down when the task becomes focused again
• Treat subagents as parallelism tools, not pause buttons
• Make handoffs specific and actionable

They proved it works before shipping it

Before rolling this out broadly, GitHub ran the change through offline regression tests and existing benchmarks. The goal was to confirm that the new policy reduced avoidable overhead without breaking cases where subagents genuinely add value. Then they moved to staff testing, then a public A/B test, then full production.

The results from that production A/B test are worth looking at carefully. Tool failures per session dropped 23%. Search tool failures specifically fell 27%. Edit tool failures dropped 18%. Total user wait time improved 5% at the 95th percentile and 3% at the 75th percentile. There was zero quality regression on the test corpus. Those are not marginal gains. That is the difference between an agent that feels clunky and one that feels smooth.

Importantly, these wins did not come from making individual LLM calls faster. They came from avoiding unnecessary subagent paths and reducing overall subagent workload per user. The system got faster by doing less unnecessary work. That is a useful frame: better orchestration often beats better models on the same hardware budget.

The headline numbers from the public A/B test:

• 23% fewer tool failures per session
• 27% reduction in search tool failures
• 18% reduction in edit tool failures
• 5% faster at the 95th percentile wait time
• Zero quality regression on the benchmark suite

What this actually feels like day to day

If you are already using Copilot CLI, this change should feel like less friction, not a new feature. Straightforward tasks are more likely to be handled directly. Complex tasks still get specialist help when it adds value. Long-running sessions keep moving with fewer unnecessary pauses.

The change is intentionally behind the scenes. Your workflow does not change. But Copilot CLI is better at coordinating work: fewer unnecessary handoffs, less repeated search work, fewer failed tool paths, and faster progress on long or multi-step tasks.

To get the benefit, make sure you are on version 1.0.42 or later. You can update by running the /update command in your terminal. That is it. No configuration. No new flags. The orchestration just works better.

A quick checklist for users who want to confirm the change is live:

• Update to Copilot CLI 1.0.42 or later with /update
• No new settings or configuration needed
• Simple tasks stay in the main agent
• Complex tasks still get parallelized correctly
• Fewer stalled sessions and repeated searches

Trade-offs

The new policy is not strictly better for every workflow. If you have a heavily customized setup that depends on the old delegation behavior, you may notice that some multi-step tasks that previously spawned a subagent now run inline in the main agent. That is usually faster, but it can change the shape of session logs in ways that matter if you have analytics or audit tooling that expects a specific call graph.

There is also a learning curve for users who trained themselves to issue broad prompts to “let the subagent handle it.” Those prompts now route differently, and the same prompt may produce different results than it did a month ago. If you have muscle memory around specific prompt phrasings, expect a brief adjustment period.

The change is also invisible, which is its own downside in a way. There is no new feature flag to celebrate, no release notes paragraph with your name in it, no migration guide to follow. You just notice that things feel less janky. That is harder to attribute and easier to take for granted, which is part of why GitHub did the public A/B test: they wanted numbers to point at instead of vibes.

What I would tell past me

If I were setting up a new Copilot CLI workflow today, I would do three things differently. First, I would stop pre-emptively asking for “thorough exploration” in my prompts. Let the agent decide when delegation helps, instead of forcing it from the user side. Second, I would structure long multi-step tasks as a single clear request rather than a chain of small ones. The new policy handles the breakdown internally, and the result is usually better than my hand-rolled split. Third, I would update to 1.0.42 or later on every machine I work on, because the version skew between machines is the silent cause of most “it works here but not there” debugging.

The broader lesson is worth naming. The instinct with agentic systems is often to add more agents, more models, more delegation logic. More capability means more power, right? Not necessarily. GitHub’s results show that the best system is not the one that delegates the most. It is the one that knows when to act directly, when to delegate, and how to keep work moving without adding friction. Sometimes the right call is to just do the thing instead of designing a hierarchy to do it for you.

If you only do one thing from this article, run /update in Copilot CLI today. The rest can wait.