wsp

Orchestrate coding agents across computers and clouds.

Get started · Documentation · Cloud providers · Architecture · Releases

Run Claude Code, Codex, OpenCode and Cursor with the tools and subscriptions you already use. Give each part of the work its own thread, on your computer, another computer or the cloud. Follow it from the first message to the reviewed result. WSP coordinating coding agents across connected computers, with a live slate beside the lead thread ## Get started ```sh curl -fsSL https://usewsp.com/install | sh ``` Open WSP, add a project, and start a thread with an agent you're signed in to. **[Setup guide](https://usewsp.com/docs) · [Download the desktop app](https://github.com/wsp-labs/wsp/releases)**
Install the CLI with npm With Node 22 or newer: ```sh npm i -g @wsp-labs/wsp ```
Free and open source under AGPL-3.0. Agent subscriptions and cloud compute are billed separately. ## Delegate across computers Keep an investigation local while another computer runs the tests. Use a different agent for the review. Every child has its own conversation, and its report returns to the lead.

One thread tree, several computers

Claude Code, Codex, OpenCode and Cursor can hand work to each other across your connected computers. The sidebar keeps each child under the thread that started it.

The sidebar and child-thread list coordinating work on several computers

Your computer. Your setup.

Connect a Linux computer over SSH and use its existing tools, or bring selected agents, sign-ins, CLIs, skills, MCP servers and shell settings. Save those choices as a recipe.

Connected computers with their specifications and CPU and memory history

Your tools, on every computer

Keep MCP servers, skills and plugins with the agents that use them. See what is available on each computer and manage it from the same panel.

The Tool servers tab showing the MCP servers available to agents
### Bring your setup with you Choose the agents, MCP servers, command line tools, skills, projects and shell settings you want on a connected computer. WSP checks the computer and walks you through the setup. Adding a computer, choosing what to bring, and following setup through to ready ### Cloud providers Cloud execution currently requires a cloud-enabled build. When work needs its own compute, launch a cloud child from your setup image. It starts from your pushed code on an independent branch. WSP manages capacity, spending limits and cleanup; the report and result come back for review.
Boat logo
Boat

Available now
Instabox logo
Instabox

Coming soon
Daytona logo
Daytona

Coming soon
Celesto logo
Celesto

Coming soon
Freestyle logo
Freestyle

Coming soon
E2B logo
E2B

Coming soon
Superserve logo
Superserve

Coming soon
Maritime logo
Maritime

Coming soon
## Follow the work As threads multiply, WSP keeps the processes, usage and questions attached to the work that produced them.

Activity, down to the process

See CPU, memory and listening ports across your computers. Follow a thread into its agent, MCP servers, builds and dev servers, including processes that outlive the shell that started them.

Activity with resource history and the agent, dev server and MCP tools attributed to their thread

Usage across your accounts

Track tokens, cache usage and API cost estimates by agent, account, computer, project or model. Check subscription limits and reset times before starting more work.

Usage charts and agent breakdowns

Resume when your limit resets

A usage limit can pause a long task. Choose Resume at reset, and WSP continues the thread when the agent’s reported window resets.

A thread set to resume automatically when its usage limit resets
## Give the thread a live view

Slate, built for the work

An architecture diagram for a review. A live chart for an investigation. A plan you can edit.

Agents build Slates beside their conversations. Panels can read current state, refresh without another agent turn, and send your edits and actions back to the agent.

Three full Slate panels: architecture, progress and live measurements
## Build and review where the work runs The same tools follow the thread onto your connected computers and cloud compute.

A terminal on any computer

Open a terminal in the thread’s project folder, locally or remotely. Your configured terminal font, colours and transparency come with it.

A close-up of the terminal pane running commands in the thread project

Preview the running application

Open the dev server beside its thread. Browser access and port forwarding bring services on connected computers and cloud compute to your desktop.

The browser pane previewing the application served by the thread

Review every change

Inspect changed files and compare code diffs on the computer where the thread runs.

Changed files and a code diff on the thread execution computer

The pull request, beside the thread

Review the PR, follow checks and inspect review feedback without leaving WSP. Send a failed check back to the agent.

A close-up of the pull request pane with review state and checks

Open in your editor

Continue in Zed, VS Code or Cursor. Supported editors open the thread’s folder over SSH when it lives on another computer.

The Open menu offering VS Code, Cursor and Zed

Ask a side question

Use /btw in a Claude Code or Codex thread. The answer opens beside the work without adding to the main conversation.

A side question and its answer in the btw pane
## Start from any surface Desktop, CLI and MCP connect to the same persistent host. Start from your terminal or an agent you already use, then open WSP to follow the same threads.

Claude Code   Codex   Cursor   OpenCode

**From your agent** > Use WSP to ask Codex on gpu-box to review this change. Run the tests on hetzner and bring both reports back here. **From your terminal** ```sh wsp run wsp "Run the test suite" --on hetzner --agent codex ``` [MCP reference](https://usewsp.com/docs/reference/mcp-tools) · [CLI reference](https://usewsp.com/docs/reference/cli) ## Built around a persistent host The **host** holds projects, threads and transcripts independently of the client. WSP’s **orchestration runtime** drives each agent’s own harness, preserves its conversation, routes messages and reports, and tracks each turn. Each execution computer runs a **Rust daemon** for files, Git, terminals, ports and process activity. A connected computer needs the daemon and your tools; the desktop renders locally. Desktop, CLI and MCP share one persistent host and orchestration runtime, which coordinate agents and Rust daemons on local, connected and cloud computers The daemon shares one process sampler between subscribers. It starts when needed, stops after the last subscriber leaves, and sends changes after the initial snapshot. Linux thread cgroups keep builds and dev servers attributed to their work after the original shell exits.
Thread isolation, shared files and lifecycle
| Execution location | Files | Conversation | | --- | --- | --- | | Same project folder | Shared working files | Separate per thread | | Local worktree | Separate checkout and branch | Separate per thread | | Connected computer | That computer's project folder | Separate per thread | | Boat cloud child | Pushed starting ref; result branch | Separate per thread | Delegation preserves the relationship between threads. It does not automatically copy the lead’s conversation or uncommitted edits. Conversation forking is an explicit operation where supported. Four stages of a child thread: request, prepare, execute and return; cloud cleanup follows the retention policy Closing a client, ending an agent turn and releasing cloud compute are separate events. The host keeps the record of the work across them.
### Native desktop beta The native Rust desktop, built with GPUI, uses the same host and runtime. Our [port write-up](https://usewsp.com/blog/gpui-port/) covers the architecture and the October 27 comparison: **438 MiB in Electron to 180 MiB in GPUI** at rest, using the same conversations. ## Contributing See [CONTRIBUTING.md](CONTRIBUTING.md) to build from source and contribute, or [report an issue](https://github.com/wsp-labs/wsp/issues). ## License [AGPL-3.0-only](LICENSE) · [Third-party notices](THIRD_PARTY_NOTICES)