One Agent, One Job: Why Specialist Crews Beat Generalists

One agent trying to research, judge risk, and write the report — that's not one job. That's three. It's the same failure mode you'd see on any team at work: one person doing every job badly, instead of a small crew where each person owns one thing and does it well. Agents are no different.

Why one generalist agent struggles

A single agent juggling multiple responsibilities has to hold every role's context, every role's tools, and every role's judgment calls in one prompt and one set of decisions. That's a recipe for the same problems generalists have everywhere: it's harder to debug (which part of the job went wrong — the research, the analysis, or the writing?), harder to improve in isolation (fixing the writing style risks disturbing the research logic), and harder to reason about, because the system prompt has to cover every responsibility at once.

The fix is separation of concerns: split the work across a small crew of narrow, specialized agents that each handle one step and hand off to the next.

A worked example: the stock brief crew

Take a task like producing a daily stock brief. Structured as one job, split across a crew, it looks like this:

Collect → Summarize → Flag Risks → Write

• One agent collects the data — pulls the relevant numbers, news, and filings. Its only job is gathering, not judging.
• One agent summarizes it — condenses the raw data into a digestible shape. It doesn't decide what's risky, just what's relevant.
• One agent flags the risks — reviews the summary and calls out what's concerning. This is a distinct judgment call from summarizing.
• One agent writes the final brief — turns the summary and the risk flags into the finished document, focused purely on communication.

Each agent has a narrow, well-defined role instead of one agent trying to do all four things in a single pass. That's the same idea as a team at work: not one person doing every job badly, but specialists handing off to each other in sequence.

How to build a crew

1. Identify the distinct responsibilities inside your current single-agent workflow. Look for the natural seams — usually anywhere you'd describe the task using "and" (research and analyze and write).
2. Give each agent a role, a goal, and only the tools it needs for that one job. A collector agent doesn't need a risk-scoring tool; a writer agent doesn't need data-fetching tools. Narrow scope keeps each agent's decisions simpler and its failure modes smaller.
3. Define the hand-off. Each agent's output becomes the next agent's input — a clean contract (e.g., collector outputs raw data, summarizer outputs a condensed summary) makes it obvious where a bug or bad output originated.
4. Test and improve each agent independently. Because responsibilities are separated, you can iterate on the writer agent's tone without touching how data gets collected, or swap out the risk-flagging logic without redoing the summary step.

Going further: nesting agents

Once you have a crew, you can compose crews too. A common advanced pattern is nesting agents, where one agent calls another agent as if it were just another tool — the calling agent doesn't need to know how the nested agent does its job, only what it returns. This is useful for large systems with a lot of moving parts, letting you build hierarchies of specialists rather than a single flat list of tools handed to one generalist.

Pitfalls

• Don't over-split. A crew of fifteen micro-agents for a simple task adds coordination overhead (and LLM calls) without a matching benefit — split along real, distinct responsibilities, not arbitrarily.
• Don't skip defining the hand-off contract. If agent outputs aren't structured predictably, the next agent in the chain inherits ambiguity instead of a clean input, and debugging gets harder, not easier.
• Don't give every agent every tool "just in case." Restricting each agent to only what its one job needs is what keeps its behavior legible — a collector agent with write access to send emails is a design smell, not a convenience.

Resources

• CrewAI docs — Agent roles, goals, and tools
• Anthropic — Building Effective Agents (multi-agent patterns)