What if I remove the chat window or hidden logs from an agent and do the thinking via files and folders instead?
When an agent works through a chat window, you see the input and the output. Everything in between is a black box.
The rules:
- No direct communication between agents
- No chat as primary interface
- The filesystem is the interface
Build multi-agent system with filesystem coordination
We are using gstack to run an experiment with multiple agents.
Goal: Build a multi-agent system where agents coordinate through the filesystem only.
Requirements:
Define at least 3 agent roles: planner, executor, reviewer Agents must communicate only via files in shared folders (queue, doing, blocked, done) No direct messaging between agents Each agent must log its actions in the filesystem Keep the system simple and observable Steps:
Analyze the gstack repo structure Propose a minimal architecture for this setup Implement the agent roles and workflow Create one example task and run it through the system Leave all artifacts in the repository for inspection Keep chat output minimal and prefer file-based outputs.
Additional constraints:
Prefer many small file updates over one large write Update logs frequently Move tasks explicitly through queue, doing, blocked, and done Rename task files to reflect state transitions where useful Keep all coordination visible in the filesystem
I had 3 agents set out to work, all with their own role: a planner, the executor and a reviewer. They shared a folder structure and I had one common goal for them all dropped in the queue. When started tasks appeared and structure was formed.
After I gave Claude Code the go-ahead to start working the actual files and folders started to move. It gave me a feeling of awe as the system became alive to me.
The planner created multiple task files. The executor picked them up one by one and the reviewer approved or rejected them.
Every file becomes a frame in the timelapse. This way you see the tasks move through the system while they are being completed.
The structure was great, but because each of the move and creation of the files had to be allowed in Claude Code it became a lot of work. This slowed the process down massively. So the filesystem-as-interface created visibility but also friction.
Another thing I did not expect, I now had more insight in the moving parts but no real urge to actually look what was done in the files. So the experiment worked, but I fixed something I didn’t need. This is a recurring theme in my experiments.
The whole experiment made it feel less like a prompting exercise and more like operating a system.
Key Insight:
Instead of logs, you can literally watch the system think with files and folder structure. These kind of esoteric things like a living filesystem make me happy.