Running Claude Code and Codex in a cloud computer

Running Claude Code and Codex in a cloud computer

How to run Claude Code and Codex in a cloud computer: sign in once, start agents in parallel on their own branches, and review from any device.

20 Nov 20266 min readhomemade team

Coding agents like Claude Code and Codex work best when they can run things: install packages, start a dev server, run the tests, read the error, try again. On your laptop that means they share your machine, your files and your attention. In a cloud computer, each agent gets a machine of its own, and you can run several at once without them stepping on each other.

This guide covers running Claude Code and Codex in a cloud computer on homemade: setting up once, starting agents per task, reviewing their work, and keeping the cost down.

Why run an agent in the cloud at all

Why bother:

  • Parallel work. One agent per task, each on its own branch, each with its own running app. On one laptop, two agents fight over ports, node_modules and the git index.
  • Your laptop stays yours. A long agent run doesn't heat your machine, stop when you close the lid, or touch files you didn't mean it to.
  • Safer by default. An agent that can run any command is easier to trust when the worst it can break is a computer you can throw away.

The trade-off is that the agent's work lives somewhere else, so you need a good way to see it, run it and pull it back. That is most of what this guide covers.

Step 1: sign in once

Every homemade computer has these agents installed: Claude Code (claude), Codex (codex), OpenCode, pi, Kimi and Grok. You don't install anything.

Open Account → AI tools in the dashboard and sign in once. You can use:

  • A subscription. Sign in with your Claude Code or Codex plan. Every computer you create starts signed in as you, so claude and codex run with no login step.
  • An API key. Add an Anthropic or OpenAI key, and every new computer uses it. A key set for a team or project under Environment wins over yours, which is handy for a shared team key.

One note on subscriptions: heavy use across many computers at once can hit your plan's rate limits. That is the provider's limit, not ours, and it is the main reason some teams switch to API keys for parallel runs.

Step 2: a computer per task

Create a computer for each piece of work, on its own branch. From the dashboard, pick the project and press New VM. From a terminal, with the homemade CLI:

homemade vm create --branch fix-auth --wait
homemade vm create --branch add-invoices --wait

Each computer starts with your repo cloned at that branch, your install commands run and your services started, each in its own terminal. Each one gets its own preview links, so the two apps never collide.

Step 3: start the agent

Open the computer's terminal in the browser, or connect from your own:

homemade ssh <computer>

Then run the agent as you would locally:

claude

or

codex

The agent sees a real Linux machine with your project, your services already running, git set up, and a network connection. It can run the tests, hit the dev server with curl, read logs and install what it needs.

If you prefer an editor, homemade open <computer> opens the computer in VS Code over SSH, and homemade open <computer> --editor cursor in Cursor. The agent's terminal and your editor work on the same files.

Step 4: chat from the dashboard

Each computer also has a Chat tab next to its terminals. It is an agent that works on that computer: it reads your code, runs commands and edits files there. You pick the model and how it is paid for (your subscription or an API key), and how much it may do:

  • Ask before commands and edits. It asks you first.
  • Plan only. It reads and plans, and runs nothing.
  • Run without asking. It works on its own.

Chat is the easy way to check on work from a phone. Open the dashboard, look at the computer, read what the agent did, and answer if it asked something.

Step 5: let it run, and get told when it needs you

An agent in a homemade computer can tell you when it needs input or when it's done. You get a real notification, by email or in Slack if you connected it. An agent can even ask for a sibling computer to split up work, one level deep and capped at 3 outstanding requests, and every one of those actions is audited.

This changes how agent work feels. You start three tasks in the morning, close the laptop, and come back to notifications instead of watching terminals.

Step 6: review the result

When an agent says it's done, you want to see it working, not just read a diff.

  • Open the preview. Every service with a URL has a link. Open the app the agent changed and click through it. Share the link with a teammate; you choose whether it is public, team only or yours only.
  • Read the diff. In the terminal, git diff and git log show exactly what changed.
  • Run the tests yourself. homemade vm exec <computer> -- pnpm test runs a command from your laptop and prints the result.
  • Push. Connect GitHub once and every computer pushes as you, with your own token, not a shared bot account.

Try a risky idea on a fork

Halfway through a task, you might want to try two directions. Fork the computer from its page. The fork has the same disk and the same things running, and the original keeps going. Give the second direction to a second agent, compare both previews, and delete the one you don't want. See forks and branches.

Keep the cost down

Agents are bursty. They work hard for twenty minutes, then wait for you for two hours. Sleep is built for that:

  • A computer goes to sleep when it is idle (after 30 minutes by default), and sleeping costs no running time.
  • It wakes with memory intact, so the agent's terminal and the running app are exactly as they were.
  • For a long unattended run, give that computer a longer sleep time, or never on Pro, so it isn't paused halfway.

Pick the size for the job. An agent editing a small web app is fine on tiny (2 vCPU, 4 GB, $0.0162 an hour). A big monorepo build wants medium (8 vCPU, 16 GB, $0.0648 an hour) or more. Pro includes $20 of usage a month. See pricing.

Give your local agent homemade as a tool

There is one more way to combine the two. Your local Claude Code or Codex can create and drive cloud computers itself, through the homemade MCP server:

claude mcp add homemade -- homemade mcp
codex mcp add homemade -- homemade mcp

The server has one tool for every API operation. Your local agent can make a computer for a task, run commands in it and clean up after itself. See the MCP page.

A typical day

A pattern that works well:

  1. In the morning, create three computers for three tickets, each on its own branch.
  2. Start Claude Code in one and Codex in another, and use Chat on the third from your phone on the way in.
  3. Get a notification when the first one is done. Open its preview, click through, read the diff, push.
  4. The idle computers go to sleep while you're in meetings. They cost nothing and wake where they were.
  5. At the end of the day, delete the merged ones and leave the rest asleep.

More on why this setup suits agents in cloud dev environments for AI agents. The setup details are in the AI tools docs.

Try homemade

Every project gets its own cloud computers, with Claude Code and Codex signed in. The Hobby plan is free.

Related posts