A2A Protocol v1.0: What's New, What Changed, and What's Next

A2A Protocol Release Timeline for 2026

A2A reached v1.0 with wide backing. The Linux Foundation's April 2026 announcement, A2A surpasses 150 organizations, counted more than 150 supporting organizations and more than 22,000 GitHub stars on the core repository, with A2A support in Azure AI Foundry, Copilot Studio, and Amazon Bedrock AgentCore Runtime.

At the time of writing, v1.0.1 is still the latest specification tag. Commits merged to the main branch since then touch documentation, build tooling, governance files, and the partner list rather than the protocol, so code written against v1.0.1 is current.

What Changed in A2A Protocol v1.0?

The project's what's new in v1.0 guide calls the part redesign the most significant breaking change. It rates part parsing, Agent Card parsing, and the A2A-Version header as fixes to make immediately.

{
  "defaultInputModes": ["text"],
  "defaultOutputModes": ["text"],
  "description": "Echo server from the A2A CLI",
  "name": "echo-agent",
  "version": "1.0.0",
  "skills": [],
  "capabilities": { "streaming": true },
  "supportedInterfaces": [
    {
      "url": "http://127.0.0.1:18081",
      "protocolBinding": "HTTP+JSON",
      "protocolVersion": "1.0"
    }
  ],
  "url": "",
  "protocolVersion": "0.3"
}

{
  "error": {
    "code": 404,
    "status": "NOT_FOUND",
    "message": "failed to get task: task not found",
    "details": [
      {
        "@type": "type.googleapis.com/google.rpc.ErrorInfo",
        "domain": "a2a-protocol.org",
        "metadata": {
          "taskId": "00000000-0000-0000-0000-000000000000",
          "timestamp": "2026-10-15T18:09:38Z"
        },
        "reason": "TASK_NOT_FOUND"
      }
    ]
  }
}

New Capabilities in A2A v1.0

Beyond the breaking changes, v1.0 gives agents and clients capabilities that v0.3 did not have:

• ListTasks - an operation in the A2A specification that lists tasks with filters and cursor-based pagination, returns only tasks the caller is allowed to see, and sorts the most recently updated tasks first.
• Multi-tenancy - a tenant field on every request lets one endpoint host many agents, and each interface in the Agent Card can declare a default tenant.
• Signed Agent Cards - a card can carry JWS signatures (RFC 7515) computed over its canonical JSON form (RFC 8785), so a client can check who published a card before trusting it across organizations.
• Version negotiation - clients send A2A-Version on every request, and a server that does not support the requested version must return VersionNotSupportedError.
• Blocking and non-blocking sends - SendMessage waits by default until the task reaches a terminal or interrupted state. With return_immediately set, it returns at once and you poll GetTask, subscribe, or receive push notifications.
• Modern OAuth - the device code flow (RFC 8628) covers CLIs and headless clients, and pkceRequired tells clients when PKCE is mandatory for the authorization code flow.

A2A v1.0.1 Patch Fixes

v1.0.1 is a maintenance release. Its release notes list specification fixes that change guidance and examples rather than adding operations:

• Media type - the HTTP+JSON binding now says requests and responses SHOULD use application/a2a+json, while the JSON-RPC example keeps application/json.
• Error mappings - the HTTP status codes in the error mapping table now follow google.rpc.Code, and an accidental change to JSON-RPC error handling was reverted.
• Task states - examples use the TASK_STATE_ values, and the specification lists all four terminal states: completed, failed, canceled, and rejected.

An HTTP+JSON server that still sends application/json stays within the rule, because it is a SHOULD. Switching to application/a2a+json matches the media type the specification's examples now use.

A2A Joins the Agentic AI Foundation

In August 2026, the project announced it was joining the Agentic AI Foundation (AAIF) as a Growth Stage project. AAIF is directed by the Linux Foundation and also hosts MCP, goose, and AGENTS.md, so A2A's roadmap is no longer tied to a single vendor.

The specification, the six official SDKs, and the v1.1 proposals all live on the a2aproject GitHub organization, so that is where to follow changes and comment on them before they ship.

The Official A2A CLI

The A2A project published introducing the A2A CLI on 1 October 2026, presenting a2a as the official command-line client for any A2A agent. It is built on the CLI from the A2A Go SDK, speaks protocol v1.0, and supports JSON-RPC, REST, and gRPC.

It installs through Homebrew, WinGet, or go install. Start the built-in echo server in one terminal, then discover it and send it a message from another:

# terminal A
a2a server --echo --port 18080 --name "echo-agent" --description "Echo server from the A2A CLI"

# terminal B
$ a2a card get -a http://localhost:18080
Name:         echo-agent
Description:  Echo server from the A2A CLI
Version:      1.0.0
Interfaces:
  HTTP+JSON    http://127.0.0.1:18080
Streaming:    true

$ a2a send -a http://localhost:18080 "hello from a v1.0 client"
Task:     01a140c0-ad24-7085-9917-c155ee7c64c4
Context:  01a140c0-ad24-78a9-899f-43a9d7b4e91d
Status:   completed (2026-10-15T23:38:51+05:30)
Artifacts:
  [01a140c0-ad24-78aa-9a79-75155d00fe30] hello from a v1.0 client
History:
  [user] hello from a v1.0 client

Add -o json and the same send shows the v1.0 wire format directly: no kind on parts, ROLE_USER for the role, and TASK_STATE_COMPLETED for the state.

{
  "task": {
    "id": "01a140c0-adda-7689-ac3c-d7ee0c3a2ce6",
    "artifacts": [
      {
        "artifactId": "01a140c0-adda-768b-9874-34d3f8725cb5",
        "parts": [{ "text": "hello from a v1.0 client" }]
      }
    ],
    "contextId": "01a140c0-adda-768a-b731-b915e9e09d2a",
    "history": [
      {
        "messageId": "01a140c0-adb8-74d8-9bfc-593b58b64a88",
        "parts": [{ "text": "hello from a v1.0 client" }],
        "role": "ROLE_USER"
      }
    ],
    "status": {
      "state": "TASK_STATE_COMPLETED",
      "timestamp": "2026-10-15T23:38:51.6744285+05:30"
    }
  }
}

The --exec mode goes further: it wraps any program that reads a message on stdin and prints a reply on stdout as an A2A server, which makes it a quick way to put an existing script or agent behind an A2A endpoint for local testing.

Note: Once an agent answers a2a send, the next question is what it did with the task. TestMu AI's Agent Assurance runs from your terminal as rook and invokes your agent the way a real client would, against staging. Try the rook CLI

How to Test A2A Agents With Rook

Conformance tells you an agent speaks A2A correctly. It does not tell you whether the agent completed the task it accepted, refused an instruction injected by a peer, or kept data it should not share, and those failures travel across agent boundaries.

Agent Assurance tests that behavior. It derives scenarios from your agent's code or spec, functional and adversarial by default, invokes the real agent, and grades each acceptance criterion as Pass, Fail, or Unable to Verify against evidence rather than the agent's own account of its work.

Rook reaches an agent through a profile: an HTTP endpoint, a command, or an MCP tool (stdio MCP servers only in the current release). An A2A agent that serves JSON-RPC or HTTP+JSON is an HTTP endpoint, so there is no separate A2A plugin to install.

Call POST https://agent.staging.example.com/message:send.
Send Content-Type: application/a2a+json and A2A-Version: 1.0.
Read A2A_TOKEN from the environment and send it as a Bearer token.
Send the goal as message.parts[0].text, with role ROLE_USER and a new UUID as messageId.
Leave configuration.returnImmediately unset so the call blocks until the task finishes.
The answer is the text of task.artifacts[].parts[]; if the response is a message, use message.parts[].text.
Return that text as agent_reply.
Return task.contextId as the conversation handle and send it back as message.contextId on later turns.
Keep task.id and task.status.state as extra fields.
Use "what can you do?" to verify it. Do not delegate real work during verification.

mkdir partner-agent && cd partner-agent
a2a card get -a https://agent.staging.example.com -o json > agent-card.json
# add the agent's PRD or API notes and call.txt next to the card

rook login
rook project create "partner-agent"
rook explore .
rook agent use <agent-id>
rook profile add a2a-staging --from call.txt
rook profile test a2a-staging --goal "what can you do?"
rook profile use a2a-staging
rook generate
rook scenarios list
rook sync
rook run --profile a2a-staging
rook report --json

A2A v1.1 Roadmap

The A2A roadmap, last updated on 15 September 2026, lists these near-term initiatives:

• v1.1 core robustness - refined task timelines, standard event filtering that stays backward compatible, and rules for messages an agent receives while it is still working. The related task-history work tracks gaps such as messages that carry no timestamp.
• Bidirectional streaming - real-time artifact updates, role management, and continuous multi-turn messaging while a task runs.
• A2A CLI and coding harnesses - the CLI as the bridge between coding tools and A2A agents.
• Elicitation and multi-turn workflows - structured human-in-the-loop interaction and multi-round negotiation patterns drawn from telecom use cases.

For validation, the roadmap points to the A2A Inspector and the A2A Technology Compatibility Kit. None of these initiatives is part of a release yet, and bidirectional streaming targets how task updates flow while a task runs, so keep stream handling behind one adapter in your client and your tests.

Conclusion

Start with your Agent Card: fetch it with a2a card get -o json, confirm it lists supportedInterfaces with protocolVersion 1.0, then send one request with A2A-Version: 1.0 and check the parts, role, and state values in the reply.

Once the wire format holds, test behavior. The Agent Assurance quickstart takes you from install to a first run against a sample agent, and the same profile approach then works on your A2A endpoint.