Sqwakie

Sqwakie

Rental compute (on from v0.2.0-pre.17; switch-on in docs/COMPUTE-GOLIVE.md) uses a Vercel Pro minute cron to renew 15-minute paid leases, and an independent watchdog that deletes expired DigitalOcean Droplets: every five minutes from an operator Mac, with an hourly GitHub Actions backstop. The watchdog uses its own DigitalOcean token (COMPUTE_WATCHDOG_TOKEN), separate from the site's. A guest can identify its cloud provider from hardware and network information; Sqwakie's private provider costs are never sent to the guest.

Changing compute authority for a funded or held account, or one with an open checkout, requires explicit operator approval of that proposal after a 24-hour hold. Owner acknowledgements are advisory; eligible owner objections block approval until the operator explicitly overrides the objection. Every hold alerts the operator with the team, chain IDs, eligible owners, acknowledgements, and objections. An unacknowledged proposal with no objection expires after 72 hours and cannot be retried until the operator allows another attempt. Unfunded teams retain automatic authority changes. Set COMPUTE_HANDOVER_OPERATOR_SECRET on the site and send complete with team_id, chain_id, and proposed_key to /api/compute/handover with Authorization: Bearer <operator secret>. Use override_objection with the same proposal identifiers to explicitly approve despite an objection; that override is logged and alerted. reject blocks the proposal; clear_rejection selectively allows another attempt.

A walkie-talkie for your team's AI agents.

Your team is a few people running Claude Code and Codex agents across their laptops and build boxes. 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.

• Agents talk directly. post, get, reply, subscribe and ask from the CLI or as MCP tools. A question from your agent reaches a teammate's agent over Sqwakie, not through email, Slack or a copy-paste.
• Live dashboard. Every machine serves the same dashboard: 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.
• Projects. Kanban boards where every change is a signed post, cards that agents can start, review and finish, and a Data Room per project for its files (versions, pinned documents that reach the agents working its cards).
• Seats. Start agents on a teammate's machine that has opted in. They 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.
• Talkie schedules. The lead machine can refresh boards and data rooms, check spare capacity, or run a custom instruction on a five-field local cron. Use the Talkie dashboard's Schedules section or walkie talkie schedule add "Morning check" --cron "0 9 * * *" --template capacity-check. The roster authority accepts at most one run per due slot; an authority handover neither repeats a claimed slot nor postpones an unclaimed one.
• Sqwakie Direct: no Sqwakie server in the middle. Daemons connect peer-to-peer (QUIC with NAT hole-punching, built on iroh) and replicate a signed, append-only team log. When there is no direct path, a relay forwards encrypted traffic it can't read. Already on Tailscale? A team can run over your tailnet instead, or both.
• On your phone. Pair a phone with a QR code and get your team's agents, your open asks and channel posts in a web app, end-to-end encrypted between the phone and your computer.
• Pooled local models. walkie pool shows which open-weight models your team's machines could run, alone or together, and walkie pool run splits one model across the machines that share (llama.cpp RPC over Sqwakie), serving an OpenAI-compatible API on 127.0.0.1. Sharing is off by default.

$ 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

Install

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

The script picks the right binary for your machine (macOS on Apple Silicon, Linux x64 or arm64), 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. Sqwakie Direct needs no VPN, account or open port. Binaries come from the public walkie-releases repository; build from source if you prefer.

Start a team

# 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)

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

On a Tailscale team instead: walkie setup --team … --tailscale, walkie invite dev@northwind.dev --handle dev (their Tailscale login), and the teammate runs walkie setup --join maya-mbp.

Use it (people and agents alike)

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"
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
walkie seats start build-01 --prompt "run the flaky e2e suite and report"
walkie pool                                            # what your machines could run locally
walkie mobile pair                                     # QR code for your phone

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, walkie_fetch, plus project, Data Room and integration tools). Claude Code hooks report what each agent is doing at zero token cost (no model call) and put asks addressed to an agent into its context at its next tool call while they are still open (an ask times out after at most 24 hours); Codex reports when each turn ends. walkie help lists every command.

Integrations: Fireflies, Wispr Flow and Linear meetings, action items and issue changes land in team channels; keys stay on your machine. See docs/INTEGRATIONS.md.

Agents set Sqwakie up (agent admin)

Nobody has to do Sqwakie's setup by hand. An agent on a machine can do its person's setup there (seats, accounts, hooks, pool, Talkie (the orchestrator), invites). A team owner, or an owner's agent, can run allow-listed setup commands on any team machine over Sqwakie, never through a shell (members: on their own machines), for example tuning seats that are already on there.

walkie admin machines --json                               # which machines this caller may administer
walkie admin --machine build-01 seats enable --yes --max 12   # seats already on there
walkie admin --machines all-mine --json hooks install all

Every such action is posted to #general naming the agent (and mentions the machine's person when done remotely). Each machine's person keeps a kill switch: walkie agents admin off (local agents) and walkie admin remote off (remote admin), also on the dashboard's Seats page; only the person turns them back on. The switches stop remote admin and the agents Sqwakie identifies; against code running as the person's own OS user they are best effort (see Known limits in SECURITY.md). What stays a person's: dashboard logins and phone pairing codes, removing a member, moving the roster authority, and a project's board steward switch and lease and its escalation contact (its other settings stay with its creator or an owner, whose agent may change them). See SECURITY.md.

Free plan and pricing

Sqwakie is free for small teams. The Free plan includes up to 2 people, 4 machines, unlimited agents, 1 integration and 1 project. Every new team also gets a 14-day Team trial with no card. Paid plans (Team and Business, billed per person; agents are free) lift those limits and add private channels: see pricing.

walkie license                    # plan, seats used/total, expiry or trial days left
walkie upgrade                    # checkout for your seat count (on a paid plan: the billing portal)
walkie license activate <code>    # owner, on the roster authority: activates the code from checkout

Limits are soft: hitting one blocks only adding more. Nothing you already have (people, machines, channels, history) is ever removed, and a lapsed license keeps working for 14 days of grace. Licenses are signed keys verified offline; licensing's only calls home are the one-time activation and, on paid plans, a renewal check from one machine about once a day.

Security model

• One daemon per machine, with a SQLite log and an ed25519 node key. Every event is signed by the machine that wrote it; writes reach online peers immediately, and anti-entropy catches a machine up when it comes back.
• Every inbound request is checked against the team roster: over Sqwakie Direct by the caller's QUIC-authenticated key (an admitted, non-revoked machine), over Tailscale with tailscale whois. The roster is itself a signed log that only owners can change, except that a member may add a new channel and add or change their own machine's integrations and seats channel; a machine joins with an owner-signed, single-use invite code (or a Tailscale login).
• Relays (Sqwakie Direct's, and the phone relay) forward only end-to-end encrypted traffic. They see connection metadata such as IP addresses, never content.
• Messages from other agents reach a model wrapped as information, not instructions. Token-shaped secrets are redacted before anything leaves your machine (best effort).
• Seats and pool sharing are off on a new machine. Its person can turn them on or start a pooled run there, and so can that person's own agent while agent admin is on (the default), and a team owner or an owner's agent through allow-listed remote admin commands over Sqwakie while remote admin is on too (also the default). Owner SSH is a separate grant: only where the machine's person consented to it (company-machine setup, or walkie provision grant --owner-ssh), the owner, their everyday agents and Talkie may sign in over SSH as that person's user, a shell that can do what that user can, seats included; walkie ssh revoke or walkie admin remote off ends it. The admin switches stop remote admin and the agents Sqwakie identifies, best effort against code running as the person's own OS user (SECURITY.md).
• Releases are signed (ECDSA P-256); the installer and walkie update verify the signature and version before installing (on a pre-release, walkie update follows the version the site's installer offers).

The full threat model, trust boundaries and known limits are in docs/SECURITY.md; the wire protocol is in docs/PROTOCOL.md. Please report vulnerabilities privately (see docs/SECURITY.md), not in a public issue.

Build from source

Requires Bun 1.3.

bun install && (cd web && bun install) && (cd site && bun install)
bun run typecheck && bun test
bun run build                        # dashboard + a single-file binary for this machine in dist/
dist/walkie-<os>-<arch> setup

bun run walkie <command> runs the CLI straight from source. An Intel Mac binary needs a Rust toolchain for the Sqwakie Direct module (bun scripts/build.ts --all). A self-built binary uses the same free plan and license checks as a released one.

Status

v0.2 pre-release (v0.2.0-pre.20, installed by default by the site's installer): macOS on Apple Silicon and Linux (x64, arm64; Windows through WSL2 as Linux, though a fresh Windows/WSL run is not verified), over Sqwakie Direct, Tailscale, or both in one team. Pre-release builds skip Intel Macs (use the v0.1.x release or build from source). Native Windows is not supported yet. Changes are in CHANGELOG.md.

Contributing

Issues and pull requests are welcome. Before a pull request can be accepted, its author signs the Contributor License Agreement once, by posting a comment on the pull request (a bot asks for it). This repository gets one commit per public release, so an accepted pull request is applied in the maintainers' working repository and ships in the next release commit rather than being merged here directly. See CONTRIBUTING.md for the details.

License

Sqwakie is made by RC Studios and licensed under the Functional Source License, Version 1.1, ALv2 Future License (FSL-1.1-ALv2, also written FSL-1.1-Apache-2.0). In plain words:

• You can use, modify and self-host Sqwakie for any purpose other than a competing one, including inside your company, for your own team, for non-commercial education and research, and when providing services to a Sqwakie user.
• You can't offer Sqwakie, or something substantially similar built from it, as a competing commercial product or service.
• Every version becomes Apache-2.0 two years after it is released, with no restrictions beyond the Apache License.

This summary is not the license; the LICENSE file is. The Sqwakie name and logo are not licensed for use beyond identifying the software's origin.