Skip to content

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 option

Rule 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 ​

BoundaryCopilot Studio Wins When...AI Foundry Wins When...Custom Azure Wins When...
Who builds itCitizen dev / business analystPro-code developers with ML expertiseExisting dev team with microservices
User interactionConversational agent with chat UINo direct user interaction (backend)Event-driven, no chat, batch
Model needsPre-built models + prompt engineeringFine-tuning, custom training, evaluationCall models from existing code
IntegrationD365, Power Platform, M365, TeamsCustom backends, third-party MLExisting Azure microservices
UI automationNo API available -> Computer UseN/ACustom screen-scraping (only if devs)
Agent orchestrationA2A protocol, multi-agent with biz logicComplex custom orchestrationSimple function chaining

The 5 Elimination Rules ​

#RuleKills Which Trap
1Temperature/confidence is NEVER a security fix.Temperature for auth, temperature for prompt injection
2Rollback fixes deployment errors, not knowledge gaps.Rollback for glossary incidents
3Permission problems get permission fixes. Content problems get content fixes.Role mapping for prompt injection
4Governance goes FIRST. Monitoring goes AFTER promotion.Telemetry too early, governance too late
5Tenant 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 isOpen standard for agents communicating with and delegating tasks to other agents across platformsOpen standard for connecting AI models/agents to external tools and data sources
DirectionAgent <---> 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?"
AnalogyTwo specialists consulting each other on a patient caseA doctor using a stethoscope, ordering lab tests
Who defines itGoogle (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
1Agent needs to delegate a subtask to another agent with its own reasoningA2AThe other entity is an agent, not a tool
2Agent needs to call an API, query a database, or read a fileMCPThese are tools/data sources, not agents
3Agents from different vendors or platforms need to collaborateA2AA2A is the interoperability standard
4Agent needs to discover what another agent can do before delegatingA2AAgent cards enable capability discovery
5Agent needs to discover and invoke tools exposed by an external systemMCPMCP servers expose tool schemas
6Multi-agent orchestration where coordinator manages specialistsA2AAgent-to-agent delegation with lifecycle management
7Agent needs to read/write to SharePoint, Dataverse, or databasesMCPData sources -- MCP connects agents to resources
8Agent needs to pass a task to a completely separate agent (different org)A2ACross-organizational agent communication
9Agent needs to execute a function (send email, create record)MCPTool invocations, not agent conversations
10Agents to negotiate, plan, or coordinate on a shared goalA2ARequires 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  -> MCP

Red 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 ​

DimensionA2AMCP
Other entityAgent (autonomous, reasoning)Tool or data source
InteractionConversation, negotiation, delegationFunction call, data query
StateBoth sides maintain stateServer is typically stateless
DiscoveryAgent cardsTool/resource schemas
Task managementFull lifecycle (submit, check, cancel)Request/response
Use together?Yes -- same agent, different connectionsYes -- complementary
Open standard byGoogleAnthropic

Personal study notes written from official documentation. Not affiliated with Microsoft or GitHub. Contains no exam questions.