A Multi-Agent Systems Architect designs how many AI agents work together. Who does what, how work passes between them, what they remember, and how one bad agent is stopped from spoiling the rest.
The role is new, and it exists because systems of agents break in ways a single model never does. Teams are now running agents in parallel on real work, and the weak point has moved from the individual agent to the space between them.
Most people doing this today carry another title, such as senior engineer or platform architect. The work is real even when the name is not.
What agents already do
Agents already carry out long stretches of delivery work. One engineering team describes running 30 or more coding environments in parallel on a shared codebase, each with filesystem access, test execution and git. The system now produces draft pull requests that have been through several rounds of writing, testing, review and verification before a person sees them.
Another account describes a system that combines delegation, independent review of implementation, negotiation over shared resources and broadcast of constraints. A person discusses scope and approves a plan, then the system runs for hours or days.
Agents also handle the plumbing of coordination. Common designs put one supervising agent in charge of planning, delegating and deciding when a task is done, or let specialists contribute to a shared memory. Checker agents, tests and retries are part of the standard build.
Where agents help and a person decides
Agents can draft an architecture, propose a split of roles and generate the evaluation cases. They are useful for reading long traces and pointing at where a run went wrong.
The architect judges the result. Is this split sensible, or just a copy of a human org chart? Does the proposed shared state have clear owners? Is the trace pointing at the real fault, or at the last agent to touch it?
The same applies to choosing a pattern. A supervisor gives control but becomes a bottleneck once tasks turn exploratory. An agent can lay out both options. A person who has seen each fail decides which to live with.
Agents can build the system faster than anyone can understand it, which is why the architect's job is to keep it understandable.
What still needs a person
Failure design stays human. In one reported run, an agent built its whole API layer on a module another agent never exported. Tests passed because the downstream agent mocked the dependency. The pull request looked clean and the system did not work. Spotting that kind of fault takes someone who expects it.
So does the decision to use fewer agents. Every extra agent adds hand-offs, state and ways to fail. Someone has to be willing to say that three agents would do the job better than eight.
Accountability also stays with a person. Where the work is regulated, audit requirements are strict, and the architect decides what gets recorded, what needs approval and where a human signs off.
Finally, there is the prompting fallacy. As one practitioner puts it, you cannot prompt your way out of a system-level failure. Fixing the design, not the wording, is the job.
What this means for who you hire
Hire for systems discipline first, and agent experience second. The strongest profile understands ownership, versioning, conflict handling, retries and observability, and has watched model-driven agents misbehave in practice.
The profile losing value is the diagram-maker. Someone who can draw boxes and arrows, name agents after job titles and describe the happy path adds little. So does the prompt specialist who treats every failure as a wording problem.
Expect the first months to produce a written architecture others can build against, with roles, hand-off rules and failure boundaries. Expect system-level evaluation, so you can tell whether a change helped, and a team that can debug coordination without calling the architect in.
Be honest with candidates that the title is new. You will spend as much time explaining the role as assessing people for it.
How to spot a strong candidate
Tell me about a coordination failure you found in production. How did you diagnose it and what changed?
A good answer is a concrete case, such as looping, deadlock or conflicting writes, found through traces and fixed in the design rather than with a prompt tweak. Vague or blame-shifting answers are a warning.
How would you evaluate a system of agents as a whole, not just each agent?
A good answer covers end-to-end task success, trace review, regression sets and isolating which agent caused a fault. Someone who only tests agents one at a time has not met the real problem.
Also ask when they would not use multiple agents. The best answers come quickly.
Where to find them
Start with distributed systems and workflow orchestration engineers who have moved towards agent work. Look too at people from reinforcement learning, game theory and agent evaluation.
Common titles are distributed systems engineer, platform architect and research engineer. Good candidates sit in enterprises building internal agent platforms, AI platform companies and teams working with agent frameworks.
Many have no agent title at all. Read what they built, not what they were called.
Sources
- The Multi-Agent Architecture That Actually Ships — Luke Alvoeiro, Factory | AI Engineer, ai.engineer
- Beyond Vibe Coding: How We Ship Production Code with 200 Autonomous Agents — AgentField, agentfield.ai
- Multi-Agent Orchestration Design Patterns | Domino.ai, domino.ai
- Designing Effective Multi-Agent Architectures – O’Reilly, oreilly.com
Our own analysis, drawn from the role profile in our job families library and recent public reporting on how agents are used in this work. Titles and practice vary by company.