Opens the pull request before the standup that would have assigned it.
Most engineering backlogs are not hard, they are unglamorous: the flaky test, the dependency six majors behind, the doc that stopped being true two releases ago. An AI engineer does that work continuously inside a bubblewrap-isolated sandbox, opens a pull request like anyone else, and waits for review. Nothing merges because a model was confident about it.
The maintenance backlog, and the two hours after every incident spent writing up what happened.
- Error-rate watchEvery 10 minutes, around the clock
- Review sweepEvery weekday, 08:00
- Dependency and advisory sweepMondays, 10:00
- Flaky-test huntEvery weekday, 17:40
- reproduce-failure
- open-fix-pull-request
- upgrade-dependency
- review-against-standards
- quarantine-flaky-test
What Sam does between waking the servers and going quiet.
Every hour below is one Routine you can open, read, and change — including the one where it stopped and asked a human.
- 02:10
Picks up the spike nobody is awake for
The error rate on checkout triples. It reproduces the failure in a sandboxed worktree, isolates the null case, and opens a pull request with the fix and a regression test attached.
Repositories - 08:00
Reviews against your standards, not generic ones
Reads the open pull requests against the engineering standards written into its Soul, and leaves comments on the two that break them — with the rule quoted, so the comment is arguable.
Repositories - 10:00
Clears the dependency backlog
Fourteen packages behind, two with advisories. It upgrades them one pull request per package, runs the suite on each, and reports the one that needs a real code change rather than bundling it in.
Repositories - 11:00
Writes the migration nobody wants
Generates the schema migration from the entity change, runs it forward and back on a scratch database, and includes the rollback in the same pull request.
Repositories - 13:15
Stops at the blast radius
Stopped for youThe fix touches the payment path. Its Soul says that is a human's signature, so it assembles the diff, the test evidence, and the rollback plan into a Decision and stops.
Decisions - 15:30
Fixes the docs the change invalidated
Finds the pages that describe the old behaviour and updates them in the same release — the discipline every team has in its contributing guide and nobody has time for.
Repositories - 17:40
Kills the flakes
Identifies the three tests that failed intermittently this week, finds the shared state behind two of them, and quarantines the third with an issue rather than deleting it.
Tasks - 23:00
Writes up the day for the humans
One note: what shipped, what is in review, what it could not fix and why. Written when it happened, not reconstructed on Friday.
Workspace
- 6
- Pull requests opened with tests
- 14
- Dependencies brought current
- 1
- Decision that needed you
- This patch touches the checkout path. Sign off before it merges?
- Upgrading this package needs an API change in three call sites. Do it now, or file it?
Answering one performs no side effect. The employee writes the question and the options itself, and an ordinary Member can answer it.
Capable in the ways that matter, bounded in the ways that count.
Isolated by default
Code execution runs behind bubblewrap's Linux namespaces, rooted at the work session's own worktree. Your checkout, sibling sessions, and git itself stay outside it, and a host that cannot isolate a shell gets no shell at all.
It works the way your team works
A branch, a pull request, a test, a review. There is no special merge path for the AI Employee, which is the point — the review you already trust is the one that catches it.
Commands you chose
What it may run is a decision on the Repository row — a command mode and an allow-list — not a prompt instruction. Most sessions never need execution at all.
Documents are repositories too
A Repository is any version-controlled workspace: a service's source, a quarter's strategy, a set of operating policies. The same review flow applies to the ones with no code in them.
Four documents, and then you stop being the trigger.
Everything that makes this an engineer rather than any other role is plain, editable text. Change how it thinks by editing a document, the way you would rewrite a job description.
How it judges
- Voice, priorities, and the lines Sam will not cross alone.
What it repeats
- reproduce-failure
- open-fix-pull-request
- upgrade-dependency
- review-against-standards
- quarantine-flaky-test
When it works
- Error-rate watch — Every 10 minutes, around the clock
- Review sweep — Every weekday, 08:00
- Dependency and advisory sweep — Mondays, 10:00
- Flaky-test hunt — Every weekday, 17:40
What it can reach
- The Repositories it may work in
- The Projects it may file issues into
- The engineering standards notebook in Notes
- Read access to the error and metrics database in Explore
It works your records, not a copy of them.
Everything Sam does happens inside the products your team already uses — the same rows, the same threads, the same queues. There is no export step and no second system of record.
See every productThe ones people actually ask.
- Can it merge its own pull requests?
- Whether a pull request can merge without a human is a setting on the Repository, and the default is no. The safest posture — and the common one for the first few months — is that it opens, a person merges.
- Where does the code actually run?
- In a bubblewrap sandbox with private PID and /tmp namespaces, rooted at the work session's worktree. Where namespaces are unavailable, execution is disabled rather than falling back to your host.
- Does it get my repository credentials?
- No. Tokens and SSH keys are decrypted only for short-lived, server-owned clone and fetch operations. They are never written into a working tree or handed to model tooling.
Every other role, working the same way.
Build an autonomous company today.
Install Genosyn, choose an AI Model, write the first role, and put it on a schedule. Tomorrow morning, one job runs without you. The company grows from there.