One task · one microVM

Give every agent its own space.

Stop juggling worktrees and fighting over ports, caches and CPU on one machine. Each task gets an isolated Linux microVM that pauses after 15 idle minutes, even with your agent open, so the compute stops too.

5 free agent-hourspaused time is freeno card

  1. Create
  2. Claim
  3. Isolate
  4. Review
  5. Release

Your agents, your tools

Bring your own account. Codex connects once; Claude Code and Pi sign in once in each task and stay signed in across pause and resume. Model usage is separate.

Works with Codex, Claude Code, Pi and SSH.

Why MicroDev

More agents. Fewer collisions.

Worktrees separate files. Your agents still share one machine: its ports, its caches, its CPU and its power switch. MicroDev gives each task an environment of its own.

The worktree shuffle

Get out of each other’s way.

Branches on one machine still collide on ports, node_modules and build caches. Each task gets its own files, processes, dependencies and ports.

The shared-machine bottleneck

Let parallel work be parallel.

Agents on one laptop queue for the same cores. Give each agent its own Linux microVM and run builds and tests side by side.

The always-on compute bill

Stop paying for the gaps.

An agent waiting on you still holds a machine. A task pauses after 15 idle minutes, even with the agent open and your terminal or the Mac app attached: its compute is released and the workspace stays saved.

How it works

One task. One environment.

From a prompt to a pull request, then out of the way.

Start your first task
  1. Create a task

    Start from any terminal (or, once it’s released, the Mac app). Pick the repository, the agent (Codex, Claude Code or Pi) and its prompt. Codex runs on the account you connect once; Claude Code and Pi sign in once in each task.

    microdev start OWNER/REPO --agent codex --prompt "…"
  2. Claim a microVM

    A fresh root filesystem boots, your repository is cloned and your agent starts on the prompt. Your Mac stays the control surface.

    fresh root fs · repo cloned · agent started
  3. Work in isolation

    The task has its own guest kernel, files, processes and network boundary. Tasks from different users share hosts; each one’s VM, disks and network are kept apart from the others and from the host’s private services.

    own kernel · own files · own network
  4. Review the diff

    In the Mac app (coming soon): review the diff in place. Comment on a line and send it back to Codex. When it looks right, open a pull request with exactly the diff you reviewed.

    review · comment · open pull request
  5. Release the compute

    Pause saves the workspace and agent sign-in, sessions and settings, then compute stops. A task also pauses itself after 15 idle minutes, even with your agent open and your terminal or the Mac app attached; builds, tests, downloads, streaming model calls and typing count as busy.

    microdev pause ENVIRONMENT_ID

One agent, many microVMs

Fan out. Converge on pull requests.

Give the coding agent on your laptop the whole job. It starts a MicroDev task for every piece, each in its own microVM with its own kernel and network. Once you’ve connected Git, the agent in each task pushes a branch with your credential and the agent on your laptop opens a pull request for each one.

A coding agent in a terminal on your laptop starts eight MicroDev tasks on a Team plan with two seats, each in its own microVM with 2 vCPUs of compute; the agent in each task pushes a branch with the Git credential you connected, the agent on the laptop opens a pull request for each with gh, and the quiet tasks pause while the pull requests stay.
  1. One agent plansGive the agent on your laptop the whole job.
  2. Fan outIt starts a MicroDev task per crate. Each one runs in its own microVM.
  3. ConvergeEach task’s agent pushes a branch with your Git credential. Your laptop’s agent opens the pull requests.
  4. ReleaseQuiet tasks pause on their own. The pull requests stay.

The agent’s side

Any agent that can run a command can do this: the skill at https://microdev.dev/skill/SKILL.md teaches it to start, watch and pause tasks, each with its own agent and prompt: microdev start OWNER/REPO --agent codex --prompt "…" --json. Each task’s Codex works on the account you connected, with no sign-in. Claude Code and Pi tasks start the same way but need one sign-in per task (microdev attach ID).

Your side

Every task shows up in the CLI (and in the Mac app once it’s released) like any other. Review each pull request on GitHub. A task pauses itself after 15 idle minutes, or the agent pauses it.

Capacity

Concurrency follows your plan: 2 tasks at once on the trial, 2 per seat on Pro and 4 per seat on Team, so the agent starts the next task as one finishes.

MicroDev for agents

Compute explorer

Run for the work. Not the whole day.

A machine left on keeps allocating compute between tasks. A MicroDev task pauses after 15 idle minutes. Try your own numbers.

An illustration, not a price quote. It compares allocated compute only and excludes subscriptions, storage and model costs. Running time includes waits for tools and models; paused time is excluded from usage.

See plans and pricing
3
2 hours
8 hours

75%

less allocated compute in this example

MicroDev, running 2 h a day120 agent-h
Machine left on 8 h a day480 agent-h

per month · one agent-hour is a task with 2 vCPUs of compute running for an hour · 20 working days

Illustration At the Pro overage rate of $1.00 per agent-hour, that is $120 versus $480 a month. Your bill differs: it ignores included hours and the seat price.

The persistence contract

Let the machine go.
Keep the momentum.

A completed pause saves your task. Resume builds a fresh environment around that progress. Save files before you pause.

Preserved on completed pause

  • The whole workspacebyte for byte: staged, uncommitted, untracked and ignored files
  • Git historyevery branch, stash and commit
  • Agent sign-insCodex, Claude Code and Pi stay signed in
  • Agent sessions and settingssession history and settings, so a resumed agent starts past onboarding

Rebuilt on resume

  • Root filesystema fresh copy of the pinned system image, checked against its SHA-256 digests
  • Your dotfilescloned fresh; init.sh runs on creation and every resume
  • Packages and home filesinstalled packages, other home-directory files and shell history
  • Processes and cachesrunning processes, tmux sessions, environment variables, agent caches and logs
Read the persistence contract

The Mac app

Your Mac is the control surface.

Coming soon: start a task with Codex, Claude Code or Pi from the composer and watch it work in a native terminal. Comment on the diff line by line, send the comments back as one batch, verify the answer and publish the pull request. Nothing runs on your laptop.

The MicroDev Mac app: a task is created with ⌘O and runs Codex in its own microVM; its changes are reviewed with ⇧⌘D, two line comments go back to Codex as one batch, its answer is verified, the cumulative diff is published as a pull request and the environment is paused.
  1. ⌘O · New taskDescribe the task. Pick the agent.
  2. One task · one microVMA fresh microVM boots, the repository is set up, Codex starts.
  3. ⇧⌘D · Review changesComment on lines. Send them to Codex as one batch.
  4. VerifyCodex answers with a new patch. Resolve what it fixed.
  5. Create pull requestPrepare the cumulative diff and publish it to GitHub.
  6. Pause environmentThe workspace is saved. The compute is released.

Mac app: coming soon

An illustrated walkthrough with sample data, not a screen recording; a real task takes minutes. Batch feedback in the agent’s own conversation works with Codex. The Mac app in the docs

Three ways to start

Start where you already work.

Every path starts on the same free trial: 5 agent-hours over 14 days, up to 2 tasks at once, no card.

Terminal

Install the CLI

Sign in with GitHub, then launch the sample repository in its own microVM.

curl -fsSL https://microdev.dev/install.sh -o install-microdev.sh
sh install-microdev.sh
export PATH="$HOME/.local/bin:$PATH"
microdev login
microdev demo
Read the quickstart

Your agent

Hand it to your agent

Paste this line to your coding agent and let it take it from there.

curl -fsSL https://microdev.dev/skill/SKILL.md
MicroDev for agents

Questions

Good questions. Straight answers.

Read the docs
Do I need a card?

No. The trial is 5 agent-hours (300 minutes) of running time over 14 days, with up to 2 tasks at once, no limit per run and up to 10 new tasks an hour (resuming a paused task doesn't count against that). Paused time is free. The control plane enforces those limits, and nothing charges you automatically. Upgrading is your choice.

Do I need a model subscription?

You bring your own agent account. The Codex, Claude Code and Pi CLIs are preinstalled. Codex runs on the account you connect once, with no further sign-in; Claude Code and Pi sign in once in each task and stay signed in across pause and resume. Model usage is billed by your model provider, separately from MicroDev compute.

What survives a pause?

Your whole workspace, byte for byte: every branch, stash and commit, and staged, uncommitted, untracked and ignored files. Codex, Claude Code and Pi sign-in, session history and settings, so a resumed agent starts signed in and past onboarding. Installed packages, other home-directory files, shell history, agent caches and logs, environment variables and running processes are not kept: resume boots a fresh copy of the pinned system image and runs your dotfiles again. See the exact contract.

On subscription plans the contract is backed by the pause guarantee: if a completed pause loses committed, uncommitted or untracked work in your workspace, that billing period’s subscription fee is credited against your next renewal (a month’s fee on monthly plans, the year’s on annual plans). How it works.

Will auto-stop kill my build?

No. A build or test run spends CPU, a download or streaming model call moves data, and typing in the terminal is activity; any of them keeps the task running. Auto-stop needs 15 continuous minutes in which every minute stayed under 2% of one vCPU and moved 32 bytes a second of data or more for less than half of it (packet headers and your SSH sessions excluded), with no typing and no transcript change. An attached terminal or Mac app nobody types into doesn't count. A tool that only sleeps or polls now and then, with no CPU, is paused like a finished agent, with its workspace kept. On the trial, tasks also pause when the trial’s running time is used up or its 14-day window ends.

How isolated is a task?

Each task runs in its own Firecracker microVM under the jailer: its own jail, cgroup, root and workspace disks, PID and mount namespaces, and a host UID and network namespace that no other running task shares. From inside the guest, even as root, other tasks’ VMs, the host’s own services, cloud instance metadata and private network ranges are unreachable; only the Internet is. A task placed in a slot another task left starts with none of its connections. Physical hosts are shared: there is no dedicated-host guarantee.

How is this different from Git worktrees?

A worktree is another checkout, but its processes, ports and installed dependencies still live on the same machine. MicroDev gives each task a separate Linux microVM, its own workspace and its own compute lifecycle. You can still use worktrees inside a task.

Can my team use it?

Yes. Create an organization, invite your team and buy seats. Seats pool across the organization: each one adds tasks at once and included agent-hours. Plans are Pro $29, Team $59, Business $119 per seat per month; Team adds usage by member and starts at 2 seats. See plans and pricing.

A little space goes a long way

Your next task. A world of its own.

Try a real isolated environment. Your first 5 agent-hours are on us.

5 agent-hours · 14 days · no card · no automatic charge