A developer handed the entire release workflow of a forked open-source browser game to autonomous AI agents and then supervised the result from a phone. Two orchestrator agents, one running in the cloud and one on a Windows laptop, split the work, messaged each other about pull requests and verification results, and merged approved changes on their own. The bill for the session was about $2.39 in cloud compute and roughly $25 to $27 in model tokens, which showed up as just 3% of the weekly limit on a $200-per-month Claude Ultra plan. The more interesting part is what the human still had to decide before letting go.

The project and the setup

The target was Kong Royale, an online 50-player browser battle royale game built around bananas. The developer forked the maintainer's public repository on GitHub so that changes could land ahead of a public release event, with the teaser site showing a November 6 launch target. Because the fork needed to stay in sync with an active upstream project, the release process involved more than building and shipping: it also meant watching for the maintainer's commits, rebasing, and resolving merge conflicts.

The orchestration ran on Capy AI, a platform for coordinating fleets of AI software engineering agents across development environments. Its central concept is the Captain, a high-level agent that breaks work into tasks and hands them to specialized agent crews running in separate threads. The developer normally works in tools such as Cursor and Factory but chose Capy AI here because the project needed heavy cloud resources and automation across several machines.

The hardware was deliberately varied:

Device Role
iPhone Steering and monitoring
MacBook Pro Local environment, Metal graphics checks, play testing
Windows laptop with RTX GPU Direct3D 11 compatibility and asset validation
Capy cloud machines Builds, triage, verification, release flow

The Captain divided the work by hardware capability, sending platform-specific builds, graphics verification and websocket tests to whichever machine could run them.

Getting the environments ready

After forking and cloning the repository into Capy AI's cloud workspace, two setup tasks ran in parallel: one configured the local environment on the MacBook Pro, the other prepared the cloud environment. Capy provisioned a large cloud instance, ran the project initializers and npm installs, executed build validation scripts, and captured an activation snapshot in about 11 seconds.

One detail stood out during setup. Capy AI automatically assigned these routine tasks to Claude Sonnet 5.5 sub-agents rather than the more expensive Claude Opus 5.5. The pattern repeated throughout the session: Opus 5.5 handled orchestration and judgment while Sonnet 5.5 did deterministic execution such as cloning, installing and basic verification. That delegation is a major reason the plan quota barely moved.

The rules a human still has to write

Handing a process to an agent does not remove the need for policy. The developer created a persistent cloud-hosted Captain named "Kong Cloud [Release]" on Claude Opus 5.5 with medium reasoning effort, and gave it ownership of four stages: feature work, bug triage and prioritized fixing, the release flow, and cloud verification checks. The configuration included several explicit rules.

Keep pull requests small and verifiable

Because the fork feeds changes back into an active upstream project, the Captain was told to submit small, self-contained pull requests that a maintainer can verify quickly. The reasoning is simple: large, monolithic pull requests tend to sit unreviewed, while small ones are more likely to be reviewed and merged promptly. This is a judgment about how open-source collaboration works, and it is one an agent may not infer on its own unless it is written into the instructions.

Robot inspector checks small boxes at a checkmark gate before a river while a huge crate sits stuck outside

▲ Small pull requests at the review gate

Watch upstream and rebase automatically

The release Captain was instructed to monitor the upstream repository, detect new commits or pull requests from the maintainer, rebase the fork's changes and resolve merge conflicts. This became a scheduled "Upstream watch" task that polls upstream every 8 to 23 hours and triggers the rebase flow when something changes.

Decide what can merge without a human

The developer permitted the agents to run on autopilot and merge validated pull requests for non-critical changes without manual sign-off. Where the line between critical and non-critical sits is a human decision, and it is the rule that most directly determines how hands-free the pipeline can be.

Decide where the Captain lives

Hosting the release Captain in the cloud rather than on a laptop was itself a deliberate choice. A cloud Captain keeps the pipeline running when the laptop lid closes or the local machine loses connectivity, which matters for a process that is supposed to continue around the clock.

Choose how much model routing to specify

The workspace also included a configuration file, pstack-models.md, that maps development roles such as feature refactoring, bug fixes, performance work, judgment and a "divergent synthesizer" to different models, including Claude Opus 5.5, Claude Sonnet 5.5, Grok 4.7 and Kimi K3.1 Pro. The developer openly questioned whether such a detailed matrix is necessary at all, given how capable Sonnet 5.5 and Opus 5.5 already are. The takeaway appears to be that the simple Opus-for-judgment, Sonnet-for-execution split did most of the useful work.

Two Captains that talk to each other

A second Captain, "Kong RTX," ran directly on the Windows laptop in its own worktree, focused on platform-specific tasks, Direct3D 11 compatibility and asset validation. Connecting the two required nothing more than mentioning "@Kong Cloud [Release]" in the instructions given to Kong RTX. From that point the two agents exchanged messages on their own.

Their conversation covered project dependencies, verification scripts and a pull request labeled PR #1. The cloud Captain produced verification skills for three runtime environments: Metal on macOS, D3D11 on Windows, and headless Linux in the cloud with CPU and GPU checks. One test booted the game client on Windows without a dedicated GPU to confirm the fallback path was stable, and play testing on the Mac verified gameplay at 65 frames per second.

Two robots on a desk laptop and in a cloud trade message envelopes beside a shared checklist with one warning

▲ Cloud and Windows Captains coordinating work

The most telling moment came from an asset licensing checker thread, tracked as KONG-13. It found that 3,494 of 3,575 public image files had no recorded source. Rather than push ahead, the cloud agent held public upstream pull requests until the licensing question could be clarified. That is exactly the kind of judgment call a release process depends on, and it suggests why the scope and rules given to the Captain matter: the agent appears to have paused because shipping clean, verifiable changes upstream was part of its mandate.

What it actually cost

Capy AI's billing view separates charges for its own machines from model costs incurred on the user's own API keys. Across seven simultaneous agent threads and two Captains, the figures for this one session were:

Item Cost
Capy cloud machine compute $2.17 to $2.39
Model tokens on the user's keys (total) $23.71 to $27.13
Of which Claude Opus 5.5 $17.99 to $19.30
Of which Claude Sonnet 5.5 $5.76 to $5.93

The developer runs a Claude Ultra subscription priced at $200 per month. The account's usage page showed the whole session, including repository setup, triage, multi-machine verification and the inter-agent coordination, at 3% of the weekly limit for all models, with the limit resetting on Tuesday at 6:00 AM.

Compute stayed low in part because Capy's cloud machines suspend automatically when idle and boot again within seconds, so nobody has to remember to shut them down during long debugging stretches. The developer expressed surprise at how little both the compute and the plan quota cost relative to the volume of code generated and audited. These are figures from a single session on a single project, not a benchmark, and the split between Opus and Sonnet usage will differ with the mix of tasks.

One caveat: getting multiple machines synchronized and correctly configured is typically the most time-consuming phase of a setup like this. The 11-second cloud snapshot is fast, but the surrounding work of wiring up local worktrees, graphics environments and permissions still takes human attention.

What to take from this

The session suggests that a repetitive but judgment-heavy process such as a software release can be handed to agents wholesale, provided the human writes down the policies the agents should follow. For anyone considering a similar setup, the practical lessons are:

  • Host the orchestrating Captain in the cloud so the pipeline survives a closed laptop or dropped connection.
  • Let lighter models such as Claude Sonnet 5.5 handle setup, cloning and routine verification, and reserve Claude Opus 5.5 for orchestration and judgment.
  • Set the Captain's reasoning effort to medium as a starting balance between quality and token use.
  • When working against an active upstream fork, require small, self-contained, easily verifiable pull requests.
  • Schedule an upstream watch so rebases happen automatically rather than piling up.
  • Decide explicitly which changes may merge on autopilot and which need a person.
  • Connect agents on different machines by mentioning each other's handles in their instructions, so they synchronize branches and verification results themselves.
  • Rely on automatic machine suspension to keep cloud compute in the low single dollars.

The cost numbers here come from one developer's project and plan, so treat them as a reference point rather than an expectation. What carries over is the method: write the rules, pick where each kind of judgment lives, and let the agents report back to your phone.