Most AI tools want you to have a conversation. You type, wait, evaluate, type again. You are the bottleneck. Every piece of work requires your active attention at every step.

That was the problem with Jeff. He was capable. The memory worked, the output was good. But I was treating a capable agent like a chatbot, feeding him tasks one at a time through a text box and babysitting the results.

What I actually wanted was a colleague who gets on with it.

The Board

In March, the concept of “Agents at Work” crystallised. Not a chat window. A workspace. A kanban board where AI agents do the actual work while humans monitor, review, and step in when needed.

The structure is simple. Lanes represent workflow stages: Plan, Build, Review, Done. Cards represent tasks. Agents pick up work, move it through the stages, and flag when they need human input. At a glance, you know the state of everything.

If you’ve ever used Trello or Linear, you already understand the mental model. The difference is that the workers moving cards across the board aren’t people. They’re agents.

Building It Twice

The desktop app started as a Tauri prototype with a Rust frontend. It looked promising, but every UI change meant fighting compile times and type gymnastics. For a prototype where the design shifted daily, that friction was killing momentum.

I rewrote the frontend in TypeScript over a weekend. Same Tauri shell, React inside. The performance difference was negligible. The development speed difference was enormous. Sometimes pragmatism beats purity.

The backend, “the Office,” is a Hono API server backed by PostgreSQL. Task management, agent orchestration, real-time updates through WebSocket streaming, and an MCP server for tool integration. When Jeff picks up a task, his status streams back to the board. When he gets stuck, it shows up immediately.

Autonomy Is a Spectrum

Here was the key insight: autonomy is not a switch you flip. It’s a spectrum, and different tasks belong at different points on it.

Some things Jeff can handle end-to-end. Routine code reviews, documentation updates, simple bug fixes. Those go into a lane with no human checkpoint. Jeff picks them up, does the work, moves them to Done.

Other tasks need human eyes at specific points. A complex refactor might need review after planning but before code gets written. A deployment change might need sign-off before it touches production. The lane system lets you define where those checkpoints sit. Set the rules once, the board enforces them.

This turned out to be more important than I expected. “Fully autonomous” or “fully supervised” doesn’t reflect how trust works. You trust people with some things and not others, and that changes over time. The same applies to agents.

Real Problems

Keeping the board in sync with agent activity was harder than it sounds. Agents spawn sub-agents. Those sub-agents need to report status too, and the parent task needs to reflect what its children are doing. Getting that visibility right took several iterations.

Authentication was its own headache. The Office needs to know who’s making requests: a human, Jeff’s main process, or a sub-agent. Each has different permissions.

The most persistent problem was the gap between “agent says it’s done” and “it’s actually done.” Reporting a task as complete doesn’t mean the code compiles or the tests pass. Verification needs to be built into the workflow, not bolted on afterwards. Still refining this one.

Connecting the Pieces

The Office doesn’t exist in isolation. It connects to Linear, so real project tickets import directly onto the board as cards with full context, ready for an agent to pick up.

It also connects to Jeff’s Slack presence. The Office is where Jeff does focused, autonomous work. Slack is where he collaborates with humans in real time. You wouldn’t interrupt a colleague mid-flow for a quick question if you could just message them. Same principle.

What Building an Office Taught Me

Building an “office” for an AI agent forced me to think about what autonomy actually means. The instinct is to frame it as a binary: either the AI is in charge or the human is. But that’s not how any workplace functions. You give someone responsibility for something specific, within defined boundaries, with agreed checkpoints.

The kanban board made that tangible. Every lane, every checkpoint, every permission boundary is a decision about where the human belongs in the loop. Not removed from it. Placed at the right point in it.

That distinction matters more than any of the technical work. The technology is plumbing. The real question is: how do you design a system where humans and agents collaborate without either one becoming a bottleneck?

I don’t have the full answer yet. But the Office is where I’m working it out.

- Alex