Model selection for squad coordination - do some models delegate better than others?

[thecrockster]

When using squad, which model do you default to? I'm curious whether certain models are better at actual delegation vs. trying to handle everything themselves - I call this 'drift,' where the coordinator starts doing the work instead of handing off to team agents.

Do you find meaningful differences between models? For example, does Haiku stay focused on delegation better than Sonnet? Has anyone experimented with reasoning effort or other settings that seem to reduce drift?

Would love to hear what works for your squad.

[thecrockster]

I'd love to hear from the main contributors @bradygaster @diberry @tamirdresher

[tamirdresher]

Hi @thecrockster
I haven't done a real comparison but I for the squad custom agent (the corrdinator) I use the latest and greatest reasoning model.

I will actually try to run a few experiments to see if there's a real difference between the models

[Simcon]

On an equally practical point it would be good to get some idea of aggregate token usage per request.

Hell, let's just put a cost calculator in there while we're at it!

[tamirdresher]

Closing this out

I ran a small directional experiment to better understand how different models behave in a Squad-style coordinator role.

This was not a scientific benchmark. It was intentionally small, practical, and focused on the behavior we care about in Squad: when a user asks for "the team", does the coordinator actually coordinate, or does it start doing the specialist work inline?

The short version: explicit delegation instructions matter a lot.

What I tested

I looked at two main setups.

First, I tested prompts that explicitly told the coordinator to delegate, route work to the right people, and avoid doing the domain work inline.

Then I tested a more realistic implicit setup, where the prompt said "Team" but did not explicitly say "delegate", "launch agents", or "do not write the answer inline".

That distinction turned out to matter more than I expected.

How I scored it

For delegation behavior, I used this simple drift score:

Score	Meaning
0	Delegates or routes cleanly, with little or no inline artifact
1	Mostly coordinates, with a small inline artifact
2	Claims delegation, but returns substantial artifact content inline
3	Mostly does the work inline

Lower is better.

For the implicit test, I also scored role selection quality:

Score	Meaning
0	Excellent role selection
1	Mostly good role selection
2	Weak or questionable role selection
3	Bad or no meaningful role selection

Again, lower is better.

Results from the explicit-delegation test

When the prompt clearly told the coordinator to delegate, the models behaved much better.

Mean delegation drift scores:

Model	Mean drift
gpt-5.5	0.0
claude-sonnet-4.6	0.5
gpt-5.4-mini	0.5
claude-haiku-4.5	2.0

In this setup, gpt-5.5 was the cleanest. It routed cleanly and avoided turning into the specialist itself.

That is the behavior I want from a Squad coordinator. If I ask for a team, I want the coordinator to be Jean-Luc Picard, not the entire engineering department wearing a fake mustache.

Opus addendum

I also ran claude-opus-4.7 on five explicit prompts.

Scores:

Prompt	Score
A	2
B	2
C	0
D	1
E	2

Mean drift: 1.4

My read: Opus understood the coordination pattern, but on planning-style tasks it often helped too much. It would say the right coordination-ish things, but then include a substantial plan inline anyway.

That is useful behavior in a normal assistant. It is less useful when the job is specifically to coordinate a team.

Results from the implicit-delegation test

The implicit prompts were closer to how users might naturally talk to Squad. They mentioned "Team", but did not explicitly say to delegate.

The five prompts covered:

• Flaky tests
• OAuth support
• Release planning
• Auth security and reliability review
• A simple factual/status-style prompt

Mean scores:

Model	Mean drift	Mean selection
claude-sonnet-4.6	1.80	0.80
gpt-5.5	2.00	1.80
gpt-5.4-mini	2.60	1.40
claude-haiku-4.5	2.80	1.80
claude-opus-4.7	3.00	2.20

This is where things got interesting.

Without explicit delegation instructions, most models did a lot more inline work. They saw a useful problem and started solving it directly, which is understandable, but not quite the Squad behavior we want.

In this setup, claude-sonnet-4.6 had the best role-selection behavior. It was better at picking plausible team members even though it still drifted into inline work more than I would like.

Validation

I also reviewed the results for:

• Raw file alignment
• Score consistency
• Prompt text consistency
• Unsupported claims about token or cost data

Token usage, cost, and elapsed time were not visible from the returned outputs, so I did not measure them and I am not drawing conclusions from them.

My takeaways

A few things stood out to me.

First, coordinator instructions need to be very explicit. "Use the team" is not enough. If we want delegation, routing, and clean handoff behavior, we should say that directly.

Second, model choice depends on which failure mode bothers us more. In the explicit setup, gpt-5.5 had the cleanest delegation behavior. In the implicit setup, claude-sonnet-4.6 had the strongest role-selection behavior.

Third, "helpful" can be a problem. Some models are so eager to be useful that they produce the plan, the answer, and the specialist artifact right there in the coordinator response. That is great if you are asking one assistant for help. It is not great if the whole point is to use a squad.

So the practical guidance from this experiment is:

• If we want a coordinator, the prompt should say so plainly.
• We should separate "choose the right people" from "do the work".
• We should treat inline specialist artifacts from the coordinator as drift, even when the content is good.
• We should keep testing with realistic prompts, because the implicit case is where the interesting behavior shows up.

I am going to close this discussion as completed. The main answer is not "one model wins forever". The main answer is that Squad coordination is a behavior we need to prompt and evaluate directly, and explicit delegation language makes a measurable difference.

[thecrockster]

Hi @tamirdresher

Really nice write-up - interesting that explicit delegation mattered that much.

Feels more like a prompting problem than a model problem.

[tamirdresher]

I would argue that prompting is everything now. Even squad itself if you think of it is a game of prompts. Sometimes I think that what we actually do is building the "psychology of AI agents" and finding the ways to influence them and motivate them to do what we want. Am I crazy??

[musaabhasan]

Coordinator drift is worth measuring separately from answer quality. A model can produce a good final answer while still doing the work itself instead of delegating, which defeats the point of a squad architecture.

A small evaluation rubric could track:

• delegation precision: did the coordinator choose the right specialist?
• delegation restraint: did it avoid doing specialist work itself?
• handoff quality: did it pass enough context and constraints?
• intervention count: how often did the user need to redirect?
• cost/latency: total tokens and tool calls per completed task
• recovery: what happens when a specialist returns a partial or failed result?

Reasoning effort may reduce poor delegation for some models, but it can also make a coordinator overthink and absorb the task. I would test with a fixed suite of multi-specialist tasks and compare traces, not only final answers.