The agent works on a real cloud computer: it reproduces the bug, writes the fix, runs the tests, and opens a change request from a branch. You review a diff.
packages/queue/src/retry.tsconst delay = base * 2 ** attempt;// Full jitter. Without it every worker wakes on the same tick and the// retry storm is indistinguishable from the outage that caused it.const delay = Math.random() * base * 2 ** attempt; packages/queue/src/retry.test.tstest("spreads retries across the window", () => { const spread = sample(1_000).stddev / EXPECTED_MEAN; expect(spread).toBeGreaterThan(0.4);});Not the rewrites. The small, well-defined work underneath them: reproductions, dependency bumps, flaky tests, a rename across two hundred files.
It takes the report, builds the case on a cloud computer, and comes back with either a failing test or the reason it could not reproduce. A session that cannot reproduce says so. It does not invent a fix for a bug it never saw.
It runs the suite in a loop, isolates which test actually fails and how often, and finds the shared state or the timing assumption underneath. The change request carries the failure rate it measured before and after.
Upgrade, build, run the suite, read the changelog for the breaking notes, patch the call sites that moved. If the suite goes red it opens the change request anyway, with the failures in the description rather than a green claim.
One rename, one API move, one lint rule turned on — the kind of change that is trivial per file and unbearable at scale. It works file by file on a branch and lands one reviewable diff.
It reads the errors the day threw, clusters them by root cause rather than by message, ranks them by how many people hit them, and takes the top one all the way to a patch.
It diffs the documented behaviour against the actual behaviour and corrects the document to match the code, or flags the code as the thing that is wrong. Both are the same commit type here — everything is a file.
What comes back is a diff on a branch, with the tests already run on the machine that wrote it. There is nothing new to learn how to read.
packages/queue/src/retry.ts-const delay = base * 2 ** attempt;+// Full jitter. Without it every worker wakes on the same tick and the+// retry storm is indistinguishable from the outage that caused it.+const delay = Math.random() * base * 2 ** attempt;packages/queue/src/retry.test.ts+test("spreads retries across the window", () => {+ const spread = sample(1_000).stddev / EXPECTED_MEAN;+ expect(spread).toBeGreaterThan(0.4);+});
The agent commits on the session branch and opens a change request against main. What arrives in review is a diff with a description — the same object a colleague would have opened.
The sandbox is a real Linux machine, so the agent installs, builds and runs the suite itself. A change request that arrives red says so in the description rather than claiming green.
Sessions run side by side on the project’s computer and share its files, so give parallel work different files, or a project of its own. Every change still reaches main as its own change request.
Most of the work happens inside the repo the session cloned. Connectors cover the rest, and their credentials stay on our side, never inside the machine.
Easy connect covers 3,000+ apps through their OAuth screens. Anything not in that catalogue is reachable through MCP, OpenAPI, GraphQL or raw HTTP — which is usually the honest answer for an internal service, because it never had a public catalogue entry to begin with.
Three ways to start the same session. The isolation and the review path do not change with the trigger.
Describe the bug in a Slack thread, or start a session from the web app. You get a reaction on your own message rather than a bot post, and the reply lands in the same thread.
Set an action to Ask and the run pauses at the call and waits, showing you the action and its arguments. Approve and the same call completes and the session carries on from exactly where it stopped.
Triage the overnight exceptions at 06:00. Or wire your alerting to a signed webhook so a paging event starts a session with the incident payload already in the prompt.
The question is not what an agent can write. It is what it can land. Here is the exact answer.
One project, one set of connectors, one memory that compounds. Each team writes the skills for its own work; nobody stands up a second system.
Start with one job and grow from there.
Free to start · No credit card required