Every session boots its own cloud computer, clones the repo, and cuts its own branch. The agent reproduces the failure, writes the patch, runs the suite, and opens a change request. You review a diff, not a transcript.
One machine per session · one branch per session · merge is default-deny
Not the architecture. The long tail underneath it — the reproductions, the bumps, the flakes, the mechanical migration across two hundred files. Work that is well-specified, individually small, and collectively the reason nothing else ships.
It takes the report, builds the case on its own machine, 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 its own 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.
The output of an engineering session is the thing engineering already reviews. There is no new artifact to learn, no summary to trust — the change is the change, and the tests either passed on the machine that wrote it or they did not.
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 do not share a working tree. Twenty of them can run against the same repo at once, each on its own branch and its own computer, without stepping on each other.
An engineering session already has the strongest reach on the platform, because most of the work is inside the repo it cloned. Connectors cover the rest — and every credential is resolved on our side of the wall, 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.
The same session machinery, started three different ways. Nothing about the isolation or the review changes with the trigger.
Describe the bug in a Slack thread, or start a session from the web app or the CLI. 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 interesting question about an autonomous engineer is not what it can write. It is what it can land. Here is the answer, stated exactly.
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.
Open source and self-hostable. Any model, your keys. Kortix Cloud, your own VPC, or your own on-prem network.