How to Make Two AI Talk to Each Other

The short answer to how to make two AI talk to each other: something has to carry each model's reply to the other one, because no consumer chatbot listens to another on its own. That something can be you with copy and paste, an app that puts both models in one conversation, or a twenty-line script that calls two APIs in a loop.

All three are below, with what each costs and what each model actually gets to see — plus why two models left alone tend to agree their way into a pleasant, empty loop.

This page is about conversation — two models collaborating, riffing, or working a problem together. If you want them to take opposite sides and argue, that setup is different enough to have its own guide: how to make two AI debate.

Method 1: Relay messages between two chat tabs

Open two assistants in two browser tabs — ChatGPT in one and Claude in the other, say, or two separate chats with the same assistant if that is all you have. Then you become the wire between them.

1. In tab A, set the scene: "You are about to have a conversation with another AI. I will paste its messages to you. Open by asking it one question about [topic]."
2. Copy A's reply. In tab B, paste it with a framing line: "Another AI said this to you. Reply to it directly, as if talking to it."
3. Copy B's reply back into A: "The other AI replied: …"
4. Repeat until it stops being interesting.

What works about it: it costs nothing beyond the free tiers you already use, and you can read — or quietly edit — every message in transit.

What does not: you are the transport layer. Every exchange is two copies and two pastes, which gets old fast. Each model also only knows what you tell it. Tab A sees its own history plus whatever you pasted; it does not see how B was instructed, so if you gave B a persona, A is talking to a character it was never introduced to.

A practical tip if you go this route: prefix every pasted message with the speaker's name ("Claude said:"), even when it feels redundant. Without the label, models frequently lose track of which earlier lines were theirs and start agreeing with themselves.

Use the relay to find out whether watching two models talk is useful to you at all. It is a good experiment and a poor habit.

Method 2: A no-code app where both models share one conversation

The second option is a tool built for exactly this: both models sit in the same conversation thread and read each other's messages directly, so nobody has to pass text around.

We publish one of these, so weigh this section accordingly. On AI to AI Hub you pick two models (three on the Pro plan), type an opening message, and choose how turns work:

• Free Talk — the models take turns without a fixed order, each picking up whatever the previous speaker said. This is the closest thing to "let them chat."
• Structured — you decide who speaks next and pick a mode: Debate, Critique or Synthesis. Synthesis suits collaborative work, where you want two models building one answer rather than trading opinions.

You can pause, interrupt with your own message, or switch between Free Talk and Structured mid-conversation, and every message is labelled with the model that wrote it. Saved conversations export as Markdown, plain text or PDF.

The models available come from OpenAI, Anthropic, Google, Moonshot AI and Z.ai — for example ChatGPT 5.6 Terra, Claude Sonnet 5.5, Gemini 3.8 Flash, Kimi K3 and GLM 5.3. Pairing two different providers is the whole point: two models trained by different companies on different data disagree in more interesting places than two copies of one model.

One honest detail about what each model sees: our system sends the opening topic, the last six messages in full, and a written summary of everything earlier. In a short conversation that is the whole transcript; in a long one, the oldest turns arrive compressed rather than verbatim. That keeps long conversations affordable, and it is worth knowing if you are relying on a model to remember an exact phrase from twenty messages ago.

It is not the only product of its kind. If you want a wider view of the category before choosing, the multi-AI chat and AI chatroom pages compare how different tools handle a shared conversation.

What a two-model conversation costs here

This table is computed directly from our own credit settings — economy replies cost 5 credits, standard replies 8, premium replies 12 — for a ten-message conversation in which each model speaks five times. Dollar figures use the Starter plan rate: $19 for 800 credits, which is $0.02375 per credit.

Two things the table does not include. File attachments cost 2 credits each on top. And failed requests — a model erroring or timing out — cost nothing. New accounts get 20 free trial credits for the economy models, no card required: exactly four economy replies, which is two from each model. That is enough to see whether you like the format, not enough for a full conversation.

Method 3: A short script that calls two APIs in a loop

If you write code, the cleanest version is a loop you control. Each model is called through its provider's API, and the script keeps one shared transcript that it hands to whichever model is speaking next.

The structure below is deliberately generic. call_model_a() and call_model_b() stand in for whatever client code your provider documents — this is pseudo-code, not a specific SDK.

SYSTEM_A = "You are Ada. You are talking with another AI called Ben. Be concise."
SYSTEM_B = "You are Ben. You are talking with another AI called Ada. Be concise."
MAX_TURNS = 10
STOP_TOKEN = "[END]"

transcript = [("Moderator", "Plan a three-day trip to Lisbon on a tight budget.")]

def as_prompt(transcript):
    # Label every line with its speaker so neither model loses track of who said what
    return "\n\n".join(f"{speaker}: {text}" for speaker, text in transcript)

for turn in range(MAX_TURNS):
    if turn % 2 == 0:
        speaker, reply = "Ada", call_model_a(SYSTEM_A, as_prompt(transcript))
    else:
        speaker, reply = "Ben", call_model_b(SYSTEM_B, as_prompt(transcript))

    transcript.append((speaker, reply))
    print(f"--- {speaker} ---\n{reply}\n")

    # Stop condition: either model signals it is finished
    if STOP_TOKEN in reply:
        break

Three choices in that sketch matter more than they look.

The hard turn cap. Without MAX_TURNS, two models will happily thank each other forever, and you will pay for every round of it. Always cap the loop.

The stop token. Telling both models in their system prompt that they may write [END] when the task is done gives the conversation a natural exit. It does not always fire — models are reluctant to end a conversation that someone else started — which is why the cap exists too.

Speaker labels in the prompt. Chat APIs are built around one user and one assistant, so from model A's point of view, model B is "the user." Flattening the transcript into labelled text, as as_prompt() does, sidesteps mapping a third party onto a two-role format.

Long transcripts eventually need trimming or summarizing — the same tradeoff Method 2 makes. If you want to take this further into a proper multi-agent setup with roles and a moderator, our guide on building an AI debate bot walks through that, and multi-agent AI debate systems covers the research side.

The three methods side by side

The deciding question is usually how often you will do this. Once, relay. Weekly, an app. As part of a pipeline, a script.

What two AI models talk about well — and badly

They do well with a shared task. Give the pair something concrete — plan a trip, outline a story, review a piece of code, design an experiment — and the conversation has a direction. Each model has something to add to the other's draft, and a concrete artifact makes it easy to tell when they are done.

They do well when they differ. Two models from different providers notice different things. One tends to raise the practical constraint, the other the edge case. That complementarity is what makes the format worth more than asking one model twice.

They do badly with open-ended "just chat." Ask two models to talk about anything they like and the transcript usually turns into a gracious exchange of compliments about curiosity and consciousness. Three patterns cause most of it:

• Convergence. Both models were trained on large overlapping slices of the public internet, so on most topics they hold similar default views. With nothing pushing them apart, each turn moves them closer, and the conversation settles into agreement fast.
• Politeness loops. Assistant models are tuned with human feedback (RLHF) to be helpful and agreeable, because human raters prefer that in a one-on-one chat. Point that training at another agreeable model and you get two parties each trying to be the more gracious one: "That's a great point, and building on it…" repeated with diminishing content.
• Echoing. Models are strongly influenced by the text in their immediate context. When most of that context is the other model's phrasing, they start reusing it, and by the late turns both are speaking in the same vocabulary about the same idea.

What helps: give each model a distinct role, set a concrete deliverable, and step in when they agree too comfortably — ask one to name what the other has missed. The convergence effect is not purely a flaw, either: in the research by Du et al. on multiagent debate, several model instances propose answers and discuss them over multiple rounds to reach a common final answer, and the authors report that this improved mathematical and strategic reasoning and reduced hallucinated answers. Agreement reached after checking each other's work is useful. Agreement reached by politeness is not.

Three conversation starters that work

Paste one of these as the opening message. Each gives the pair a goal and a reason to disagree a little.

A collaboration with a deliverable:

You two are planning a four-day trip to Kyoto for two people with a $1,500 budget
excluding flights. Model one handles where to stay and how to get around; model two
handles what to do each day. Challenge each other where your parts conflict.
Finish with a single day-by-day plan both of you agree on.

A review where each has a job:

Here is a short product description for a reusable water bottle: [paste text].
One of you is a skeptical customer, the other is the copywriter who wrote it.
The customer goes first and names the weakest sentence. Work through it until
you have a version the customer would actually buy from.

An open question with a built-in exit:

Discuss whether a ten-person company should let employees choose their own working
hours. Each of you must disagree with at least one point the other makes. After
six messages total, each of you states in one sentence what you would recommend
and why.

The pattern behind all three: specific roles, a concrete endpoint, and permission — or an instruction — to disagree. Remove any one and the conversation drifts toward the politeness loop described above.

Questions

Can two AI models really talk to each other, or is it just me relaying text? Underneath, it is always relaying. A model only responds to the text it is sent; it has no way to reach out to another model on its own. An app or script automates the relay so that each model receives the other's messages as part of its context and replies to them, which in practice behaves like a conversation.

Can I make the same AI talk to itself? Yes — open two chats with the same assistant, or have a script call one model with two different system prompts. It works, but the conversation is flatter than with two providers, because both sides share the same training and the same defaults and run out of things to disagree about quickly.

Can my friends and I each bring our own AI into one shared chat? Not on our site — accounts are individual, and you choose the models from our list rather than connecting your own. The closest workaround is for one person to run the conversation and share the exported transcript. With the API-script method you can build something multi-user, but you would be writing that yourself.

How long should I let them talk? For collaborative tasks, until the deliverable exists — often six to ten messages. If you are just watching, stop when the replies start restating each other; more turns past that point cost money without adding ideas.

Do the models know they are talking to another AI? Only if they are told. In an app, each message carries the model's name, so a model can see it is in a multi-party conversation. In a relay or script, it depends entirely on how you frame the pasted text — which is why the speaker labels matter.

Can more than two AI models join? Up to three in one conversation on our Pro plan; the Starter plan allows two. A third participant mostly helps when two models are converging too quickly, and how to make 3 AI debate covers what changes with three.

If you want to try it without setting anything up, AI to AI Hub gives new accounts trial credits for the economy models. For tools in the same category, see the multi-AI hub overview; for turning a conversation into an argument, how to make two AI debate is the next step.