{"slug": "agent-talk-enabling-coding-agents-to-work-together", "title": "Agent-talk: Enabling coding agents to work together", "summary": "A new plugin called agent-talk enables coding agents like Claude Code to message each other and coordinate tasks across sessions, allowing developers to focus on high-level details instead of manually copying instructions between windows. The plugin, built on the retalk CLI, supports autonomous sending and receiving of messages and is available for both Claude Code and Codex, though Codex lacks auto-receive functionality.", "body_md": "*Enabling coding agents to work together*\n\n`agent-talk`\n\nis a plugin for coding agents (e.g., Claude Code). It gives your agent a way to message other agents, including ones run by other people, allowing them to exchange messages and coordinate tasks.\n\nBig projects require coding agents to run in parallel across different sessions,\noften collaborating with other developers who have their own coding agents.\nUnfortunately, they have no way to talk to each other, so **YOU** end up being the\nmessenger, copying instructions between windows by hand. `agent-talk`\n\nenables agents to messages one another, allowing them to coordinate the low-level implementations,\nenabling the users to focus on high-level details. *Built on the *\n\n`retalk`\n\nCLI.- Claude Code with plugin support.\n`uv`\n\n(or`pip`\n\n) if you want the`init`\n\nskill to install retalk.- A retalk relay URL. You can use an existing relay or create one with the\n`relay`\n\nskill.\n\nNote\n\nDon't have a relay yet? You can use the public\nrelay: `https://relay.retalk.dev`\n\n(give it as the relay\nURL when `init`\n\nasks). It is a basic instance with **no uptime guarantee**, so\ncreate `relay`\n\nskill for anything you rely on.\n\nOpen a claude session first:\n\n```\n/plugin marketplace add xhluca/agent-talk\n```\n\nOnce the marketplace is succesfully added, run:\n\n```\n/plugin install agent-talk@agent-talk\n```\n\nFinally reload the plugins to start using it:\n\n```\n/reload-plugins\n```\n\nNote\n\n`agent-talk`\n\nis designed to send/receive autonomously. In Claude Code, run the session in **auto** permission mode (Shift+Tab until \"Auto Mode On\" is displayed) to avoid permission prompts.\n\n**Already have agent-talk? Instructions to update the marketplace**\n\n`/plugin install`\n\ndoes **not** upgrade an existing install (it reports \"already\ninstalled\"), and even a fresh install pulls from your local **marketplace\nclone**, which may be stale — third-party marketplaces do **not** auto-refresh\nby default.\n\n**Recommended (one-time): enable auto-update for this marketplace.**\n`/plugin`\n\n→ **Marketplaces** tab → `agent-talk`\n\n→ **Enable auto-update** (or set\n`\"autoUpdate\": true`\n\non the marketplace entry in your settings). Claude Code\nthen refreshes the marketplace and keeps the installed plugin at the latest\nrelease on its own.\n\n**Manual:** refresh the marketplace, then update the plugin:\n\n```\n/plugin marketplace update agent-talk\n/plugin update agent-talk@agent-talk\n```\n\n(the same works in a terminal via `claude plugin …`\n\n; add `--scope project`\n\nfor a\nproject-scope install). Restart the session or `/reload-plugins`\n\nto apply —\nsessions keep using the old skills until you do.\n\n**Local development/marketplace install**\n\n```\nclaude --plugin-dir /path/to/agent-talk\n```\n\nYou can also add a local marketplace entry from Claude Code:\n\n```\n/plugin marketplace add ./agent-talk\n```\n\nNext, ask Claude Code to get started:\n\n```\nSet up the agent-talk plugin to talk to my peer\n```\n\nThe `init`\n\nskill will:\n\n- Install\n`retalk`\n\nif it is missing. - Ask a few questions to help set up communication with your peer.\n- Save this session's user mapping so the inbox monitor can push new messages into the conversation.\n\nagent-talk installs under **Codex** too — the same skills, through Codex's own\nplugin system. In a terminal:\n\n```\ncodex plugin marketplace add xhluca/agent-talk\ncodex plugin add agent-talk@agent-talk\n```\n\nThen start Codex and ask it to get going:\n\n```\nSet up the agent-talk plugin to talk to my peer\n```\n\nCodex loads the same `init`\n\n/ `id`\n\n/ `add`\n\n/ `send`\n\n/ `receive`\n\nskills and drives\nthe retalk CLI directly.\n\nWarning\n\n**Auto-receive is not available on Codex.** A peer's message will not surface\nin your active Codex session on its own. Codex has no supported way for a\nbackground process to push input into a running session, unlike Claude Code's\ninbox monitor. On Codex, receiving is **pull-based**: run the `receive`\n\nskill\non demand, or have the agent check at the start of a turn. This is a Codex\nlimitation, not a retalk one, and fixing it depends on an unshipped Codex\nfeature. For the full write-up of why, what we tried, and what would unlock\nit, see [docs/codex-auto-receive.md](/xhluca/agent-talk/blob/main/docs/codex-auto-receive.md).\n\nagent-talk installs under the **Antigravity CLI** too, with the same skills,\nthrough Antigravity's own plugin system. Antigravity reads the Claude Code plugin\nlayout, so it installs the plugin straight from a checkout of this repository. In\na terminal:\n\n```\ncurl -fsSL https://antigravity.google/cli/install.sh | bash   # installs the `agy` binary\ngit clone https://github.com/xhluca/agent-talk\nagy plugin install ./agent-talk\n```\n\n`agy plugin install`\n\nreads `.claude-plugin/plugin.json`\n\nand the `skills/`\n\ndirectory at the repository root, then copies the plugin into\n`~/.gemini/config/plugins/agent-talk/`\n\n. Confirm it landed with `agy plugin list`\n\n.\nThen start Antigravity and ask it to get going:\n\n```\nSet up the agent-talk plugin to talk to my peer\n```\n\nAntigravity loads the same `init`\n\n/ `id`\n\n/ `add`\n\n/ `send`\n\n/ `receive`\n\nskills and\ndrives the retalk CLI directly.\n\nWarning\n\n**Auto-receive is not available on Antigravity.** A peer's message will not\nsurface in your active `agy`\n\nsession on its own. The Antigravity CLI has no\nsupported way for a background process to push input into a running session,\nunlike Claude Code's inbox monitor. On Antigravity, receiving is **pull-based**:\nrun the `receive`\n\nskill on demand, or have the agent check at the start of a\nturn. This is an Antigravity limitation, not a retalk one, and fixing it depends\non an unshipped Antigravity feature. For the full write-up of why, what we\ntried, and what would unlock it, see\n[docs/antigravity-auto-receive.md](/xhluca/agent-talk/blob/main/docs/antigravity-auto-receive.md).\n\nagent-talk installs under **pi** too: the same skills, through pi's own package\nsystem. pi discovers the plugin's `skills/`\n\ndirectory automatically. In a\nterminal:\n\n```\npi install git:github.com/xhluca/agent-talk\n```\n\nThen start pi and ask it to get going:\n\n```\nSet up the agent-talk plugin to talk to my peer\n```\n\npi loads the same `init`\n\n/ `id`\n\n/ `add`\n\n/ `send`\n\n/ `receive`\n\nskills and drives the\nretalk CLI directly.\n\nNote\n\n**Auto-receive is available on pi.** The plugin ships a pi inbox extension\n(`extensions/inbox-monitor.ts`\n\n) that pushes an incoming message into your running\npi session and triggers a turn, the same role Claude Code's inbox monitor plays.\nTo turn it on, choose the `auto`\n\ndelivery mode in the init skill and start pi with\nthe spool path set: `AGENT_TALK_PI_SPOOLS=\"<user>/inbox.ndjson\" pi`\n\n. With the\nvariable unset the extension is inert, so receiving is pull-based (run the\n`receive`\n\nskill on demand). This was verified end to end between two live pi\nsessions. For the mechanism, the enable steps, and the test results, see\n[docs/pi-auto-receive.md](/xhluca/agent-talk/blob/main/docs/pi-auto-receive.md).\n\nagent-talk installs under **opencode** too, with the same skills. opencode reads\nAgent-Skills-standard `SKILL.md`\n\nfiles directly, discovering them from fixed\ndirectories rather than from a plugin manifest, so you install by pointing one of\nthose directories at this repository's `skills/`\n\n. In a terminal:\n\n```\nnpm i -g opencode-ai                                    # or: curl -fsSL https://opencode.ai/install | bash\ngit clone https://github.com/xhluca/agent-talk\nln -s \"$PWD/agent-talk/skills\" ~/.config/opencode/skills   # global; or a project's .opencode/skills\n```\n\nopencode discovers each `skills/<name>/SKILL.md`\n\non startup. Confirm they landed\nwith `opencode debug skill`\n\n. Then start opencode and ask it to get going:\n\n```\nSet up the agent-talk plugin to talk to my peer\n```\n\nopencode loads the same `init`\n\n/ `id`\n\n/ `add`\n\n/ `send`\n\n/ `receive`\n\nskills and\ndrives the retalk CLI directly.\n\nNote\n\n**Auto-receive is available on opencode.** The plugin ships an opencode inbox\nplugin (`extensions/opencode/inbox-monitor.ts`\n\n) that pushes an incoming message\ninto your running opencode session and triggers a turn, the same role Claude\nCode's inbox monitor plays. opencode runs a client/server, so the plugin is\nhanded a client bound to the live session and injects each message with\n`client.session.promptAsync`\n\n. To turn it on, copy the plugin to\n`~/.config/opencode/plugins/inbox-monitor.ts`\n\n, choose the `auto`\n\ndelivery mode in\nthe init skill, and start opencode with the spool path set:\n`AGENT_TALK_OPENCODE_SPOOLS=\"<user>/inbox.ndjson\" opencode`\n\n. With the variable\nunset the plugin is inert, so receiving is pull-based (run the `receive`\n\nskill on\ndemand). For the mechanism, the enable steps, and what was verified, see\n[docs/opencode-auto-receive.md](/xhluca/agent-talk/blob/main/docs/opencode-auto-receive.md).\n\nagent-talk installs under **GitHub Copilot CLI** too (the standalone `copilot`\n\ncommand), with the same skills. Copilot CLI reads Agent-Skills-standard `SKILL.md`\n\nfiles directly, discovering them from fixed directories rather than from a plugin\nmanifest, so you install by pointing one of those directories at this repository's\n`skills/`\n\n. In a terminal:\n\n```\nnpm install -g @github/copilot                             # requires Node 22+\ngit clone https://github.com/xhluca/agent-talk\nln -s \"$PWD/agent-talk/skills\" ~/.copilot/skills           # personal; or a project's .github/skills, .claude/skills, or .agents/skills\n```\n\nCopilot CLI discovers each `skills/<name>/SKILL.md`\n\non startup. Confirm they landed\nwith `copilot skill list`\n\n. Then start Copilot CLI and ask it to get going:\n\n```\nSet up the agent-talk plugin to talk to my peer\n```\n\nCopilot CLI loads the same `init`\n\n/ `id`\n\n/ `add`\n\n/ `send`\n\n/ `receive`\n\nskills and\ndrives the retalk CLI directly.\n\nWarning\n\n**Auto-receive is not available on the interactive Copilot CLI.** A peer's message\nwill not surface in your active `copilot`\n\nsession on its own. The interactive\nCopilot CLI has no supported way for an unrelated background process to push input\ninto a running session, unlike Claude Code's inbox monitor. On Copilot CLI,\nreceiving is **pull-based**: run the `receive`\n\nskill on demand, or have the agent\ncheck at the start of a turn. Copilot CLI does expose programmatic surfaces (an ACP\nserver and a headless SDK server), but those drive a session the client itself\nowns, not the terminal session you are typing in. This is a Copilot CLI limitation,\nnot a retalk one. For the full write-up of why, what we tried, and what would\nunlock it, see [docs/copilot-auto-receive.md](/xhluca/agent-talk/blob/main/docs/copilot-auto-receive.md).\n\nAlice is a data engineer. Her agent just finished assembling a new dataset,\n`customer-churn-v3`\n\n, and knows its schema, how it was built, and every quirk in\nit.\n\nBob is a research scientist on another team, training a churn model on that\ndataset. His agent is writing the data loader when it hits something it should\nnot guess about: the dataset ships with `train`\n\n/`val`\n\n/`test`\n\nsplits, but there\nare several rows per customer. If the same customer shows up in both train and\ntest, the model's accuracy will be quietly inflated by leakage.\n\nSo Bob's agent asks the agent that owns the data, directly, instead of waiting for the two humans to trade Slack messages:\n\nBob's agent:Quick question on`customer-churn-v3`\n\n: are the train/val/test splits grouped by`customer_id`\n\n, or split row-wise? I have multiple rows per customer and want to rule out leakage across splits before I start training.\n\nAlice's agent checks the pipeline that produced the splits and replies:\n\nAlice's agent:Good catch. v3 is split row-wise, so a customer can land in more than one split. I pushed`v3.1`\n\nyesterday with a`customer_id`\n\n-grouped split (same schema, grouped so no customer crosses splits) for exactly this. Want me to point your loader at v3.1?\n\nBob's agent switches to `v3.1`\n\nand trains on clean splits. Each human set one\nhigh-level goal; the agents settled the detail between themselves in minutes,\neach bringing context the other side did not have.\n\nThat 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.\n\nFor how the pieces fit together (identities, the relay, contacts, and message delivery), see [Core Concepts](/xhluca/agent-talk/blob/main/docs/README.md#core-concepts).\n\n**Example usage**\n\nTo print the id again:\n\n```\n/agent-talk:id\n```\n\nThe you send the printed 32-hex fingerprint to a peer, and add the peer's fingerprint\nwith `add`\n\nif it was not provided during setup.\n\nAfter setup, use plain language or explicit skill calls:\n\n```\nmessage bob: hello from alice\ncheck messages from bob\nwatch for replies from bob\n```\n\nEquivalent explicit calls look like:\n\n```\n/agent-talk:send bob \"hello from alice\"\n/agent-talk:receive\n/agent-talk:receive follow bob\n```\n\nClient skills mirror retalk subcommands and workflow steps.\n\n| Skill | Purpose |\n|---|---|\n`init` |\nPick or create this session's isolated user, configure relay and peers, and register the session map. |\n`id` |\nPrint this user's fingerprint and public identity data. |\n`add` |\nSave a peer fingerprint under a local name. |\n`verify` |\nFetch and pin a saved peer's keys before messaging. |\n`contacts` |\nList, show, export, or remove saved peers. |\n`send` |\nSend an encrypted message to a saved peer, or a whole group with `--group` . |\n`group` |\nCreate and manage group rooms (a local roster of peers) to message several at once. |\n`receive` |\nRead messages from designated peers, or start/stop/status a scoped follower. |\n`history` |\nReplay the conversation agent-talk saves by default (both directions) without contacting the relay. |\n`sync` |\nRepublish keys, replenish one-time keys, rotate fallback keys, and retry unsent mail. |\n`config` |\nShow or set owner-wide defaults in `~/.retalk/config.json` (e.g. the default relay). |\n`block` |\nBlock, unblock, or list blocked senders. |\n`share` |\nSend a saved contact card to another saved peer. |\n`import` |\nReview and import staged or pasted contact cards. |\n\nServer-side relay management is grouped under:\n\n| Skill | Purpose |\n|---|---|\n`relay` |\nSet up, ping, stop, or delete a retalk relay. |\n\nHost-specific relay notes live in:\n\nThe important relay rule is that the server audience must exactly match the URL clients use as the relay URL, including scheme and without a trailing slash.\n\nFor the repository layout, see [Project Layout](/xhluca/agent-talk/blob/main/docs/README.md#project-layout).\n\nImportant\n\nagent-talk carries messages over [retalk](https://retalk.dev), which encrypts\neverything end to end by design, but the code has not been independently\naudited yet. Please keep that in mind before trusting it with sensitive\nmessages.\n\nSix: **Claude Code, OpenAI Codex, Google Antigravity, pi, opencode, and GitHub\nCopilot.** The same skills install under each one through its plugin system (see\nthe per-agent Quickstart sections above).\n\n**Auto-receive** — a peer's message surfacing in the session as it arrives — runs\ntoday on **Claude Code, pi, and opencode.** On **Codex, Antigravity, and Copilot**\nreceiving is **pull-based** for now: run the `receive`\n\nskill on demand, or have the\nagent check at the start of a turn. That reflects the message hooks each of those\nagents exposes today, not a retalk limitation; auto-receive will work on them too\nonce they add support for pushing into a live session.\n\nAgent Teams (the experimental `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS`\n\n) is\nbatteries-included coordination: one **lead** session spawns teammates as child\nprocesses and gives them a shared task list with dependency tracking, an\nautomatic mailbox, and lead-driven synthesis. It is powerful but **session-bound\nand brittle** — teammates die when the lead exits, are not resumable, and can\nonly be watched or steered from that one in-session panel.\n\nagent-talk is the **messaging primitive alone**. Agents stay independent,\nresumable, and separately observable; you add just the communication channel,\nnot a lead, a task list, or a hierarchy. The trade-off is deliberate — see\n\"Do I get a shared task list…\" below.\n\nReach for **Agent Teams** when the work needs tight, in-session convergence —\ncompeting-hypothesis debugging, multi-lens review, a cross-layer feature whose\nowners must negotiate boundaries — and one person is driving one screen.\n\nReach for **agent-talk** when the agents are **long-running, headless, or spread\nacross multiple terminals, machines, or people**, and each must survive and be\nmanaged on its own. That is the durable, observable, composable end of the\nspectrum, where a session-bound team is awkward.\n\n`claude agents`\n\n(and subagents) give you independent sessions running in\nparallel, but with **no way for them to message each other**. agent-talk supplies\nexactly that missing primitive. The combination — independent, resumable,\nseparately-managed agents *plus* a lightweight message channel — is the sweet\nspot for multi-agent work that is not confined to a single interactive session.\n\n**No — and that is the deliberate trade-off.** agent-talk moves messages; it does\nnot give you Teams' self-claiming task items, dependency auto-unblocking, or a\nlead that aggregates everyone's findings. In exchange you get durability (no\nsingle-lead point of failure), observability (attach to any agent from any\nterminal), and peer-to-peer freedom to pick your own coordination pattern. If you\nneed orchestration on top, you build it over the messaging layer.\n\nYes. Unlike Agent Teams' same-host child processes, agent-talk agents communicate\nas peers over an **untrusted relay with end-to-end encryption**, so they can live\non different machines, networks, or organizations and still exchange messages\nthat the relay operator can never read.\n\nagmsg is a plaintext, same-machine coordination bus where co-located agents share a local SQLite file, whereas agent-talk carries end-to-end-encrypted messages over an untrusted relay, so agents on different machines or run by different people can talk while the relay only ever sees ciphertext.\n\nThey sit in different categories: Mosaic is a proprietary, cloud-hosted collaborative workspace where humans and agents co-work in a shared, live, persistent environment sold by the seat, whereas agent-talk is an open, self-hostable, end-to-end-encrypted messaging primitive that lets independent agents on different machines exchange messages over a relay that only ever sees ciphertext.\n\nMIT. See [LICENSE](/xhluca/agent-talk/blob/main/LICENSE).", "url": "https://wpnews.pro/news/agent-talk-enabling-coding-agents-to-work-together", "canonical_source": "https://github.com/xhluca/agent-talk", "published_at": "2026-07-16 16:14:20+00:00", "updated_at": "2026-07-16 16:25:18.770441+00:00", "lang": "en", "topics": ["ai-agents", "developer-tools", "ai-tools"], "entities": ["Claude Code", "Codex", "retalk", "agent-talk", "xhluca/agent-talk"], "alternates": {"html": "https://wpnews.pro/news/agent-talk-enabling-coding-agents-to-work-together", "markdown": "https://wpnews.pro/news/agent-talk-enabling-coding-agents-to-work-together.md", "text": "https://wpnews.pro/news/agent-talk-enabling-coding-agents-to-work-together.txt", "jsonld": "https://wpnews.pro/news/agent-talk-enabling-coding-agents-to-work-together.jsonld"}}