SwarmSpan · companion for SwarmMarshal

Make your Mac and PC work as one.

Your computers can work together.

If you live between a Mac and a PC, you already know the tax: the clipboard doesn't cross, files take a cloud detour, and you build on one machine but have to test, sign, or ship from the other. SwarmSpan is a tray-only app for both platforms that turns the computers already on your desk into one private swarm — shared clipboard, direct file handoff, and an agent lane for assigning work to whichever machine has the right files, tools, and permissions.

Get SwarmSpan See the cross-platform dev workflow

LAN trusted devices Local-first, no hosted clipboard account

Win+Mac native tray apps Built for daily cross-OS work

Work agent bridge Assign jobs to a paired computer

Why

Two operating systems, one workflow.

Switching between a Mac and a PC means a dozen tiny handoffs a day. Each one is small; together they break your flow. SwarmSpan closes the gap so the two machines feel like one.

The clipboard stops at the OS line

Copy a path, a stack trace, or a screenshot on one machine and it's stranded there. You email it to yourself or retype it. SwarmSpan makes one shared clipboard with history across both.

Files take the cloud detour

A build log or a signed installer goes up to some drive and back down again just to cross the room. SwarmSpan streams it device-to-device on your LAN — no third party in the middle.

You build here but ship there

Notarizing needs the Mac. Signing the EXE needs the PC. SwarmSpan lets you hand the job to the machine that owns the platform instead of physically switching seats.

Shared clipboard

One clipboard across both machines.

Copy on the Mac, paste on the PC — and the other way around. Text, formatting, images, and files all cross, with a searchable history that survives a reboot.

Coming from Apple's Universal Clipboard? See how SwarmSpan extends it to your PC →

One hotkey, both platforms

Press Ctrl+Alt+V on Windows or Control+Option+V on macOS to open SwarmSpan's history and paste any recent item into the app in front of you.

Every format you actually copy

Plain text, rich HTML, PNG images, file lists, and even files you drag straight onto SwarmSpan all sync between paired devices.

Plain text Rich HTML PNG images File lists Dragged-in files

History that sticks around

A local SQLite history keeps thousands of recent items and survives reboots — even with nothing paired. On Windows, remote items also flow into Win+V when Clipboard history is on.

File handoff

Move files directly, at any size.

A dedicated transfer subsystem — separate from the clipboard — streams files straight to disk on both ends. No cloud round-trip, no size ceiling, and the receiving machine stays in control of what leaves it.

Push, pull, and resume

Send a file to a device or pull one from it, right from the tray menu, with a live Transfers window. Each chunk is SHA-256-verified, and an interrupted transfer resumes from the bytes already on disk.

Multi-GB without blowing up RAM

Chunks stream to a .pbpart file at their byte offset, then atomically rename into place. Memory stays flat regardless of file size, so multi-GB installers move safely.

The receiver sets the scope

Each device has shared folders (default ~/SwarmSpan Shared). Files inside auto-serve to paired peers; anything else raises an Allow / Always-allow / Deny prompt. Requested paths are canonicalized so traversal can't escape the shared folder.

Agent bridge

Let an agent on one machine summon the other.

Beyond clipboard and files, SwarmSpan adds a message lane and a loopback-only MCP bridge so Codex, Claude, or any tool-capable agent can browse paired folders, move artifacts, and assign structured work to the agent on your other device.

An agent on the PC calls send_message or assign_work Through SwarmSpan's MCP bridge over a loopback-only, bearer-token control channel — it never touches the open network.
The Mac summons its agent With the Agent bridge enabled, the inbound message launches your configured CLI (e.g. claude -p or a Codex profile) in the right working directory. The text is passed as a discrete argv argument — no shell, no injection.
The answer comes back to the PC's inbox The Mac's stdout returns as a correlated reply that the caller picks up with poll_messages. Artifacts ride the Agent Handoff folder, not the message.

Execution modes — the caller chooses how the peer handles the work

`headless`

Run the selected CLI/API provider and return its stdout. The classic automation path for builds, tests, and scripted jobs.

`visible`

Open a visible desktop session — like a Codex thread on the peer's logged-in machine — so you can watch and steer the work, then get an immediate "launched" reply.

`persistent`

Use a long-lived session command (Codex defaults to codex app-server) so the process and thread stay alive across later requests. default lets the peer pick.

MCP tools — files & transfers

Tool	What it does
`list_peers · list_shared_folders · list_remote_files`	See which of your devices are reachable, what folders they share, and what's inside — before you move a byte.
`pull_file · send_file`	Pull a file from a paired device or push one to it. Streams to disk on both ends; multi-GB safe.
`send_file_to_handoff · prepare_remote_handoff`	Stage a patch, log, or signed installer into a peer's Agent Handoff folder with SHA-256 metadata, then pull it.
`get_transfer_status · list_transfers · cancel_transfer`	Watch in-flight transfers, resume interrupted ones from the bytes already on disk, or cancel cleanly.

MCP tools — messaging & work

Tool	What it does
`send_message · poll_messages`	Free-form text/JSON across the trusted device lane. Replies land back in your inbox for a polling agent to drain.
`assign_work`	Send a structured swarm.work.v1 order: goal, context, success criteria, expected artifacts, handoff folder, provider, and execution mode.
`list_work · get_work_status · cancel_work`	Track the local audit ledger of assigned work — accepted, running, completed, blocked, failed.
`diagnostics · live_activity`	When a job looks stuck, report transfer/work ages, agent-handler state, and redacted provider-profile checks before draining messages.

The bridge is off by default. Enable it under Settings → File sharing & MCP, then point your agent's MCP config at the installed SwarmSpan.Mcp binary. The serving device still enforces its own shared-folder scope, per-peer trust, and approval prompts — the MCP can't bypass them.

In practice

Building and shipping a cross-platform app across two machines.

This is the workflow SwarmSpan was sharpened on: developing a Mac/PC desktop app where each release needs the Mac to notarize and the PC to sign, then a single push to the website so installed copies auto-update. Two computers, one coordinated pipeline.

Pair the two machines once Type the six-digit code, and the Mac and PC discover each other on the LAN from then on. No accounts, no re-pairing each session.
Debug across both with the shared clipboard A stack trace from the Windows run, a notarization error from the Mac, a config snippet — copy on either machine and paste straight into the editor or chat on the other with Ctrl+Alt+V.
Hand each build to the machine that owns it assign_work to the Mac to build and notarize the .dmg; assign_work to the PC to build and sign the .exe. Each device uses its own toolchain, certificates, and OS APIs — no remote VM, no shipping secrets around.
Pull the signed artifacts back, verified Both installers land in the Agent Handoff folder with SHA-256 metadata. Pull them with one tool call and know they arrived intact.
Ship to the website so installed apps update Assign the publish step to whichever machine holds the deploy credentials. The new installers and manifests go live, and existing copies pick up the update — the whole loop coordinated from one agent across both computers.

Pairing

Trusted by a code, secured by a key.

Pairing is a one-time, local act. After that, SwarmSpan discovers your trusted devices on the LAN and authenticates every message between them.

Your Mac Shows a 6-digit code

paired over LAN

Your PC You type the code in

One six-digit code

Shown on one device, typed on the other. PBKDF2 over the code proves both sides know it during the handshake; the long-lived peer secret then mixes in random salts from both machines.

Auto-discovery after that

A UDP discovery beacon finds your paired devices on the local network, so they reconnect on their own whenever they're both awake on the same LAN.

Every envelope authenticated

Each message carries a per-peer HMAC-SHA256 over its kind, nonce, sender, and body. A device that isn't paired — or a tampered packet — simply doesn't validate.

Private by default

The swarm stays your own computers.

SwarmSpan is local-first by design. There's no hosted clipboard, no relay server, and no account holding your data. Trust is established between your devices and enforced on each of them.

No cloud middleman Clipboard items and files move directly between your devices over the LAN. Nothing is uploaded to SwarmSpan, and there's no account to create.
The receiver owns its boundaries Shared-folder scopes, per-peer "always allow" trust, and Allow / Deny prompts all live on the serving device. It decides what leaves it — even when an agent is doing the asking.
Agent control is loopback-only The MCP bridge listens on 127.0.0.1 behind a bearer token stored in your local app data. It's off until you enable it, and it can't be reached from another machine.
The agent bridge is opt-in Summoning an agent on inbound messages is disabled by default. You choose the command, the working directory, and the execution mode — and message text is always passed as a discrete argument, never a shell string.

Signed installers

Windows 0.2.10 / Apple Silicon Mac 0.2.9

SwarmSpan spans your own Macs and PCs with local clipboard sync, file handoff, and peer-agent work requests.

Download for Windows Download for Mac (Apple Silicon)

Windows · PowerShell

One-line install

iwr -useb https://swarmmarshal.com/swarmspan-install.ps1 | iex

Downloads the signed .exe installer, verifies SHA-256, runs setup, and starts SwarmSpan from the tray.

macOS · Terminal

One-line install

curl -fsSL --proto '=https' --tlsv1.2 https://swarmmarshal.com/swarmspan-install.sh | bash

Downloads the signed .dmg installer, verifies SHA-256, installs SwarmSpan in Applications, and opens it.

The device-swarm layer for SwarmMarshal

SwarmMarshal knows your communication. SwarmSpan reaches your other computers.

SwarmMarshal is the communication intelligence workbench. SwarmSpan is the local bridge between your trusted Macs and PCs, so a larger job can cross from inbox evidence to local files, build tools, signed installers, and peer agents — without making cloud storage the middleman.

Get SwarmSpan SwarmMarshal MCP server