AB-100 platform selection
Two platform questions come up again and again: which Microsoft platform should build the solution, and which protocol connects the pieces.
Quick-Reference Decision Tree
START: What does the scenario need?
|
+- "Conversational agent for business users"
| +- Citizen developer / low-code team? -----------------> Copilot Studio
| +- Needs D365 or Power Platform integration? ----------> Copilot Studio
| +- Needs topics, prompt actions, agent flows? ---------> Copilot Studio
| +- Needs Computer Use (UI automation w/o APIs)? -------> Copilot Studio
|
+- "Custom AI model or complex AI pipeline"
| +- Fine-tuning, custom training, model evaluation? ----> Azure AI Foundry
| +- RAG with vector search + custom embeddings? --------> Azure AI Foundry
| +- Multi-model orchestration (not multi-agent)? -------> Azure AI Foundry
| +- Red-teaming / safety benchmarking? -----------------> Azure AI Foundry
| +- Model catalog / endpoint management? ---------------> Azure AI Foundry
|
+- "Full code-level control, non-conversational workload"
| +- Event-driven processing (no user-facing chat)? -----> Custom Azure (Functions)
| +- Existing microservices architecture? ---------------> Custom Azure (Functions)
| +- Sub-millisecond latency / extreme throughput? ------> Custom Azure (Functions)
| +- Need to call AI Foundry models programmatically? ---> Custom Azure (Functions) + AI Foundry APIs
|
+- BOUNDARY: Two options seem valid?
+- Agent + custom model? --> Copilot Studio (front) + AI Foundry (back)
+- Agent + event pipeline? -> Copilot Studio (chat) + Functions (processing)
+- Read the constraints --> The constraint eliminates one optionRule of thumb: Microsoft prefers the highest-level managed platform that satisfies the constraints. Only drop down to custom code when the scenario explicitly requires it.
Summary: Boundary Rules to Memorize
| Boundary | Copilot Studio Wins When... | AI Foundry Wins When... | Custom Azure Wins When... |
|---|---|---|---|
| Who builds it | Citizen dev / business analyst | Pro-code developers with ML expertise | Existing dev team with microservices |
| User interaction | Conversational agent with chat UI | No direct user interaction (backend) | Event-driven, no chat, batch |
| Model needs | Pre-built models + prompt engineering | Fine-tuning, custom training, evaluation | Call models from existing code |
| Integration | D365, Power Platform, M365, Teams | Custom backends, third-party ML | Existing Azure microservices |
| UI automation | No API available -> Computer Use | N/A | Custom screen-scraping (only if devs) |
| Agent orchestration | A2A protocol, multi-agent with biz logic | Complex custom orchestration | Simple function chaining |
The 5 Elimination Rules
| # | Rule | Kills Which Trap |
|---|---|---|
| 1 | Temperature/confidence is NEVER a security fix. | Temperature for auth, temperature for prompt injection |
| 2 | Rollback fixes deployment errors, not knowledge gaps. | Rollback for glossary incidents |
| 3 | Permission problems get permission fixes. Content problems get content fixes. | Role mapping for prompt injection |
| 4 | Governance goes FIRST. Monitoring goes AFTER promotion. | Telemetry too early, governance too late |
| 5 | Tenant settings != environment DLP != row-level security. | Tenant settings for user-level data filtering |
A2A vs. MCP
| A2A (Agent-to-Agent Protocol) | MCP (Model Context Protocol) | |
|---|---|---|
| What it is | Open standard for agents communicating with and delegating tasks to other agents across platforms | Open standard for connecting AI models/agents to external tools and data sources |
| Direction | Agent <---> Agent (peer-to-peer or hierarchical) | Agent ---> Tool/Data Source (client-server) |
| Problem it solves | "How do independently built agents collaborate on complex tasks?" | "How does an agent access tools, APIs, and data it needs?" |
| Analogy | Two specialists consulting each other on a patient case | A doctor using a stethoscope, ordering lab tests |
| Who defines it | Google (open standard, adopted by Microsoft) | Anthropic (open standard, adopted by Microsoft) |
The One-Liner
- A2A = agents talking to agents (collaboration/delegation)
- MCP = agents talking to tools and data (capability/access)
If/Then Decision Rules
| # | IF... | THEN use... | Why |
|---|---|---|---|
| 1 | Agent needs to delegate a subtask to another agent with its own reasoning | A2A | The other entity is an agent, not a tool |
| 2 | Agent needs to call an API, query a database, or read a file | MCP | These are tools/data sources, not agents |
| 3 | Agents from different vendors or platforms need to collaborate | A2A | A2A is the interoperability standard |
| 4 | Agent needs to discover what another agent can do before delegating | A2A | Agent cards enable capability discovery |
| 5 | Agent needs to discover and invoke tools exposed by an external system | MCP | MCP servers expose tool schemas |
| 6 | Multi-agent orchestration where coordinator manages specialists | A2A | Agent-to-agent delegation with lifecycle management |
| 7 | Agent needs to read/write to SharePoint, Dataverse, or databases | MCP | Data sources -- MCP connects agents to resources |
| 8 | Agent needs to pass a task to a completely separate agent (different org) | A2A | Cross-organizational agent communication |
| 9 | Agent needs to execute a function (send email, create record) | MCP | Tool invocations, not agent conversations |
| 10 | Agents to negotiate, plan, or coordinate on a shared goal | A2A | Requires agent-level intelligence on both sides |
The Meta-Rule
Ask: "Is the thing on the other end an AGENT (with its own reasoning) or a TOOL (a function/data source)?"
- Agent -> A2A
- Tool/Data -> MCP
How A2A and MCP Work Together
They're complementary, not competing:
Copilot Studio
+----------+
| Your |---- A2A -----> External Specialist Agent
| Agent |
| |---- MCP -----> SharePoint (data)
| |---- MCP -----> REST API (tool)
| |---- MCP -----> Prompt Library (prompts)
| |---- A2A -----> D365 Service Agent
+----------+Trick Question Eliminators
"It uses AI internally, so it must be an agent" -> WRONG
From the agent's perspective, if it calls an API endpoint with input and gets output, it's a tool via MCP. Internal implementation doesn't determine the protocol.
"It's third-party, so A2A" -> WRONG
Third-party APIs are tools via MCP. "Third-party" doesn't mean agent. Evaluate agent characteristics (state, reasoning, conversation).
"It delegates work, so A2A" -> WRONG
You "delegate" to tools too. A2A delegation means giving a task to an autonomous reasoner. Check if the other side reasons independently.
"The vendor calls it an agent" -> WRONG
Marketing labels are irrelevant. Evaluate behavior: stateless API vs conversational agent.
"It performs a complex task, so it must be an agent" -> WRONG
Complex tools exist (search engines, diagnostic APIs). Agency = state + reasoning + conversation, not complexity.
Quick Reference Decision Card
Does the other entity:
- Maintain conversation state?
- Ask follow-up questions?
- Reason autonomously?
- Negotiate or refuse?
- Have its own goals?
YES to any -> A2A
NO to all -> MCPRed Flags That Signal A2A (Not MCP)
- "The other agent decides..."
- "...may ask clarifying questions"
- "...built by a different team/vendor as an autonomous agent"
- "...agent card" or "capability discovery for agents"
- "...multi-agent orchestration"
- "...task lifecycle (pending, working, completed)"
Red Flags That Signal MCP (Not A2A)
- "...REST API" or "...API endpoint"
- "...returns structured data"
- "...defined input/output schema"
- "...stateless" or "no conversation"
- "...data source" or "...knowledge source"
- "...tool" or "...function" or "...resource"
- "...prompt template library"
Summary Table
| Dimension | A2A | MCP |
|---|---|---|
| Other entity | Agent (autonomous, reasoning) | Tool or data source |
| Interaction | Conversation, negotiation, delegation | Function call, data query |
| State | Both sides maintain state | Server is typically stateless |
| Discovery | Agent cards | Tool/resource schemas |
| Task management | Full lifecycle (submit, check, cancel) | Request/response |
| Use together? | Yes -- same agent, different connections | Yes -- complementary |
| Open standard by | Anthropic |