Blog
Visibility, Approvals, and Auditability for Multi-Agent Coding Workflows
The supervision problem
If you have spent time with Claude Code or similar terminal-based coding agents, you have probably seen the same pattern: one agent is waiting for approval to run a command, another is blocked on a question you missed, and a third finished ten minutes ago in a tmux pane you have not looked at since lunch. With one agent, this is manageable. With several agents running in parallel, it becomes a supervision problem.
The interesting question is no longer just whether one agent can write useful code. It is what happens when one developer is supervising several active agent workstreams at once. In terminal-heavy workflows, the control layer starts to break down before the model does.
A typical breakdown
A common failure mode looks like this. Agent A is running tests in repo 1 and asks for permission to read a few more files. Agent B is working in repo 2 and asks a clarifying question you do not notice for several minutes. Agent C is in repo 3 and is ready to edit config or run a more sensitive command. All three events arrive as terminal text in different panes.
You now have to maintain visibility across active workstreams, respond quickly enough that agents do not sit idle, and distinguish routine requests from the ones that deserve real scrutiny. Miss one prompt, approve the wrong thing, or lose track of which pane matters, and the system stops feeling like leverage and starts feeling like operational drag.
What breaks when you move from one agent to several
With one agent, a raw terminal interface is often good enough. You can watch the output, answer questions as they come in, and reconstruct what happened from recent context. With several agents running in parallel, four problems show up quickly.
First, you lose visibility across agents. Every agent lives in its own terminal or tmux pane, and there is no single place to see who is working, who is idle, who is blocked, and who needs approval now. Staying in control becomes a polling loop.
Second, human response time becomes the bottleneck. Agent throughput can increase faster than a single developer's ability to review requests and answer questions. The system may look fast because several agents are active, while the actual limiting factor is the person trying to keep up.
Third, safe and risky requests arrive with the same weight. "Read this file" and "run a destructive shell command" should not create the same mental overhead. In practice, terminal prompts often flatten that distinction, so you spend attention on low-risk requests while also trying not to miss high-risk ones.
Fourth, terminal history is not a usable audit trail. When something goes wrong, scrollback can help, but it is not a clean record of which requests were auto-approved, which were explicitly denied, what changed while you were away, or which agent asked for what.
Some developers solve this by running with --dangerously-skip-permissions — full speed, no interruptions, no safety net. Others approve everything reflexively without reading. Both are rational responses to a broken feedback loop. The real problem is that the feedback loop itself needs fixing.
Existing tools help with execution more than supervision
Developers already use tmux, shell scripts, and wrappers to run more than one agent at a time. Those tools help with execution and concurrency, but they do not really solve the supervision problem. They do not give you a unified status view, centralize queued questions, separate routine approvals from risky ones, or leave behind a clean audit trail.
In other words, they help you run more agents, but not necessarily manage them safely.
What a control layer needs to do
Once multi-agent workflows become normal, the missing piece is a control layer built around practical questions: which agents are active, which ones are blocked, which approvals are routine enough to flow automatically, which actions need explicit human review, and what happened across the system while you were not watching.
That implies a few concrete requirements: one place to see status across agents, one queue for questions and approvals, a clear distinction between routine actions and risky ones, an audit log of approvals and denials, and fast navigation back to the relevant terminal context.
Where ACTower fits
ACTower is our attempt to build around that problem. It wraps around tmux-based agent workflows and provides a control layer rather than another agent runtime. Concretely, it runs locally around tmux sessions, centralizes questions and approvals, records decisions into an audit log, and provides fast re-attachment to the relevant tmux pane when you need the full terminal context.
The goal is not to replace the underlying agent tools. The goal is to make parallel agent workflows easier to supervise. In practice, the useful parts are simple: a unified view of agent states such as WORKING, IDLE, QUESTION, and HAS ACTIVITY; a centralized queue for questions and approvals; auto-approval for low-risk actions (file reads, git status, grep) and explicit human review for higher-risk ones; an audit trail that is easier to inspect than scrollback; and fast return to the relevant tmux session.
Why this matters
Most discussion around coding agents still focuses on raw capability: which model is better, which agent writes better code, and which prompt or setup gets the best output. Those questions matter, but they are not the only ones that matter.
As developers start running more concurrent agent workstreams, the harder problem becomes maintaining visibility, response time, and trust. If the control layer is weak, then more capable agents can increase operational mess rather than reduce it.
The question we keep coming back to is not just "how capable is the agent?" It is "how well can a human supervise several of them at once?" That is where visibility, approvals, and auditability stop feeling like nice-to-have features and start looking like infrastructure.