Research loops with forked agents
If you've had a coding agent work on making something faster or more accurate, you've probably watched a run settle on one idea and keep tweaking it until the score stops improving. A loop works better: start several agents from the same place, grade each result, keep the best one, and start the next round from there.
A recent Microsoft Research paper, Fork-and-Flush, tested this on long research tasks. Separate runs of the same agent finished at very different scores, because each run got stuck on its own set of ideas. Copying the best run's files into several fresh agents, keeping the best of those and repeating did better than one long run, and better than several separate runs with the best picked at the end, for the same amount of compute.
Set it up once
The slow part of any of this is setup: cloning the repo, installing dependencies, downloading data, and signing in to Claude Code or Codex. On Orble you do that once, in one box.
You don't have to do it by hand either. A supervisor agent, like Claude Code or Codex on your laptop with Orble's MCP server connected, can create the box, set it up, and write the task, the notes so far and a grader for you:
Make an Orble box called lab for speeding up the parser in this repo. Install what the benchmark needs, write a grader that checks the output and times the benchmark, and keep the grader on this laptop. Then set up a research loop in lab.
The only thing you do yourself is sign in to the coding agent once, in lab's terminal in the dashboard.
Then fork it
Once lab is ready, the supervisor can fork it while it's running. Each fork is a full copy of the virtual machine, with the same files, the same installed tools and the same signed-in agent, and it's ready right away. Nothing gets reinstalled, and nobody signs in again. Every fork starts a fresh coding agent on the same task, and since each fork is its own VM, one fork's work can't leak into another's.
Fork lab into several copies and run a round.
When the round is done, the supervisor grades every fork and picks the winner. The winner gets a short summary from each of the other forks about what was tried and what happened, so the next round doesn't repeat it. Then the supervisor forks the winner, and the next round starts from the best result so far with fresh agents.
Forks that lose suspend when they go idle, and a suspended box only costs storage, so you can keep them around and delete them later. The dashboard shows every fork under the box it came from, so you can trace the result back through every round.
Forks instead of worktrees
The usual way to run several coding agents in parallel is a git worktree per agent on one machine. Worktrees only separate the files git tracks, though. Each one needs its own node_modules or virtualenv and its own build, and everything else is shared: ports, running dev servers and databases, global caches, ~/.config, and the agents' sign-ins. Two test suites running at once can collide on a port or a temp directory, and a pip install or rm -rf in one worktree can break the others.
Forking a VM copies the whole machine state instead: the disk, the memory and every running process, including dev servers, databases and open shells. Orble takes copy-on-write snapshots of the disk and memory, so a fork doesn't duplicate the data up front, and each fork gets its own kernel, network and address. That makes a fork a cheap checkpoint. You can branch from any state a box has reached, compare the branches, and delete the ones you don't need, with nothing to clean up on your machine. Because each branch is fully isolated, you can let agents skip their permission prompts, install system packages or restart services without any risk to the other branches.
Grading belongs outside the boxes for the same reason. The supervisor runs its own copy of the grader against each fork, against held-out tests where you have them, so nothing that changes inside a fork's VM can influence its score. That's the simplest guard against reward hacking, and it means every round's winner is chosen by the same harness.