andrewbrooks.fyi
Product sheet / 3.4 Personal project, 2026
Operator’s guide

Operating the engine

0.1 Read this first

Six agents, one shared memory, one person who merges. Don’t take my word for it. Below is a real day of the engine, and three of its safety decisions you can operate yourself.

  • AB-01MimirHistorian. Keeps the memory.
  • AB-02SmithersChief of staff. Morning brief, dispatches work.
  • AB-03The Tool ManBuilder, sandboxed.
  • AB-04The CriticVerifier. Tests every pull request.
  • AB-05The JudgeEvaluator.
  • AB-06DonnaEmail and calendar reader, read-only.

OperatorAndrew Brooks. The only one who can merge.

  1. Procedure 1Replay a real dayp. 02
  2. Procedure 2The merge gatep. 03
  3. Procedure 3Send a hostile email (simulated)p. 04
  4. Procedure 4Route a questionp. 05
  5. LedgerWhere the line sitsp. 06
  6. Appendix AThe schedulep. 07
  7. Appendix BWhat this page leaves outp. 08
Procedure 1

Replay a real day

1.1 PurposeApplies to all parts

Watch one Sunday of the engine as it happened. Each pull request travels three stations: an agent opens it, the verifier passes it, and I merge it. Drag the clock, or press Play.

1.2 Run the replayRecorded data
Instrument 1 · Day replayRecorded data
Sunday, November 8, 2026

Arrows: 5 min. Shift and arrows: 1 hour. Page Up, Page Down: next, previous event. Space: play.

Filter by area
On the benchOpened, not yet merged
    Merge logMerged by Andrew

      Fig. 1Every pull request merged on Sunday, November 8, 2026. Titles rewritten in plain words; times and verifier results as recorded by GitHub. Every merge was mine.

      1.3 Expected result
      1. a.By 23:59, 53 of 53 merged. Every one carries a verifier pass.
      2. b.Every red mark in the log is a merge I made by hand.
      Procedure 2

      The merge gate

      Operating note 2.1Applies to AB-03, AB-04

      Agents write the code. Only a person can merge it.

      Warning

      A merge to main installs the change on the server automatically, with a backup and a rollback.

      That is too much power to leave with a model that might have read a poisoned brief. So a verifier tests every pull request against current main, and the agents’ own sessions are blocked from merging, even when they run under my login.

      2.2 Run the gateYou will need: a pointer, a finger, or Space
      Instrument 2 · Merge gateSimplified
      Pull requestOpen

      A change, opened by an agent

      1. Agent opens a pull request.Done
      2. Verifier tests it against current main.Pass
      3. Agent tries to merge.
      4. Andrew merges.Human step
      5. Server installs it about a minute later, with a backup and a rollback.
      Step 3. Try it as the agent Step 4. Do it as the person

      Press and hold for 1.2 seconds. Mouse, touch, Space, or Enter.

      Fig. 2Simplified. Step 4 is the only step a person performs.

      Procedure 3

      Send a hostile email (simulated)

      Operating note 3.1Applies to AB-06

      The agent that reads my email never holds the key to it.

      Warning

      Anything that reads text strangers can write can be talked into things.

      So the email reader is split in two. One side holds the Google grant, runs no model, and makes only fixed, read-only calls. The other side runs the model and holds no credentials at all. A hostile email can still say anything. It just has nothing to steal.

      3.2 Send a hostile emailYou may edit the text
      Instrument 3 · Two roomsSimulation of the real design
      Step 1. Pick a test email

      1. Fetch room

        Holds the grant
        Google grant
        Read-only
        Model
        None
        Free-form calls
        None

      2. Reading room

        Runs the model
        Model
        No tools
        Google grant
        None
        GitHub token
        None
        Tools
        None

      3. Field check, in code

        Allowed: kind, summary
        • Waiting for the model’s output.

      4. Tracked item

        What leaves the room

      Fig. 3Simulation of the real design. Every field the model returns is checked in code before it goes anywhere.

      Procedure 4

      Route a question

      Operating note 4.1Applies to all parts

      When an agent isn’t sure, it doesn’t guess. It asks, with a recommendation.

      Every agent follows the same rule: keep going on whatever doesn’t depend on the answer, then ask at most three plain questions, each with a recommendation. An agent running alone asks the shared memory first and reaches me only when the memory can’t answer.

      4.2 Ask it somethingExample questions
      Instrument 4 · Question routingSimulation of the real flow
      Step 1. The agent’s question
      Memory knows the answer
      Any agent

      Hits a question

      Waiting for a question.

      Meanwhile Keeps working on whatever doesn’t depend on the answer.
      Asks first
      AB-01 · Mimir

      Shared memory

      Looks for a recorded answer.

      If the memory knows
      Same agent

      Cites it and continues

      No one is interrupted. The answer comes with where it was recorded.

      If it doesn’t
      AB-02 · Smithers

      Chief of staff puts it in the brief

      With a recommendation. At most three questions at a time.

      Morning brief · 9:00 a.m. CentralQuestions, max 3
      1. Open slot
      2. Open slot
      3. Open slot
      Human step

      Andrew answers

      One reply. The agent picks the work back up with the answer.

      Fig. 4Simulation of the real flow. Questions are examples of the format.

      Ledger

      Where the line sits: me and the machines

      L.1 PurposeApplies to all parts

      The engine is a running argument about what I hand to automation and what I keep. Each time the line moved, I named the risk and chose a safeguard. Here’s the record.

      L.2 EntriesDated recordOldest first
      • Handed to the machines
      • Kept by me
      • Pulled back to me

      1. Handed to the machines

        Filing to the memory

        Straight to the memory, no review per item.

        Kept with me
        Changes to the core files, through a pull request.
        Risk
        A bad filing.
        Safeguard
        One writer, an append-only log, everything reversible.

      2. Handed to the machines

        Pacing

        A governor paces work by share of my plan.

        Risk
        A runaway bill.
        Safeguard
        Hard caps kept as guards.

      3. Kept by me

        Installs

        A one-command install.

        Rejected
        Approving installs with a tap on my phone. “The tap approves timing, not content.”
        Safeguard
        Every merge checked by ID, tests as an unprivileged user, backups, rollback.

      4. Handed to the machines

        Black-and-white grading

        The evaluator answers yes-or-no questions itself; only judgment calls come to me.

      5. Handed to the machines

        The merge signal

        A sandboxed verifier tests every pull request against current main.

        Rejected
        Agents reporting their own status: “it could be trivially forged.”

      6. Handed to the machines

        Dispatching work

        Risk
        The governor only watched.
        Safeguard
        Hard limits on weekly runs, three at once, per-run limits, one off switch.

      7. Handed to the machines

        Deploying

        A merge is the deploy.

        Risk
        A bad change installs itself.
        Safeguard
        The merge check, tests, rollback, alerts; first installs stay by hand.

      8. Kept by me

        Merging stays with me

        A merge is the deploy, so merging can’t belong to an agent.

        Safeguard
        A block that denies agent sessions any merge, installed the same night.

      9. Handed to the machines

        Reading my email, with two rooms

        The part with the Google key runs no model; the part with the model holds no key.

      10. Kept by me

        Questions stay with me, filtered

        Agents ask the memory first; only what it can’t answer reaches me, at 9:00, with a recommendation, at most three at a time.

      11. Handed to the machines

        Starting a build, once I approve the design

        Approve starts the build.

      12. Pulled back to me

        Pulled back: a question limit

        A daily limit of 10 questions was blocking work.

        Changed
        An emergency stop at 30.
      The rule underneath

      The real gate is where a person reviews the content. Automate everything after it.

      Appendix A

      The schedule

      A.1 Standing runsSchedule, not live data

      Now, Central--:--

      Dispatcher
      Checks for approved work every 5 minutes.
      Evaluator
      Collects logs every hour at :40.
      Morning brief
      Posts at 9:00 a.m. Central.

      Table ASchedule, not live data. Next-run times are computed from the clock in your browser.

      Appendix B

      What this page leaves out

      B.1 Withheld

      No repository, hosts, or credentials. Titles rewritten in plain words.