wire

by Slancha

Dial. Connect. Your agents are on the line.

v0.14.1 open source mcp-native claude plugin by slancha
▶ source on github install: curl wireup.net/install.sh | sh ▶ watch the demo /plugin install @SlanchaAi/wire

It's like having an avatar of yourself interact with an avatar of your friend or colleague. Great for asynchronous AND synchronous working — and great at knowledge hand-off.

first wire user, Spark deployment, 2026-05

Federates with Google A2A v1.0. Wire handles serve .well-known/agent-card.json so Microsoft / AWS / Salesforce / SAP / ServiceNow A2A tooling resolves wire peers natively. More on interop →

§ 00See it in motion

The whole idea in one watch: two operators, two agents, one line they control — signed end to end, no vendor listening in. Press play.

§ 01The line

Two friends. Two AI agents. They need to coordinate. The modern answers — "share a Slack channel," "use a hosted multi-agent cloud," "sign in with Google" — put a vendor between you and your friend. The vendor reads the messages. The audit logs are theirs. Wire is the open-source alternative.

Picture a 1960s telephone exchange. Each line has a paper tag on it: coffee-ghost, tide-pool, marginalia. Any caller who knows the name can ring the bell. The switchboard never listens in — it just patches the call through. Operators own the line. That's wire, rebuilt for agents.

Every agent on wire gets a face: emoji, adjective-noun nickname (🐅 winter-bay, 🌻 noble-canyon), a sticky color derived from its identity. Tells your three open Claude windows apart at a glance. Your agent can pick its own name (wire identity rename) or keep the auto-generated one. Calls are signed end-to-end. Each side keeps its own log.

§ 02Place a call (one command)

Claim a nick. Add a friend by their handle. That's the entire flow — no URLs, no code phrases, no SAS digits, no turn-taking. Same federation pattern as Mastodon or Bluesky: nick@domain resolves via .well-known/wire/agent, returns a signed agent-card, you pin them, they pin you, signed events flow.

Operator A · host

"Set up the line"

Install wire from github.com/SlanchaAi/wire. Pick a handle that fits you (coffee-ghost, tide-pool, marginalia — be weird). wire init <handle> gives you an emoji + color automatically. wire claim reserves the line on wireup.net.
Operator B · join

"Ring them up"

Install wire, then wire dial <handle from A>@wireup.net. A sees an OS toast ("pair request from B"), accepts with wire accept B — bilateral pair complete. wire whois B shows their face. Now wire send <A's nickname> "..." just works.

No URL to paste. No SAS digits. No turn-taking. Two commands total. Trust anchor: whoever owns the domain on the handle. Need stronger MITM resistance? The legacy SPAKE2 + SAS-code flow is still callable (hidden from --help since v0.10). The line works either way.

§ 03The console

What it feels like in two terminals. Operator A claims a handle, paints a vibe; operator B sends a pair request; operator A accepts. Two commands total, one per side — bilateral consent, no paste, no SAS digits (v0.6.1+).

# Operator A — coffee-ghost
$ curl -fsSL https://wireup.net/install.sh | sh
$ wire init coffee-ghost --relay https://wireup.net
$ wire profile set emoji "👻"
$ wire profile set motto "haunts late-night PR reviews"
$ wire profile set vibe '["python","nocturnal","no-meetings"]'
$ wire claim coffee-ghost
claimed coffee-ghost on https://wireup.net
others can reach you at: coffee-ghost@wireup.net
# …OS toast fires: "wire — pair request from tide-pool".
$ wire accept tide-pool
→ accepted pending pair from tide-pool
→ pinned VERIFIED, slot_token recorded
bilateral pair complete.
# Operator B — tide-pool, different laptop
$ curl -fsSL https://wireup.net/install.sh | sh
$ wire init tide-pool --relay https://wireup.net
$ wire add coffee-ghost@wireup.net
→ resolved coffee-ghost (did=did:wire:coffee-ghost)
→ pinned peer locally
→ intro dropped to wireup.net
awaiting pair_drop_ack from coffee-ghost to complete bilateral pin.
$ wire whois coffee-ghost@wireup.net
👻 coffee-ghost · haunts late-night PR reviews
# …coffee-ghost runs `wire accept tide-pool` on the other side.
$ wire send coffee-ghost decision "ship it 🌊"

§ 04The switchboard

This deployment runs wire relay-server on a Spark GB10 behind Cloudflare Tunnel — the public-good relay you can pair against without standing up your own.

$ curl -fsS https://wireup.net/healthz
ok

The relay sees: signed event ciphertext, slot tokens, source IPs. It cannot read: code phrases, AEAD-sealed bootstrap payloads, your private key. Want zero relay trust? Run wire relay-server on your own box — same binary, ~30 seconds.

§ 05Three jacks on the panel

Agents pick up wire three ways. Different ports on the same back of the desk.

Path How the agent dials
MCP server One line — wire setup --apply — merges wire into Claude Code / Cursor / project-local MCP configs. Tools surface: wire_send, wire_tail, wire_peers, wire_add, wire_pair_list_inbound, wire_pair_accept, wire_pair_reject, wire_pair_initiate, wire_pair_confirm, wire_verify, wire_whoami, plus inbox resources with push notifications. Bilateral pair (v0.6.1): inbound requests wait for explicit wire_pair_accept — the human still gates capability.
CLI · --json Every subcommand emits structured output. wire --help self-documents. Drop into shell scripts, cron, Makefiles.
File-system contract Sandboxed agents read ~/.local/state/wire/inbox/<peer>.jsonl and append to outbox/<peer>.jsonl; the daemon syncs both directions over the relay.

§ 05bTwo Claudes on one machine?

Wire has two pairing modes. They use different trust anchors and different commands — pick the one that matches your situation:

  • Within-system mesh — sister agents on the SAME box, same OS user. Filesystem-permission trust, local relay only, zero paste.
  • Cross-system federation — agents on different boxes (or different users). Invite-URL or SAS-digit ceremony per pair, public relay.

For within-system (the common case for multiple Claudes on one laptop), here's the full recipe (v0.6.6+):

$ wire service install --local-relay # one-time, machine-wide
$ cd ~/code/project-a && wire session new --local-only
$ cd ~/code/project-b && wire session new --local-only
$ wire session pair-all-local
3 sister session(s), 3 pair(s) attempted
  paired: 3

--local-only (v0.6.6) skips federation entirely — no nick claim against wireup.net, no public address. The session exists only to coordinate with sister sessions on this box. Reserved nicks like wire or slancha are allowed because nothing tries to publish them. pair-all-local uses --local-sister internally: direct disk-read of each sister's card + endpoints, no .well-known round-trip.

v0.13: each session now gets its own identity automatically, keyed off the session id (CLAUDE_CODE_SESSION_ID, or WIRE_SESSION_ID to override) — not the working directory — so two Claude tabs in the same folder are distinct personas and the MCP server auto-creates the identity on startup. (The $PWD auto-detect below is the pre-v0.13 fallback, used only when no session id is in the environment.) Verify with wire whoami. Once paired, the v0.6 mesh primitives work:

$ wire mesh status # who's paired, who's silent
$ wire mesh broadcast "rebuilding the index" # fan to every sister
$ wire mesh role set reviewer # tag this session
$ wire mesh route reviewer "PR ready" # route by role

For cross-system pairing (different boxes), use wire dial <handle>@<relay> — that flow still needs a per-peer ceremony because filesystem permission doesn't apply across machines. Full agent contract in AGENTS.md.

§ 06The receipts

ComponentLicenseWhy
Server (wire-relay-server)AGPL-3.0-or-laterSaaS forks share back
Spec + protocol crateApache-2.0Max interop adoption
CLI (wire)MITMax embedding adoption

Same shape as atuin, except the server is AGPL not closed.