Microsoft Agent Framework: Agent to Agent (A2A) with .NET

In this post, let's see how we can expose an agent over the Agent-to-Agent (A2A) protocol, and then call it from another application as if it were a local agent.

So far in this series, whoever called our agents either ran them in the same process or knew exactly how they were hosted. A2A is an open protocol for the case where they don't: an agent publishes a card describing itself, and any A2A client, built with any framework, can discover it and talk to it. Agent Framework has packages for both sides.

We'll use the same weekend-planner agent as in Getting Started with Microsoft Agent Framework 1.0.0 in .NET, with its three tools: GetWeather, GetActivities and GetCurrentDate.

Exposing the agent

The server is an ASP.NET Core application with these packages (latest as of today, it will change).

<PackageVersion Include="Microsoft.Agents.AI.Foundry" Version="1.25.0-preview.261014.1" />
<PackageVersion Include="Microsoft.Agents.AI.Hosting.A2A.AspNetCore" Version="1.25.0-preview.261014.1" />

The agent itself is created the usual way.

AIAgent agent = new AIProjectClient(new Uri(endpoint), credential)
    .AsAIAgent(
        model: deploymentName,
        name: "weekend-planner",
        description: "Plans weekends and suggests activities based on the weather.",
        instructions: """
            You help users plan their weekends and choose the best activities for the given weather.
            If an activity would be unpleasant in weather, don't suggest it.
            Include date of the weekend in response.
            """,
        tools: [
            AIFunctionFactory.Create(GetWeather, nameof(GetWeather)),
            AIFunctionFactory.Create(GetActivities, nameof(GetActivities)),
            AIFunctionFactory.Create(GetCurrentDate, nameof(GetCurrentDate))
        ]);

The agent card

Then the agent card. This is what other agents read to discover ours before they send it anything, and the client we write later starts from it.

// What other agents read to discover this one, before they send it anything
AgentCard agentCard = new()
{
    Name = agent.Name!,
    Description = agent.Description!,
    Version = "1.0.0",
    DefaultInputModes = ["text/plain"],
    DefaultOutputModes = ["text/plain"],
    Capabilities = new()
    {
        Streaming = false,
        PushNotifications = false
    },
    Skills =
    [
        new()
        {
            Id = "weekend-planning",
            Name = "Weekend planning",
            Description = "Suggests weekend activities for a city, based on the weather.",
            Examples = ["What should I do this weekend in Auckland?"]
        }
    ],
    SupportedInterfaces =
    [
        new()
        {
            Url = agentUrl,
            ProtocolBinding = ProtocolBindingNames.JsonRpc,
            ProtocolVersion = "1.0"
        }
    ]
};

There is no method that builds the card from the agent, so it is all ours to fill in. What the agent already knows, its name and description, we take from it, so they are defined in one place. SupportedInterfaces is what tells a client where to send messages and which binding to use, so it has to match the endpoint we map next.

Hosting it

Now we register an A2A server for the agent, map its endpoint, and serve the card.

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);
builder.AddA2AServer(agent);

// Sessions are not kept by default, so every message would start a new conversation
builder.Services
    .AddKeyedSingleton<AgentSessionStore>(agent.Name, new InMemoryAgentSessionStore());

WebApplication app = builder.Build();

app.MapA2AJsonRpc(agent, "/");

// Served at /.well-known/agent-card.json
app.MapWellKnownAgentCard(agentCard);

app.Run();

A few things to note here.

A2A defines two protocol bindings, JSON-RPC and HTTP+JSON, and there is a map method for each: MapA2AJsonRpc and MapA2AHttpJson. You can map both if you want clients to pick. Here I am using JSON-RPC only.

MapWellKnownAgentCard comes from the A2A SDK (A2A.AspNetCore), not from Agent Framework, and serves the card at /.well-known/agent-card.json. 

/.well-known/agent-card.json

Only one card can be served per host, so if you host several agents in one application, only one of them is discoverable this way.

The AgentSessionStore line is easy to miss. Without it, the server doesn't keep any sessions, so a follow-up message from the same client has no memory of the first one. InMemoryAgentSessionStore keeps them in the process, which is fine for a sample. It is still experimental, so you need to suppress MAAI001.

Calling it over HTTP

Before writing a client, let's see what is on the wire. Run the server, and use the following .http file.

@host = http://localhost:5000

POST {{host}}/
Content-Type: application/json
A2A-Version: 1.0

{
  "jsonrpc": "2.0",
  "id": "1",
  "method": "SendMessage",
  "params": {
    "message": {
      "messageId": "1",
      "role": "ROLE_USER",
      "parts": [
        {
          "text": "What should I do this weekend in Auckland?"
        }
      ]
    }
  }
}

Runs the agent, tools and all, and the answer comes back as an A2A message.

Agent Run

The contextId is the conversation. Send it back on the next message and the server picks up the same session from the session store; leave it out and a new conversation starts.

Note that the reply is a message, not a task. Agent Framework returns every response as an immediate message for now, as background responses aren't supported yet for A2A hosted agents.

Calling it from another agent application

The client is a console application with just one package.

<PackageVersion Include="Microsoft.Agents.AI.A2A" Version="1.25.0-preview.261014.1" />

It only needs the server's base address. It reads the card, and turns it into an AIAgent.

using A2A;
using Microsoft.Agents.AI;

string agentUrl = Environment.GetEnvironmentVariable("A2A_AGENT_URL")!;


// Reads the agent card from /.well-known/agent-card.json
A2ACardResolver cardResolver = new(new Uri(agentUrl));

AgentCard agentCard = await cardResolver.GetAgentCardAsync();

Console.WriteLine($"[A2A] Found '{agentCard.Name}': {agentCard.Description}");

// The remote agent becomes an AIAgent, called like any local one
AIAgent agent = agentCard.AsAIAgent();

// One session, so the follow-up continues the same conversation on the remote side
AgentSession session = await agent.CreateSessionAsync();

string[] userInputs =
[
    "What should I do this weekend in Auckland?",
    "What about the weekend after that?"
];

foreach (string userInput in userInputs)
{
    Console.WriteLine();
    Console.WriteLine("--- User ---");
    Console.WriteLine(userInput);

    AgentResponse response = await agent.RunAsync(userInput, session);

    Console.WriteLine();
    Console.WriteLine("--- Agent Response ---");
    Console.WriteLine(response.ToString());
}

Console.ReadLine();

That's the nice part. Once we have the AIAgent, nothing in the rest of the code knows it is remote. The session carries the contextId for us, so the second question is answered in the context of the first.

[A2A] Found 'weekend-planner': Plans weekends and suggests activities based on the weather.

--- User ---
What should I do this weekend in Auckland?

--- Agent Response ---
Weekend dates: **Saturday 2026-10-24 and Sunday 2026-10-25** in **Auckland**.
Forecast: **~18°C and rainy**, so I’d avoid **the beach** and **hiking** (wet, windy, slippery tracks).
// Omitted for brevity

--- User ---
What about the weekend after that?

--- Agent Response ---
Weekend dates: **Saturday 2026-10-31 and Sunday 2026-11-01** in **Auckland**.
Forecast: **~18°C and rainy**, so I’d skip **the beach** and **hiking** again (not great in wet weather).
// Omitted for brevity

And on the server, the tools ran for both weekends.

[Tool] Getting current date
[Tool] Getting weather for 'Auckland'.
[Tool] Getting activities for 'Auckland' on '2026-10-24'.
[Tool] Getting activities for 'Auckland' on '2026-10-25'.
[Tool] Getting weather for 'Auckland'.
[Tool] Getting activities for 'Auckland' on '2026-10-31'.
[Tool] Getting activities for 'Auckland' on '2026-11-01'.

Note there's no second GetCurrentDate call. The agent already knew today's date from the first turn, which shows the server really did keep the session.

The complete sample is here.

More read:

   Microsoft Agent Framework: A2A Hosting
   Microsoft Agent Framework: A2A Agent
   Agent2Agent (A2A) Protocol Specification

Hope this helps.

Happy Coding.

Regards,
Jaliya