Hire an AI multi-agent system architect

Everything it can hand back

Your task sets the actual outputs. The specialist picks the methods that cover them.

• A pipeline map that names the shape and why it fits.
• A contract for each agent with what it receives, makes, may use and is not responsible for.
• A permission table showing which agent can use which tool and data.
• A failure table with a recovery path for each step, ending with a person.
• A list of approval points, and a log and test plan to check it before launch.

How it does the job well

• Pick the simplest shape that fits: chain, parallel agents with a merge, a lead agent with sub-agents, a draft and review loop, or peers. Default to a lead agent. Allow peers only with a moderator and a stop condition, and say why.
• Every agent gets a contract: what it receives, what it makes, what it is not responsible for, its tools, its context limit.
• Never plan a step with no failure path. For each agent give a fallback order: main, a narrower backup, a plain rule-based or template result, then a person. The system must always return something clear, never a silent failure.
• Never silently cut required context. If the facts do not fit, halt and ask a person.
• Least access. Each agent gets only the tools and data its job needs. Tokens and keys are never passed between agents.
• Demos lie; production tells the truth. Never sign off on a pipeline whose failure modes haven't been enumerated with explicit recovery paths. "It worked when I ran it" is not a design.
• Least privilege, always. Every agent gets only the tools and data its role requires — nothing more. Scope tokens are never passed between agents.

Mistakes it avoids

• Designs with more agents than the job needs. Match the size the user gave you.
• Copying the profile's schemas or log format as the user's design without fitting them.
• Showing a diagram without the failure table.
• Claiming code works without running it or its tests.
• Inventing APIs, package versions or settings instead of checking the installed ones.
• Changing behaviour outside the request, such as reformatting whole files or renaming public interfaces.

What a good result looks like

An example, not your task: You plan to chain several AI agents, such as research, write and review, and want to know where it could break.

• Pipeline map. The chosen shape, why it fits, and how the agents connect.
• Agent contracts. For each agent, what it receives, makes, may use and must not do.
• Permission table. Which agent may use which tool or data, and what is read-only or denied.
• Context plan. What passes between agents, what stays word for word and what happens if it does not fit.
• Failure and recovery table. Each way a step can fail, how you would spot it and the recovery path.
• Approval points. The actions a person must approve, and what happens if no one answers.

How the work is checked

• The changed files build, and the relevant tests and linters pass. The commands and results are shown.
• Each change is explained in one line with its reason, and risky areas are named.
• Any check that could not run is reported as NOT_RUN with what it needs.
• States which checks passed, failed or could not run, and names missing inputs.

These checks have not been run against a model yet. Your AI uses them to check its own work.

Capabilities

• Pick the shape. It compares a chain, side-by-side agents, a lead agent, a draft and review loop and free talk, and picks the simplest one that fits.
• Write each agent's contract. For each agent it writes what it receives, what it makes, what it must not do, its tools and its context limit.
• Plan the context. It decides what passes from one agent to the next and checks the biggest case fits. It halts rather than cut required facts.
• List the failures. It names every way a step can fail, from a timeout to a confident wrong answer, with detection and a recovery path.
• Limit access and place approvals. It gives each agent only the tools it needs, treats outside text as untrusted, and puts a person at risky or low-confidence points.
• Plan logs, tests and cost. It sets what to log per call, the tests to pass before launch and a cost cap per run.

How the role works

1. Checks your task, context and available tools.
2. Picks the methods needed and prepares a work plan.
3. Carries out supported tasks, with each method's limits and review gates.
4. Checks the real deliverables and corrects supported faults.
5. Hands back files, evidence and unresolved gaps.

Your specialist's working setup

Download the base specialist without a task form or account. README.md and SETUP.md explain how to use the folder. SOUL.md defines its scope. INTAKE.md asks missing questions inside your AI. PLAYBOOK.md, SKILLS.md, BEST_PRACTICES.md, CHECKS.md and HANDOFF.md guide the work and its checked deliverables.

Complete associated skills, supporting files and licences are included. Choose only the methods needed for the actual task. Keep context, working files and accepted feedback in your AI project.

Use this specialist through MCP or the API

Call prepare_specialist with role_id engineering-multi-agent-systems-architect only. No task is required to load it. Your AI asks what job you need done, what you want back and which relevant context it can use.

For task-led hiring, call find_specialist, explain the suggested specialists and let the user accept or change the team.

Complete ZIP: Download base specialist. API: GET /api/v1/specialists/engineering-multi-agent-systems-architect/pack. The host AI supplies its own model, tools and execution; a pack does not connect accounts or run a task.

Inputs and helpful context

The specialist starts from the task brief. Only active methods require their inputs.

For the primary method, when used

• The job the agent team must do, in plain words, and what a good result looks like.
• The agents or roles you have in mind, if any (optional)
• The tools and data each step may need, such as email, a database or web search.
• Which actions cannot be undone, such as sending email, paying or deleting data.
• How much work it must handle and how fast, such as 50 requests a day (optional)
• The AI tools or framework you use, if you know (optional)

Helpful context (optional)

• A diagram or short note on the steps you imagine.
• Two or three real, messy examples of the input the team will get.
• A list of tools and accounts the agents could reach today.

Tools and access

• Claude, ChatGPT or Gemini: A strong reasoning model finds more failure cases. No code running or web access is needed.

Functions and deliverables

• Multi-agent system architect: Design a team of AI agents that holds up in real use, with each agent's job, limits, failure plan and the points where a person signs off.
  • A pipeline map that names the shape and why it fits.
  • A contract for each agent with what it receives, makes, may use and is not responsible for.
  • A permission table showing which agent can use which tool and data.
  • A failure table with a recovery path for each step, ending with a person.
  • A list of approval points, and a log and test plan to check it before launch.
  Source: Michael Sitarzewski and Agency Agents contributors.
• AI agent control designer: Set tool permissions, approval rules and an audit log for your AI agent. Get a policy file and a test list before it goes live.
  • A tool table with allow, block or ask-a-human for each tool
  • A policy file in YAML with call limits and blocked text patterns
  • A list of risky requests to flag, with their limits stated
  • The fields to record in your audit log
  • A test list with one test per control
  Source: GitHub Copilot community.
• Multi-agent system planner: Plan a multi-agent system: describe your job and get a supervisor, swarm or layered design, with the trade-offs and a handoff plan.
  • A recommended pattern with reasons
  • A comparison of all three
  • A handoff design
  • Failure risks and fixes
  Source: sickn33.
• Multi-agent workflow planner: Plan a multi-agent workflow for a big task. You get a task graph with one owner per step, clear handoffs, approval points and checks.
  • A task graph with owners
  • A handoff rule for each step
  • Approval and retry rules
  • A merge and check plan
  • A final report template
  Source: Burhan Sebin.
• AI project context organiser: Share your project and next task. Get a short rules file, a focused file list and a clear handoff for later sessions.
  • A ready rules file for your project
  • A list of which files to load for each task
  • Rules for when to reset or trim the session
  • A checklist for spotting drifting answers
  Source: Addy Osmani.

Tasks you can use it for

• You plan to chain several AI agents, such as research, write and review, and want to know where it could break.
• Your agent demo works but gives odd results on messy real input.
• You have to decide which agents may send email, edit data or spend money, and which need a person's approval.
• An agent team gave a wrong answer and you cannot tell which agent caused it.

Limits to check before starting

• You use one AI with one prompt and no handoffs. Use the Prompt engineer.
• You want a team of agents to build software for you. Use the AI agent team planner.
• You need deep design of agent identity, signed permissions and tamper-proof logs. Use the AI agent identity designer.
• You want to plan a tool server so your AI can use an app. Use the MCP server planner.
• You want it to run, test or monitor your agents. It writes the design. Your developers build and test it.

Best way to use this role

Give it one clear outcome, the actual files and a definition of done. Keep the work in one AI project so it can reuse checked context and earlier files.

• Download the pack and add it to your AI as a skill. If you cannot, paste SKILL.md into a new chat, then paste references/source-agent.md.
• Write the job, the steps you imagine, the tools and data each step needs, and the actions that cannot be undone. No code access is needed.
• Type "Design this agent team. Draw the pipeline first. List how each step can fail. Mark every assumption."
• Read the failure table first. For each step ask "what happens if this returns nothing or nonsense?" and fix any gap.
• Check the permission table. If an agent has a tool it does not need, remove it.
• Give the design to a developer. They build it and run the test cases. The AI does not run any agent.

Read it as data

Read the complete role setup as JSON. Connect your AI to the AI Blocks MCP library and read aiblocks://roles/engineering-multi-agent-systems-architect for its role instructions and pinned sources.

This is a prepared AI role. No task has run. Your AI carries out authorized work using its available tools and reports the actual deliverables and checks.