The Agent-to-Agent (A2A) protocol is a method for utilizing AI Agents which are not cohosted together. For example, you have AI Agent X located at an HTTPS address #1 and AI Agent Y hosted at HTTPS address #2 and AI Agent Z that runs from a Chat and needs to utilize X and Y. This reminds me of an old term Service Oriented Architecture (SOA) which is also like microservices, however in this case instead of running small snippets of highly optimized code, AI Agents are executed. Pretty smart, but the same in principle. It is more than MCP, I see it as something like an MCP for AI Agents instead of tools. Figure 1 is a mind map of a section of the AI-103 training on Microsoft Learn which specifically covers A2A.
Figure 1, A2A fundamentals
Table 1 provides some relevant information contained in Figure 1.
| Attribute | Description |
| Agent Card | the public profile of an agent |
| Agent Skill | represents a specific capability that an agent provides |
| Request Handler | the entry point into the agent |
| Agent Executor | the component responsible for performing the requested work |
| Agent Logic | the actual intelligence or business functionality |
| Server Application | the application that hosts the agent |
| Host | the environment where the server application executes |
Table 1, A2A attributes
Before I get to far into this, I think this is a very interesting “protocol” however I would choose another more enterprise proven, highly scalable and resilient solution for running, building, and maintaining a solution like this. That being said, let’s take a look at it as there is much to learn about this “MCP for AI Agents”.
NOTE: remember that every AI Agent always needs its set of instructions, I like to call these system prompts. The system prompt is sent to the LLM, in this context gpt-5-mini hosted on Microsoft foundry, along with the user prompt, which is the instruction the AI Agent is expected to infer within the constraints provided in the system prompt.
The exercise is located here so that you can review the details. The exercise consists of 3 AI Agents, title_agent, routing_agent, and an outline_agent, which when invoked infers the following prompt.
Create a title and outline for an article about passing the AI-103 certification.
As with any AI Agent implementation you must instantiate the AI Agent client. In this example there is a file named agent.py in the title_agent/ directory.
from azure.ai.agents import AgentsClient
from azure.identity import DefaultAzureCredential
self.client = AgentsClient(
endpoint=os.environ['PROJECT_ENDPOINT'],
credential=DefaultAzureCredential(
exclude_environment_credential=True,
exclude_managed_identity_credential=True
)
)
Listing 1, A2A instantiation of an AI Agent client
Next you instantiate the AI Agent with the client. The Microsoft Foundry project endpoint is passed as a parameter to with the client, Notice that the model is passed when the AI Agent instance is created, this supports the utilization of different models per AI Agent, make sense.
self.agent = self.client.create_agent(
model=os.environ['MODEL_DEPLOYMENT_NAME'],
name='title-agent',
instructions="""
You are a helpful writing assistant.
Given a topic the user wants to write about,
suggest a single clear and catchy blog post title.
""",
)
Listing 2, A2A AI Agent instantiation
The AI Agent creation is where you place the instructions, aka the system prompt. This is a relative simple one, but it is also the place you can implement safety controls and Human In The Loop (HITL) capabilities that can limit or prevent the AI Agent from acting in unexpected behaviors.
Because there are 3 individual AI Agents all running within the same process (in this case a process is something like an EXE) and we want them to execute in parallel we need to bind them to their own thread. Remember that a process can have multiple threads.
thread = self.client.threads.create()
Listing 3, A2A thread for each AI Agent for parallelism
In the title_agent/server.py file is where the Agent Skill is defined, as mentioned in Table 1 previously.
skills = [
AgentSkill(
id='generate_blog_title',
name='Generate Blog Title',
description='Generates a blog title based on a topic',
tags=['title'],
examples=[
'Can you give me a title for this article?',
],
),
]
Listing 4, A2A Agent Skill
LLMs are very great at making assumptions on what a human means when inferring a prompt. Sometimes the inference in unexpected due to the lack of clarity in the provided prompt, we call this hallucination. I believe we can prevent much of the hallucination by reducing the amount of ambiguity in instructions. Listing 4 is the place where you have control over the quality of the outcome. The name, the description, the tags, and examples if explained clear, simple, and in exact explanation of what the expectation from the AI Agent is will result in great inference.
The Agent Card as you can see is kind of like a business card that explains the details about the AI Agent.
agent_card = AgentCard(
name='Microsoft Foundry Title Agent',
description='An intelligent title generator agent
powered by Foundry. '
'I can help you generate catchy titles for your articles.',
url=f'http://{host}:{port}/',
version='1.0.0',
default_input_modes=['text'],
default_output_modes=['text'],
capabilities=AgentCapabilities(),
skills=skills,
)
Listing 5, A2A Agent Card
The Agent Card provides a description and the HTTP address of where and how to invoke it. The Agent Executor is a wrapper for the AI Agent.
agent_executor =
create_foundry_agent_executor(agent_card)
Listing 6, A2A Agent Executor
Notice that the agent_card is passed into the agent_executor. The Request Handler is used to handle the incoming requests to the agent_executor.
request_handler = DefaultRequestHandler(
agent_executor=
agent_executor, task_store=InMemoryTaskStore()
)
Listing 7, A2A Request Handler
Notice here that the agent_executor which links to the agent_card is passed into the request_handler. You can see how it is all linked together here.
Then finally, you link it all together with the Starlette Server Application, as seen in Listing 8.
a2a_app = A2AStarletteApplication(
agent_card=agent_card, http_handler=request_handler
)
Listing 8, A2A Server Application
So, there is a lot more to this in the background to invoke the threads, retrieve the list of remote AI Agents, make calls to the LLM to decide which AI Agents to use, invoke them, manage and consolidate their completions, then output a final response. One observation is that like with MCP servers, the tools are first retrieved and loaded into a local object list, then that is list is sent to the LLM for inferring which tools are useful for executing the instructions. This model here looks similar to that, but instead of MCP tools, AI Agents are utilized. Which is a way is very great.
Take note that the prompts being entered in the solution are related to the AI Agents configured within it, right? Some learnings I am gaining is that we cannot simply created a generic AI Agent or set of AI Agents and expect them to be magical and fulfill all our expectations. The AI Agents must be tuned, defined, hosted, and invoked in a scope for which the expected prompt categories target. I know that is clear, but one example is that you would not take you car to be repaired to a dentist.
The following 2 figures show the output of the A2A internal processing and information gathering. After that is the text generated by the 2 remotely hosted AI Agents.
Title - Master AI-103: Your Roadmap to Azure AI Engineer Success Article outline Introduction and purpose - Target audience: IT professionals preparing for the AI-103 exam - Goal: map study topics to exam skills and practical tasks - Outcome: pass the exam and be ready to implement Azure AI solutions - Recommended prior knowledge: basic Azure, ML concepts, and Python familiarity AI-103 exam overview: objectives and structure - Exam focus: designing, building, and deploying Azure AI solutions - Question types: scenario-based case questions, multiple choice, drag-and-drop - Typical domains: cognitive services, ML lifecycle, deployment, monitoring, security - Scoring and passing: weighted by skills measured (refer to Microsoft exam page) - Logistics: proctored online or test center; schedule on Microsoft certification portal Core knowledge areas aligned with AI-103 skills - Cognitive Services: Vision, Speech, Language, Decision - Service selection, API usage, customization, SDKs - Conversational AI and Bot Framework - Bot design, integration with Language Service, channels, QnA patterns - Azure Machine Learning and model management - Train, register, version, deploy models; pipelines and MLOps basics - Data engineering and feature pipelines - Data ingestion, preprocessing, storage; Azure data services for features - Deployment and scaling: endpoints, containers, AKS - Deploy models as endpoints, containerize, autoscale, cost controls - Monitoring, troubleshooting, and optimization - Telemetry, Application Insights, performance tuning, model drift detection - Security, identity, and governance - RBAC, managed identities, Key Vault, data protection, compliance - Responsible AI and ethics - Fairness, interpretability, privacy practices, documentation/processes Study strategy: resources, hands-on practice, labs, time management - Official resources - Microsoft Learn AI-103 modules, exam skills outline, product docs - Courses and books - Instructor-led training, Pluralsight/Coursera, official MS courseware - Practice tests and quizzes - Use MeasureUp or other reputable mock exams for timing and format familiarity - Hands-on practice and labs - Create an Azure free subscription or sandbox; complete cognitive services quickstarts - Build an end-to-end sample: ingestion → training → deployment → monitoring - Use GitHub sample repos and Microsoft Learn labs for guided exercises - Time-management techniques - Weekly study targets, active recall, spaced repetition, focused lab sessions - Track weak areas and allocate ~30-40% of lab time to them - Community and peer learning - Study groups, Microsoft Tech Community, Stack Overflow, study buddies Common pitfalls and how to avoid them - Studying only theory, no hands-on experience - Commit to project-based labs and real deployments - Ignoring Responsible AI and security topics - Study governance docs and include bias/fairness checks in labs - Not practicing scenario-based questions - Use mock exams and timed case practice - Poor time management during the exam - Practice pacing with full-length mocks; use question-flagging strategy - Relying on outdated docs or deprecated services - Verify resources against current Microsoft documentation and exam skills outline 8-week sample study schedule (estimate 8-12 hours/week) - Week 1: Azure fundamentals refresh; core AI service overview; set up Azure account - Week 2: Cognitive Services - Vision and Speech labs; quickstarts and APIs - Week 3: Language services and conversational AI; Bot Framework basics and QnA - Week 4: Azure Machine Learning fundamentals; register models and run pipelines - Week 5: Deployment scenarios - containers, AKS, endpoints, scaling and cost controls - Week 6: Monitoring, logging, model drift detection, optimization labs; security topics - Week 7: Full-length practice exams; identify weak areas and targeted remediation - Week 8: Final review of notes, one or two timed mocks, rest and logistics check Exam-day tips - Confirm ID, exam scheduling, and testing environment (for online proctoring) - Prepare your room: stable internet, quiet space, required materials out of sight - Read each question carefully; flag and return to uncertain items - Manage time: average time per question, leave buffer for review - Stay calm: breathe, take short mental breaks if allowed Conclusion and next steps - Book your exam date to create a firm deadline - Follow the 8-week plan, prioritize hands-on labs, and use practice tests - Join study communities, iterate on weak areas, then schedule the exam - Encouragement: consistent practice + focused review leads to success