Every Claude Code and Codex thread gets a VM of its own, set up and running before you look. No servers to keep, no installs to run, no ports to share: say what you want and review what comes back.
A whole Linux machine each. Every thread can run Postgres and use port 3000, and none can break another.
Ensemble VMs (coming) start from your project's image in seconds and stop when idle. Your own server works today.
It installs what the project needs, writes it into ensemble.toml and starts the dev server. You never type pnpm install.
Sign in with your work and your personal Claude account. When one hits its limit, new chats go to the other.
Each thread's machine has your repo checked out and your setup already done: an Ensemble VM, or a Firecracker microVM on your own server. Agents install what they want and break what they like; the worst case is a machine that was going to be thrown away anyway.
Setup, servers, ports and logins used to be your job. Now they're not.
The agent starts what your project runs (its dev script, each compose service, the Procfile) inside the thread's machine. The preview sits in that machine's network, so localhost, cookies and OAuth redirects just work.
Agents add what they install to the project's ensemble.toml, so the next thread starts ready on any machine. Nobody types pnpm install.
Sign in with both and see what each has left. When one hits its limit, new chats carry on with the other.
Write the e2e testFix Safari's payment sheetAn agent hands work to helpers it starts itself: a chat on the same machine, or a thread with its own machine and branch that becomes its own PR. It waits for them and carries on.
Agents, and any postinstall script they run, only ever see placeholders for your logins, tokens and secrets.
| Moment | Memory |
|---|---|
| 1.3 GB while it builds | 1300 MB |
| 301 MB a minute later | 301 MB |
| 0 MB paused | 0 MB |
| awake in 1.3 s | 84 MB |
On your server a machine gives its memory back a minute after a turn and pauses after five idle minutes. An Ensemble VM stops when it's idle, so its hours only count while an agent works. Your next message wakes either where it left off.
Each agent is told what the others are changing, and the app marks the files two threads both touch.
Linear, Sentry, Notion, Vercel and more, installed once for every machine. Their logins stay with the host; agents never see them.
Commit, open the PR, watch checks, hand failures back to the agent, merge. The status bar says what's next.
Open a file from the thread, change it, ⌘S. It's written straight to the thread's machine.
Leave comments on the diff's lines, as on GitHub, then send them to the agent in one go. The PR's review comments show on their lines too.
Done: checkout keeps the cart in the URL, so a refresh doesn't lose it. Tests pass.
Try it another way from any reply: a new chat in the same thread, or a thread of its own with the code and conversation as they were. /btw asks on the side without touching the work.
pnpm db:reset --seedOn your Mac, steps wait for your OK, a classifier stops the risky ones, or the agent has full access. In a VM it always has: the machine is the boundary.
See what needs you, what's working and what's done, across every machine. Answer an agent's question with a tap, or send it a message, from anywhere.
Projects, threads, diffs, PRs and checks. Online, a hub in Ensemble Cloud, or on your own server, keeps the threads going while it sleeps.
One program: ours in Ensemble Cloud, or installed for you on your server. It keeps your threads, their history and your keys, and starts their machines.
An Ensemble VM, a Firecracker microVM on your server, or a box on your boat.dev account. Paused when idle, destroyed when archived; the branch and the conversation stay.
No config files, no tokens to hunt for, no servers to set up.
Start on your Mac straight away, with your own Claude or Codex login. No machine needed yet.
A server of your own by its address and an SSH key, set up for you over port 22. Or Ensemble VMs, coming soon, with nothing to set up.
Pick a project from GitHub or a folder, say what you want, and start as many as you like.
Most agent apps squeeze every thread onto your laptop, or run their own agent on their machines with a config file per repo. Ensemble runs your Claude Code and Codex, on your own plans, each in a VM that sets itself up, with your keys kept out of it. On our machines, or on yours.
| On your laptopworktrees, one machine | In their cloudhosted agents | Ensembleyour agents, a VM each | |
|---|---|---|---|
| Threads at once | ~Until the fans spin up | ✓Many | ✓Up to 100 on Ensemble VMs; idle ones stop |
| Isolation | ✕Shared ports, databases and caches | ✓A container or VM each | ✓A whole Linux machine each: Docker, Postgres, port 3000 |
| Setup | ~You run it, per worktree | ~A config file per repo | ✓The agent sets it up once; the next thread starts ready |
| Laptop closed | ✕Everything stops | ✓Keeps going | ✓Keeps going, on Ensemble VMs or your own server |
| Where your code lives | ✓Your Mac | ✕Their servers | ✓Ensemble VMs, or your own server or Mac: your choice |
| Your API keys and tokens | ✕Readable by the agent | ~Stored with them | ✓Never in the VM; filled in on the way out |
| Agents | ✓Whatever you install | ~Usually just theirs | ✓Claude Code and Codex, on your work and personal accounts |
| Previews | ~Port clashes between threads | ~Varies | ✓localhost just works, per thread |
| What it costs | ✓Your laptop | ~Per seat or per run | ✓Your agents' plans, plus Ensemble VMs from $20 a month (coming), or your own server |
The agents run on your own Claude and Codex plans. Ensemble VMs only count while an agent works.
Your Mac and your own machines.
A VM of ours for every thread.
For a lot of agents at once.
| Size | VM | Counts | Plans |
|---|---|---|---|
| Small | 2 vCPU, 4 GB | 1 VM-hour an hour | Pro, Max |
| Medium | 4 vCPU, 8 GB | 2 VM-hours an hour | Pro, Max |
| Large | 8 vCPU, 16 GB | 4 VM-hours an hour | Max |
Past the included hours it's $0.03 a VM-hour, billed with the next month, up to a limit you set; at the limit new turns wait and your other machines keep working. An idle thread's VM is stopped, and stopped VMs don't count.
On Ensemble VMs once they launch, or on machines of your own. With Pro or Max every thread will get a VM of ours (Small is 2 vCPUs and 4 GB), started from your project's image in seconds and stopped when it's idle. You can also add a Linux server with KVM, where every thread gets a Firecracker microVM (we suggest 4 GB, $24 a month, for two threads building at once), or a boat.dev key, or run threads on your Mac as folders.
Threads on your Mac or your own machines are free, and so is online mode on Ensemble Cloud. Ensemble VMs, when they launch, come with Pro, $20 a month for 300 VM-hours and 20 threads at once, or Max, $50 for 1,200 hours and 100 at once; past the hours it's $0.03 a VM-hour, up to a limit you set. The agents run on your own Claude and Codex plans.
Yes. On your Mac, threads run as local processes, each in its own clone of the project. They share your Mac, so ports can clash; pick Ensemble VMs or add a server when you want every thread in its own machine.
On Ensemble VMs, and on your own server in online mode, yes: the hub runs somewhere that's always on, and your phone can reach it. A thread on your Mac stops when it sleeps, but it can move: tell the agent you're off and it offers to carry on in an Ensemble VM, its work and conversation with it.
Yes, both. Sign in with each, and the app shows what each has left this week and in the last five hours. When one hits its limit, new chats go to the other. Codex works the same way.
Only on Ensemble Cloud and Ensemble VMs. They run the hub and the machines for you, so they hold what they run (code, transcripts, the agents' logins), as any hosted agent product does. Offline, or with the hub on your own server, the app talks to your machines directly, and your code, conversations and keys stay on them and your Mac.
Claude Code and Codex, with your own logins or API keys.
No. A thread's machine gets placeholders for your Claude and Codex logins (a ChatGPT sign-in too), your GitHub token and your project's secrets; the host fills in the real value only on requests to the service it belongs to.
It's on its way, for online mode. It pairs through a QR code and shows every thread that needs you, across all your machines; you answer questions, send messages and start threads from it. Every request is signed by your phone and sealed to the machine it's for. Notifications come next.
Your Ensemble account, and our hub, so you don't run one: online mode with nothing to set up, the phone included, free. On Pro and Max it runs Ensemble VMs too, a VM per thread on our machines.
For Ensemble VMs, yes: they get your code from GitHub. Elsewhere a project can be any git remote or a folder on your Mac. With GitHub connected you also get pull requests, checks and merging inside the app.
Its machine is destroyed; its branch, uncommitted work and conversation are kept. Reopen it and it gets a new machine with all of that back.
VAT depends on the country. Take it from the address, not a constant.
Not sent yet