If you're reading this, there's a decent chance you have six terminals open right now, each running Claude Code or Codex in its own git worktree. Maybe they're tmux panes. Maybe they're cmux tabs with the blue notification rings. Either way, you've already figured out the thing most developers haven't: one agent at a time is a waste of you.
You also figured it out without help from the vendors. Claude Code out of the box still doesn't really do parallelism. Agent Teams is experimental, off by default, can't be resumed (/resume and /rewind don't restore teammates), runs one team at a time, burns dramatically more tokens, and its split panes require tmux or iTerm2 — explicitly not Ghostty. Claude Code on the web runs in Anthropic's sandboxes, which means no local dev server, no local database, none of your environment. Anthropic's own docs, when you ask how to actually run agents in parallel, punt to: use git worktrees and run multiple sessions yourself.
So the terminal crowd built the answer themselves. tmux + git worktree add. claude-squad. And most notably cmux — 21,000+ stars in four months, a genuinely excellent native macOS terminal built on libghostty, with sidebar tabs showing each workspace's branch and PR status, and notification rings that finally answer the question "which agent needs me right now?" If you want the best raw terminal for running agents in parallel, cmux is probably it. We mean that.
But cmux's founder describes it, deliberately, as "a primitive" — his words from the launch: GUI orchestrators "lock you into their workflow," so cmux refuses to have one. When someone asked how it manages worktrees, the answer was a four-line shell snippet you run yourself. Session layouts don't persist across restarts. There's no review surface, no merge workflow, no task state, no CI awareness. By design.
Which is fine — until you notice where your time actually goes.
The wall every parallel-agent user hits
Spend a week running five agents and a pattern emerges. The bottleneck was never spawning sessions. It's everything after the agent stops typing.
The HN threads on every parallel-agent tool read like the same group therapy session:
"Once I have about 3 or more running at a time it's very easy to forget about one and have it paused waiting for confirmation." — on Conductor
"How are people productive using 10 parallel agents? Doesn't human review time become a bottleneck?" — on Superset
"I have 5-10 agents with completed plans, and I'm just slogging through executing them one at a time."
"The real bottleneck isn't human review per se, it's unstructured review."
That last one is the whole problem in one sentence. And it's not anecdotal anymore: LinearB's 2026 benchmarks found AI-generated PRs wait 4.6x longer for first review pickup than human-written ones. GitHub says it. Anthropic built a nine-agent PR review feature because of it. "Review is the new bottleneck" stopped being an insight sometime last winter; it's now just the weather.
Concretely, the DIY terminal workflow breaks in three places:
- Environment setup. A fresh worktree doesn't have your
.env, yournode_modules, your database, or a free port. Every parallel-agent thread has someone pointing this out ("starting a new worktree requires additional setup"; "I would need ten different copies of my database"). You end up with setup scripts you maintain by hand. - Unstructured review. Six agents finish. You now have six diffs in six worktrees, no queue, no order, no record of what you sent back and why. The terminal shows you sessions. It has no opinion about which diff to look at next.
- State that lives in your head. Which branch was that fix on? Did CI pass? Did I already review this one before lunch? Was that session waiting on me or just done? tmux doesn't know. cmux's rings tell you an agent is waiting — they can't tell you where the work is in its lifecycle, because there is no lifecycle. There are just panes.
cmux made the panes excellent. The panes were never the problem.
What Fredrin is
Fredrin starts from the same primitive you already use — N independent agent processes in N isolated git worktrees, each in a real PTY terminal session, not a chat veneer — and wraps the missing lifecycle around it.
The unit isn't a session. It's a ticket:
- One ticket, one Worker, one worktree, one branch. Create a ticket, and the worktree and branch exist. The agent (Claude Code, Codex, Cursor, or Copilot — your pick, your keys) runs inside it in an interactive terminal you can pop open and type into at any moment. It's still your terminal. It's just attached to a unit of work instead of floating free.
- The board is the multiplexer view. Instead of a strip of tabs ordered by recency, you get columns ordered by lifecycle: backlog → planning → building → review → completed. A glance tells you not just who's waiting, but what stage everything is at. An agent that needs input parks its ticket in Blocked; answering in chat unblocks it automatically.
- Plans with acceptance checks. Each ticket carries a structured plan — outcome, acceptance checks, touchpoints. Workers tick checks one at a time as they verify them, and the server owns the checkbox state so an agent can't wishfully bulk-tick its own homework. This is the "tight contract per worktree" that makes parallel review tractable instead of a slog.
- CI on the card, merge closes the loop. Tickets are GitHub-shaped: branch, optional PR, CI status flowing back onto the board. Acceptance checks run with real exit codes and stamp the PR. Merging the PR auto-completes the ticket. No tab to remember to close, no state to update by hand.
- Review as the product, not a tab. When a ticket hits review, your job is the glance: diff, CI, ship or send back. Send-backs are durable — your rejection feedback is recorded and prepended when the Worker resumes, so "I already told it not to do that" actually means something across sessions.
- Context lives in your repo, not our database. Workers read
CONTEXT.md,docs/adr/, andAGENTS.mdfrom the worktree — files you own, in git. When a Worker learns something worth keeping, it ships the refinement as acontext:commit you review like any other code. If you delete Fredrin tomorrow, your project's accumulated context walks away with you, because it was never ours.
In other words: keep the terminals. Add the pipeline.
About that graveyard
We'd be insulting your intelligence if we pitched "a kanban board for AI agents" like it's novel. You've seen the Show HNs — there's a new one roughly monthly. You've also seen how it ends: Terragon shut down in February. Bloop's Vibe Kanban — 26,000 stars, the category leader — shut down in April, the founder saying plainly that the users were free and the business model never arrived. Conductor and Sculptor are good products that are free with no visible revenue, which after this spring should worry you as a user, not reassure you.
Our read on why the category keeps dying:
They built session viewers, not lifecycles. Worktrees + parallel sessions + a diff pane is table stakes now — it's in Cursor 2.0, the Codex desktop app, Zed, JetBrains Air, and a dozen free OSS tools. A veneer over sessions is a feature, and features get absorbed. The full loop — plan contract, acceptance verification, review queue, CI on the card, merge-completes-ticket, context commits — is an opinionated pipeline, and pipelines are products.
They were free, or they resold compute. Hosted Claude-Code-in-the-cloud died the moment Anthropic shipped it themselves (that's the Terragon story). Free-forever died of being free (that's the Bloop story). Fredrin is BYOS by default — bring your own subscription, so the Claude or ChatGPT plan you already pay for does the work instead of an expensive metered API bill — and we charge for the surface: flat, lane-based pricing, not a token markup. We think the only honest position in 2026 is "the model bill is yours, the shipping pipeline is worth paying for," and we'd rather find out fast if we're wrong.
The honest section
Some things you should know before you get excited:
- We're in closed alpha, macOS only. Early. Bugs exist. Multi-seat features are young.
- We're an Electron shell. Yes, really. The terminals inside are real PTYs and feel like terminals, but if your bar is Ghostty-grade input latency on raw scrollback, cmux wins that contest today and we're not going to pretend otherwise.
- cmux is the better pure terminal, and tmux is the better SSH session manager. If all you want is fast panes and notification rings, you don't need us. Fredrin earns its keep at the moment panes stop being enough — when the question shifts from "which agent is waiting?" to "what's reviewable, what's blocked, what shipped?"
- The giants are coming. Cursor runs eight parallel agents. OpenAI shipped a desktop app with worktrees. GitHub is building "mission control." Anthropic is absorbing orchestration into Claude Code itself. Our bet — and it is a bet — is that platform owners ship general-purpose surfaces (threads, command centers) and are organizationally incapable of shipping an opinionated solo-dev pipeline. Opinion is the moat. We have a lot of it.
Why we think this is the ground that's breaking
For two years the industry argued about which agent writes the best code. That argument is basically over — they're all good, and they're all getting better without our help. The question that decides whether you ship 2x or 10x more is no longer "which model?" It's: what is the unit of work?
The terminal's answer is a session. A session has no goal, no acceptance criteria, no review state, no relationship to CI, and no concept of done. Everything a session lacks, you supply from memory — and at six parallel sessions, your memory is the system of record for a small engineering org.
Fredrin's answer is a ticket that carries its own contract from idea to merge — and a board where the human does the one thing agents genuinely can't: decide what ships. Parallelism was step one, and the terminal community nailed it without anyone's permission. Shipping in parallel is step two.
Keep your terminals. We'll bring the pipeline.
Fredrin is in closed alpha on macOS. BYOS — Claude Code, Codex, Cursor, and Copilot runtimes. If you're running agents in parallel today and hitting the wall described above, we want you in the alpha: fredrin.com.