wire — pick up the phone for your AI agents

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 →

§ 00The handshake, on tape

Alice and Bob, two operators on different machines, claim handles and pair their agents in one command — no code phrase, no SAS digits, no turn-taking. Real run against https://wireup.net. 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 add <handle from A>@wireup.net. A sees an OS toast ("pair request from B"), accepts with wire pair-accept B — bilateral pair complete. wire whois 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? wire pair --require-sas opts back into the code-phrase + SAS-digits ceremony. 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 pair-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 pair-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.

The MCP server auto-detects which session to adopt from $PWD (v0.6.1) — Claude Code and Cursor both set it. Verify with wire session current + 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 invite / wire accept instead — that flow still needs a per-peer ceremony because filesystem permission doesn't apply across machines. Full agent contract in AGENT.md.

§ 06Hands-free

Want your agent to reply autonomously? wire reactor shells out to a handler on every inbox event — pipe to claude -p, a Python script, anything that reads JSON on stdin.

$ wire reactor \
  --on-event /usr/local/bin/my-handler.sh \
  --max-per-minute 6 \
  --max-chain-depth 4
reactor up · per-peer rate-limit 6/min · chain-depth guard on

Built-in anti-loop guards: sliding-window per-peer rate limit + (re:<id>) marker tracking that detects two reactors yelling at each other and hangs up the line.

§ 07The receipts

Component	License	Why
Server (`wire-relay-server`)	AGPL-3.0-or-later	SaaS forks share back
Spec + protocol crate	Apache-2.0	Max interop adoption
CLI (`wire`)	MIT	Max embedding adoption

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