AI Engineer works 02:10 to 23:00.

At 02:10 the checkout error rate tripled. Sam reproduced it in a bubblewrap-isolated worktree, isolated the null case, and opened a pull request with a regression test before the standup that would have assigned it. Nothing merged: a Member reads the diff and merges it, and only an owner or admin can push.

What a human loses today

Your phone goes off at 02:10, and the fourteen dependency bumps nobody has volunteered for since March are still waiting on Monday.

Employee

• Name: Sam
• Discipline: Engineering
• Hours: 02:10–23:00
• Stops: Decision at 13:15

The day · 8 runs · Tuesday

Sam stops once, at 13:15.

Decisions

• 13:15 DECISION

• Picks up the spike nobody is awake for
  Checkout's error rate triples. Sam reproduces the failure in a sandboxed worktree, narrows it to the null case, and opens a pull request with the fix and a regression test attached.

• 08:00 Reviews against your standards, not generic ones
  Reads the open pull requests against the engineering standards written into its Soul. Two break them, and each comment quotes the rule it broke so you can argue with it.

• 10:00 Clears the dependency backlog
  Fourteen packages behind, two of them carrying advisories. It upgrades one package per pull request and runs the suite on each. The one needing a real code change is reported, not bundled in.

• 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 puts the rollback in the same pull request.

• 13:15 Stops at the blast radius
  The fix touches the payment path, and its Soul says that one carries a human's signature. It assembles the diff, the test evidence, and the rollback plan into a Decision, then stops.

• 15:30 Fixes the docs the change invalidated
  Finds the pages still describing the old behaviour and updates them in the same release. Every team has that discipline written into its contributing guide and no time to do it.

• 17:40 Kills the flakes
  Three tests failed intermittently this week. Shared state explains two of them. The third goes into quarantine with an issue filed against it, not deleted.

Tasks

• 23:00 Writes up the day for the humans
  One note covering what shipped, what is in review, and what it could not fix and why. Written while it was happening rather than reconstructed on Friday.

Workspace

• By the end of the day
  • 6 Pull requests opened with tests
  • 14 Dependencies brought current
  • 1 Decision that needed you

What it brought back

• 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?

A Decision is the employee choosing to ask. It writes the question and the options itself, answering one performs no side effect, and any Member can answer it. An Approval is the system holding an action the employee already attempted, and only an admin releases that.

4 things Sam does unattended.

The work happens in the products your team already opens, on the same rows a Member edits. Nothing is exported and there is no second system of record.

Isolated by default

Code runs behind bubblewrap's Linux namespaces, rooted at the work session's own worktree. Your checkout, sibling sessions, and git itself stay outside. 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, and that is the point. The review you already trust is the one that catches it.

Commands you chose

What it may run is a setting on the Repository row, a command mode plus an allow-list, rather than an instruction the model reads. Most sessions never need to run a command 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 all qualify, and the same review flow applies to the ones with no code in them.

Setting it up · 5 skills · 4 routines · 4 grants

4 documents decide how Sam works.

Everything that makes this an engineer rather than another role is plain text you can edit. Change the Soul and the next Run reads the new version.

Soul

One document says how Sam judges: what to work on first, and when to stop and ask rather than guess. You rewrite it the way you would rewrite a job description.

Grants

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

Skills

• reproduce-failure
• open-fix-pull-request
• upgrade-dependency
• review-against-standards
• quarantine-flaky-test

Routines

• Error-rate watch*/10 * * * *
• Review sweep0 8 * * 1-5
• Dependency and advisory sweep0 10 * * 1
• Flaky-test hunt40 17 * * 1-5

3 questions about the AI Engineer.

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.