Parallel coding agents need more than separate terminals
Separate terminals make agents easier to watch. Reliable parallel work also needs explicit ownership of files, processes, shared services, and integration.

Imagine two coding agents working on the same application. One changes an API response. The other builds the screen that consumes it. Each has its own terminal, its own instructions, and a convincing completion message.
The screen still breaks when their changes meet.
Separate terminals make activity visible. They do not establish who owns a file, which version of a contract each agent is using, or whether the combined application works. Those are coordination decisions the surrounding system has to make.
In Hive, I approached this through persistent terminal sessions, visible agent status, and optional Git worktrees. In ForgeLoop, the focus extends to bounded tasks, integration, verification evidence, and human review. They address different parts of the same problem: making concurrent work understandable enough to supervise.
Start with the shared state
Before splitting a task, identify what the workers can change. Source files are the obvious answer, but the list can also include a development database, generated clients, local ports, build output, and external accounts.
Consider two agents running integration tests against one database. Separate checkout directories will not prevent one test from deleting records the other needs. The filesystem is isolated; the test environment is still shared.
For each resource, choose an ownership rule. Give it to one worker, create a separate instance for each worker, or coordinate access explicitly. If none of those options is practical, run that part of the work sequentially.
This is also a useful way to decide whether parallelism is worth introducing. Two changes in independent packages may be straightforward to separate. Two changes to the same evolving data model may spend more time waiting on each other than they save.
Worktrees separate edits, not meaning
Hive can start a terminal in a fresh Git worktree and branch. That gives an agent a separate working directory and makes its changes easier to inspect independently. It also warns when agents share a directory, because separate panes can otherwise hide a shared filesystem.
There is still a contract problem. An API agent might rename status to state, while a UI agent keeps reading status. Both branches can be internally consistent. Git may merge them without a textual conflict because they changed different files.
For that task, I would establish the response shape first, then split the implementation around it. If the contract must change, the dependent task needs an explicit update. A clean merge only tells us that Git could combine the text.
The task boundary should say what a worker owns, what it depends on, and what it must leave alone. “Build the frontend” is less useful than “Implement the job list against this response shape; leave the API schema unchanged.”
Give running work a clear lifetime
A long-running agent should not accidentally depend on whether its terminal interface stays open. Hive separates the interactive client from a background daemon that owns the pseudo-terminals and processes. Closing the interface can leave the work running; reconnecting restores a terminal snapshot before live output continues.
That guarantee has limits. In Hive, a running process can survive a client disconnect, but it does not survive a daemon restart or a machine reboot. Restoring a session and resuming an agent's supported conversation flow is a different operation from keeping the original process alive.
Making that distinction visible matters. A user deciding whether to close a window needs to know whether work continues, pauses, or ends. The implementation and the interface should tell the same story.
Treat status as a request for attention
When several agents run at once, the scarce resource often becomes the developer's attention. Which session needs input? Which has stopped? Which result is ready to inspect?
Hive exposes working, needs-input, and done states. These help a person decide where to look next. A done state is not evidence that a patch meets its requirements; verification belongs to a separate step.
Input ownership matters here too. If multiple windows can observe one session, they should not silently send competing keystrokes. Hive makes control explicit so observation and interaction have different meanings.
The broader design principle is to keep activity, control, and correctness separate. A busy agent may be stuck. An idle agent may need approval. A finished agent may have produced a change that still fails review.
Verify the combined result
Suppose each worker passes its checks. Those results describe the versions and environments the workers tested. After integration, the combined application needs checks of its own.
For the API and UI example, that means exercising the request from the screen through the service and confirming that the returned data is rendered correctly. Unit checks on either side remain useful, but neither alone establishes that the two implementations agree.
ForgeLoop's delivery model puts integration and verification before the human review boundary. The important idea is to preserve enough evidence to answer a concrete question: what was checked on the change I am about to accept?
I would want a handoff to identify the integrated revision, the requirements examined, the results, and anything still awaiting judgment. A reviewer should not have to reconstruct that from several terminal histories.
Choose concurrency you can explain
My starting point for parallel agent work is a small set of explicit responsibilities: isolated edits where possible, clear ownership of shared resources, visible dependencies, and a reviewable integration step.
Add another worker when its task can be separated and its result can be checked. Keep a step sequential when the next decision depends on the previous result. The useful measure is whether the workflow produces a coherent, verifiable change with less coordination effort, not how many terminals are active.
That is the part of agent tooling I find most interesting to build: the systems around execution that help a person understand what is happening, recover from interruptions, and decide what to trust.