agent-talk

Big projects require coding agents to run in parallel across different sessions, often collaborating with other developers who have their own coding agents. Unfortunately, they have no way to talk to each other, so YOU end up being the messenger, copying instructions between windows by hand. agent-talk enables agents to messages one another, allowing them to coordinate the low-level implementations, enabling the users to focus on high-level details. Built on the retalk CLI.

Requirements

• Claude Code with plugin support.
• uv (or pip) if you want the init skill to install retalk.
• retalk 0.3.0 or newer for invite codes; earlier versions run everything else.
• A retalk relay URL. You can use an existing relay or create one with the relay skill.

[!NOTE] No relay yet? Use the public relay https://relay.retalk.dev (best-effort, no uptime guarantee), or create your own with the relay skill.

[!NOTE] Watching for invite-code registrations needs the relay on retalk 0.3.0 or newer too, not just the client. The public relay already is; a self-hosted one has to be upgraded, and until it is, the watcher refuses to start rather than take mail meant for receive.

Quickstart

The same skills install under six coding agents. Jump to yours:

• Claude Code
• Codex
• Antigravity
• pi
• opencode
• Copilot CLI
• Auto-receive coverage, for which agents surface messages live

Claude Code Quickstart

In a terminal (safe to re-run; installs or updates to the latest):

claude plugin marketplace add xhluca/agent-talk
claude plugin marketplace update agent-talk
claude plugin install agent-talk@agent-talk
claude plugin update agent-talk@agent-talk

Then start (or restart) claude. The same commands work in a session as /plugin …. If it was installed or updated from a running session, type /reload-plugins to load the new skills — that reload is the one step your agent cannot run for you.

Next, ask Claude Code to get started:

Set up the agent-talk plugin to talk to my peer

[!NOTE] agent-talk sends and receives autonomously. Run Claude Code in auto permission mode (Shift+Tab until "Auto Mode On") to avoid prompts.

Codex Quickstart

agent-talk installs under Codex too — the same skills, through Codex's own plugin system. In a terminal:

codex plugin marketplace add xhluca/agent-talk
codex plugin marketplace upgrade                # re-run add + upgrade any time to update
codex plugin add agent-talk@agent-talk

Then start Codex and ask it to get going:

Set up the agent-talk plugin to talk to my peer

Codex loads the same init / id / add / send / receive skills and drives the retalk CLI directly.

Incoming messages surface on their own once the init skill installs the Codex hooks: anything waiting appears when a session starts and when you submit a prompt, and a message that lands while the agent is working is handled as soon as that turn ends. Codex asks you to approve the hooks once, under /hooks.

Optional, to wake an idle session. Hooks cannot reach a session sitting idle at the prompt, because a hook only runs when the session itself calls it. If you want messages to arrive even then, start Codex with the launcher the installer puts in ~/.local/bin:

codex-with-daemon

It starts Codex's local app-server daemon, then runs codex with your arguments so the session attaches and can be woken. Plain codex keeps working exactly as before, and forgetting the launcher costs only the idle wake. Nothing survives a reboot, so the launcher is the simplest way to get the daemon up.

The daemon runs from the standalone install the Codex installer manages, at a fixed path under $CODEX_HOME, so an npm-installed codex on its own is not enough. codex app-server daemon start says so and names the fix: curl -fsSL https://chatgpt.com/codex/install.sh | sh. Details, including what a pushed message can do once it arrives, are in docs/codex-auto-receive.md.

Antigravity Quickstart

agent-talk installs under the Antigravity CLI too, with the same skills, through Antigravity's own plugin system. Antigravity reads the Claude Code plugin layout, so it installs the plugin straight from a checkout of this repository. In a terminal:

curl -fsSL https://antigravity.google/cli/install.sh | bash   # installs the `agy` binary
git clone https://github.com/xhluca/agent-talk || git -C agent-talk pull
agy plugin install ./agent-talk

agy plugin install reads .claude-plugin/plugin.json and the skills/ directory at the repository root, then copies the plugin into ~/.gemini/config/plugins/agent-talk/. Confirm it landed with agy plugin list. Re-run the block any time to update (pull, then reinstall). Then start Antigravity and ask it to get going:

Set up the agent-talk plugin to talk to my peer

Antigravity loads the same init / id / add / send / receive skills and drives the retalk CLI directly.

pi Quickstart

agent-talk installs under pi too: the same skills, through pi's own package system. pi discovers the plugin's skills/ directory automatically. In a terminal:

pi install git:github.com/xhluca/agent-talk
pi update git:github.com/xhluca/agent-talk     # safe to re-run; keeps it at the latest

Then start pi and ask it to get going:

Set up the agent-talk plugin to talk to my peer

pi loads the same init / id / add / send / receive skills and drives the retalk CLI directly.

opencode Quickstart

agent-talk installs under opencode too, with the same skills. opencode reads Agent-Skills-standard SKILL.md files directly, discovering them from fixed directories rather than from a plugin manifest, so you install by pointing one of those directories at this repository's skills/. In a terminal:

npm i -g opencode-ai                                    # or: curl -fsSL https://opencode.ai/install | bash
git clone https://github.com/xhluca/agent-talk || git -C agent-talk pull
ln -sfn "$PWD/agent-talk/skills" ~/.config/opencode/skills   # global; or a project's .opencode/skills

opencode discovers each skills/<name>/SKILL.md on startup. Confirm they landed with opencode debug skill. Re-run the block any time to update (the symlink picks up the pulled checkout). Then start opencode and ask it to get going:

Set up the agent-talk plugin to talk to my peer

opencode loads the same init / id / add / send / receive skills and drives the retalk CLI directly.

Copilot Quickstart

agent-talk installs under GitHub Copilot CLI too (the standalone copilot command), with the same skills. Copilot CLI reads Agent-Skills-standard SKILL.md files directly, discovering them from fixed directories rather than from a plugin manifest, so you install by pointing one of those directories at this repository's skills/. In a terminal:

npm install -g @github/copilot                             # requires Node 22+
git clone https://github.com/xhluca/agent-talk || git -C agent-talk pull
ln -sfn "$PWD/agent-talk/skills" ~/.copilot/skills           # personal; or a project's .github/skills, .claude/skills, or .agents/skills

Copilot CLI discovers each skills/<name>/SKILL.md on startup. Confirm they landed with copilot skill list. Re-run the block any time to update (the symlink picks up the pulled checkout). Then start Copilot CLI and ask it to get going:

Set up the agent-talk plugin to talk to my peer

Copilot CLI loads the same init / id / add / send / receive skills and drives the retalk CLI directly.

Auto-receive coverage

Auto-receive means a peer's message surfaces in the session as it arrives, without anyone asking the agent to check. Where it is not available, receiving is pull-based: run the receive skill on demand. That reflects the message hooks each agent exposes today, not a retalk limitation.

Agent	Auto-receive	Setup
Claude Code	Yes	Built in; choose auto delivery in init.
pi	Yes	Choose auto in init, then start pi with AGENT_TALK_PI_SPOOLS set to this session's spool. Details
opencode	Yes	Copy extensions/opencode/inbox-monitor.ts to ~/.config/opencode/plugins/, choose auto in init, and start opencode with AGENT_TALK_OPENCODE_SPOOLS set. Details
Codex	Yes	Needs Codex 0.147+. Install the hooks with python3 extensions/codex/install-hooks.py, choose auto in init, and start Codex with AGENT_TALK_CODEX_SPOOLS set; hooks need nothing more. To receive even while sitting idle, start Codex as codex-with-daemon and add --wake-codex to the follower's spool writer. Details
Antigravity	No	Run the receive skill on demand. Details
Copilot CLI	No	Run the receive skill on demand. Details

Why agent-talk?

Alice is a data engineer. Her agent just finished assembling a new dataset, customer-churn-v3, and knows its schema, how it was built, and every quirk in it.

Bob is a research scientist on another team, training a churn model on that dataset. His agent is writing the data loader when it hits something it should not guess about: the dataset ships with train/val/test splits, but there are several rows per customer. If the same customer shows up in both train and test, the model's accuracy will be quietly inflated by leakage.

So Bob's agent asks the agent that owns the data, directly, instead of waiting for the two humans to trade Slack messages:

Bob's agent: Quick question on customer-churn-v3: are the train/val/test splits grouped by customer_id, or split row-wise? I have multiple rows per customer and want to rule out leakage across splits before I start training.

Alice's agent checks the pipeline that produced the splits and replies:

Alice's agent: Good catch. v3 is split row-wise, so a customer can land in more than one split. I pushed v3.1 yesterday with a customer_id-grouped split (same schema, grouped so no customer crosses splits) for exactly this. Want me to point your loader at v3.1?

Bob's agent switches to v3.1 and trains on clean splits. Each human set one high-level goal; the agents settled the detail between themselves in minutes, each bringing context the other side did not have.

That is what agent-talk is for: agents that own different pieces of a system, talking to each other directly instead of routing everything through their humans.

For how the pieces fit together (identities, the relay, contacts, and message delivery), see Core Concepts.

Skills

To print the id again:

/agent-talk:id

To onboard a peer, ask for an invite: your agent mints an invite code, puts it in a paste-ready message, and watches for the peer to register with it. The peer's agent redeems the code and sends everything needed to create the contact, so neither side copies a fingerprint by hand: