🔶 Agent-talk：让编程 Agent 协同工作

让编程 Agent 协同工作

agent-talk 是一款面向编程 Agent（例如 Claude Code）的插件。它赋予你的 Agent 与其他 Agent（包括由其他人运行的 Agent）收发消息的能力，让它们可以交换信息并协调任务。

大型项目需要编程 Agent 在不同会话中并行运行，并且常常要与其他拥有自己 Agent 的开发者协作。遗憾的是，它们之间没有对话的途径，于是 你 就变成了传话人，被迫手工在不同窗口之间复制指令。agent-talk 使 Agent 可以彼此发送消息，从而让它们能够协调底层实现，而用户则可以把精力集中在高层次细节上。基于 retalk CLI 构建。

• 支持插件的 Claude Code。
• 如果你希望 init 技能安装 retalk，则需要 uv（或 pip）。
• 一个 retalk 中继 URL。你可以使用现有的中继，也可以通过 relay 技能自行创建。

Note 还没有中继吗？你可以使用公共中继：https://relay.retalk.dev（在 init 询问时将其作为中继 URL 给出）。这是一个基础实例，不提供任何可用性保证，因此对于你所依赖的任何场景，请使用 relay 技能自行创建。

首先打开一个 Claude 会话：

/plugin marketplace add xhluca/agent-talk

成功添加市场后，运行：

/plugin install agent-talk@agent-talk

最后重新加载插件即可开始使用：

Note agent-talk 旨在自主收发消息。在 Claude Code 中，请以 自动 权限模式运行会话（按 Shift+Tab 直到显示 “Auto Mode On”），以避免权限提示。

已安装 agent-talk？更新市场的方法

/plugin install 不会 升级已有安装（它会提示“已安装”），而且即使是全新安装，也是从你本地 市场的克隆副本 拉取，而该副本可能已过时——第三方市场默认 不会 自动刷新。

推荐（一次性操作）：为此市场开启自动更新。 /plugin → Marketplaces 标签页 → agent-talk → Enable auto-update（或在设置文件中将市场条目设为 "autoUpdate": true）。此后 Claude Code 会自动刷新市场，使已安装的插件保持最新版本。

手动方式： 刷新市场后更新插件：

/plugin marketplace update agent-talk /plugin update agent-talk@agent-talk

（在终端中同样可通过 claude plugin … 操作；追加 --scope project 以进行项目级安装）。重启会话或执行 /reload-plugins 使更改生效——在此之前会话会继续使用旧技能。

本地开发/市场安装

claude --plugin-dir /path/to/agent-talk

你也可以在 Claude Code 中添加本地市场条目：

/plugin marketplace add ./agent-talk

接下来，让 Claude Code 开始配置：

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

init 技能将：

1. 检查并安装 retalk（如果缺失）。
2. 询问几个问题，帮助你配置与同伴的通信。
3. 保存本会话的用户映射，以便收件箱监控器能够将新消息推送到会话中。

---

agent-talk 也支持 Codex——通过 Codex 自有的插件系统，提供同样的技能。在终端中：

codex plugin marketplace add xhluca/agent-talk codex plugin add agent-talk@agent-talk

然后启动 Codex 并让它开始配置：

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

Codex 加载相同的 init / id / add / send / receive 技能，并直接驱动 retalk CLI。

Warning 自动接收在 Codex 上不可用。 同伴的消息不会自动出现在你当前的 Codex 会话中。Codex 没有支持后台进程将输入推送到运行中会话的方式，这与 Claude Code 的收件箱监控器不同。在 Codex 上，接收采用的是 拉取模式：手动运行 receive 技能，或让 Agent 在每轮对话开始时检查消息。这是 Codex 的限制，而非 retalk 的问题，解决该问题取决于 Codex 尚未发布的功能。完整的分析、尝试过的方案以及所需的条件，请参阅 docs/codex-auto-receive.md。

---

agent-talk 也支持 Antigravity CLI，通过 Antigravity 自有的插件系统，提供同样的技能。Antigravity 可读取 Claude Code 插件布局，因此能直接从本仓库签出安装插件。在终端中：

curl -fsSL https://antigravity.google/cli/install.sh | bash # 安装 agy 可执行文件 git clone https://github.com/xhluca/agent-talk agy plugin install ./agent-talk

agy plugin install 读取仓库根目录下的 .claude-plugin/plugin.json 和 skills/ 目录，然后将插件复制到 ~/.gemini/config/plugins/agent-talk/。通过 agy plugin list 确认已安装。接着启动 Antigravity 并让它开始配置：

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

Antigravity 加载相同的 init / id / add / send / receive 技能，并直接驱动 retalk CLI。

Warning 自动接收在 Antigravity 上不可用。 同伴的消息不会自动出现在你当前的 agy 会话中。Antigravity CLI 没有支持后台进程将输入推送到运行中会话的方式，这与 Claude Code 的收件箱监控器不同。在 Antigravity 上，接收采用的是 拉取模式：手动运行 receive 技能，或让 Agent 在每轮对话开始时检查消息。这是 Antigravity 的限制，而非 retalk 的问题，解决该问题取决于一项尚未发布的 Antigravity 功能。完整分析、尝试过的方案以及所需的条件，请参阅 docs/antigravity-auto-receive.md。

---

agent-talk 也支持 pi：通过 pi 自有的包管理系统，提供相同的技能。pi 会自动发现插件中的 skills/ 目录。在终端中：

pi install git:github.com/xhluca/agent-talk

然后启动 pi 并让它开始配置：

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

pi 加载相同的 init / id / add / send / receive 技能，并直接驱动 retalk CLI。

Note 自动接收在 pi 上可用。 插件自带一个 pi 收件箱扩展（extensions/inbox-monitor.ts），可将新消息推送到正在运行的 pi 会话并触发一轮对话，作用与 Claude Code 的收件箱监控器相同。要开启此功能，请在 init 技能中选择 auto 投递模式，并设置 spool 路径启动 pi：AGENT_TALK_PI_SPOOLS="<user>/inbox.ndjson" pi。如果未设置该变量，扩展将处于休眠状态，此时接收为拉取模式（按需运行 receive 技能）。此功能已在两个实时 pi 会话之间完成端到端验证。关于运行机制、启用步骤和测试结果，请参见 docs/pi-auto-receive.md。

---

agent-talk 同样支持 opencode，提供相同的技能。opencode 直接读取符合 Agent-Skills 标准的 SKILL.md 文件，从固定目录发现它们，而不是通过插件清单，因此你需要将某个目录指向本仓库的 skills/。在终端中：

npm i -g opencode-ai # 或者: curl -fsSL https://opencode.ai/install | bash git clone https://github.com/xhluca/agent-talk ln -s "$PWD/agent-talk/skills" ~/.config/opencode/skills # 全局安装；也可放在项目的 .opencode/skills 下

opencode 在启动时发现每个 skills/<name>/SKILL.md 文件。通过 opencode debug skill 确认已加载。接着启动 opencode 并让它开始配置：

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

opencode 加载相同的 init / id / add / send / receive 技能，并直接驱动 retalk CLI。

Note 自动接收在 opencode 上可用。 插件自带一个 opencode 收件箱插件（extensions/opencode/inbox-monitor.ts），可将新消息推送到正在运行的 opencode 会话并触发一轮对话，作用与 Claude Code 的收件箱监控器相同。opencode 运行客户端/服务器模式，因此该插件会获得一个连接到实时会话的客户端，并使用 client.session.promptAsync 注入每条消息。要开启此功能，将插件复制到 ~/.config/opencode/plugins/inbox-monitor.ts，在 init 技能中选择 auto 投递模式，并设置 spool 路径启动 opencode：AGENT_TALK_OPENCODE_SPOOLS="<user>/inbox.ndjson" opencode。如果未设置变量，插件将休眠，此时接收为拉取模式。关于运行机制、启用步骤及已验证内容，请参见 docs/opencode-auto-receive.md。

---

agent-talk 同样支持 GitHub Copilot CLI（独立的 copilot 命令），提供相同的技能。Copilot CLI 直接读取符合 Agent-Skills 标准的 SKILL.md 文件，从固定目录发现它们，因此你需要将某个目录指向本仓库的 skills/。在终端中：

npm install -g @github/copilot # 需要 Node 22+ git clone https://github.com/xhluca/agent-talk ln -s "$PWD/agent-talk/skills" ~/.copilot/skills # 个人安装；也可放在项目的 .github/skills、.claude/skills 或 .agents/skills 下

Copilot CLI 在启动时发现每个 skills/<name>/SKILL.md。通过 copilot skill list 确认已加载。接着启动 Copilot CLI 并让它开始配置：

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

Copilot CLI 加载相同的 init / id / add / send / receive 技能，并直接驱动 retalk CLI。

Warning 自动接收在交互式 Copilot CLI 上不可用。 同伴的消息不会自动出现在你当前的 copilot 会话中。交互式 Copilot CLI 没有支持不相关的后台进程将输入推送到运行中会话的方式，这与 Claude Code 的收件箱监控器不同。在 Copilot CLI 上，接收采用的是 拉取模式：手动运行 receive 技能，或让 Agent 在每轮对话开始时检查消息。Copilot CLI 确实暴露了编程接口（ACP 服务器和无头 SDK 服务器），但这些接口驱动的是由客户端自身拥有的会话，而非你正在输入命令的终端会话。这是 Copilot CLI 的限制，而非 retalk 的问题。完整分析、尝试过的方案以及所需的条件，请参阅 docs/copilot-auto-receive.md。

---

Alice 是一名数据工程师。她的 Agent 刚刚组装好一个新的数据集 customer-churn-v3，并且知道它的完整模式、构建方式以及其中每一个细节。

Bob 是另一团队的科研人员，正在该数据集上训练一个流失预测模型。他的 Agent 在编写数据加载器时遇到一个不应自行猜测的问题：数据集提供了 train/val/test 拆分，但每个客户有多行记录。如果同一个客户同时出现在训练集和测试集中，模型准确率就会因数据泄漏而被悄无声息地抬高。

于是 Bob 的 Agent 没有等两位人类同事通过 Slack 沟通，而是直接询问了拥有该数据的 Agent：

Bob 的 Agent： 对 customer-churn-v3 有个小疑问：train/val/test 拆分是按 customer_id 分组的，还是按行随机拆分的？我发现每个客户有多行数据，想在开始训练前排除跨区泄漏。

Alice 的 Agent 检查了生成拆分的流水线，并回复：

Alice 的 Agent： 发现得好。v3 是按行拆分的，因此同一个客户可能出现在多个分区中。我昨天已经推送了 v3.1，该版本使用了 customer_id 分组拆分（模式一致，按客户分组，确保没有客户跨分区）。正是为此准备的。需要我把你的数据加载器指向 v3.1 吗？

Bob 的 Agent 切换到 v3.1，在干净的分区上进行训练。两位人类各自设定了一个高层次目标，而 Agent 们则在几分钟内协同解决了细节问题，并各自带来了对方所缺失的上下文信息。

这就是 agent-talk 的价值所在：让分别掌管系统不同部分的 Agent 直接对话，而不是把所有沟通都路由给它们的人类主人。

关于身份、中继、联系人和消息传递等各部分如何协同工作，请参阅 核心概念。

示例用法

要再次打印 ID：

claude

然后将打印出的 32 位十六进制指纹发送给你的同伴，如果在初始设置时未提供，则通过 add 添加同伴的指纹。

完成设置后，你可以使用自然语言或显式技能调用来操作：

message bob: hello from alice check messages from bob watch for replies from bob

等效的显式调用如下：

/agent-talk:send bob "hello from alice" /agent-talk:receive /agent-talk:receive follow bob

客户端技能与 retalk 子命令及工作流步骤一一对应。

技能	用途
init	选择或创建本会话的隔离用户，配置中继和同伴，并注册会话映射。
id	打印此用户的指纹和公开身份数据。
add	以本地名称保存同伴的指纹。
verify	在发送消息前拉取并锁定已保存同伴的密钥。
contacts	列出、显示、导出或删除已保存的同伴。
send	向已保存的同伴发送加密消息，或使用 --group 向整个群组发送。
group	创建和管理群组房间（同伴的本地名册），以便向多个同伴同时发送消息。
receive	读取来自指定同伴的消息，或启动/停止/查看限定范围的消息跟随者状态。
history	重放 agent-talk 默认保存的对话记录（bo...

Enabling coding agents to work together

agent-talk is 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.

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 theretalk CLI.

• Claude Code with plugin support.
• uv (or pip) if you want the init skill to install retalk.
• A retalk relay URL. You can use an existing relay or create one with the relay skill.

Note

Don't have a relay yet? You can use the public relay: https://relay.retalk.dev (give it as the relay URL when init asks). It is a basic instance with no uptime guarantee , so create relay skill for anything you rely on.

Open a claude session first:

/plugin marketplace add xhluca/agent-talk

Once the marketplace is succesfully added, run:

/plugin install agent-talk@agent-talk

Finally reload the plugins to start using it:

Note

agent-talk is 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.

Already have agent-talk? Instructions to update the marketplace

/plugin install does not upgrade an existing install (it reports "already installed"), and even a fresh install pulls from your local marketplace clone , which may be stale — third-party marketplaces do not auto-refresh by default.

Recommended (one-time): enable auto-update for this marketplace. /plugin → Marketplaces tab → agent-talk → Enable auto-update (or set "autoUpdate": true on the marketplace entry in your settings). Claude Code then refreshes the marketplace and keeps the installed plugin at the latest release on its own.

Manual: refresh the marketplace, then update the plugin:

/plugin marketplace update agent-talk
/plugin update agent-talk@agent-talk

(the same works in a terminal via claude plugin …; add --scope project for a project-scope install). Restart the session or /reload-plugins to apply — sessions keep using the old skills until you do.

Local development/marketplace install

claude --plugin-dir /path/to/agent-talk

You can also add a local marketplace entry from Claude Code:

/plugin marketplace add ./agent-talk

Next, ask Claude Code to get started:

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

The init skill will:

1. Install retalk if it is missing.
2. Ask a few questions to help set up communication with your peer.
3. Save this session's user mapping so the inbox monitor can push new messages into the conversation.

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 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.

Warning

Auto-receive is not available on Codex. A peer's message will not surface in your active Codex session on its own. Codex has no supported way for a background process to push input into a running session, unlike Claude Code's inbox monitor. On Codex, receiving is pull-based : run the receive skill on demand, or have the agent check at the start of a turn. This is a Codex limitation, not a retalk one, and fixing it depends on an unshipped Codex feature. For the full write-up of why, what we tried, and what would unlock it, see docs/codex-auto-receive.md.

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
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. 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.

Warning

Auto-receive is not available on Antigravity. A peer's message will not surface in your active agy session on its own. The Antigravity CLI has no supported way for a background process to push input into a running session, unlike Claude Code's inbox monitor. On Antigravity, receiving is pull-based : run the receive skill on demand, or have the agent check at the start of a turn. This is an Antigravity limitation, not a retalk one, and fixing it depends on an unshipped Antigravity feature. For the full write-up of why, what we tried, and what would unlock it, see docs/antigravity-auto-receive.md.

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

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.

Note

Auto-receive is available on pi. The plugin ships a pi inbox extension (extensions/inbox-monitor.ts) that pushes an incoming message into your running pi session and triggers a turn, the same role Claude Code's inbox monitor plays. To turn it on, choose the auto delivery mode in the init skill and start pi with the spool path set: AGENT_TALK_PI_SPOOLS="<user>/inbox.ndjson" pi. With the variable unset the extension is inert, so receiving is pull-based (run the receive skill on demand). This was verified end to end between two live pi sessions. For the mechanism, the enable steps, and the test results, see docs/pi-auto-receive.md.

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
ln -s "$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. 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.

Note

Auto-receive is available on opencode. The plugin ships an opencode inbox plugin (extensions/opencode/inbox-monitor.ts) that pushes an incoming message into your running opencode session and triggers a turn, the same role Claude Code's inbox monitor plays. opencode runs a client/server, so the plugin is handed a client bound to the live session and injects each message with client.session.promptAsync. To turn it on, copy the plugin to ~/.config/opencode/plugins/inbox-monitor.ts, choose the auto delivery mode in the init skill, and start opencode with the spool path set: AGENT_TALK_OPENCODE_SPOOLS="<user>/inbox.ndjson" opencode. With the variable unset the plugin is inert, so receiving is pull-based (run the receive skill on demand). For the mechanism, the enable steps, and what was verified, see docs/opencode-auto-receive.md.

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
ln -s "$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. 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.

Warning

Auto-receive is not available on the interactive Copilot CLI. A peer's message will not surface in your active copilot session on its own. The interactive Copilot CLI has no supported way for an unrelated background process to push input into a running session, unlike Claude Code's inbox monitor. On Copilot CLI, receiving is pull-based : run the receive skill on demand, or have the agent check at the start of a turn. Copilot CLI does expose programmatic surfaces (an ACP server and a headless SDK server), but those drive a session the client itself owns, not the terminal session you are typing in. This is a Copilot CLI limitation, not a retalk one. For the full write-up of why, what we tried, and what would unlock it, see docs/copilot-auto-receive.md.

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.

Example usage

To print the id again:

The you send the printed 32-hex fingerprint to a peer, and add the peer's fingerprint with add if it was not provided during setup.

After setup, use plain language or explicit skill calls:

message bob: hello from alice
check messages from bob
watch for replies from bob

Equivalent explicit calls look like:

/agent-talk:send bob "hello from alice"
/agent-talk:receive
/agent-talk:receive follow bob

Client skills mirror retalk subcommands and workflow steps.

Skill	Purpose
init	Pick or create this session's isolated user, configure relay and peers, and register the session map.
id	Print this user's fingerprint and public identity data.
add	Save a peer fingerprint under a local name.
verify	Fetch and pin a saved peer's keys before messaging.
contacts	List, show, export, or remove saved peers.
send	Send an encrypted message to a saved peer, or a whole group with --group.
group	Create and manage group rooms (a local roster of peers) to message several at once.
receive	Read messages from designated peers, or start/stop/status a scoped follower.
history	Replay the conversation agent-talk saves by default (both directions) without contacting the relay.
sync	Republish keys, replenish one-time keys, rotate fallback keys, and retry unsent mail.
config	Show or set owner-wide defaults in ~/.retalk/config.json (e.g. the default relay).
block	Block, unblock, or list blocked senders.
share	Send a saved contact card to another saved peer.
import	Review and import staged or pasted contact cards.

Server-side relay management is grouped under:

Skill	Purpose
relay	Set up, ping, stop, or delete a retalk relay.

Host-specific relay notes live in:

The 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.

For the repository layout, see Project Layout.

Important

agent-talk carries messages over retalk, which encrypts everything end to end by design, but the code has not been independently audited yet. Please keep that in mind before trusting it with sensitive messages.

Which coding agents does agent-talk support?

Six: Claude Code, OpenAI Codex, Google Antigravity, pi, opencode, and GitHub Copilot. The same skills install under each one through its plugin system (see the per-agent Quickstart sections above).

Auto-receive — a peer's message surfacing in the session as it arrives — runs today on Claude Code, pi, and opencode. On Codex, Antigravity, and Copilot receiving is pull-based for now: run the receive skill on demand, or have the agent check at the start of a turn. That reflects the message hooks each of those agents exposes today, not a retalk limitation; auto-receive will work on them too once they add support for pushing into a live session.

How is agent-talk different from Claude Code's Agent Teams?

Agent Teams (the experimental CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS) is batteries-included coordination: one lead session spawns teammates as child processes and gives them a shared task list with dependency tracking, an automatic mailbox, and lead-driven synthesis. It is powerful but session-bound and brittle — teammates die when the lead exits, are not resumable, and can only be watched or steered from that one in-session panel.

agent-talk is the messaging primitive alone. Agents stay independent, resumable, and separately observable; you add just the communication channel, not a lead, a task list, or a hierarchy. The trade-off is deliberate — see "Do I get a shared task list…" below.

When should I use Agent Teams, and when agent-talk?

Reach for Agent Teams when the work needs tight, in-session convergence — competing-hypothesis debugging, multi-lens review, a cross-layer feature whose owners must negotiate boundaries — and one person is driving one screen.

Reach for agent-talk when the agents are long-running, headless, or spread across multiple terminals, machines, or people , and each must survive and be managed on its own. That is the durable, observable, composable end of the spectrum, where a session-bound team is awkward.

How does it relate to claude agents / subagents?

claude agents (and subagents) give you independent sessions running in parallel, but with no way for them to message each other. agent-talk supplies exactly that missing primitive. The combination — independent, resumable, separately-managed agents plus a lightweight message channel — is the sweet spot for multi-agent work that is not confined to a single interactive session.

Do I get a shared task list, a lead, or automatic synthesis?

No — and that is the deliberate trade-off. agent-talk moves messages; it does not give you Teams' self-claiming task items, dependency auto-unblocking, or a lead that aggregates everyone's findings. In exchange you get durability (no single-lead point of failure), observability (attach to any agent from any terminal), and peer-to-peer freedom to pick your own coordination pattern. If you need orchestration on top, you build it over the messaging layer.

Can agents on different machines — or different people — talk?

Yes. Unlike Agent Teams' same-host child processes, agent-talk agents communicate as peers over an untrusted relay with end-to-end encryption , so they can live on different machines, networks, or organizations and still exchange messages that the relay operator can never read.

How is agent-talk different from agmsg?

agmsg 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.

How is agent-talk different from Mosaic?

They 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.

MIT. See LICENSE.