When AI Agents Talk to Each Other

Since ChatGPT arrived, the shape of using AI has been fixed. You type, it answers, you decide what to do with the answer. Every product has been a variation on that loop, and you have been the one carrying things between them.

That loop started coming apart this year. Two products now let their AI agents talk directly to each other, a third coordinates a team of them through shared files, and an open-source foundation is hosting the standard for the version where they all can, across vendors. None of it is finished yet.

Claude sessions can now message each other

Claude Code is Anthropic’s terminal tool: it runs in the text window developers type commands into, rather than a chat box, and works on files on your own machine. You can have several conversations with it open at once, each one called a session. As of the August 2026 releases, separate sessions can send messages to each other and list which others are running. Later versions extended that across machines, so a session on your laptop can reach one on your desktop, and added an @ mention for naming which session you mean.

In practice that means one session can research while another writes, passing findings over directly instead of through you and a clipboard.

There is a third way to do this, and it is the one we have actually run. Cabinet wraps Claude Code and turns it into a small team: you create named agents, each with a role written in plain English, a schedule that fires it automatically, and a set of markdown files it reads and updates. The agents do not message each other. They coordinate through those shared files, the way colleagues coordinate through a shared drive rather than by copying each other on everything. We built one for this site in August and wrote up what it did.

The catch is that it is a developer tool. You need the terminal, you need to name your sessions, and you need to know which one you are addressing. It works, but you have to set it up.

Grok Bot says there is nothing to set up. What does that mean?

Grok Bot approaches the same idea from the other end. Its pitch is that there is nothing to configure. From the announcement: “Other AI tools may ask you to set up and build workflows and routines first. With Grok Bot, simply message a Bot to take on a task and it gets it done.”

The agent-to-agent part is part of the messaging itself. Bots “can independently message each other and share context in threads”, and you can “place Bots in a group chat where they can coordinate on their own. They pass work, assign ownership, and only pull you in for judgment calls.”

That last clause is the whole design. The bots decide when you are needed. Worth sitting with for a second, because it inverts the arrangement you have had with every AI tool until now. Everything in this section is xAI describing its own product; we have tested Grok Bot on real work in our Grok Bot review, but not the multi-bot coordination, so treat the group-chat behaviour as a claim we have not checked.

	Claude Code sessions	Grok Bot	Cabinet
Where it happens	Your terminal	A chat thread on phone or desktop	A local app on your own machine
Setup required	Name your sessions, know which to address	None stated	One command, then a five-question wizard
How agents reach each other	Sessions message each other directly; you name which one to address	They message each other on their own	Through shared files they all read and update
Who decides you are needed	You set up who talks to whom, then they hand off on their own	They do, for judgment calls	You do; work queues for approval
Across different vendors	No	No	No, it runs on Claude Code or Codex CLI

Why is this only a precursor?

The last row is the one that matters. Claude sessions talk to Claude sessions, Grok Bots talk to Grok Bots, and Cabinet coordinates agents that are all running on the same underlying tool. None of the three can hand work to an agent built by someone else. That is the limitation you would expect this early, and it is the thing being standardised underneath.

The standard is called A2A, short for Agent2Agent. Google built it, then donated it to the Linux Foundation so no single vendor owns it. In April 2026 the project announced it had passed 150 participating organisations, among them AWS, Cisco, IBM, Microsoft, Salesforce, SAP and ServiceNow, and said the protocol had been built into Microsoft’s and Amazon’s agent platforms. Signing on and shipping working support are not the same thing, and that count is the most recent public figure. The Linux Foundation describes A2A as letting agents “discover, communicate, and transact with each other across different frameworks, vendors, and platforms”, so they can “delegate sub-tasks, and coordinate complex workflows without sharing internal memory.”

That last phrase matters more than it looks, and it is easy to over-read. It means agents can work together without exposing how each one works inside: its tools, its state, its stored context. The protocol’s own summary calls them opaque applications. Whether your personal details travel with a handoff is a separate question, decided by what each agent chooses to send, and the standard does not settle it for you.

If MCP, the Model Context Protocol that connects one assistant to your files and apps, was about wiring an assistant to your tools, A2A is about wiring assistants to each other. What Claude Code and Grok Bot are doing now is the same idea, kept inside one company at a time.

Where does your review step go?

With one assistant, checking is obvious. It gives you something, you read it, you use it or you do not. With a chain of them, the output you see has passed through several hands, and the moments where checking would have helped most are already behind you.

A public database maintained by the researcher Damien Charlotin has recorded close to 2,000 court cases worldwide involving AI-invented material. Reading through them, the pattern is rarely an exotic model failure. It is that nobody read the output before it went out. We went through that database in what happens when AI invents court cases. Add a handoff between two agents and you have removed one more chance to notice.

• Put the check at the exit, not in the middle. You will not follow every handoff. Decide what leaves the system unread, and make that list short.
• Give agents narrow jobs. Narrow jobs make a chain auditable. Two generalists negotiating does not.
• Watch what they hand each other. A mistake that survives three agents almost never gets caught by the later ones. They inherit it and pass it on with more confidence than it started with.
• Keep a person on anything with a deadline or a penalty.

What agents handing off to agents cannot do

• They cannot tell you the task was the wrong task. A chain executes the brief it was given, faster and more agreeably than a colleague who would have pushed back.
• They cannot carry accountability across the handoff. When the output is wrong, the name on it is still yours.
• They cannot notice the thing nobody asked about, which is most of what an experienced person contributes.

Common questions about agent-to-agent AI

Do I need any of this today?

Almost certainly not. One assistant used well beats a chain of them used carelessly. This becomes relevant when you have a repeating job with distinct stages and you already trust the tool with each stage separately.

Is this the same as an AI agent?

An agent is a single assistant that can take actions rather than only answer. This is several of them coordinating. We cover the first distinction in AI agents versus chatbots.

Can a Claude agent talk to a Grok agent?

Not today. Both keep it inside their own product. Crossing that line is what A2A is being built for, and neither company has announced A2A support as of this writing.

Does one agent see everything another one knows?

By design, no. A2A is specified so agents coordinate without sharing internal memory. Inside a single product the answer depends on that product; Grok Bot says its bots share context in threads, which is the point of it. If you would not want an agent repeating something, do not tell it in a shared thread.

What should I actually do about it?

Nothing structural. Get good at checking one assistant’s work, because that habit is the thing that transfers. The people who will handle chains of agents badly are the ones who never built a review step for a single one.

Sources

• xAI — Introducing Grok Bot (all Grok Bot quotes above, read 30 August 2026)
• Linux Foundation — A2A protocol surpasses 150 organizations (9 April 2026)
• A2A Protocol — official documentation (originally built by Google, donated to the Linux Foundation)
• Anthropic — Claude Code changelog (cross-session messaging entries, read 30 August 2026)
• Damien Charlotin — AI Hallucination Cases database (read 29 August 2026)
• Grokipedia — MCP

Read next

• Grok Bot, tested on real work
• Building a team of AI agents
• AI agents versus chatbots
• What is Claude Code?
• What Claude remembers about you
• When AI invents court cases
• The AI glossary