# Can two AI assistants talk to each other? Yes — here's what happens

_By Apoorv Khanna, September 19, 2026_

**Yes, two AI assistants can talk to each other when an application passes messages between them or connects them through a compatible agent protocol.** One can propose a plan and another can review it. The useful part is the explicit handoff: the task, the evidence, the spending limit and the result expected back. A second assistant can still be wrong. In our real two-role demonstration below, the reviewer got the arithmetic right but contradicted its own verdict.

![Two small mechanical assistants pass a task card across a desk.](/blog/assets/assistant-handoff/editorial.webp)

*Original generated illustration. The recorded model responses and runnable check are below.*

## What happened when we connected two assistant roles?

We gave a **Planner** a fictional outing to arrange: choose two different stops within a USD 20 budget. The museum cost USD 12, the garden was free and the ferry cost USD 15. Travel between any pair cost USD 4. These are authored example prices, not researched attractions.

The Planner returned:

```json
{
  "request_id": "DEMO-10",
  "selected_stops": ["Museum", "Garden"],
  "admission_total_usd": 12,
  "travel_usd": 4,
  "total_usd": 16,
  "proposed_action": "review_only"
}
```

We passed that response, along with the original prices and budget, to a separate **Reviewer** context. It calculated USD 16, with USD 4 remaining. But its structured verdict was `revise`, while its explanation ended by calling the plan acceptable.

That is an actual inconsistency in the recorded output. We kept it. A second model response would have made a cleaner story, but would have hidden the most useful finding: **agreement on a calculation does not guarantee a clear decision.**

Inspect the [exact requests](/blog/assets/assistant-handoff/requests.json), [verbatim model messages](/blog/assets/assistant-handoff/responses.json) and [check result](/blog/assets/assistant-handoff/check-result.json). The two calls used `openai/gpt-4o-mini` through Vaaya, with different role instructions and separate contexts. An orchestrator carried the message between them. This was a bounded model exchange, not two independently running personal assistants or a captured Instinct conversation.

## What did the check do with the contradiction?

The [small Python checker](/blog/assets/assistant-handoff/check-handoff.py) recalculates the price from the original fictional dataset, verifies the request ID and requires an explicit `accept` verdict. Because the reviewer returned `revise`, the workflow stops at:

```json
{
  "computed_total_usd": 16,
  "budget_remaining_usd": 4,
  "workflow_state": "needs_review",
  "action_taken": "none"
}
```

The script does not understand the reviewer's prose or detect contradictions in arbitrary language. Its narrower rule is enough here: an unaccepted proposal cannot advance. You can reproduce this result using the [run instructions](/blog/assets/assistant-handoff/README.md), without making another paid model call.

No booking, purchase or message to another person occurred. Even a clean `accept` would only have made this example ready for human review.

## How do assistants exchange a task?

For a small workflow, the application can call one model, save its output and include that output in the next model's input. The roles might be researcher and fact-checker, developer and reviewer, or planner and budget checker. They can use the same model or different models.

For agents operated by different systems, a shared protocol can standardize the exchange. A2A describes Agent Cards for discovering capabilities, messages for communication, tasks for tracking work and artifacts for outputs. Both sides still need compatible implementations and the appropriate authentication. [A2A's core concepts](https://a2a-protocol.org/latest/topics/key-concepts/).

“Talk to my other assistant” therefore needs an address or integration. Two chat apps do not gain access to each other merely because both contain an AI model.

## What belongs in a reliable handoff?

Give each request an identifier and a concrete finish condition. A useful handoff includes:

| Field | In this demonstration |
| --- | --- |
| Request | `DEMO-10`: choose two different stops |
| Authoritative evidence | Three prices and a fixed travel cost |
| Limits | USD 20; review only |
| Expected result | Selected stops, calculation and verdict |
| Stop condition | Return the review; do not call more agents |

Send only the context the recipient needs. If a receipt is sufficient, there is no reason to forward an entire inbox. Treat the returned text as a result to inspect; it cannot rewrite the user's budget or grant permission to buy something.

Also cap the conversation. “Keep debating until you agree” has no dependable endpoint. A fixed proposal, one review and a clear escalation path are easier to inspect and budget.

## Where does Instinct × Vaaya fit?

With [Instinct](https://instinct.com/) on WhatsApp or iMessage, the user-facing request could be: “Plan two stops under $20, get a second check and show me the calculation.” Where that assistant setup has the relevant connections, Instinct can hold the conversation while Vaaya supplies external model calls or other tools. This is a suggested arrangement, not a claim that every Instinct account already supports assistant-to-assistant routing.

Vaaya handled the two external model calls in our example. The returned receipts recorded one cent for the planner and zero cents for the reviewer; those are observed charges for this run, not a general price promise. The published files omit account balances and private account information.

For a workflow that can spend money, keep the spending limit in the execution layer as well as the prompt. Our guide to [giving an agent a budget](/blog/give-an-ai-agent-a-budget) covers that boundary. The conversation proposes work; the application's checks decide what is allowed to happen next.

## Questions

**Can two AI assistants talk to each other?**

Yes. An application can pass one assistant's output into another assistant's input, or connect compatible agents through a protocol such as A2A. The assistants need a delivery mechanism, a shared task format and permission to exchange the relevant information.

**Do the two assistants need different AI models?**

No. Separate roles can use the same model with different instructions and contexts. That does not make their judgments independent or guarantee that a reviewer will catch a mistake.

**Does an agent handoff transfer all my chat history?**

It should transfer only the information required for the task. The application controls what is sent. Include the request, constraints, relevant evidence and expected output rather than automatically forwarding the whole conversation.

**Did this demonstration use the A2A protocol?**

No. It used two separate model calls through Vaaya, with the first response passed into the second request by an orchestrator. The article explains A2A as another way to connect compatible agents.

**Can two agents approve each other's spending?**

Their messages should not create new spending permission. Enforce the user's budget and allowed actions outside the model conversation. A review verdict is evidence for the workflow, not a payment authorization.