MyDot Consultancy

Featured image: AI-generated conceptual illustration. Sources checked 26 October 2026.

Adding more agents can make a system look more capable without making the work better. The important question is whether the task contains useful independent branches and whether the benefits of separating them exceed the cost of coordination. Start with the work graph, not an organizational chart of imaginary specialists.

A work graph shows which outputs depend on which inputs. Some tasks naturally split into independent investigations. Others revolve around a shared record that should be changed in a controlled sequence. Those shapes suggest different architectures, even when the user experiences both through the same conversational interface.

Compare two hypothetical tasks

A market-research brief might examine several suppliers independently, then combine the findings into one comparison. Each branch can gather sources and return a structured result. Separate contexts may help keep the investigations focused, provided the final reviewer checks consistency and evidence.

An order correction is different. The agent must resolve identity, inspect the current order, obtain approval and apply one change. Splitting every step among autonomous workers may add handoffs without creating useful independence. If several workers can edit the same order, coordination becomes a safety issue.

Anthropic’s multi-agent research case study describes parallel investigation with a coordinating agent and discusses additional reliability challenges. It is evidence about one architecture and use case, not proof that multi-agent systems outperform single agents on every business task.

Build the single-agent baseline first

Give one bounded agent the necessary tools, clear instructions and a representative task set. Measure accepted outcomes, review effort, cost and latency. Inspect failures before deciding that another agent is the remedy.

If the problem is missing data, ambiguous tools or weak authorization, dividing the work may reproduce the same problem in several places. A second agent does not automatically provide independent evidence, especially when it uses the same source and inherits the same mistaken assumption.

A baseline makes the architecture discussion concrete. The team can ask whether delegation improves a particular failure mode or merely moves it into the coordination layer. Without a baseline, a more elaborate system can receive credit for benefits that a simpler design would also have delivered.

Separate context when it has a purpose

A specialist task can benefit from a focused context and narrow toolset. For example, one research worker may review technical documentation while another checks publicly stated support terms. Their assignments should produce distinct evidence rather than duplicate summaries of the same pages.

Define what each worker must return: findings, source links, unresolved questions and scope limitations. The coordinating process should not accept a confident conclusion without enough provenance to inspect it. A summary is a compression of evidence, and compression can omit important qualifications.

The OpenAI Agents SDK orchestration guide distinguishes patterns coordinated through models and through code. That gives implementation choices, but the work graph should determine which choice fits. A fixed sequence of known steps may be better orchestrated deterministically.

Account for coordination costs

Parallel branches still need instructions, tool calls, result handling and synthesis. Workers may duplicate searches or reach incompatible conclusions. A coordinator may spend substantial effort resolving differences. Include that work in the comparison rather than measuring only the time spent inside each branch.

Define ownership of shared artifacts. If workers edit the same file or record, decide whether they operate on separate sections, return proposed changes or use a controlled merge process. Avoid allowing the architecture’s diagram to conceal competing writes.

Consider failure isolation too. If one worker cannot access a source, the coordinator should retain that gap and decide whether the final output can proceed. It should not silently fill the missing branch with an unsupported inference. Partial failure needs a business policy, not just an exception handler.

Keep authority local to the subtask

Delegation should not copy every permission from the parent. A source-review worker may need read-only access to one repository. A drafting worker may need no external tools at all. Limit each role to the capabilities required for its assigned output.

If a consequential action requires approval, delegation does not remove that requirement. Make the action owner explicit and link the approval to the eventual execution. A coordinator’s instruction to “finish the job” should not be interpreted as new authority for every worker.

Run an architecture comparison

• Use the same task set and acceptance criteria for single-agent and delegated designs.
• Count all worker and coordinator usage, including retries and duplicate research.
• Inspect source quality and contradictions in the final synthesis.
• Measure end-to-end latency rather than only parallel branch duration.
• Test a failed worker, an unavailable tool and conflicting partial results.
• Check that shared-state writes and approval boundaries remain controlled.

The OpenAI evaluation guidance supports evaluating the actual application rather than relying on generic model benchmarks. Apply that principle to architecture: measure the assembled system under the conditions it will face.

Choose the smallest design that earns its complexity

A hybrid may be best. One agent can manage the user interaction while code launches a few bounded research tasks. A deterministic workflow can route specialized questions without giving every component autonomy. Architecture is not a contest to maximize the number of agents.

Document why each additional agent exists and what evidence would justify removing it. A role that does not improve quality, isolation or useful concurrency may be unnecessary. As models, tools and workloads change, revisit the decision rather than preserving complexity as an achievement.

Multi-agent systems are valuable when the work genuinely benefits from decomposition and the coordination is well designed. Start with dependencies, evidence and authority. If those are clear, the number of agents becomes an implementation decision rather than a substitute for understanding the task.

Sources and further reading

Anthropic: How we built our multi-agent research system. First-party parallel research architecture and operational challenges; published June 2025.

OpenAI Agents SDK: Agent orchestration. Model-led and code-led orchestration patterns; checked October 2026.

OpenAI: Evaluation best practices. Application-specific evaluation principles; checked October 2026.