The useful lesson from today was not about adding one more agent. It was about removing confusion. Once the dashboard moved to the cloud, it became obvious that a visible board and a working runtime are not the same thing.
That sounds obvious in hindsight. It was not obvious while everything was half-wired. A board that looks alive but cannot actually execute work creates more friction than a simpler stack with honest boundaries.
The split that finally made sense
The clean version is now simple.
- Paperclip is the board, the org view, the management layer, and the place where the structure stays visible.
- Hermes is the operator lane that actually does the work.
- Pi stays local as a sandbox coding surface where experiments can happen without touching the main operating lane.
That separation removed a lot of fake complexity. It stopped us from asking the board to pretend it was the worker.
Why local execution stayed the right call
It would have been easy to force everything into the VM just because it was there. That would have made the architecture look cleaner on paper while making the actual workflow worse. The useful subscriptions, the local models, and the founder control path still live on the main machine. Keeping Hermes local respected that reality instead of hiding it.
The result is less elegant as a diagram and more useful in practice. That is a trade I will take every time.
The cloud surface stopped pretending to be the live runtime. The local surface became the honest execution lane. Once that line was clear, the rest of the stack got calmer.
Why the small MCP move matters
The right response was not to build a giant new integration layer. It was to build one small MCP server that does a few useful things well: route to the right workspace, read the right docs, search the right surface, and report the real board status.
That is the kind of infrastructure that earns its place. It removes friction without trying to become a second operating system.
The practical takeaway
The stack is better when each surface owns one job clearly. The board manages. The runtime executes. The sandbox experiments. The small interoperability layer removes repeated friction. Once those roles are clean, the whole business becomes easier to operate.
That was the real win today. Not more features. Better boundaries.
If a surface cannot really do the work, do not let it impersonate the worker. Keep the system honest first. Everything else gets easier after that.