the two-plane idea here is really interesting -- separating long-lived planners from short-lived workers is a clean mental model.
curious what happens when you're on windows though? tmux + ttal means you're locked out of a decent chunk of potential users.
been building in this space too -- pane (github.com/Dcouple-Inc/Pane) takes a different approach, standalone desktop app, no tmux at all. each pane maps to one worktree + n terminals, agents spin up and tear down cleanly. works the same on windows, mac, linux.
the telegram interface for managing from your phone is a nice touch -- does it block if the manager agent gets stuck waiting for human input?
the way i handle it in pane: every pane is one worktree, and the diff viewer + keyboard shortcuts (squash, rebase, merge) are right there before you ever push. so the review step isn't a context switch -- it's just... the next thing in the same window
the harder problem you're pointing at is agent-to-agent coordination. i don't try to solve that at the orchestration layer. i keep it simple: one agent per feature, and they don't touch each other's worktrees. when feature A needs something from feature B, i merge feature B first. boring, but it doesn't blow up
the ADR / architectural governance point from agilevibecoding.org is interesting though -- have you seen teams actually ship something like that in practice? or is it mostly theoretical at this scale?
i built this because i was running claude code and cursor on the same repo and they kept overwriting each other's files -- that sentence is exactly what motivated pane too.
git-lanes solves the isolation problem cleanly as a CLI layer. pane approaches it from the other direction -- the worktree isolation is baked into the UI model itself (one pane = one worktree), so there's nothing to run or remember. you just open pane, create a pane for your feature, and the worktree exists.
curious if you considered going the desktop app direction or if the CLI-only scope was intentional? there's something appealing about a zero-dependency shell tool.
github.com/Dcouple-Inc/Pane -- fully open source (agpl-3.0) if you want to compare approaches.
the "containers manually vs compose" framing is exactly right -- that's the coordination layer that's missing from raw worktrees.
one thing i'm curious about with chatml: how's the experience on windows and linux? you mentioned it's running but with bugs. i built pane specifically because conductor and most of the other tools in this space were mac-first (or mac-only), and a huge chunk of the multi-agent dev community is on windows or linux.
pane is the same app, same shortcuts, same UI across all three. not "cross-platform eventually" -- ships to all three now. built on xterm.js (same engine as vs code) so terminal compatibility isn't a thing you have to debug.
if anyone on windows or linux is hitting walls with chatml or conductor, pane might be worth a look: github.com/Dcouple-Inc/Pane
the persistent markdown approach to context drift is clever - treating state files as a first-class primitive rather than hoping the agent remembers between sessions is the right instinct.
one thing i've noticed: even with perfect context files, multi-agent setups still hit the physical isolation problem - multiple agents in the same working directory stepping on each other's files mid-session. the context drift and the file conflict problem are separate issues that both need solving.
i've been working on the isolation layer: pane gives each agent its own git worktree (isolated filesystem per feature) so context drift from file collisions is removed entirely. fully open source (agpl-3.0): github.com/Dcouple-Inc/Pane - the two approaches actually complement each other pretty cleanly.
the "45 minutes watching one agent" framing is exactly right - the serial bottleneck is the real problem, not the model.
one thing worth thinking through as shard matures: the management layer for those parallel agents running in worktrees. decomposition and dispatch is one side; the human staying oriented across 4 concurrent sessions - seeing what each is doing, switching between them, reviewing diffs inline, handling the merge step without context switching overhead - is the other.
i built pane for that layer specifically. fully open source (agpl-3.0), works with any cli agent. curious how you're handling the merge step when tasks in the dag have soft dependencies - like when two tasks touch overlapping files but aren't explicitly linked: github.com/Dcouple-Inc/Pane
Cool concept with the Blueprints system - defining agent teams declaratively is a nice touch.
I'm building something adjacent called Pane (https://runpane.com) that comes at it from the terminal management side rather than orchestration. Each pane is one feature with its own git worktree + N terminals, and worktree creation/cleanup is fully automated. The idea is you shouldn't have to think about the git or tmux layer at all.
Main difference from Seshions is Pane is a standalone desktop app rather than sitting on top of tmux, so it owns the terminal emulator directly. Tradeoff is less composability with existing tmux workflows, but the PTY handling and cross-platform support (Windows included) got way simpler.
The auto-snap detection is clever - automatically splitting when it detects an agent CLI is a great UX decision.
I took a similar "own the terminal" approach with Pane (https://runpane.com), but organized around git worktrees instead of splits. Each feature gets its own isolated worktree with N terminals, so agents never step on each other's files. The worktree lifecycle is fully automated.
Curious how you handle the case where someone is running 5+ agents on different features simultaneously? That's where the worktree isolation really shines vs. splits in a single repo checkout.
Nice work! The at-a-glance status monitoring is a great idea - the "what are all my agents doing right now" problem is real once you're running 4+ sessions.
I'm working on something in the same space called Pane (https://runpane.com) but took a slightly different approach - instead of a TUI layer, it's a standalone desktop app where each "pane" is one feature branch with its own worktree + N terminals. The worktree creation and cleanup is fully automated so you never touch git worktree commands.
Curious what made you go with Bubble Tea over a desktop app approach? I found the PTY handling was way easier when I owned the terminal emulator directly.
Oh, arguably the best part (which I forgot to mention) is that our terminals continue running in the cloud, so dev work isn't blocked by our computers going to sleep.
Fair enough - with that said - be mindful of the times. I am pretty deeply involved in Seattle's startup scenes and a notable startup recently laid off 35% of its engineers, and may lay off more, specifically because the engineering team was hesitant to adopt AI. In another case, a Ex-IPOd Seattle founder just hired two of my 21–22-year-old friends who are very AI native - they use Pane every day for their dev. The world is changing.
Fair enough, I spend a maximum of 200 a month given I use the MAX plan from CC. I don't find myself every hitting the weekly limits - but recently I've gotten close!
curious what happens when you're on windows though? tmux + ttal means you're locked out of a decent chunk of potential users.
been building in this space too -- pane (github.com/Dcouple-Inc/Pane) takes a different approach, standalone desktop app, no tmux at all. each pane maps to one worktree + n terminals, agents spin up and tear down cleanly. works the same on windows, mac, linux.
the telegram interface for managing from your phone is a nice touch -- does it block if the manager agent gets stuck waiting for human input?