[ Self-host it ]

Run Woodshed on your own machines.

Try the console on your laptop first. Then host your environments with Docker on any machine you have, or in an AWS account of its own. The console and the environments are the same on each.

1 · Try it locally
2 · Docker on any machine
3 · AWS

Setting it up with your own agent? Give it llms.txt.

Try the console locally

Made-up sessions on the local provider, with no AWS, GitHub or Docker. You need Node 22.

Get the code.

git clone https://github.com/ChifferCo/woodshed

Start the console, from the clone.

node woodshed/console/bin/devConsole.mjs

Then open localhost:7690/s/aaaa1111. The made-up sessions have no container behind them, so their terminals and apps go nowhere.

Host it with Docker on any machine

The console runs on the machine, each session is a container, and the services sessions share run from a compose file. Any VM or bare-metal server works: Hetzner, OVH, any other provider, or your own hardware.

You need Docker with the compose plugin, Node 22, the GitHub CLI (gh) on the console's PATH, and a GitHub App for the repo its sessions work on. The console can make the App for you.

Build the session image from the repo root, as session/Dockerfile says, and tag it woodshed-session.
Copy stack.env.example and session-env.example.json outside the repo, fill them in, and make both readable by you only. Make up the two root passwords.

A root password, made up.
```
openssl rand -hex 24
```

Start the databases.

docker compose -f woodshed/providers/local/compose.yml --env-file ~/woodshed/stack.env up -d

Make the secrets key, then put the root passwords in the secret store. Values are read from stdin, never from a command line.

Load the settings into this shell.

set -a && . ~/woodshed/stack.env && set +a

Make the key.

node woodshed/providers/local/bin/secret.mjs new-key "$WOODSHED_LOCAL_SECRETS_KEY_FILE"

Store the Postgres root password.

printf %s "$WOODSHED_LOCAL_PG_ROOT_PASSWORD" | node woodshed/providers/local/bin/secret.mjs put db-root/postgres

Store the Mongo root password.

printf %s "$WOODSHED_LOCAL_MONGO_ROOT_PASSWORD" | node woodshed/providers/local/bin/secret.mjs put db-root/mongo

Start the console with the same settings, then open your WOODSHED_CLOUD_PUBLIC_URL.
```
node woodshed/providers/console.mjs
```
In the console, /setup/github walks through making the GitHub App and installing it on the repo. Then set the session secrets on the Secrets & webhooks page, and build the database template once, or start a session, whose first copy waits for it.

On a server your team reaches: run the console as a service with Restart=on-failure, put a proxy with a certificate in front (sign-in cookies need HTTPS), and let it answer only your IP until the GitHub App is in. About 2 to 3 GB per session once Claude and its browser run: 12 GB holds three at a time.

Host it on AWS

The console on one always-on EC2 machine, each session a Fargate task, and the secrets, saved agent homes, webhooks and databases in AWS services, all in an AWS account of its own. Terraform builds it.

Costs about $55 a month idle, and about $0.13 an hour per session, plus the Anthropic usage. The budget emails at 80% and 100% of $150 a month.

Once, a versioned, private bucket for Terraform's state.

Name it, such as woodshed-cloud-tfstate-<account id>.

bucket=<your state bucket>

Create it.

aws s3api create-bucket --bucket "$bucket" --region us-east-1

Turn on versioning.

aws s3api put-bucket-versioning --bucket "$bucket" --versioning-configuration Status=Enabled

Block public access.

aws s3api put-public-access-block --bucket "$bucket" \
  --public-access-block-configuration BlockPublicAcls=true,IgnorePublicAcls=true,BlockPublicPolicy=true,RestrictPublicBuckets=true

Create the GitHub App for the repo, then write the installation's terraform.tfvars and backend.hcl from example.tfvars and example.backend.hcl. None of their values is secret: check them in to your own repo.

From providers/aws/terraform/, plan, read the plan, then apply it. The first plan must only create.

terraform init -backend-config=<your backend.hcl>

terraform plan -var-file=<your terraform.tfvars> -out=woodshed.tfplan

terraform apply woodshed.tfplan

Create the GitHub environments and set the repository variables from Terraform's outputs, then run the "Woodshed Cloud images" workflow with both. It ends by starting the console.
Open https://<your domain>. On its Secrets & webhooks tab, set the session secrets and upload the GitHub App's key, build the database template once, and set up the webhook.

Every step in full, with updating and removing it: providers/aws/README.md ↗. For Docker on any machine: providers/local/README.md ↗.