Skip to content

A2A: When Agents Work Together

Agent Card, Message, Task and Artifact explained clearly: how A2A 1.0 connects independent agent systems, what sets the protocol apart from MCP and when delegating to an independent system pays off.

≈ 9 min readSoftwareAIArchitecture

An agent system needs a limited code change in someone else’s repository. It could load tools itself, read the code and draft the change. But it can also hand the job over to an independent system that runs in a different environment, has its own permissions and later reports back a verifiable result.

A2A 1.0 – the abbreviation stands for Agent2Agent – describes, for this second case, how a job is handed over and tracked between independent systems. The published specification of the open protocol covers how a client finds a remote agent, sends it messages, tracks longer-running tasks and receives results. It doesn’t prescribe which language model, which programming language or which framework works internally.

Independent is the key word#

Not every named role is a separate agent. If an application runs three prompts one after the other and manages all tools, credentials and state centrally, then from an architecture perspective, those are three work steps in one agent system. A2A brings little there.

A remote A2A agent, by contrast, is an independent service. Within its job, it decides for itself how it works. The calling agent sees the offered capabilities and the exchanged data, but not automatically the other system’s internal memory, reasoning or tools. This encapsulation separates the permission and task boundaries of both systems: the remote agent works with its own access rights, and only what the job calls for should be exchanged.

In the protocol, an A2A client makes contact on behalf of the user. The A2A server provides the remote agent. Client and server are communication roles, not classes of systems: for a different job, the same system can take on the other role.

flowchart LR
    U["User<br/>sets a goal"] --> C["Calling agent<br/>A2A client"]
    C -->|"Read Agent Card"| S["Remote agent<br/>A2A server"]
    C -->|"Message<br/>job and context"| S
    S -->|"Task<br/>state and follow-up questions"| C
    S -->|"Artifacts<br/>results"| C
    S --> M["Internal models, tools<br/>and data sources"]
    C -.->|"no automatic access"| M

The Agent Card is the description, not the permission#

Before a client sends a job, it has to know what the other agent offers and how it can be reached. That is what the Agent Card is for, a JSON document with metadata. The published A2A 1.0 specification describes in it, among other things, identity, supported interfaces and offered skills; as ways to obtain it, it names a standardized address (https://{domain}/.well-known/agent-card.json), as well as catalogs or a fixed configuration.

The following fictional publishing example is reduced to the fields needed here and doesn’t claim to be a complete A2A 1.0 Agent Card.

{
  "name": "Publishing Agent",
  "description": "Builds previews and prepares approved releases",
  "supportedInterfaces": [
    {
      "url": "https://publishing.example.com/a2a",
      "protocolBinding": "HTTP+JSON",
      "protocolVersion": "1.0"
    }
  ],
  "version": "1.0.0",
  "capabilities": {
    "streaming": true,
    "pushNotifications": true,
    "extendedAgentCard": true
  },
  "defaultInputModes": ["text/plain", "application/json"],
  "defaultOutputModes": ["text/markdown", "application/json"],
  "skills": [
    {
      "id": "prepare-publication",
      "name": "Prepare publication",
      "description": "Creates a preview from approved knowledge",
      "tags": ["publishing", "preview", "content"]
    }
  ]
}

The Agent Card is comparable to a public service description. The fact that a skill is listed there doesn’t yet permit a call. Authentication and authorization remain separate security decisions: for every job, the server has to check who is asking and what this client is allowed to do. A public Agent Card should also not reveal internal capabilities or confidential endpoints.

Message, Part, Task and Artifact#

Message, Part, Task and Artifact denote different building blocks of a job.

Term Meaning Example in delegated work
Message A conversational turn by the user or the agent “Analyze this dependency and propose a change.”
Part A component of a Message or an Artifact Instruction as text, a file or structured data
Task A stateful unit of work with a unique ID The job is waiting for an answer to a question or keeps working
Artifact A result produced by the agent Analysis report, prepared change, preview URL

A Message can be answered immediately with another Message. That fits a short conversation without a lasting work state. If the work has to keep running or be preserved across several conversation rounds, the remote agent responds with a Task.

The Task is more than a technical request ID. It holds the state of a domain unit of work. The client can read it later, answer a follow-up question or request a cancellation. According to the specification, several Messages can belong to the same conversation context via a contextId; a taskId denotes the concrete work. A simplified, non-normative example:

POST /message:send HTTP/1.1
Host: agents.example.com
Authorization: Bearer <token>
Content-Type: application/a2a+json
A2A-Version: 1.0

{
  "message": {
    "role": "ROLE_USER",
    "messageId": "msg-123",
    "parts": [
      {
        "text": "Prepare a limited change proposal. Do not merge it."
      },
      {
        "data": {
          "repository": "product-service",
          "scope": ["dependency-upgrade"]
        },
        "mediaType": "application/json"
      }
    ]
  }
}

The Parts separate different kinds of content within the same Message: text carries an instruction, a file hands over a document, structured data allows an agreed schema without parsing it out of prose again. The recipient has to check the media type, size, origin and permission of each piece of content.

Artifacts are the work results, not just conversational turns. According to the specification, a Task can deliver several Artifacts, and an Artifact can be extended step by step during a stream. The client should therefore store the Artifact ID and Task ID instead of just copying the last visible text. A typical first response looks like this – the server has accepted, but not finished yet:

{
  "task": {
    "id": "task-456",
    "contextId": "context-789",
    "status": {
      "state": "TASK_STATE_WORKING",
      "timestamp": "2026-08-07T10:05:00Z"
    },
    "artifacts": []
  }
}

The lifecycle makes longer work visible#

A2A is designed for asynchronous tasks. A server can return a Task immediately and keep working in the background. For updates, the specification provides three delivery paths: queries, a continuous stream or push notifications.

stateDiagram-v2
    [*] --> SUBMITTED
    SUBMITTED --> WORKING
    WORKING --> INPUT_REQUIRED: follow-up question
    INPUT_REQUIRED --> WORKING: further Message
    WORKING --> AUTH_REQUIRED: additional approval
    AUTH_REQUIRED --> WORKING: permission granted
    WORKING --> COMPLETED
    WORKING --> FAILED
    SUBMITTED --> REJECTED
    WORKING --> CANCELED
    COMPLETED --> [*]
    FAILED --> [*]
    REJECTED --> [*]
    CANCELED --> [*]

The diagram simplifies the state space defined in the version 1.0 specification. INPUT_REQUIRED means that the agent needs further domain information. AUTH_REQUIRED signals an authorization needed during the job; credentials don’t belong in a Message as plain text but go through a separate, previously agreed path. The specification defines COMPLETED, FAILED, CANCELED and REJECTED as final states. A client must not revive a final state by blindly retrying, but has to deliberately create a new Task.

Polling, streaming and push solve the same delivery problem in different ways. With polling, the client asks for the Task at sensible intervals – simple, but wasteful during long pauses. With streaming, a connection stays open and the server sends status and Artifact updates as events; after an interruption, the client has to read the stored Task again, because a stream is not an archive. Push notifications spare you the permanent connection, but require a secured HTTP endpoint on the client side, including authentication, protection against internal target addresses and handling of duplicate deliveries.

Delegation creates no new permission#

A2A doesn’t make any security decision for a system. A calling agent should not trust an Agent Card it found just because it is formally correct. Before a job, it has to be clear which provider your own system trusts, which data may leave it and which effects the remote agent can trigger.

The A2A server has the same obligation: for every job, it has to check who is asking and what this client is allowed to do, and treat Messages as untrusted input. The most important principle behind this: delegation must not create new permissions. Whoever submits a job must not gain more rights in the target system by doing so, and the executing agent must not silently inherit the rights of its client. The job stays limited.

A target system can make this limitation explicit: a delegated job is then bound to an active, human-approved job state. What this state doesn’t allow, even a technically correct A2A call cannot trigger. A human approval step thus remains a domain decision in the target system – an agent must not infer an approval from friendly wording in a Message.

MCP, A2A and a web UI are different access paths, not labels#

MCP provides an agent application with tools and context; responsibility for the open task stays with the application. A2A connects independent agent systems: the client hands over a goal, the remote agent is responsible for the execution and runs its own Task lifecycle. MCP and A2A thus model different responsibilities and lifecycles.

Question MCP A2A
Counterpart Capability server Independent agent system
Discoverable description Tools and context sources Agent Card with skills and interfaces
Typical work Select and call a tool Delegate a goal or subtask
Longer-running state Modeled by the application Task lifecycle is a protocol concept
Result Tool result or resource Message or one or more Artifacts
Internal implementation Capability with a defined schema Remote agent stays independent internally

On top of that comes a web UI as an access path for people. These access paths have different jobs, and a system can offer several of them without that turning into several domain models.

For example, a system can offer limited analysis and change jobs via A2A 1.0, while REST, MCP, A2A and the web UI read the same structured task and result record.

When A2A makes sense#

A2A pays off when several conditions apply at the same time: the agents involved are developed or operated independently. The work may take longer than a single request, needs follow-up questions or produces several results. The client defines the goal and the permitted effect; the remote agent is responsible for the internal execution.

For a known sequence of fixed steps, a deterministic workflow is usually simpler. Merely different role names, several language models or separate prompts don’t yet justify a distributed agent architecture – they only create an additional network boundary without an additional boundary of responsibility.

The decision can be anchored in who carries the responsibility for the open task. If it stays in your own application and only needs tools or context, MCP may be enough. If an independent system takes over a limited job with its own Task lifecycle, A2A is the right contract. If you keep these levels apart, you don’t build unnecessary agents – and you recognize the features of the delegation described here: an Agent Card, an authenticated call, a traceable Task and a limited job.

Further reading#

Revised and translated from German with the help of AI.