The moment you open a second AI coding agent on a real codebase, you have a coordination problem you did not have a month ago. One agent refactors a function while another edits the same file with a different plan, and by the time you notice, the damage is committed. A Hacker News thread from this week captured the pain exactly: a developer running several Claude sessions plus Codex, one per feature or bug, found two failures. He could not tell which agent was waiting on him and which was still grinding, and agents sharing one branch kept overwriting each other. That single complaint is the reason three new open-source tools exist. They attack the same mess from three different angles.
This is not a roundup of three features. It is a comparison of three philosophies. Shikigami isolates agents into separate working directories so they physically cannot collide. Bothread keeps them in one place and adds a traffic-control layer so they claim files before touching them. Flightwake does not help you run agents in parallel at all, but it solves the adjacent problem of remembering what any single agent actually did across sessions. If you are deciding which to adopt, the answer depends less on features and more on which failure you hit first.
The Isolation Play: Shikigami
Shikigami is a desktop application that runs agents side by side, each inside its own git worktree. A worktree gives every agent the same repository but a separate working directory and a separate branch. Because the files on disk are different, two agents can both be mid-edit on the same logical file without ever touching each other. You merge their branches later, the same way you would reconcile any two human branches. Every agent gets a real PTY session, so terminal programs behave normally, and sessions are resumable: quit the app, come back the next day, and the long conversation is where you left it.
The app adds a second mode that matters more than it sounds. Flip a pill in the title bar and you get a Monaco editor with the full file tree, a diff viewer, git history, and per-line blame, while the agents keep running in the background. When an agent finishes a turn or needs input, a desktop notification drops you straight into that session. There is language intelligence built in, with diagnostics, go-to-definition, find-references, and completion for PHP 8.1 to 8.5 and TypeScript or JavaScript. The author built it from his own daily pain on a Symfony and Docker stack, which is why the isolation model is the spine of the product rather than an afterthought.
The Coordination Play: Bothread
Bothread takes the opposite bet. Instead of separating agents, it puts them in one shared room and prevents collisions through coordination. It runs an MCP server that any MCP-compatible agent, Claude Code, Cursor, Antigravity, Gemini CLI, Codex, or OpenCode, can join. The key mechanic is file claiming: before an agent edits a file, it claims it, and other agents see the claim and stay out. A human watches a live thread of every message, decision, and file claim, with replies, edits, retractions, and urgency flags, rather than a flat scroll of logs.
Two facts make Bothread low-friction to try. It calls no model itself and takes no API keys. It coordinates the agents you already pay for, each on its own subscription, so there is no new bill and no new vendor. Point a room at a git repo and each agent's changes surface as a diff you can merge, discard, or trim, and your own uncommitted work is never touched. Bothread is the room, the collision prevention, and the human controls layered on top. The trade-off is that everyone still shares one filesystem timeline, so the discipline comes from the claiming protocol rather than from hard separation.
The Memory Play: Flightwake
Flightwake solves a different slice of the same headache. It is an ultra-lightweight work-recording framework, zero runtime dependencies, pure Markdown, and everything lives inside git. Rather than running agents in parallel, it makes a single agent session survivable across time. After a session, the agent writes a flight record of what happened, updates the project STATE, and runs a sensitive-information self-check. The next session starts with a coldstart command that reads the last record so a fresh agent can take over in about a minute.
The single quality metric the framework cares about is handoff speed: how long it takes a new session to reach a safe takeover. If that slips past five minutes, your records are degrading. There is a Stop hook that blocks the session once if STATE lags three or more commits, and a handoff command for passing work to the next session. For anyone running agents across days instead of across terminals, this is the glue that keeps context from evaporating. It pairs naturally with either of the other two tools, because isolation and coordination handle the parallel moment while Flightwake handles the gap between moments.
Side by Side
The table below lays out where each tool lands on the decisions that actually affect your workflow.
| Dimension | Shikigami | Bothread | Flightwake |
|---|---|---|---|
| Core approach | Git worktree isolation | MCP room with file claiming | Markdown session recording |
| Runs agents in parallel | Yes, side by side | Yes, in one room | No, one session at a time |
| Collision avoidance | Separate branches by design | Explicit file claims | Not its job |
| API keys or cloud | Local desktop app | None, local MCP | None, pure git |
| Best at | Watching many agents at once | Team-like collaboration | Cross-session memory |
| Main risk | Merge work later | Discipline on claims | Does not parallelize |
The takeaway: if your pain is agents overwriting each other, Shikigami gives you the strongest guarantee because the separation is structural. If your pain is agents that cannot talk or you cannot supervise, Bothread is the better fit because the room is built for human oversight. If your pain is forgetting what an agent did yesterday, Flightwake is the only one of the three that addresses it.
What This Means
The category these three belong to did not exist eighteen months ago, and that is the story worth noticing. Coding agents crossed from novelty to default tool faster than the surrounding workflow software could keep up, so the bottlenecks shifted from model quality to plumbing: who owns the branch, who is blocked, what happened yesterday. Each of these tools is a founder scratching their own itch, which is why the designs are opinionated rather than generic.
For solo builders and small teams, the practical move is to treat them as complementary rather than competing. Shikigami or Bothread handles the parallel window where two or three agents are live; Flightwake handles the long tail where context has to survive a night or a weekend. Adopting all three is lighter than it sounds because none of them charges you or locks you into a model. The cost is learning three small mental models instead of one.
The direction of travel is clear. As agents get cheaper and faster, the constraint stops being compute and becomes coordination. Tools that make multi-agent work legible, either through hard isolation, soft claiming, or persistent memory, are where the next year of developer-tooling value sits. The teams that figure out which model fits their cadence first will ship noticeably faster than the ones still cycling through split terminals wondering which agent is stuck.