Why I built a 3D room for my AI coding agents

The day my work became invisible

By late 2025 most of the code I shipped was not typed by me. It was written by AI coding agents in a terminal: Claude Code first, then Codex CLI and Gemini CLI next to it. Anyone who has made that jump knows the strange feeling that comes with it. You hand over a task, the agent starts working, and your screen shows you almost nothing. A spinner. A scrolling wall of tool calls. Maybe a plan, if you squint.

I was responsible for everything those agents did, and I could not see any of it. Not in the way humans mean when they say see. Which files is it reading right now? Is it stuck? Is it running a migration it should not run? Is this the third retry or the thirtieth? The information technically existed in the scrollback, the way a security incident technically exists in the logs.

I started noticing what this did to my behavior. I either hovered over the terminal reading every line, which threw away the entire point of delegation, or I walked away and came back anxious, scrolling up through thousands of lines to reconstruct what happened. There was no middle mode. No way to just glance.

A robot walks to a desk

The prototype was a weekend joke. A low-poly room in Three.js, one procedural robot, one desk. When the agent started a task, the robot walked to the desk and sat down. When the agent read a file, the robot pulled a card out of a filing cabinet. When a command ran, the little monitor lit up. That was all it did.

It refused to stay a joke. Within days I could not go back to bare terminals, because my peripheral vision had learned the room. A robot standing idle when I expected it to be working meant something had stalled or was waiting on my approval. Two robots crowding the same cabinet meant two agents were touching the same part of the codebase. The monitor glowing red meant a command failed. I was not reading logs; I was noticing things, the way you notice a colleague frowning at their screen.

That distinction became the whole thesis. Human attention is terrible at parsing text streams and spectacular at reading spatial scenes. We evolved for rooms, not logs. If agents are going to do the work of a team, the interface should borrow what makes teams observable: bodies, places, posture, motion.

What visibility actually changes

Three things happened when the agents got bodies, and they are the reasons this became a product instead of a toy.

Trust got calibrated. Not higher, calibrated. Watching an agent read the right files before editing builds real confidence. Watching it charge into an edit without reading anything tells you to check that diff carefully. Both are better than the flat, blind trust a spinner forces on you.

Timing got better. Most agent disasters are not evil, they are momentum: a wrong assumption compounding for twenty minutes. When the work is visible, you interrupt at minute two. The room turned my interventions from autopsies into course corrections.

Delegation stopped feeling like anxiety. This one surprised me. A game-like room keeps you comfortably aware without demanding that you read anything. It made running several agents in parallel feel like managing a small studio rather than juggling chainsaws.

What The Termi Protocol is

The Termi Protocol is not a chat app and not an IDE. Real CLI agents run on your machine, in real shells, on your real repositories. The app gives each one a body, a desk and a room, plus the boring infrastructure delegation actually needs: checkpoints you can roll back to, task boards, per-agent memory, and a live view of what each agent costs. Everything the agent does, every file read, every command, every edit, becomes something happening in a place you can watch.

I built it because I needed it, which is still the most honest reason to build anything. If you spend your days handing work to agents and staring at scrollback, wondering what is actually happening in there, it was built for you too.