For developers

Build agentsthe way you build code.

Use the coding agent you already like. Your agents, skills, triggers and connectors are files in one repo, and one CLI takes them from your laptop to a fleet of cloud computers. Every change comes back as a diff you review.

Get started Read the CLI docs

machine init · machine ship · one repo · any model

~/acme · terminalready

$ curl -fsSL https://themachine.myapps.ai/install | bash

$ machine init acmeInitialized project "acme"  + machine.yaml  + .machine/opencode/agents/ $ cd acme && machine ship✓ machine.yaml validated✓ committed and pushed main

Copy me!

Cloud computer per session

Git branch per session

3,000+

Apps to connect

Agent merges by default

01The thesis

The coding-agent loop, for real work.

Describe what you want, an agent edits the files, you review the diff. Machine runs that same loop for support, ops and research.

Agents are sandboxes

Every session runs in its own disposable cloud computer, on its own git branch. Run as many as you need in parallel. Nothing is shared between them.

Work is code

Agents, skills, triggers, connectors and policies are plain files in one repo. Diff them, review them in a change request, roll them back.

You own the stack

Bring your own model keys. Read the agent configuration, the policy decisions, and every recorded action.

02The loop

From curl to production.

One repo, one config, one command. Here is the whole path, top to bottom.

Step 01

Install and scaffold

One line installs the CLI. machine init starts a fresh project with machine.yaml and .machine/, and wires in the coding agents you pick: OpenCode, Claude Code, Codex, Pi or Cursor.

terminal

$ machine init acmeInitialized project "acme"  + machine.yaml  + .machine/opencode/opencode.jsonc  + .machine/opencode/agents/  + .machine/opencode/skills/ Next:  cd acme

Step 02

Build it locally, like code

An agent is a markdown file: what it is for, how it behaves, and its instructions. Skills are folders it loads on demand. Write them by hand, or describe what you want and let your coding agent write them.

.machine/opencode/agents/support.md

---description: Acme support. Resolves tickets end to end.mode: primarypermission:  bash: ask--- You are the support agent for Acme. Resolvecustomer tickets end to end, with full productand order context. Refunds under $500 you can issue yourself.Anything higher goes to a person to approve.

Step 03

Declare the project in one file

machine.yaml names your secrets, the machine each session boots on, your triggers and connectors, and what each agent may touch. It is versioned from the first commit, and machine validate checks it before you ship.

machine.yaml

machine_version: 2default_agent: support project:  name: acme # Secret NAMES only. Values stay encrypted.env:  required: [STRIPE_API_KEY] # a trigger starts a session on its owntriggers:  - slug: daily-digest    type: cron    agent: support    cron: "0 0 9 * * 1-5"    prompt: Summarize yesterday’s tickets # what each agent may touchagents:  support:    secrets: [STRIPE_API_KEY]

Step 04

Ship it

machine ship checks your config, commits, offers to set any secret that is still missing, pushes the branch you are on, and connects any connector that still needs auth. The first run creates the cloud project. After that, run it whenever you want to sync.

machine ship

$ machine ship✓ machine.yaml validated✓ committed 4 files? STRIPE_API_KEY is not set. Set it now? yes✓ pushed main✓ connectors ready

03The fleet

One session, one computer, one branch.

Every session runs in its own isolated sandbox, on its own git branch off main. Run as many as you need at once. Nothing they do can touch each other, or main, until a person says so.

git log --graphmain

*   c7e2  CR #84 merged   (main)|\| *  s_7f2a  triage 14 tickets| *  s_3c1d  build board deck| *  s_9a04  draft outreach|/*   a1f3  baseline   (main) # every session is a branch. main is the truth.

Work comes back as a change request

Anything worth keeping lands as a change request against main. A person reviews it, then it merges.

main is the source of truth

Every agent action is git history you can audit. Branch, diff, review, merge. It is git all the way down.

The same CLI in every sandbox

The machine CLI comes signed in inside every session, so agents drive Machine with the exact commands you do.

Isolated compute per session

Each session gets its own computer. One runaway agent cannot reach another.

04Models

Bring your own keys and models.

Sessions run on OpenCode, an open runtime. Connect a provider with an API key or sign in with OAuth, then pin each agent to the model you want.

terminal

$ machine providers set anthropic# saved as an encrypted project secret $ machine providers login openai# OAuth device-code flow, nothing to paste $ machine agents model support glm-5.2# one agent pinned, no config commit $ machine agents models

Your API keys

Anthropic, OpenAI, OpenRouter, Google, Groq, xAI, DeepSeek, Mistral and Bedrock. Each key is stored as an encrypted project secret.

Or sign in

Use the plan you already pay for: ChatGPT Plus or Pro, or GitHub Copilot, through a device-code sign-in.

A model per agent

Pin one agent to one model, instantly. An agent without a pin follows the project default.

05One CLI

The whole lifecycle, one CLI.

Scaffold, ship, run, automate, connect and review. The same binary is signed in inside every sandbox, so your agents use the commands you do.

Scaffold and ship

$ machine init
Start a new project in a fresh directory
$ machine ship
Create the cloud project, then push your code
$ machine validate
Check your machine.yaml before you ship
$ machine doctor
Health check: sign-in, project, session, reply

Run and talk

$ machine sessions
List, create and restart sessions
$ machine connect
Attach the full OpenCode TUI to a session
$ machine chat
Talk to a session's agent
$ machine files
Browse files, commits, branches and diffs

Automate

$ machine triggers
List, fire, enable and disable triggers
$ machine channels
Connect Slack to this project
$ machine marketplace
Search and install marketplace items

Connect

$ machine connectors
Manage the connectors agents call as tools
$ machine secrets
Manage project secrets
$ machine env
Pull and push secrets as a dotenv file

Review and govern

$ machine cr
Open, review and merge change requests
$ machine access
Invite, grant and revoke project access
$ machine audit
Read the audit trail: who did what, when

Models and hosts

$ machine providers
Connect model providers by key or OAuth
$ machine agents
Set which model each agent runs on
$ machine hosts
Sign in and switch between hosts

Full CLI reference

06Connectors

Every tool, behind one interface.

Machine connectors put 3,000+ apps, plus any MCP, OpenAPI, GraphQL or HTTP endpoint, behind one interface your agents call as tools.

connectors · request path

AppMCPOpenAPIGraphQLHTTP

sandboxagent runtime

only a scoped token leaves the box

scoped Machine token

Machine connectorcredentials live here

Slack

GitHub

Salesforce

Notion

Stripe

Linear

+ 3,000 more apps, and any endpoint

3,000+ one-click apps

Connect an app in a click. The OAuth dance is handled for you.

Or bring any endpoint

Any MCP server, OpenAPI spec, GraphQL API or plain HTTP endpoint gets the same interface.

Credentials stay server-side

Connector credentials never reach the sandbox. Only a scoped token leaves it.

Connect once, for everyone

Agents hold one scoped Machine token. A connection is shared across the org and refreshes itself.

07It’s all code

A platform that improves itself.

Because everything is code in a repo, the system can read its own blueprint, extend itself, and stay healthy as it grows.

Everything is files

Agents, skills, tools, connectors and schedules live in the repo. Edit them in your IDE, in the web app, or let an agent edit them.

Agents edit themselves

Describe a change and an agent makes it, reusing what already exists, and opens a change request you review.

Skills, git-backed and invisible

Anyone can publish a skill as markdown. Machine handles the branch, the change request and the merge behind the scenes.

Self-healing integrations

When a token expires, Machine refreshes it, or asks you to reconnect in plain language. Never a cryptic error.

Reviewed before it lands

Nothing an agent writes reaches main until a person approves the change request. Fast, and still yours.

Every feature is a conversation

The UI is a reference, not a requirement. Anything you can do in a menu, you can do with a message.

Start building

Ship your firstinternal agent.

Install the CLI, run machine init, and ship the agent you already use.

Get started Read the docs

machine init
machine ship
Any model
Reviewed changes