I've been running several Claude Code sessions in parallel on one project (the automation stack of my family's business), and two things kept going wrong:



1. I couldn't tell which session was sitting there waiting for my permission. From a phone it was hopeless.

2. Sessions overwrote each other. One would rewrite a whole file while another was halfway through a patch in that same file.



So I built a small control room:



**• Live terminals in a browser grid** (tmux + ttyd). Close the tab and the sessions keep running. Works from a phone.

**• State from Claude Code hooks.** Each tile shows working, idle or waiting for your permission, and a red badge takes you to the one that needs you. No screen-scraping, so it doesn't break when the CLI's UI changes.

**• A shared board with hierarchical locks** (slog). Every session sees what the others are doing and can claim a resource or just part of it: api:auth and api:billing run side by side, but taking api warns you if either is held. The agents follow it because their [CLAUDE.md](http://CLAUDE.md) tells them to.

**• Skills that survive the session**. A small structure plus a skill-sync step, so what one session learned doesn't die with it.



No frameworks: bash, the Python standard library and one HTML file. Free and MIT licensed.



**Try it without installing anything**: the README has an "Open in Codespaces" button. It builds in about 2 minutes and the port is private to your GitHub account.



Repo: [https://github.com/Ramillax/claude-code-control-room](https://github.com/Ramillax/claude-code-control-room)



**How I built it**: it grew out of my own setup, one problem at a time. First a browser grid of tmux sessions so I could check on them from my phone. Then Claude Code hooks for the state, after trying to scrape the terminal and watching it break every time the CLI changed. The lock board came after two sessions clobbered the same file: I had Claude write slog as a plain Markdown file plus flock, so any session can read it with one command and nothing gets loaded into context automatically. Locks are advisory on purpose (they warn, they don't block), because a hard lock left behind by a crashed session is worse than a warning. The last step was stripping everything specific to my stack to publish it, and adding the Codespaces setup so people can try it without installing anything. Most of it was written with Claude Code, running inside this same control room.



**How do you handle this?** If you run parallel sessions, how do you keep them from colliding: worktrees, one session per repo, something else?



(The screenshots come from a staged demo: real Claude Code screens and real slog commands, with the state events fired by hand. If you self-host, it ships with no auth on purpose, so put your own login in front; the README explains how.)

I run up to 6 Claude Code sessions on the same codebase. I built a control room so they stop stepping on each other (open source)