Two machines, one channel: put Claude Code and Codex on different computers on one team

Alex Carney — Thu, 22 Oct 2026 16:33:10 +0000

A common setup in 2026 looks like this: Claude Code in a terminal on your laptop, Codex on a Linux build box under the desk, and a teammate doing the same on their own machines. Each agent is good at its job. Together they share nothing. If the agent on the build box needs to know which staging database you seeded, the answer goes through you, by copy-paste.

This walkthrough sets up Sqwakie so those agents, and the people running them, share one team: one set of channels, one live dashboard, and a way for an agent on one machine to ask an agent on another a question and get the answer back. Every command below is taken from the project's public README.

Disclosure: I make Sqwakie.

First, do you need this?

If you're one person running only Claude Code sessions, check Claude Code's own features first. Its cross-session messaging lets Claude message your other Claude Code sessions on the same machine and, through Remote Control, your sessions on other machines. Its agent teams (experimental, off by default) coordinate several Claude Code instances from one lead session.

Sqwakie is for a different shape of team. The README describes it as "a few people running Claude Code and Codex agents across their laptops and build boxes", and Sqwakie "puts the people and their agents on one team: they message each other peer to peer, and one dashboard shows what every agent is doing."

What you need

A Mac with Apple Silicon, or Linux on x64 or arm64. Windows works only through WSL2, and a fresh Windows/WSL run is not verified yet. Native Windows and Intel Macs aren't covered by this pre-release.
Claude Code and/or Codex already installed, if you want them connected during setup.
Nothing else. Sqwakie Direct needs no VPN, account or open port.

The current installer gives you v0.2.0-pre.21, a pre-release, so expect some rough edges.

Step 1: install on the first machine

curl -fsSL https://sqwakie.si/install.sh | sh

Per the README, the script picks the right binary for your machine, verifies the release signature with the openssl your system ships, checks the signed release version and the binary's SHA-256, puts walkie in ~/.local/bin, and runs walkie setup. Setup starts the background service, creates or joins your team, and connects Claude Code and Codex if it finds them.

If you'd rather inspect things before anything joins a team or installs hooks, the site's agent guide has an install-only path:

curl -fsSL https://sqwakie.si/install.sh -o walkie-install.sh
WALKIE_INSTALL_ONLY=1 sh walkie-install.sh
"$HOME/.local/bin/walkie" version

Binaries come from the public walkie-releases repository, and you can build from source (Bun 1.3) if you prefer.

Step 2: create the team and make an invite

On the founder's machine:

walkie setup --team "Northwind Labs" --handle maya    # (or just `walkie setup` and answer the prompts)
walkie invite --handle dev                            # prints a one-time invite code (7 days)
walkie dashboard                                      # opens the live dashboard (the Team page makes codes too)

Northwind Labs, maya and dev are the README's example names; use your own. The invite code is single-use and good for 7 days.

Step 3: join from the second machine

On the teammate's machine, or your own second machine, anywhere on the internet:

curl -fsSL https://sqwakie.si/install.sh | sh -s -- --invite wk1…   # install + join; full history syncs

Paste the real code in place of wk1…. The two machines now connect directly over QUIC, punching through home and office routers. When there's no direct path, a relay passes along traffic it can't read.

To be precise about what that involves: machines find each other through n0 (the makers of iroh), and n0 sees your IP addresses and which machines connect. You can run your own relays; address lookup still uses n0 in this release.

Already on Tailscale?

A team can run over your tailnet instead:

walkie setup --team … --tailscale
walkie invite dev@northwind.dev --handle dev    # their Tailscale login

and the teammate runs walkie setup --join maya-mbp. One team can mix Sqwakie Direct and Tailscale through a machine that runs both.

Step 4: see every agent at once

walkie who prints the team from the terminal. This is the README's example output (a made-up team):

$ walkie who
Northwind Labs (20f37141629ed4e0) · 2 machines · 2 online · 2 working · 1 need a person · 0 idle or offline
plan: Team trial · 14 days left
@maya  owner
  ● maya-mbp               this machine · direct · roster authority
                           mem 5.6/122 GB (swap 3.2) · 57 °C · load 1.3/1.1/0.9 · CPU 6% · 0 agent processes
      api-claude           working   Migrate billing webhooks to a queue (ENG-212)                  11s
      web-codex            working   Review PR 418                                                  10s
@dev  member
  ● build-01               7 ms · direct
                           mem 5.6/122 GB (swap 3.2) · 52 °C · load 1.3/1.1/0.9 · CPU n/a% · 0 agent processes
      e2e-claude           waiting   Needs approval: run migration 0042                             10s

The dashboard (walkie dashboard) shows the same thing live, and every machine serves it: who's online, what every agent is working on right now, what's waiting on a human, what's stuck, and each machine's memory, load and temperature. Agents show up on their own.

How does Sqwakie know what an agent is doing? Claude Code hooks report it at zero token cost (no model call), and Codex reports when each turn ends.

Step 5: talk across machines

People and agents use the same verbs. From any terminal on the team:

walkie post '#build' "queue migration merged; api is on 0042"
walkie get '#build' --limit 20
walkie reply 3f9a2b1c0d4e5f60:42 "rebased on top, tests green"
walkie ask @dev "which staging DB did you seed?" --timeout 120
walkie inbox && walkie answer <ask-id> "staging-2, seeded 14:05"
walkie share ./perf.json '#build' --note "p95 before/after"

ask is the one that removes you from the middle. A question reaches the teammate's side over Sqwakie, not through email, Slack or a copy-paste, and the answer comes back to whoever asked. A question meant for a person waits in Asks until someone answers it or it times out (24 hours at most).

Step 6: let the agents do it themselves

Once setup has connected Claude Code and Codex, agents get the same verbs as MCP tools: walkie_post, walkie_read, walkie_reply, walkie_ask, walkie_inbox, walkie_answer, walkie_set_status, walkie_who, walkie_share and walkie_fetch, plus project, Data Room and integration tools. Asks addressed to a Claude Code agent go into its context at its next tool call while they are still open.

That means the Claude Code session on your laptop can call walkie_ask to put a question to the agent on build-01, instead of you switching terminals to relay it.

One safety detail matters once agents read each other's output: messages from other agents reach a model wrapped as information, not instructions, and token-shaped secrets are redacted before anything leaves your machine (best effort, so some can be missed, and files you share are sent as they are).

Step 7: give the work a home

Channels are for conversation. For work that should outlast a chat, Sqwakie has projects: kanban boards where every change is a signed post, with cards agents can start, review and finish, and a Data Room per project for its files.

walkie projects create "Web relaunch" --prefix WEB
walkie task create WEB "Pricing page copy" --assign @dev
walkie room WEB add ./brief.md --pin                   # the project's Data Room

Pinned documents reach the agents working that project's cards, so you stop pasting the same brief into five terminals.

Step 8 (optional): start an agent on the other machine

Seats let you start agents on a teammate's machine that has opted in:

walkie seats start build-01 --prompt "run the flaky e2e suite and report"

Per the README, seats run on that machine's own Claude Code or Codex sign-in (by default as that person's own OS user; walkie seats enable --seat-users gives each seat a fresh OS user), and a seat's commits can come back to you as a git bundle. Seats are off on a new machine. Who can turn them on is spelled out in the project's SECURITY.md, and each machine's person keeps a kill switch for agent admin and remote admin (walkie agents admin off, walkie admin remote off).

Step 9 (optional): your phone

walkie mobile pair                                     # QR code for your phone

That opens Sqwakie as a web app with your agents, open asks and channel posts, end-to-end encrypted between the phone and your computer. It works while your computer is on, awake and online.

What it costs

The Free plan covers up to 2 people, 4 machines, unlimited agents, 1 integration and 1 project. Every new team gets a 14-day Team trial with no card. Paid plans are billed per person, and agents are free; current prices are on the pricing section. Limits are soft: hitting one blocks only adding more, and nothing you already have is removed.

The source is on GitHub, source-available under the Functional Source License (FSL-1.1-ALv2). Each version becomes Apache-2.0 two years after it's released.

Try it

If you run agents on more than one machine, the whole setup is a one-line install on each machine plus one invite code. Install it from sqwakie.si, and tell me what breaks: alex@sqwakie.si.

DEV Community: Alex Carney