I Just Wanted Two Terminals to Talk to Each Other
The thing that started the-bureau wasn't a vision for agent orchestration. It was a Linux box I didn't want to babysit.
Nobody sets out to build an agent orchestration engine. Mine started with a simpler itch: I wasn’t thinking about DAG schedulers or task graphs or quality gates. I just wanted to know when my Linux box was done with something.
But I’m getting ahead of myself.
The rabbit hole
A few weeks before any of this, I was doom-scrolling Instagram and landed on one of those agentic workflow videos. You know the ones. Someone’s pipeline catches an error, dispatches an investigation agent, hands off to a fix agent, creates a PR, waits for human review, deploys — and the loop continues. The specific vision that stuck with me was this: those pesky null-check bugs that slip through because someone was tired. A pipeline that just… handles them. While you sleep.
I went deep. n8n, LangGraph, CrewAI, every orchestration tool I could find. n8n worked — but it produced just as many issues as outputs, and the part that bothered me wasn’t the bugs — it was that every quality gate had to be specified manually, per workflow. You had to remember to wire in the checks. If you forgot, the pipeline trusted itself. That’s not a tool I can walk away from.
Then I hit Directed Acyclic Graphs, and something clicked. Simple enough to sketch on a napkin. Tasks, dependencies, a clear execution order. No cycles, no ambiguity about what runs when. I couldn’t stop thinking about it: imagine telling a voice assistant to coordinate building a product launch page, with the details in OneDrive, and the-bureau just… handles the delegation. Figures out the graph. Runs it.
That was the dream. What I actually built first was considerably more humble.
The actual problem
I had a small LLM demo I wanted running on my homelab Linux box — testing some local inference, nothing fancy. The kind of task where you kick it off and walk away. The problem was I also had work to finish, and I was sitting in front of my main machine, not the Linux box. I didn’t want to keep switching terminals to check on it.
I just wanted the Linux machine to be able to tap me on the shoulder through Claude. “Hey, I’m done. Hey, I need to know X.”
Redis Streams I already knew well. A peer registry wasn’t hard — just keys with TTLs, sessions registering themselves with a heartbeat. Messages over streams, a spawner that could reach a remote Claude session. A few hours of work, spread across an evening and into early morning.
Two terminals
By 2am on April 1st, I had two tmux windows open. One Claude session running on the Linux box. One running on my main machine in front of me.
I sent a message from the remote session.
It arrived.
“Hey, remote Claude wants to know x.”
That was it. That was the whole thing. Two disjointed terminals, Redis in the middle, passing messages between two Claude sessions running on different machines. It shouldn’t have felt like much. It was barely a demo. But I sat there for a moment and didn’t close the terminal.
What that moment actually was
The practical problem I’d set out to solve — I wanted my Linux box to ping me — was solved. Done. I could have stopped there.
I didn’t, obviously. Because sitting in front of those two windows, the thought that arrived wasn’t “great, that works.” It was: what if the sessions weren’t just talking to each other? What if one of them was coordinating the other? What if there were ten of them? What if the work between them was structured as a graph?
The rabbit hole from the Instagram video suddenly had a floor to stand on. This wasn’t theoretical anymore. Two terminals were talking. I had a wire I could build on.
I called it the-bureau that night, mostly because I needed a name and it felt like what it was becoming — a coordination layer, something that dispatched work and tracked what came back.
What it would actually become — a DAG scheduler, a task engine, something running in k3s handling concurrent agents with quality gates baked in at the engine level — I had no idea yet. That’s the next part of this story.
For now: two terminals. One Redis instance. One message that arrived when I didn’t expect to feel anything about it.
That was enough.