Machines for a software factory

What infrastructure does a software factory need?

A factory needs machines that:

• Start ready. The repository is cloned, dependencies are installed and images are pulled before the agent starts. A task then begins by fetching its commit instead of setting up from nothing. A Snapshot, a saved copy of a set-up Sandbox’s files, holds that ready state.
• Keep tasks apart. Each task gets its own VM and disk, so two agents never share a working tree, a database or a kernel.
• Run the whole project. Agents need sudo, Docker and systemd to run the test suite and the services it depends on, as on any Linux server.
• Keep running when the orchestrator restarts. The orchestrator is the service that assigns tasks. A disconnect never cancels a command, so a forty-minute test run keeps going while the orchestrator restarts or redeploys.
• Keep logins off the machine. Agents use a Claude or ChatGPT account without its login being stored in a VM the agent can read. Connections handle that.
• Report what survived a failure. When hardware fails, the factory learns what was saved and which commands were running. It decides itself what to rerun. Host failures explains why Ortam never reruns anything.
• Stop using compute while idle. A task waiting for review shouldn’t hold a running VM. A stopped Sandbox pays only for its saved disk.

What does your factory keep, and what does Ortam run?

Your factory keeps

• Users, sign-in and permissions
• Repositories and where changes go
• Agents, models and prompts
• The task queue and its scheduling
• Tests, review and shipping

Ortam runs

• A Linux VM per Sandbox
• Disk saves and recovery
• Commands, results and output
• Agent logins, kept off the VM
• Private terminal links

Your users never need an Ortam account. Your backend holds an organization key and decides which Sandbox serves which task, project or user.

How does a task move through the factory?

• The task arrives in your queue, from an issue tracker, a chat message or a schedule.
• Your factory starts a Sandbox from the repository’s Snapshot, fetches the task’s commit and grants the Sandbox the agent’s Connection. A Sandbox started from a Snapshot gets the Snapshot’s files but no grants.
• The agent works through commands your factory sends. It can be Claude Code, Codex or your own agent, with its account granted through a Connection.
• Your factory checks the result, runs the tests in the same Sandbox, and pushes a branch or opens a pull request.
• The Sandbox stops once the work is done and keeps its files for review at storage cost only, or your factory deletes it.

These API calls use your organization key. They create the Sandbox and send the agent’s first command. The Idempotency-Key header lets you retry a call without it acting twice. The route for granting a Connection is to be published.

# A Sandbox for this task, from the repository's ready state
curl -X POST "$ORTAM_API/v1/sandboxes" \
  -H "Authorization: Bearer $ORTAM_API_KEY" \
  -H "Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{"name": "task-1482", "snapshot_id": "'"$SNAPSHOT_ID"'"}'

# The agent's first command; a stopped Sandbox starts first
curl -X POST "$ORTAM_API/v1/sandboxes/$SANDBOX_ID/executions" \
  -H "Authorization: Bearer $ORTAM_API_KEY" \
  -H "Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{"argv": ["/bin/bash", "-lc", "claude -p \"fix the flaky cart test\""], "cwd": "/home/developer/app", "connection_id": "'"$CONNECTION_ID"'"}'

Where to go next

• An internal factory for your own repositories, where agents pick up issues for your engineers: background coding agents.
• A factory that works for your customers, such as an agency, an agent product or an app builder: coding agents for your customers.
• Your own agent sessions, off your laptop, to start with: Claude Code and Codex in the cloud.

Common questions

Does Ortam run the agents or the models?

No. Ortam runs the Sandboxes your agents work in. Your factory chooses the agent, sends its commands and decides what to do with the result. The agent calls its model provider with the account you grant it.

Does Ortam replace the task queue or the CI system?

No. Your factory keeps its queue and its CI. A Sandbox is where an agent works on one task. Your queue decides which task runs next, and your CI can still run on clean machines.

How does the agent push its work?

With git, as on any Linux machine. Pass a credential for your Git host in a command’s environment instead of a file, so it isn’t saved with the disk. Keep environments warm shows how.

Can one factory serve many teams or customers?

Yes. Each Sandbox serves whatever your factory assigns it to. Customers who must be kept apart by keys and credentials get an organization each. Coding agents for your customers covers how.