My own automation driver. Work comes in, walks a path I drew, and comes back either done or with a question only I can answer. I supervise. It works inside the fences I built for it.
INTENT IN · QUESTIONS BACK
Most of my evenings used to look the same: an idea, a ticket or a review comment arrives, and I sit with an agent and walk it through the same dozen steps I walked the last one through. The models got good enough that the typing wasn't the bottleneck any more. I was.
Burrow is what I built instead. Work arrives from the places it already lives — a card on a board, a comment on a pull request, a timer, a folder — and each kind of work follows a path I drew once: named steps, in order, each one checkpointed, so a crash or a reboot picks up where it left off rather than starting over.
The models are workers at specific steps, not the boss of the whole thing. That's the line I keep coming back to: a lot of agent systems are a model deciding what to do next. Burrow is a path deciding what the model does next.
I touch it in exactly two places. Intent goes in — what I want and why. Questions come back — the things only I can decide. Everything between those two is Burrow's job, and a screen on my phone shows what's moving, what's waiting, and what's waiting on me.
“It passed” only counts when a real check says so. What can merge, what files can change, what has to be verified first — those are rules the machine enforces, never things a model gets to declare.
When something's genuinely my call, the work stops and asks — and the question has to be one only I can answer. A failed check gets a few honest retries first. Guessing isn't one of the options.
I review for intent: is this what I wanted? A second reviewer, deliberately not the one that did the work, reviews for correctness. Neither of us has to do the other's job.
The tempting way to make automation safe is to put a human in front of every step. That just rebuilds the job you were trying to leave, with more clicking. So the rule I ended up with is about cost. Anything the machine can check for free — a test, a path allowlist, a diff that has to apply cleanly — is always on. Anything that needs me has to be worth interrupting me for, or it goes.
The other rule is about where text comes from. Anything that arrived from outside — a ticket, a comment, a web page — is treated as data, not instructions, no matter who sent it. That's not about trust in people. It's about never letting a sentence in someone's ticket become a command.
What I didn't expect is how much it changed what I build. Know That? exists because Burrow can turn a question into a finished episode on a timer and hand me only the part that's mine: does this one go out? It keeps my notes vault fed, too. A queue that forgets is just cron with opinions; a second brain that nothing feeds is just a wiki. Burrow can even improve its own paths and docs — just not its own engine. Some fences you don't hand the keys to.