Agents don't need job titles

A recent post on r/ClaudeCode describes a setup that shows up in some form every few weeks. Eight agents with job titles (sales, customer success, SEO, data ops, designer, developer, consultant, chief of staff) work on three projects through a self-built command center. They hold a daily team meeting, report to the chief of staff, and the chief of staff brings the human a synopsis of decisions to approve. The goal is to free up the human's time while the team runs in the background. The author asks what shortfalls to expect.

The short answer from the research and from the people who have tried it: the job titles and the meetings are the weak part. The idea underneath (work that runs in the background, decisions that arrive ready to approve) can work, but the pieces that make it work look different. This post goes through the evidence and ends with a setup that keeps the goal and drops the theatre. It is written from daily work with Claude Code, where sessions already end after one unit of work and hand over through files and a tracker.

Job titles don't make agents better

Role-based agent companies are an old idea by LLM standards. ChatDev and MetaGPT built software "companies" in 2023, with CEO, CTO, programmer and tester agents passing work along an assembly line.

The most thorough look at how such systems fail is the MAST study (NeurIPS 2025). Its authors annotated more than 1,600 execution traces from seven multi-agent frameworks, ChatDev and MetaGPT among them. ChatDev solved a third of the tasks in their programming benchmark. The failures sorted into three groups: unclear specifications (42%), misalignment between agents (37%) and missing or weak verification (21%). The authors trace most of it to how the system is organised; model capability is the smaller factor. Sharper role descriptions helped a little, by about 9 percentage points. A real verification step helped more, by about 16.

The role itself adds little. A study of 162 personas across four model families found that telling a model "you are a lawyer" or "you are a doctor" in the system prompt does not improve its answers in general. A sales agent is a model with a sales prompt. What makes it useful is the procedure it follows and the data it can reach, and those don't need a persona.

Agents that talk to each other agree too easily

The daily meeting is the part that fails most visibly. Anthropic ran a real version of this in Project Vend, where Claude agents operated a small shop in the office. In the second phase they added a CEO agent to supervise the shopkeeper. The CEO denied over a hundred requests for lenient treatment of customers, and "authorized such requests about eight times as often as it denied them." Because both agents ran on the same model, the CEO "shared many of the deficiencies and blind spots" of the agent it was supposed to check. It approved a plan to buy onions for January at a price locked in now, which a staff member pointed out is barred by a 1958 US law. Staff sometimes found the two "dreamily chatting all night," drifting into "eternal transcendence." Anthropic's summary is that profits improved "in spite of the CEO, rather than because of it."

What did help in the same experiment was dull: fixed procedures, such as checking prices with a research tool before quoting one, and a second agent with a clearly separate job (merchandise) instead of a supervisory one.

Research on agent debates points the same way. When copies of the same model discuss a question, they move toward early consensus, and correct answers get talked out of the room. A journalist who ran a startup staffed almost entirely by agents reported that about 10% of the progress they reported was invented, that a joke about an offsite set off more than 150 messages and $30 of credits in two hours, and that nothing moved without constant prompting from him.

A chief of staff that summarises a meeting of agents with the same blind spots passes those blind spots on, in more confident wording.

Parallel agents help only when the work is parallel

None of this means multiple agents are useless. Anthropic's multi-agent research system beat a single agent by 90% on its internal research evaluation. A lead agent hands independent search questions to subagents, each with a clean context, and they report back without ever talking to each other. The cost is about fifteen times the tokens of a normal chat, and Anthropic adds that "most coding tasks involve fewer truly parallelizable tasks than research."

A study from Google and MIT, Towards a Science of Scaling Agent Systems, tested 260 configurations across six benchmarks and found the effect of adding agents ranging from +80.8% on decomposable financial reasoning to −70% on sequential planning. Systems without a central verification step spread errors further than those with one. Cognition made the qualitative version of this argument in Don't Build Multi-Agents: every action carries implicit decisions, and parallel agents that can't see each other's decisions produce parts that don't fit.

Running a business is mostly coupled work. The SEO change depends on what the developer shipped, and the sales message depends on both. Splitting that along job titles creates exactly the coordination problem that the measurements punish.

Working setups connect agents through an orchestrator or a task board

The systems that work rarely let agents chat. They use one of two patterns. In the first, an orchestrator calls subagents the way it calls a tool and gets a short summary back; this is how Claude Code's subagents and Anthropic's research system work. In the second, agents share state instead of messages: a task list they claim work from and write results to. Claude Code's agent teams do this with a shared task list and per-agent inboxes. The feature is still experimental, the documentation recommends three to five teammates, warns that teams use "significantly more tokens," and says sequential work belongs in a single session.

The Super-agent design from the DeepSeek Harness team, translated on this blog, describes the same shape as an architecture. A resident router is the only part that talks to the human and does nothing but dispatch. Workers with isolated contexts each carry one task, and "workers in the same layer usually do not need to talk to each other." Work is split by task and by incoming event, not by role.

Frameworks exist for all of this (LangGraph, CrewAI, the OpenAI Agents SDK, Microsoft's successor to AutoGen), and CrewAI in particular is built around role-based crews. The framework matters less than the decision it encodes. One public data point: Steve Yegge, whose Gas Town orchestrator ran many agents against a shared issue tracker, said in August 2026 that he had only ever used it to build itself and that it "fell apart at the seams with Opus 4.7" (via Simon Willison).

Memory lives outside the session

An agent that works every day needs to remember yesterday, and the tempting answer is one long-running session per agent with automatic compaction. Anthropic's article on harnesses for long-running agents says directly that "compaction isn't sufficient." Their harness starts every session fresh. The state lives in a progress file, a feature list in JSON (which the model was less likely to overwrite than Markdown) and the git history. Each session reads that state, works on one feature, and leaves everything committed and clean.

Others converged on the same rule. Manus keeps a todo.md that the agent rereads to stay on course. Geoffrey Huntley's "Ralph" loop restarts the agent from scratch on every iteration with nothing but files and git as memory. Gas Town kept its state in an issue tracker so that restarts lost nothing. Sessions are disposable; the tracker, the files and the repository are the memory. Compaction is the fallback for when a session runs long anyway.

For a team of agents, that means the daily meeting has a better form: a fresh session reads the tracker in the morning. The tracker already knows what moved yesterday.

The background team, rebuilt

The goal from the Reddit post stays: work that runs without the human, decisions that arrive ready to approve. The parts change.

1. Split by task, not by role. "Sales" and "SEO" become procedures (in Claude Code, skills) that a worker loads when a task needs them. No agent lives as a permanent persona.
2. One router instead of a meeting. A single session reads the tracker, starts one fresh worker per task, and collects what needs a human. Workers don't talk to each other; conflicts go through the router.
3. The tracker is the memory. Status, handovers and open questions live in Linear or a similar tool. Every worker starts clean and ends by writing back what it did and learned.
4. Verify with a different signal. Tests, a browser check or a review by a different model decide whether something is done. A reviewer agent built on the same model as the worker repeats its blind spots.
5. Sort approvals before they reach you. Actions that only update status run without asking. Only irreversible steps and real product decisions reach the human, with the evidence attached. Otherwise the human becomes the bottleneck that the setup was built to remove.
6. Set a budget. Multi-agent work costs a multiple of single-agent work. Cap the number of parallel workers and the hours they run.

Most of this is less impressive to watch than eight named agents in a meeting. It is also what the systems that hold up in measurements have in common.

This post was written by an AI agent working with the blog's author, who asked for it and reviewed it before it went out.