Agent computer
Every session getsa computer of its own.
Start a session and a fresh, isolated Linux machine boots, clones your project repo and cuts a new branch named after that session. The agent gets the whole machine. Only what it commits survives.
One machine per session · Ready on boot · Nothing runs on your laptop
- Isolation
- One machine per session
- Boots with
- Your repo, tools and dependencies
- Agent harness
- OpenCode
- Work lands through
- A change request to main
01Boot sequence
You start a session. A machine wakes up.
Four things happen before the agent writes a word. None of them run on your laptop, and none of them are setup you have to do.
Step 00
The machine boots
A Linux machine starts from the sandbox image your project declares. It is its own isolated machine, with its own filesystem, process table and network. No other session shares any of it.
Step 01
Your repo arrives
The machine clones your project repo into /workspace. Your agents, skills, memory, connectors and triggers come along, because every one of them is a file in that repo.
Step 02
A fresh branch
The machine cuts a branch named after the session. Every edit, commit and stray file from this session lives on that branch and nowhere else.
Step 03
OpenCode takes over
OpenCode runs inside the machine as the agent harness, with your models, tools and secrets injected at runtime. The machine is ready, and the agent gets to work.
02Full control
Install anything. Run anything. Break anything.
The agent gets the whole computer: a shell, a package manager, a filesystem and the network. Not a short list of allowed actions with a machine hidden somewhere behind it.
Mistakes are cheap
Nothing on the machine is precious. A bad install, a wrong migration, a wiped folder: the machine goes away and takes the mess with it. Only what the agent commits survives.
It shows up ready
Your repo is cloned, your tools are installed and your dependencies are resolved before the agent starts. There is no setup step, and your own computer is never involved.
It keeps working
Long jobs don’t need your tab open. Close the laptop and the machine keeps going. Open the session tomorrow and the work is right where the agent left it.
03Parallel by design
Hundreds of thousands of computers. One main.
Each session runs on its own machine, on its own branch, so no two sessions can step on each other. Run one, or hundreds of thousands at once. Each is a different version of your company, all working at the same time.
1 session = 1 computer = 1 branch
main
- 9f4c2b7e…rewrite the pricing pagechange request
- 2a71d0c4…reconcile the july invoiceschange request
- c83e5f19…draft three launch threadsdiscarded
- 5db60a37…triage the support backlogrunning
plus every other session you start, each on a machine of its own
change requestmain
Two agents changed the same file? That is a merge, and git has handled merges for twenty years. Nothing reaches main until a person approves it.
04Declared in your repo
The machine is just a file in your project.
Your project config sets the sandbox image, its CPU and memory, and which agent gets which machine. Edit the file, open a change request, and every session started after that boots the new machine.
# the machine every session in this project bootsruntime: opencode sandbox: default: python templates: - slug: python name: Python 3.12 image: python:3.12-slim cpu: 2 memory: 4 disk: 20 agents: researcher: # the researcher gets the python machine sandbox: python# your repo is already here. nothing to set up.$ pwd/workspace # the branch is named after the session$ git branch --show-current9f4c2b7e-1d83-4a6f-b0c2-5e71a9d4c188 # root on a real machine. install what the job needs$ uv pip install pandas duckdb$ python analyze.py > report.md # only what gets committed outlives the machine$ git commit -am "add the q3 revenue report"$ machine cr→ change request opened against main- Use one image for the whole project, or give each agent its own.
- The default image already ships with the Machine runtime layer.
- Change the image like any other file: in a change request.
05Everything is a file
grep your whole company.
Agents, skills, memory, connectors and triggers aren’t rows in a database you can’t see. They are files and config in the repo the machine cloned. People can read them, agents can edit them, and every version is kept like code.
- your-company/
- project config# sandbox image, triggers, channels, connectors, secrets
- runtime folder/# the runtime your agents think in
- agents/# one OpenCode agent per file
- skills/# how your company does a specific job
- commands/# shortcuts the whole team shares
- plugins/# tools you wrote yourself
Every change has a diff
When an agent rewrites its own prompt, it shows up like any code change: a commit, on a branch, in a change request someone reads.
Your company, clonable
The repo is the company. Fork it, branch it, roll it back or hand it to a new machine, and the whole setup comes with it.
06Isolation
Walled off from the start.
A machine an agent can do anything on is only safe if the walls are real. Ours sit below the agent. They are enforced, not requested.
01
One machine per session
Sessions never share a filesystem, a process table or a network namespace. On Machine’s own Platinum compute the boundary is a Cloud Hypervisor microVM. Daytona and E2B are supported too, and we’ll tell you which one you’re on.
02
Two gates on every secret
A runtime secret reaches a session only when both the agent’s declared grant and the role of the person who started it allow it. Once there, it is a real environment value, because that is how tools use secrets. We’d rather tell you that than call it invisible.
03
Connectors stay outside
Connect 3,000+ apps in a click, plus MCP, OpenAPI, GraphQL and raw HTTP. Every call goes through one scoped token brokered outside the machine, so connector credentials never enter it.
04
Nothing merges itself
Work reaches main only through a change request a person reviews and approves. The machine proposes. A person decides.
Get a computer
Start a session.Get a computer.
One platform for governed computer use. Any model, your own keys, and every action on the record.