Woodshed Docs Self-host GitHub ↗

A cloud environment
for every task.

Give Claude Code and Codex a full environment for every task. Run many at once, and let each one test its own work before it opens a PR.

Try Woodshed Cloud free Self-host it

Setting it up with your own agent? Point it at llms.txt.

The Woodshed console: a rail of session cards beside a session starting, with its start checklist. The Woodshed console in dark: the session rail beside a session's start checklist. Video coming soon

[ 01 · Managed ]

Cloud dev environments, managed for you.

One console starts, lists, pauses and stops every environment. Open any of them to watch the agent, take over its terminal or review its changes, from your laptop or your phone.

[ 02 · One per task ]

A separate environment for each thing you're working on.

Each task gets its own container, branch, Postgres and Mongo, and a running copy of your app at its own address. Work on ten things at once and test each one apart: nothing one does reaches another.

[ 03 · Verified ]

Agents that verify their own work.

With the whole app running beside it, the agent checks its change in a real browser before it opens a pull request, and says what it proved. You review finished work and ship faster.

Start an environment from where the work is.

From GitHub, from the console, or from a question in Slack.

GitHub

A label or a comment

Add the woodshed label to an issue, or comment on any issue or pull request. Within 30 seconds the console starts an environment for it. Everyone signed in can see it.

/woodshed fix the flaky retry test
The console

New session

A private environment: only you can see it, it runs on your own Claude Code or Codex sign-in, and the console posts nothing on GitHub. Point it at an issue, a pull request or a branch.

+ New session · Work on PR #123
Slack

A question

Mention the bot with a question about the code. A short read-only environment reads master and answers in the thread.

@woodshed how does a task decide to retry?

One task, one environment, one proven PR.

The agent works like an engineer on their own dev box: code, run the app, check the change, open the pull request.

Fix the flaky retry testWorking
  1. LabelledSomeone with write access adds woodshed or comments /woodshed ….
  2. Container startedThe console starts one from the session image and links it on the issue.
  3. Working on its branchClaude Code or Codex on woodshed/<issue>-<id>, with the issue as its task.
Retry the Xero sync on a 429 PR #26629 · checks running

## Summary

  • Waits for Retry-After and tries the sync again when the API answers 429.

## Proof

  • Started the app and ran a sync against a stub that answers 429 once: it waited and finished.
  • On master, the same sync failed with "Too Many Requests".
  • Not proven: the real Xero rate limit. The session has no production tokens.

It shows what it checked, and what it couldn't.

Every pull request an environment opens has a ## Proof section. Anything it could not prove is marked "not proven", so a reviewer knows where to look.

  • The app, not just the testsThe environment runs the repo's own app and checks the change in a browser before it opens the pull request.
  • A draft until it is provenThe pull request stays a draft unless the check can only run after merge.

An example pull request body, in the shape sessions write.

Every environment, live, from your laptop or phone.

Each environment's page has the agent's terminal, a shell beside it, a review of its changes and its own running app.

Agent and Terminal

Agent is the live terminal of Claude Code or Codex: watch it, or type to take over. Terminal is a plain shell in the repo beside it, with the same environment.

A session's pane bar: Agent, Terminal, Review, Diff and App log tabs, the session's status and PR chip, then Start app, Editor and Stop session. A session's pane bar in dark.

Pause and resume

An idle environment pauses after an hour, pushing its work first. A later comment, or Resume, picks it up where it stopped, with the same conversation and databases.

Review

The diff against master, uncommitted work included, laid out in a reading order with an analysis of the change. Ask about any line or file, or chat beside it. In a private environment with GitHub connected, comment, approve and merge from the same page.

Run analysis · Ask about a line · Submit review

Its own app

Start app runs the repo's app inside the environment, on its own databases. Open app opens it at the environment's own address. Editor ↗ opens VS Code on its checkout.

https://<session>.woodshed.example.com

On a phone

The list becomes the page, and an environment is its pane alone. A key bar sends what a phone keyboard lacks, and a message box under the agent's terminal takes dictation, paste and photos.

  • esc
  • ↑
  • ↓
  • tab
  • ⇧tab
  • ⏎
  • ^C
The console on a phone: the Everyone list with status chips and session rows. The console on a phone in dark: the session list.
A session on a phone: its name, PR chip, tabs, and the key bar with esc, arrows, tab, enter, control C and text size. A session on a phone in dark, with the key bar.
The phone's message box: attach, Message claude, and the microphone. The phone's message box in dark.

Runs where you put it.

Host the environments on AWS, or with Docker on any machine. The console and the environments are the same on each.

aws

An AWS account of its own, built with Terraform.

Environments
Fargate tasks
Secrets
Secrets Manager
Saved agent homes
A private S3 bucket
GitHub and Slack events
A Lambda URL into SQS
Databases
RDS Postgres and Mongo, a copy for each environment
Cost
About $55 a month idle, and about $0.13 an hour per environment, plus model usage

docker

Docker on any machine: a VM or bare-metal server on Hetzner, OVH or any other provider, or your own hardware.

Environments
Docker containers on the console's machine
Secrets
Files, each sealed with a key
Saved agent homes
Files in a folder
GitHub and Slack events
Received directly, or GitHub's poll
Databases
Your Postgres and Mongo, a copy for each environment
Cost
The machine

✓ Never in an environment: AWS credentials, production data or production integration tokens. Each environment's databases are its own, and nothing one does to its data reaches another.

The repo describes itself.

One file at the repo's root says what an environment needs: its env files, its database, its app and how to prove a change. Only version must be written.

Every field, with an example ↗

.woodshed/project.yaml
version: 1
dependencies: [api, web]
envFiles:
  - path: api/.env
    secret: api-env
database:
  user: app_user
  name: app
  dir: api
  migrate: npm run migrate
  seed: npm run seed
app:
  start: make serve
  frontendPort: 3001
  backendPort: 9000
  # What the agent is told if it opens a PR without starting the app.
  howToProve: Run `make serve` and check each change in the browser.
editor: true

Free to run yourself.

Self-hosting is open source and free. Cloud is free for one person; teams and enterprise are coming.

Open source

Self-hosted

Free
On AWS, or Docker on any machine
  • Every feature on this page
  • Your own servers and your own Claude Code or Codex plan
  • AGPL-3.0, with shared/ under MIT
Self-host it
Cloud

For individuals

Free
Hosted by us
  • Nothing to set up
Sign-up opening soon
Cloud

For teams

Soon
Coming soon
  • Hosted by us
Enterprise

Self-hosted in your VPC

Soon
Coming soon
  • In your own cloud account

Before you set it up.

What does it cost to run?

The software is free. On AWS, an installation costs about $55 a month idle and about $0.13 an hour per environment on Fargate, plus model usage. With Docker, it costs whatever machine you run it on.

Whose plan does it use?

Each environment runs Claude Code or Codex. A private one runs on your own sign-in, saved on My settings. A shared one, started from GitHub, reaches Anthropic through the console, which adds the installation's key or the plan of whoever started it. A shared environment never holds anyone's token.

Can it touch production?

No. Environments never get AWS credentials, production data or production integration tokens. Each one gets its own copy of the databases, made from a template, and GitHub tokens that last an hour and reach one repo.

What happens when an environment is idle?

After an hour waiting for input it pauses, and it stops at 8 hours in all. It commits and pushes its work in progress first, and keeps its conversation and databases, so a later label, comment or Resume picks it up where it was.

Does it work on a phone?

Yes. Below 720px the list is the page and an environment is its pane alone. A key bar sends esc, the arrows, tab, ⏎ and ^C, and a message box under the agent's terminal uses the phone's own keyboard, so dictation and paste work.

How many can I run at once?

As many as you host. On AWS each environment is its own Fargate task, up to the limit you set. With Docker each one uses about 2 to 3 GB once the agent and its browser run, so a 12 GB machine holds three.

Can I use it on my own repo?

Yes. An installation works on one repo, which describes itself in .woodshed/project.yaml. A repo with no file gets an empty project and runs with Woodshed's own rules alone.