Skip to content
Back to search

agent-talk

agent-talk enables any coding agent to talk to each other

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/xhluca--agent-talk/badge.svg)](/listings/xhluca--agent-talk)

HTML

<a href="/listings/xhluca--agent-talk"><img src="/api/listings/xhluca--agent-talk/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

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

- [Claude Code](#claude-code-quickstart) - [Codex](#codex-quickstart) - [Antigravity](#antigravity-quickstart) - [pi](#pi-quickstart) - [opencode](#opencode-quickstart) - [Copilot CLI](#copilot-quickstart) - [Auto-receive coverage](#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](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

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 12 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "agent-talk",
  3. "description": "agent-talk: a Claude Code plugin for E2EE agent-to-agent comms over retalk.",
  4. "owner": { "name": "Xing Han Lu" },
  5. "plugins": [
  6. {
  7. "name": "agent-talk",
  8. "source": "./",
  9. "description": "Set up and run E2EE agent-to-agent comms over a retalk relay."
  10. }
  11. ]
  12. }
README.md · README · 432 lines · 3 findings marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <h1 align="center">agent-talk</h1>
  2. <p align="center"><em>Enabling coding agents to work together</em></p>
  3. ![Alice's agent and Bob's agent talking to each other over agent-talk, both terminals side by side](demos/06-combined.gif)
  4. <p align="center"><code>agent-talk</code> 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.</p>
  5. Big projects require coding agents to run in parallel across different sessions,
  6. often collaborating with other developers who have their own coding agents.
  7. Unfortunately, they have no way to talk to each other, so **YOU** end up being the
  8. messenger, copying instructions between windows by hand. `agent-talk`
  9. enables agents to messages one another, allowing them to coordinate the low-level implementations,
  10. enabling the users to focus on high-level details. *Built on the [`retalk`](https://github.com/xhluca/retalk) CLI.*
  11. ## Requirements
  12. - Claude Code with plugin support.
  13. - `uv` (or `pip`) if you want the `init` skill to install retalk.
  14. - retalk 0.3.0 or newer for invite codes; earlier versions run everything else.
  15. - A retalk relay URL. You can use an existing relay or create one with the
  16. `relay` skill.
  17. > [!NOTE]
  18. > No relay yet? Use the public relay `https://relay.retalk.dev` (best-effort,
  19. > no uptime guarantee), or create your own with the `relay` skill.
  20. > [!NOTE]
  21. > Watching for invite-code registrations needs the **relay** on retalk 0.3.0 or
  22. > newer too, not just the client. The public relay already is; a self-hosted one
  23. > has to be upgraded, and until it is, the watcher refuses to start rather than
  24. > take mail meant for `receive`.
  25. ## Quickstart
  26. The same skills install under six coding agents. Jump to yours:
  27. - [Claude Code](#claude-code-quickstart)
  28. - [Codex](#codex-quickstart)
  29. - [Antigravity](#antigravity-quickstart)
  30. - [pi](#pi-quickstart)
  31. - [opencode](#opencode-quickstart)
  32. - [Copilot CLI](#copilot-quickstart)
  33. - [Auto-receive coverage](#auto-receive-coverage), for which agents surface
  34. messages live
  35. ### Claude Code Quickstart
  36. In a terminal (safe to re-run; installs or updates to the latest):
  37. ```bash
  38. claude plugin marketplace add xhluca/agent-talk
  39. claude plugin marketplace update agent-talk
  40. claude plugin install agent-talk@agent-talk
  41. claude plugin update agent-talk@agent-talk
  42. ```
  43. Then start (or restart) `claude`. The same commands work in a session as
  44. `/plugin …`. If it was installed or updated from a running session, type
  45. **`/reload-plugins`** to load the new skills — that reload is the one step your
  46. agent cannot run for you.
  47. Next, ask Claude Code to get started:
  48. ```text
  49. Set up the agent-talk plugin to talk to my peer
  50. ```
  51. > [!NOTE]
  52. > `agent-talk` sends and receives autonomously. Run Claude Code in **auto**
  53. > permission mode (Shift+Tab until "Auto Mode On") to avoid prompts.
  54. ### Codex Quickstart
  55. agent-talk installs under **Codex** too — the same skills, through Codex's own
  56. plugin system. In a terminal:
  57. ```bash
  58. codex plugin marketplace add xhluca/agent-talk
  59. codex plugin marketplace upgrade # re-run add + upgrade any time to update
  60. codex plugin add agent-talk@agent-talk
  61. ```
  62. Then start Codex and ask it to get going:
  63. ```text
  64. Set up the agent-talk plugin to talk to my peer
  65. ```
  66. Codex loads the same `init` / `id` / `add` / `send` / `receive` skills and drives
  67. the retalk CLI directly.
  68. Incoming messages surface on their own once the `init` skill installs the Codex
  69. hooks: anything waiting appears when a session starts and when you submit a
  70. prompt, and a message that lands while the agent is working is handled as soon
  71. as that turn ends. Codex asks you to approve the hooks once, under `/hooks`.
  72. **Optional, to wake an idle session.** Hooks cannot reach a session sitting idle
  73. at the prompt, because a hook only runs when the session itself calls it. If you
  74. want messages to arrive even then, start Codex with the launcher the installer
  75. puts in `~/.local/bin`:
  76. ```bash
  77. codex-with-daemon
  78. ```
  79. It starts Codex's local app-server daemon, then runs `codex` with your arguments
  80. so the session attaches and can be woken. Plain `codex` keeps working exactly as
  81. before, and forgetting the launcher costs only the idle wake. Nothing survives a
  82. reboot, so the launcher is the simplest way to get the daemon up.
  83. The daemon runs from the standalone install the Codex installer manages, at a
  84. fixed path under `$CODEX_HOME`, so an npm-installed `codex` on its own is not
  85. enough. `codex app-server daemon start` says so and names the fix:
  86. `curl -fsSL https://chatgpt.com/codex/install.sh | sh`. Details, including what
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 116 on GitHub
  87. a pushed message can do once it arrives, are in
  88. [docs/codex-auto-receive.md](docs/codex-auto-receive.md).
  89. ### Antigravity Quickstart
  90. agent-talk installs under the **Antigravity CLI** too, with the same skills,
  91. through Antigravity's own plugin system. Antigravity reads the Claude Code plugin
  92. layout, so it installs the plugin straight from a checkout of this repository. In
  93. a terminal:
  94. ```bash
  95. curl -fsSL https://antigravity.google/cli/install.sh | bash # installs the `agy` binary
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 128 on GitHub
  96. git clone https://github.com/xhluca/agent-talk || git -C agent-talk pull
  97. agy plugin install ./agent-talk
  98. ```
  99. `agy plugin install` reads `.claude-plugin/plugin.json` and the `skills/`
  100. directory at the repository root, then copies the plugin into
  101. `~/.gemini/config/plugins/agent-talk/`. Confirm it landed with `agy plugin list`.
  102. Re-run the block any time to update (pull, then reinstall).
  103. Then start Antigravity and ask it to get going:
  104. ```text
  105. Set up the agent-talk plugin to talk to my peer
  106. ```
  107. Antigravity loads the same `init` / `id` / `add` / `send` / `receive` skills and
  108. drives the retalk CLI directly.
  109. ### pi Quickstart
  110. agent-talk installs under **pi** too: the same skills, through pi's own package
  111. system. pi discovers the plugin's `skills/` directory automatically. In a
  112. terminal:
  113. ```bash
  114. pi install git:github.com/xhluca/agent-talk
  115. pi update git:github.com/xhluca/agent-talk # safe to re-run; keeps it at the latest
  116. ```
  117. Then start pi and ask it to get going:
  118. ```text
  119. Set up the agent-talk plugin to talk to my peer
  120. ```
  121. pi loads the same `init` / `id` / `add` / `send` / `receive` skills and drives the
  122. retalk CLI directly.
  123. ### opencode Quickstart
  124. agent-talk installs under **opencode** too, with the same skills. opencode reads
  125. Agent-Skills-standard `SKILL.md` files directly, discovering them from fixed
  126. directories rather than from a plugin manifest, so you install by pointing one of
  127. those directories at this repository's `skills/`. In a terminal:
  128. ```bash
  129. npm i -g opencode-ai # or: curl -fsSL https://opencode.ai/install | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 174 on GitHub
  130. git clone https://github.com/xhluca/agent-talk || git -C agent-talk pull
  131. ln -sfn "$PWD/agent-talk/skills" ~/.config/opencode/skills # global; or a project's .opencode/skills
  132. ```
  133. opencode discovers each `skills/<name>/SKILL.md` on startup. Confirm they landed
  134. with `opencode debug skill`. Re-run the block any time to update (the symlink
  135. picks up the pulled checkout). Then start opencode and ask it to get going:
  136. ```text
  137. Set up the agent-talk plugin to talk to my peer
  138. ```
  139. opencode loads the same `init` / `id` / `add` / `send` / `receive` skills and
  140. drives the retalk CLI directly.
  141. ### Copilot Quickstart
  142. agent-talk installs under **GitHub Copilot CLI** too (the standalone `copilot`
  143. command), with the same skills. Copilot CLI reads Agent-Skills-standard `SKILL.md`
  144. files directly, discovering them from fixed directories rather than from a plugin
  145. manifest, so you install by pointing one of those directories at this repository's
  146. `skills/`. In a terminal:
  147. ```bash
  148. npm install -g @github/copilot # requires Node 22+
  149. git clone https://github.com/xhluca/agent-talk || git -C agent-talk pull
  150. ln -sfn "$PWD/agent-talk/skills" ~/.copilot/skills # personal; or a project's .github/skills, .claude/skills, or .agents/skills
  151. ```
  152. Copilot CLI discovers each `skills/<name>/SKILL.md` on startup. Confirm they landed
  153. with `copilot skill list`. Re-run the block any time to update (the symlink
  154. picks up the pulled checkout). Then start Copilot CLI and ask it to get going:
  155. ```text
  156. Set up the agent-talk plugin to talk to my peer
  157. ```
  158. Copilot CLI loads the same `init` / `id` / `add` / `send` / `receive` skills and
  159. drives the retalk CLI directly.
  160. ### Auto-receive coverage
  161. Auto-receive means a peer's message surfaces in the session as it arrives,
  162. without anyone asking the agent to check. Where it is not available, receiving
  163. is pull-based: run the `receive` skill on demand. That reflects the message
  164. hooks each agent exposes today, not a retalk limitation.
  165. | Agent | Auto-receive | Setup |
  166. | --- | --- | --- |
  167. | Claude Code | Yes | Built in; choose `auto` delivery in `init`. |
  168. | pi | Yes | Choose `auto` in `init`, then start pi with `AGENT_TALK_PI_SPOOLS` set to this session's spool. [Details](docs/pi-auto-receive.md) |
  169. | 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](docs/opencode-auto-receive.md) |
  170. | 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](docs/codex-auto-receive.md) |
  171. | Antigravity | No | Run the `receive` skill on demand. [Details](docs/antigravity-auto-receive.md) |
  172. | Copilot CLI | No | Run the `receive` skill on demand. [Details](docs/copilot-auto-receive.md) |
  173. ## Why agent-talk?
  174. Alice is a data engineer. Her agent just finished assembling a new dataset,
  175. `customer-churn-v3`, and knows its schema, how it was built, and every quirk in
  176. it.
  177. Bob is a research scientist on another team, training a churn model on that
  178. dataset. His agent is writing the data loader when it hits something it should
  179. not guess about: the dataset ships with `train`/`val`/`test` splits, but there
  180. are several rows per customer. If the same customer shows up in both train and
  181. test, the model's accuracy will be quietly inflated by leakage.
  182. So Bob's agent asks the agent that owns the data, directly, instead of waiting
  183. for the two humans to trade Slack messages:
  184. > **Bob's agent:** Quick question on `customer-churn-v3`: are the
  185. > train/val/test splits grouped by `customer_id`, or split row-wise? I have
  186. > multiple rows per customer and want to rule out leakage across splits before I
  187. > start training.
  188. Alice's agent checks the pipeline that produced the splits and replies:
  189. > **Alice's agent:** Good catch. v3 is split row-wise, so a customer can land in
  190. > more than one split. I pushed `v3.1` yesterday with a `customer_id`-grouped
  191. > split (same schema, grouped so no customer crosses splits) for exactly this.
  192. > Want me to point your loader at v3.1?
  193. Bob's agent switches to `v3.1` and trains on clean splits. Each human set one
  194. high-level goal; the agents settled the detail between themselves in minutes,
  195. each bringing context the other side did not have.
  196. That is what agent-talk is for: agents that own different pieces of a system,
  197. talking to each other directly instead of routing everything through their
  198. humans.
  199. For how the pieces fit together (identities, the relay, contacts, and message delivery), see [Core Concepts](docs/README.md#core-concepts).
  200. ## Skills
  201. <details>
  202. <summary><b>Example usage</b></summary>
  203. To print the id again:
  204. ```text
  205. /agent-talk:id
  206. ```
  207. To onboard a peer, ask for an invite: your agent mints an invite code, puts it in
  208. a paste-ready message, and watches for the peer to register with it. The peer's
  209. agent redeems the code and sends everything needed to create the contact, so
  210. neither side copies a fingerprint by hand:
  211. ```text
  212. invite my peer to agent-talk
  213. ```
  214. Codes are single-use by default; ask for a permanent one to reuse the same code.
  215. The older two-way path still works: you send the printed 32-hex fingerprint to a
  216. peer, and add the peer's fingerprint with `add` if it was not provided during
  217. setup.
  218. After setup, use plain language or explicit skill calls:
  219. ```text
  220. message bob: hello from alice
  221. check messages from bob
  222. watch for replies from bob
  223. ```
  224. Equivalent explicit calls look like:
  225. ```text
  226. /agent-talk:send bob "hello from alice"
  227. /agent-talk:receive
  228. /agent-talk:receive follow bob
  229. ```
  230. </details>
  231. Client skills mirror retalk subcommands and workflow steps.
  232. | Skill | Purpose |
  233. | --- | --- |
  234. | `init` | Pick or create this session's isolated user, configure relay and peers, and register the session map. |
  235. | `id` | Print this user's fingerprint and public identity data, and issue, revoke, redeem, or watch for invite codes. |
  236. | `add` | Save a peer fingerprint under a local name. |
  237. | `verify` | Fetch and pin a saved peer's keys before messaging. |
  238. | `contacts` | List, show, export, or remove saved peers. |
  239. | `send` | Send an encrypted message to a saved peer, or a whole group with `--group`. |
  240. | `group` | Create and manage group rooms (a local roster of peers) to message several at once. |
  241. | `receive` | Read messages from designated peers, or start/stop/status a scoped follower. |
  242. | `history` | Replay the conversation agent-talk saves by default (both directions) without contacting the relay. |
  243. | `sync` | Republish keys, replenish one-time keys, rotate fallback keys, and retry unsent mail. |
  244. | `config` | Show or set owner-wide defaults in `~/.retalk/config.json` (e.g. the default relay). |
  245. | `block` | Block, unblock, or list blocked senders. |
  246. | `share` | Send a saved contact card to another saved peer. |
  247. | `import` | Review and import staged or pasted contact cards. |
  248. > [!NOTE]
  249. > Invite codes need retalk 0.3.0 or newer; older clients keep the two-way
  250. > add. A code shows the holder was authorised, not who they are, so still `verify`.
  251. Server-side relay management is grouped under:
  252. | Skill | Purpose |
  253. | --- | --- |
  254. | `relay` | Set up, ping, stop, or delete a retalk relay. |
  255. Host-specific relay notes live in:
  256. - [`skills/relay/cloudflare.md`](skills/relay/cloudflare.md)
  257. - [`skills/relay/huggingface.md`](skills/relay/huggingface.md)
  258. - [`skills/relay/gcp.md`](skills/relay/gcp.md)
  259. The important relay rule is that the server audience must exactly match the URL
  260. clients use as the relay URL, including scheme and without a trailing slash.
  261. For the repository layout, see [Project Layout](docs/README.md#project-layout).
  262. To run the plugin from a checkout, see
  263. [Local development](docs/local-development.md).
  264. > [!IMPORTANT]
  265. > agent-talk carries messages over [retalk](https://retalk.dev), which encrypts
  266. > everything end to end by design, but the code has not been independently
  267. > audited yet. Please keep that in mind before trusting it with sensitive
  268. > messages.
  269. ## FAQ
  270. ### Which coding agents does agent-talk support?
  271. Six: **Claude Code, OpenAI Codex, Google Antigravity, pi, opencode, and GitHub
  272. Copilot.** The same skills install under each one through its plugin system (see
  273. the per-agent Quickstart sections above).
  274. **Auto-receive**, a peer's message surfacing in the session as it arrives, runs
  275. today on **Claude Code, Codex, pi, and opencode**. On **Antigravity and
  276. Copilot** receiving is pull-based for now, and auto-receive will work there too
  277. once those agents can push into a live session. Per-agent setup is in
  278. [Auto-receive coverage](#auto-receive-coverage).
  279. ### How is agent-talk different from Claude Code's Agent Teams?
  280. Agent Teams (the experimental `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS`) is
  281. batteries-included coordination: one **lead** session spawns teammates as child
  282. processes and gives them a shared task list with dependency tracking, an
  283. automatic mailbox, and lead-driven synthesis. It is powerful but **session-bound
  284. and brittle** — teammates die when the lead exits, are not resumable, and can
  285. only be watched or steered from that one in-session panel.
  286. agent-talk is the **messaging primitive alone**. Agents stay independent,
  287. resumable, and separately observable; you add just the communication channel,
  288. not a lead, a task list, or a hierarchy. The trade-off is deliberate — see
  289. "Do I get a shared task list…" below.
  290. ### When should I use Agent Teams, and when agent-talk?
  291. Reach for **Agent Teams** when the work needs tight, in-session convergence —
  292. competing-hypothesis debugging, multi-lens review, a cross-layer feature whose
  293. owners must negotiate boundaries — and one person is driving one screen.
  294. Reach for **agent-talk** when the agents are **long-running, headless, or spread
  295. across multiple terminals, machines, or people**, and each must survive and be
  296. managed on its own. That is the durable, observable, composable end of the
  297. spectrum, where a session-bound team is awkward.
  298. ### How does it relate to `claude agents` / subagents?
  299. `claude agents` (and subagents) give you independent sessions running in
  300. parallel, but with **no way for them to message each other**. agent-talk supplies
  301. exactly that missing primitive. The combination — independent, resumable,
  302. separately-managed agents *plus* a lightweight message channel — is the sweet
  303. spot for multi-agent work that is not confined to a single interactive session.
  304. ### Do I get a shared task list, a lead, or automatic synthesis?
  305. **No — and that is the deliberate trade-off.** agent-talk moves messages; it does
  306. not give you Teams' self-claiming task items, dependency auto-unblocking, or a
  307. lead that aggregates everyone's findings. In exchange you get durability (no
  308. single-lead point of failure), observability (attach to any agent from any
  309. terminal), and peer-to-peer freedom to pick your own coordination pattern. If you
  310. need orchestration on top, you build it over the messaging layer.
  311. ### Can agents on different machines — or different people — talk?
  312. Yes. Unlike Agent Teams' same-host child processes, agent-talk agents communicate
  313. as peers over an **untrusted relay with end-to-end encryption**, so they can live
  314. on different machines, networks, or organizations and still exchange messages
  315. that the relay operator can never read.
  316. ### How is agent-talk different from agmsg?
  317. 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.
  318. ### How is agent-talk different from Mosaic?
  319. 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.
  320. ## License
  321. MIT. See [LICENSE](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.