Solutions · Engineering
The tickets that neverreach the top.
Every session boots its own cloud computer, clones your 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
- Runs on
- A real Linux machine with a shell
- Works on
- Its own branch, cut per session
- Lands as
- A change request against main
- Merge
- Default-deny for agents
01The handoff
The backlog you stopped planning to get to.
Not the architecture. The long tail under it: the repros, the bumps, the flaky tests, the same small change across two hundred files. Each piece is clear and small. Together they are why nothing else ships.
Job 01
The bug nobody has reproduced
Hand it the report. It builds the case on its own machine and comes back with a failing test, or with the reason it could not reproduce. If it cannot reproduce, it says so. It never invents a fix for a bug it never saw.
Job 02
The flaky test everyone reruns
It runs the suite in a loop, pins down which test really fails and how often, and finds the shared state or timing assumption behind it. The change request shows the failure rate it measured before and after.
Job 03
Dependency bumps, with the build proved
Upgrade, build, run the suite, read the changelog for breaking notes, fix the call sites that moved. If the suite goes red, it still opens the change request, with the failures in the description instead of a green claim.
Job 04
The same change across two hundred files
One rename, one API move, one lint rule switched on. Trivial per file, painful at scale. It works through them file by file on its own branch and lands one diff you can review.
Job 05
Last night’s exceptions, grouped
It reads the errors the day threw, groups 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.
Job 06
Docs that drifted from the code
It compares what the docs say against what the code does. Then it fixes the doc to match the code, or flags the code as the thing that is wrong. Both are the same kind of commit, because everything is a file.
02What comes back
A diff on a branch, with the suite already run.
An engineering session hands back the thing engineers already review. No new format to learn and 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);+});
2 files · +7 −1 · 214 tests pass
You review the change, not a report about it
The agent commits on the session branch and opens a change request against main. What reaches review is a diff with a description, the same thing a teammate would have sent you.
It ran before you read it
The sandbox is a real Linux machine, so the agent installs, builds and runs the suite itself. If the change request arrives red, the description says so instead of claiming green.
One branch, one machine, no collisions
Sessions never share a working tree. Twenty of them can work the same repo at once, each on its own branch and its own computer, without stepping on each other.
03Where it reaches
The repo, the tracker, the thread.
Engineering already has the most reach of any team, because most of the work happens inside the repo the session cloned. Connectors cover the rest, and every credential is resolved on our side, never inside the machine.
The repo itself
Cloned into the sandbox when the session starts, on a fresh branch. The agent has a shell, a filesystem and the full history. It can bisect, run the suite, and read the commit that introduced the line it is about to change.
GitHub
Read issues, comments and branch state, and write back where you allow it. Machine opens the change request itself. The connector handles everything around it.
Linear
Pull the ticket that started the session, read the acceptance criteria, and post the change request link back when the work lands. The ticket stays the source of truth for scope.
Slack
The live channel. Mention the bot in a thread and that thread becomes a session. The answer, and any file it made, comes back to the same thread. Teams is built in too, but stays off until your deployment turns it on.
Your own services
Point Machine at an OpenAPI or Postman spec, a GraphQL endpoint, a remote MCP server, or a plain HTTP base URL. It reads the source, works out the auth, and turns every operation into a tool the agent can call.
Easy connect covers 3,000+ apps through their own OAuth screens. Anything outside that catalogue is reachable through MCP, OpenAPI, GraphQL or raw HTTP. For an internal service that is usually the real answer anyway, since it never had a catalogue entry to begin with.
04How it runs
Ask now. Watch the ones that matter. Sleep through the rest.
The same session, started three ways. The isolation and the review path stay the same whatever starts it.
01 · On demand
From the thread you are already in
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 instead of a bot post, and the reply lands in the same thread.
02 · Human-assisted
It stops where you told it to
Set an action to Ask and the run pauses at that call, showing you the action and its arguments. Approve it and the same call completes, and the session picks up exactly where it stopped.
03 · Automated
On a cron, or off your own alerts
Triage the overnight exceptions at 06:00. Or point your alerting at a signed webhook, so a paging event starts a session with the incident payload already in the prompt.
05Control
Nothing merges itself.
The real question about an autonomous engineer is not what it can write. It is what it can land. Here is the exact answer.
01
Merge is default-deny
An agent cannot merge to main. The permission exists: an admin can grant project.cr.merge. But the grant lives in your project config, so widening it is itself a change someone reviews. There is no hidden default.
02
Approval gates are off until you set them
The shipped default is permissive: actions run unless you say otherwise. Set Ask on the ones that should pause and Block on the ones that should never happen, per action or with one pattern rule. We would rather tell you the real default than let you assume the safer one.
03
Each session is walled off from the others
One disposable Linux machine per session, on its own branch. The only thing truly shared is the world outside, which is why connectors, not the machine, decide what an agent can reach.
04
Connector credentials stay out of the machine
The sandbox carries one project-scoped Machine token and no third-party keys. The gateway decrypts the real credential server-side and attaches it to the outgoing call. A runtime secret you choose to grant is different: it is a real environment value the agent can read, by design.
05
Every tool call is written down
The gateway that resolves the credential also writes the record: the action, the agent, the person or trigger behind the session, the outcome, and who released a held call.
06Other teams
Same machine. Every other team.
One project, one set of connectors, one memory that keeps growing. Each team writes the skills for its own work. Nobody builds a second system.
- SalesResearch, drafts and CRM cleanup, held for your yesOpen
- MarketingProduction work in your voice, because the voice is a fileOpen
- ProductFeedback turned into specs, with the evidence attachedOpen
- FinanceThe close, the reconciliation and the variance note, with the working shownOpen
- PeopleScheduling, kits and onboarding, never the hiring decisionOpen
- ITRunbooks that run, and a platform that passes your reviewOpen
- Data ScienceA real machine, a real query, an analysis you can re-runOpen
- All solutionsEvery team on one page, plus the rules that never change between them.Open
Engineering
Give it the ticketnobody picked up.
One governed platform for engineering agents. Any model, your keys. Every action recorded.
- One machine per session
- Lands as a change request
- Every action recorded