Overview
Multi-Agent Orchestration is the smallest section at 5%, with two objectives. The first asks you to judge whether a multi-agent design inside one Salesforce org, which Salesforce calls Single-Org, Multi-Agent (SOMA), suits a scenario's scalability and control needs. In that pattern an orchestrator or supervisor agent gives users one front door and routes work to specialist agents, for example billing, support or returns.
The second objective covers open standards. Model Context Protocol (MCP) lets Agentforce use tools and resources exposed by external MCP servers through a standard contract, and Salesforce can also expose capabilities as an MCP server. The Agent2Agent (A2A) protocol lets agents from different vendors delegate tasks to each other, inbound or outbound. Salesforce's interoperability guidance sums up the choice: if the remote capability is a tool, use MCP; if it is a collaborating agent that owns its own reasoning, use A2A.
How it's tested
Questions give an agent landscape, such as one agent with too many topics, several departments wanting their own agents, or an external system that must work with Agentforce. You decide whether a multi-agent pattern fits and whether MCP, A2A or a standard action is the right integration.
-
One agent or many
An agent is growing or several teams own processes, and you judge whether a SOMA design with an orchestrator improves scalability and control.
-
Tool or collaborator
An outside capability must be used, and you choose MCP for tools or A2A for agents that reason independently.
-
Keep it simple
A small use case is presented with a complex multi-agent option, and you recognize that one agent with clear topics is enough.
A company's single service agent now has 30 topics owned by four departments, and misrouting is rising. Each department wants to release changes on its own schedule. A SOMA design with an orchestrator agent routing to four specialist agents reduces topic overlap and lets each team test and deploy independently. A partner's shipping-rate service, by contrast, is a simple tool, so it fits MCP rather than A2A.
Objectives 2
Official objectives from the Salesforce outline, in outline order.
6.1 Given a scenario, determine whether a Single-Agent (SOMA) architecture is appropriate for scalability and control.Deciding between one agent and orchestrated specialists.
- What it means
- SOMA, as described in Salesforce's interoperability guidance, means several specialized Agentforce agents in one org behind a single conversational entry point. An orchestrator or supervisor agent interprets the request and delegates to the right specialist, either through model-driven routing or deterministic logic in Agent Script.
- What to understand
- Choose a multi-agent design when one agent has grown too many overlapping topics, when separate teams need independent ownership and release cycles, or when specialists need different permissions. Keep a single agent when the scope is small and topics are distinct. Avoid anti-patterns such as many delegation layers, overlapping specialist scopes and every agent talking to every other. Each specialist still needs its own tests, agent user permissions and monitoring.
- How it shows up
- An agent or program is described with growth, ownership or control concerns, and you decide whether orchestration helps.
- Common confusion
- Assuming more agents always scale better, when routing overhead and overlap can make results worse.
6.2 Explain the purpose of existing open standard multi-agent protocols such as MCP and A2A.Model Context Protocol and Agent2Agent in Agentforce.
- What it means
- MCP is an open protocol that standardizes how AI applications discover and call tools, resources and prompts on external servers. A2A is an open protocol for agents built on different platforms to discover each other's capabilities and exchange tasks and results.
- What to understand
- In Agentforce, MCP client support lets admins register external MCP servers so agents can use their tools without custom integrations, with safety checks applied, and Salesforce also offers hosted MCP servers that expose its capabilities to other AI hosts. A2A supports outbound delegation from Agentforce to a partner agent and inbound requests from external agents. The deciding question is whether the remote side is a tool you call or an agent that owns part of the reasoning.
- How it shows up
- An external system or partner AI must work with Agentforce, and you choose MCP, A2A or neither.
- Common confusion
- Treating MCP and A2A as interchangeable, when MCP connects tools and A2A connects autonomous agents.
High-yield concepts
The terms, rules and formulas this domain turns into questions most often.
-
SOMA
Single-Org, Multi-Agent: several Agentforce agents in one org behind one entry point.
- Remember
- An orchestrator routes requests to specialist agents.
- Tested as
- Scalability and ownership scenarios.
- Trap
- Using it for a small, simple scope.
-
Orchestrator agent
Agent that interprets requests and delegates to specialists.
- Remember
- Also called a supervisor; can route by reasoning or script.
- Tested as
- Multi-agent design questions.
- Trap
- Giving it its own business actions that overlap specialists.
-
Specialist agent
Agent focused on one domain such as billing or returns.
- Remember
- Owns its own topics, tests and permissions.
- Tested as
- Ownership and release scenarios.
- Trap
- Overlapping scope with other specialists.
-
MOMA
Multi-Org, Multi-Agent delegation across Salesforce orgs.
- Remember
- Delegation is limited to keep chains short.
- Tested as
- Context for cross-org questions.
- Trap
- Confusing it with SOMA.
-
Model Context Protocol (MCP)
Open standard for exposing tools and resources to AI applications.
- Remember
- Use when the remote capability is a tool.
- Tested as
- Tool integration scenarios.
- Trap
- Using it for an agent that plans on its own.
-
MCP client in Agentforce
Agentforce calling tools on registered external MCP servers.
- Remember
- Admins register servers; Agentforce stays the orchestrator.
- Tested as
- Connecting external tools without custom code.
- Trap
- Expecting no admin approval or review.
-
Agent2Agent (A2A)
Open protocol for agents on different platforms to exchange tasks.
- Remember
- Use when the remote side owns its own reasoning.
- Tested as
- Partner agent collaboration scenarios.
- Trap
- Using it for a single API call.
-
Deterministic routing
Orchestrator handoffs written in Agent Script.
- Remember
- Predictable delegation for known request types.
- Tested as
- Control-focused scenarios.
- Trap
- Relying only on model routing where rules are fixed.
-
Delegation depth
How many layers of agents call other agents.
- Remember
- Keep layers few to avoid latency and confusion.
- Tested as
- Anti-pattern questions.
- Trap
- Chaining agents several levels deep.
Side by side
Concepts candidates mix up, compared on the point that decides the answer.
Single agent vs SOMA
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Single agent | One agent with distinct topics | Simplest to build, test and monitor | Keeping it after topics overlap heavily |
| SOMA | Orchestrator plus specialist agents in one org | Independent ownership and clearer scope | Adopting it for small use cases |
MCP vs A2A
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| MCP | Standard tool and resource access | Remote side is a tool | Using it for a reasoning partner |
| A2A | Agent-to-agent task exchange | Remote side is an autonomous agent | Using it for a simple lookup |
| Standard action or API call | Flow, Apex or external service action | Fits one well-known integration | Overlooking it when no protocol is needed |
Exam traps
Each trap is an answer that looks right. Learn the clue that should change your mind.
-
More agents scale better
- What candidates pick
- Recommend a multi-agent design for every program.
- Why it looks right
- It sounds modern and modular.
- Why it's wrong
- For small scopes, routing between agents adds latency and failure points without improving answers.
Clue to watch for The scenario lists only a few distinct topics.
-
A2A for tools
- What candidates pick
- Use A2A to call a partner's rate calculator.
- Why it looks right
- Both are integration protocols.
- Why it's wrong
- A calculator is a tool, which MCP or a standard action handles; A2A suits agents that plan and reason.
Clue to watch for The remote capability returns a value for given inputs.
-
MCP for collaborators
- What candidates pick
- Use MCP to work with a partner's autonomous agent.
- Why it looks right
- MCP is widely discussed.
- Why it's wrong
- MCP treats the remote side as a tool under Agentforce's control; a partner agent that owns its reasoning fits A2A.
Clue to watch for The partner system plans multi-step work itself.
-
Deep delegation
- What candidates pick
- Chain agents several layers deep for flexibility.
- Why it looks right
- Each layer seems to add specialization.
- Why it's wrong
- Each layer adds latency and loses context; Salesforce guidance favors shallow delegation.
Clue to watch for Requests pass through more than two agents.
-
Shared governance
- What candidates pick
- Assume the orchestrator's tests cover all specialists.
- Why it looks right
- The user sees one front door.
- Why it's wrong
- Each specialist has its own topics, actions and permissions that need separate testing and monitoring.
Clue to watch for Specialists are owned by different teams.
Answer framework
Use these steps when a scenario raises multi-agent design or outside agent integration.
- Check whether one agent with distinct topics can meet the need before considering multiple agents, because each extra agent adds routing, testing and permission overhead.
- Choose a SOMA design with an orchestrator when topics overlap heavily, ownership is split across teams or permissions must differ by specialist.
- Define non-overlapping specialist scopes and decide whether routing should be model-driven or scripted for predictable cases such as order-status lookups.
- For outside capabilities, use MCP when the remote side is a tool and A2A when it is an agent that owns its reasoning.
- Plan testing, agent user permissions and monitoring for every specialist, keeping delegation shallow so failures stay easy to trace.
Practice question
Want more like this? The AI-201 practice test has questions for every domain.
Checklist
0 of 10
Tick each one you can do without notes. Your ticks stay in this browser.
Study strategy
Keep this section to a few focused hours. Start with Salesforce's Agentforce interoperability guide, which explains single-org and multi-org multi-agent patterns, orchestrator agents, MCP and A2A with use cases and anti-patterns. Read the public overviews of Model Context Protocol and Agent2Agent to understand what each standard defines, without going into protocol details.
Then sketch two designs on paper: a single agent with five distinct topics, and a program with an orchestrator and three specialist agents owned by different teams. For each, note how testing, permissions and monitoring change. Write a short list of external capabilities, such as a tax calculator, a partner's logistics agent and a document search service, and label each MCP, A2A or standard action.
High-priority ideas are the tool versus agent rule and the signals for orchestration. The most underestimated point is when not to use multiple agents. Practice by eliminating any answer that adds agents or protocols the scenario does not need.
FAQ
How much is Multi-Agent Orchestration worth on the Agentforce Specialist exam?
Multi-Agent Orchestration is 5% of the exam per third-party copies of the current guide, the smallest section, roughly three scored questions as a planning estimate.
What does SOMA stand for?
In Salesforce's interoperability guidance, SOMA means Single-Org, Multi-Agent: several Agentforce agents in one org, usually behind an orchestrator. The exam objective wording pairs it with 'Single-Agent', so read questions carefully.
Is the Agent API part of this section?
In the Spring '26 guide, the Agent API objective sits under AI Agents. The earlier Multi-Agent Interoperability section included it alongside MCP and A2A.
Do I need to know MCP message formats?
No. Know the purpose of MCP, how Agentforce uses external MCP servers as tools, and how it differs from A2A.
When is A2A the right choice?
When an external agent owns part of the reasoning or execution and Agentforce should delegate a task to it, or when an outside agent needs Agentforce's Salesforce expertise.
What replaced the Multi-Agent Interoperability section?
Multi-Agent Orchestration replaced it in the Spring '26 guide at the same 5% weight, adding the SOMA architecture decision and keeping MCP and A2A.
Other Artificial Intelligence & Machine Learning certifications
Where the same subject shows up in other exams. Cards marked "Same subject" open the matching domain.
Test your Domain 6 knowledge
You have covered single-org multi-agent design, orchestrators, MCP and A2A. Check whether you can tell when orchestration helps and which protocol fits.
Keep going
- Training Training Built on your Weak areas
- Practice test Questions by domain, with explanations
- Mock exam Full length, timed like the real exam
- Readiness test Find your weakest domain in minutes
- Cheat sheet Key terms and formulas on one page
- Ask the AI-201 AI tutor Get any concept explained your way