I built Fredrin because I kept losing the plot.
Not the code — the code was fine. The agents write good code now. I lost the plot: which thing I was doing, what I'd already decided, what I'd told the agent ten minutes ago, which of the six branches in front of me was the one that actually mattered. The bottleneck of my day wasn't typing and it wasn't waiting on a model. It was reassembling, over and over, the answer to a single question: where was I?
That question has a name. It's context. And the reason vibe coding gets exhausting at scale isn't the volume of code — it's that your context is shattered across three places that don't talk to each other.
The three places your context goes to die
Spend a real day running agents in parallel and watch where your attention actually leaks:
The terminal. Each agent runs in its own session — a worktree, a branch, a scrolling river of output. Six of them open and the terminal can tell you one thing: who's printing text right now. It can't tell you which session is done, which is waiting on you, which one you already reviewed before lunch. The terminal holds the execution. It holds none of the meaning.
The tickets. So you keep a tracker — Linear, a notes file, a whiteboard, your head. That's where the intent lives: what each task is for, what "done" means, what you decided last week and don't want to relitigate. But the tracker has no idea what the agents are doing. It's a list of nouns sitting in a different window from the verbs.
The chat. And then there's the conversation itself — the back-and-forth where the actual thinking happened. "No, use the existing helper." "Don't touch the migration." "Acceptance criteria are X, Y, Z." All of it real, all of it load-bearing, all of it buried in a scrollback you will never scroll back through.
Three surfaces. Three copies of the truth, none of them complete. The glue holding them together is you, refreshing the whole graph in your head every time you switch tasks. At one agent that's free. At six, you've quietly become the system of record for a small engineering team — and human memory is a terrible database.
That's the real tax on parallel AI coding. Not the code. The context-switching.
Why chat is the wrong shape for context
Here's the part I had to learn the hard way: a chat interface actively destroys the context it creates.
Think about what a scrollable chat is. It's a single column, ordered by time, where the most important thing — the decision you made, the constraint you set, the criteria you agreed on — gets the exact same treatment as "ok" and "looks good" and a 400-line stack trace. Everything flows down and off the screen at the same rate. To find what you decided, you scroll up through everything you said since. The interface that captured your reasoning is the same one that buries it.
And chat is linear in time but your work isn't. You don't think one task at a time. You've got a fix, a feature, and a refactor all live at once. Cram three parallel trains of thought into one time-ordered column and you get a transcript where nothing is next to the thing it relates to. It reads back as noise because it was recorded as noise.
A board is the opposite shape. It's linear in lifecycle, not in time. Backlog, planning, building, review, done — left to right, and every piece of work sits in exactly the column that says where it is. You don't scroll to find state; you glance. The board is spatial memory: this fix is in review, that feature is still building, that refactor is blocked on a question I need to answer. Your eyes do in half a second what scrolling a chat does in thirty.
That's the whole bet behind Fredrin. Chat is a fine way to talk to one agent. It's a catastrophic way to hold the state of ten. The board isn't a prettier list — it's a place your context can live without you having to keep it alive.
What Fredrin actually is
Fredrin is a desktop kanban for vibe coding, and the one sentence version is this: it makes the ticket the place all your context comes back together.
Not three windows you reconcile in your head. One object that holds the whole thing.
A ticket in Fredrin is a unit of work that owns its own world. Create it and it gets a branch and an isolated worktree automatically. A single AI agent — your pick: Claude Code, Codex, Cursor, Copilot, your keys — runs inside that worktree as a real terminal you can open and type into anytime. The intent (the plan, the acceptance checks) lives on the ticket. The conversation lives on the ticket. The branch, the PR, the CI status — all on the ticket, all in one place. One ticket, one Worker, one worktree, one branch, one coherent context.
The three shattered surfaces become one:
- Execution and intent stop being separate windows. The terminal session is attached to the ticket it's working on. The plan sits next to the agent doing the plan.
- The board is the multiplexer. Instead of tabs ordered by who typed last, you get columns ordered by lifecycle. A glance tells you not just who's waiting, but what stage everything is at. An agent that needs you parks its ticket in Blocked; you answer and it resumes.
- Decisions become durable. When you send work back from review, the reason is recorded and handed to the Worker when it picks the ticket back up. "I already told it not to do that" finally means something across sessions, instead of evaporating into scrollback.
- The deep context lives in your repo, not our database. A project's lasting knowledge — its glossary, its decisions, its conventions — lives as Project Context files (
CONTEXT.md,docs/adr/,AGENTS.md) right in the worktree. Every Worker reads them on every ticket. When one learns something worth keeping, it ships the refinement as a commit you review like any other code. Delete Fredrin tomorrow and your accumulated context walks away with you, because it was never ours to begin with.
That's what "unified context layer" means, concretely. Per-task context collapses onto the ticket. Cross-task knowledge collapses into files in your repo. Nothing important is left living only in your head.
Why this is what makes multitasking actually fast
The promise of parallel agents was always throughput: kick off ten things, ship ten things. The reality, for most people, is ten things half-started and a head full of which-was-which. The gap between the two isn't compute. It's the cost of every context switch.
When context is unified on the ticket, switching gets cheap. You don't reconstruct anything. You look at the board, see the one ticket sitting in review, open it, and everything you need is already there — the diff, the CI result, the plan it was built against, the conversation that shaped it. You make the one call agents genuinely can't make — does this ship? — and move to the next. Then you glance again.
That loop — glance, decide, glance — is the whole product. It's only possible because you never have to rebuild the picture before you can act on it. The picture is the board. The detail is the ticket. Your working memory gets to be small again, which means you can run far more in parallel before your own head becomes the bottleneck.
High velocity was never about agents going faster. It's about you not having to slow down to remember where you were.
Why I built it
I built Fredrin for the version of me that had six terminals open and was losing things in the gaps between them. The agents were never the problem — they're good, they're getting better, and they'll keep getting better without my help. What no one was building was the surface that holds everything around the agents: the intent, the state, the decisions, the lifecycle. The connective tissue. The context.
So that's what Fredrin is. Not a faster terminal — cmux already won that. Not a better model — that's not my fight. It's the layer that keeps the plot from getting lost when you're running ten things at once. The place your context lives so it doesn't have to live in your head.
Keep your agents. Keep your keys. Let Fredrin hold the rest.
Fredrin is in closed alpha on macOS. BYOS — Claude Code, Codex, Cursor, and Copilot runtimes. If you're running agents in parallel today and feeling the cost of context-switching more than the cost of compute, we want you in the alpha: fredrin.com.