We gave Codex its own computer

Vladimir Petrov — Fri, 31 Jul 2026 12:50:21 +0000

We recently launched Cobalt, a browser-based app that gives every coding task its own remote development computer.

We built it because we were tired of juggling Git worktrees locally.

Git worktrees are useful when two branches need to exist on the same machine, but separating the files is only part of the job. Each piece of work may also need its own dependencies, containers, database, ports, environment variables, terminals, and running application. Move between three worktrees and you are soon checking which server belongs to which branch, restarting processes, and trying not to point one frontend at another feature’s API. Not to mention the waste of disk space this is!

So we asked a different question: what if every feature had its own complete development environment?

That idea became Cobalt.

Connect your repository and coding agent

Starting a task begins with two connections: the repository containing the code and the coding agent that will work on it.

Cobalt supports repositories hosted on GitHub and Azure DevOps. Once a repository is connected to a workspace, choose the branch or pull request that contains the right starting point for the task.

You can currently run tasks with Codex, Cursor, OpenCode, or Pi. Connect the agent account you already use, then select it when creating the task.

The agent changes from task to task. The repository, computer, preview, and Git workflow around it remain consistent.

Every task gets a dedicated computer

When you start a task, Cobalt launches a remote development computer for it and checks out the selected repository state.

The coding agent is then asked to prepare the project. It can install dependencies, start Docker containers, create local databases, run migrations, and launch the services the application needs. If the repository contains a .cobalt/README.md, the agent reads it for project-specific setup, startup, and verification instructions.

This gives the agent a repeatable way to prepare the environment instead of rediscovering the project on every task. The runbook lives with the repository, so it can evolve with the code and differ between branches when necessary.

Some environments still take time to prepare. A large repository may need a lengthy dependency restore, several containers, generated assets, or seeded development data before useful work can begin. Once a computer reaches a good starting state, you can save it as a named snapshot.

Future tasks can begin from that snapshot with the dependencies and project state already in place. The new task still receives its own independent computer, but it avoids repeating the slowest parts of the setup.

Open the application beside the conversation

After preparing the project, the agent runs the code.

When Cobalt detects a web service, it makes that service available through Preview. The application opens beside the task conversation, so you can use it while the agent works.

A task can expose more than one service. A frontend, API explorer, component library, and administration app can all run from the same computer and appear as separate previews. Development servers retain WebSocket support, hot module replacement, and live reload where the framework provides them.

Not every coding task produces something that can be shown in a browser. A library change, command-line tool, or background worker may only have tests and command output to inspect. When an application does expose a web interface, Preview lets you verify the result against the same environment in which the agent built it.

Prompt the agent as you normally would

Working with an agent in Cobalt feels familiar if you already use Cursor or Codex.

Describe the change in the task conversation:

Add a compact navigation mode for smaller screens. Update the existing tests and start the application so I can review it in Preview.

The agent edits the repository, runs commands, and reports its progress. When the application updates, you can click through it and send another message if something needs changing.

There is no need to translate feedback into a special workflow. Tell the agent that the navigation opens too slowly, that a button belongs somewhere else, or that an edge case still fails. The next turn continues from the same checkout, installed dependencies, running services, and conversation history.

Alongside Preview, Cobalt lets you browse the files on the computer and inspect the current Git diff. This makes it possible to review the implementation and the behaviour together before publishing anything.

Return the result through a pull request

When the task is finished, its changes return through Git.

Review the diff, check the tests, and create a commit from the task. You can then push the branch and open a pull request in GitHub or Azure DevOps.

The pull request remains the place for automated checks, code review, approvals, and the final merge. Cobalt handles the development environment and the agent’s work leading up to it; the result enters the same repository workflow as any other change.

If the work is not ready, keep the task open and continue the conversation. Its computer and repository state remain available until you decide to publish, suspend, or delete it.

Run several tasks without sharing their state

The original worktree problem becomes more noticeable when several pieces of work are active at once. One feature needs the frontend on one port, another needs a different database migration, and a bug investigation needs to reproduce production behaviour without disturbing either of them.

Cobalt gives each task a separate computer.

You can start a feature, a bug fix, and an experiment in parallel. Each task has its own repository checkout, dependencies, processes, containers, database, ports, and conversation. One agent restarting its application does not interrupt another task, and none of the work touches your local development environment.

When a task finishes, keep the result that matters and remove the computer you no longer need. There are no local worktrees to clean up and no forgotten development servers left running in old terminals.

Cobalt has only just launched

Cobalt launched recently, and we are still learning where dedicated coding computers are most useful and where the workflow creates friction.

We would like to hear how it behaves with different repositories, development stacks, and coding agents. If setup takes too long, Preview does not recognise part of your application, or something about the path from task to pull request feels awkward, that feedback will help us decide what to improve next.

You can start a task at app.cobaltcode.ai.

To see the full workflow—from connecting a repository to running the application and preparing the result for Git—watch the Cobalt introduction on YouTube.

DEV Community: Vladimir Petrov