Wanigan 2 · alpha · for macOS

Run several coding agents without losing track.

Name: Wanigan
Author: Dane Petersen

Two or three agents in, you stop knowing what each one is doing, what’s waiting on you, and what’s actually done. Wanigan is a Mac app that gives every project a board, runs one Claude Code or Codex session per card, and keeps one list of what needs you.

Build it from source Source on GitHub

Free and open source, MIT
No account, no telemetry
macOS 13 or later, Apple silicon
Alpha, version 2.0.0-alpha.0

Wanigan: a clear glass globe, half full of blue water, with two dark eyes.

Wanigan, rendered by the same water simulation as the app.

The Wanigan window: a sidebar with Needs you, Running and three projects, and the Northstar Storefront board with Inbox, Ready, Working, Review and Done columns. Inbox cards carry Jev’s suggestion, such as “Ready 88%”, and three cards in Working are held by Claude Code sessions marked Working. — fig. 1 A project’s board. The demo, with sample data.

Two or three agents is where you lose the thread.

An agent sits on a permission prompt, and you don’t notice.
Another says it’s done, and it isn’t.
A change shows up, and you can’t tell which session made it.

A better model doesn’t fix that, and more terminals make it worse. It’s a process problem.

The workflow.

This is the part worth taking away. It works with any tool, even a whiteboard.

Decide what “done” means first.
Write acceptance criteria on the card before anyone starts. The agent is told its card when it starts.
Agents file work. They don’t pick it.
What an agent finds lands in an Inbox. You accept it to Ready, and only then can an agent take it.
One agent per card, in a real terminal.
Start Claude Code, Codex or a shell on a card. It holds the card while it runs, on its own branch if you want.
Nothing reaches review without evidence.
A file, a link or a note: a test log, a screenshot, a URL. No evidence, no Review.
Only you mark it done.
Approve it, or send it back with a note the agent sees. If a done card turns out not fixed, reopen it: what’s still wrong becomes a new criterion.
One list says when you’re needed.
Needs you gathers permission prompts, reviews, questions, failures and finished turns from every project, most urgent first.

Wanigan’s board enforces every step. The rules live in its core process, not the window, and an agent’s own wanigan command can’t break them.

Wanigan’s How this works panel in three lanes. Filing: you file a card, agents file what they find into the Inbox, Jev reads each new card. Your call: you accept a card from the Inbox to Ready. The work: a session takes it, works in a real terminal, submits with evidence for your review, and only you approve it as Done. Beside it, when you are needed and who does what. — fig. 2 How this works, on every board, with live numbers. The demo, with sample data.

Claude Code or Codex, on your own accounts.

Wanigan runs the real CLIs you already use, in real terminals, signed in the way they already are. It doesn’t sell model usage: your agents use your own Anthropic or OpenAI plan.

Each project has its own accounts, and each session can pick its agent, account, model and effort.
Every Claude Code and Codex account on your Mac is found on disk, shown with who it’s signed in as.
When Claude Code hits a usage limit, continue the same conversation on another account in one click, with its card.
Close the window and your sessions keep running: a separate core process owns every terminal. Open Wanigan again and each one is where you left it.

Codex has gaps today: its usage limit isn’t detected, and replying from Needs you is Claude Code only. A plain shell works too. Other agents aren’t supported yet. Restarting your Mac, or quitting Wanigan’s core, ends running sessions; a Claude Code or Codex conversation can then be resumed from History.

The New session dialog: Project Northstar Storefront, Agent Claude Code, Codex or Shell, Account Default, Model Default, and Effort from Low to Max. — fig. 3 Starting a session: the agent, its account, model and effort. From the app’s interface tests, with sample data.

Jev triages the Inbox. It’s optional, and it’s advice.

Jev is TypeSafe’s fast decision model. Give Wanigan a TypeSafe key and Jev reads each new card in under a second: what to do with it, how much it matters, and whether it repeats another card.

Each project chooses

Off: Jev reads nothing in this project.
Reads: Jev reads every new card and suggests. It changes nothing.
Reads and accepts: Jev may also move a confident card to Ready, and only one that already has acceptance criteria. Only if you pick this.

No key, no Jev: nothing is sent. Jev sees a card’s text and the titles of a few similar cards, never your code, files or transcripts. Every call and its cost is recorded.

A card’s acceptance criteria, then Jev’s read: four bars and “breaks something important: checkout, data, sign-in, deploys or builds”, a Read again button, and the note “Jev is TypeSafe’s decision model. It reads the card’s text, never its code, and its read is advice.” — fig. 4 Jev’s read on a card. The demo, with sample data.

Evidence, a second opinion, then your call.

A card reaches Review only with evidence. You read it beside the card’s criteria, then approve it, or send it back with a note the agent sees.

For a second opinion, click AI review. Claude Code checks each criterion with read-only tools, names the file and quotes the exact line that shows it, and Wanigan checks every quote against the file. It’s advice. It never moves the card.

Changes shows uncommitted work, or everything a card’s branch changed, in syntax colour, unified or side by side. Mark each file Viewed, and send notes on lines to the agent as one message.

The card “Free shipping banner over $75” in Review, with Approve and Send back buttons, two acceptance criteria, Jev’s read, and an AI review marked “Needs your judgment” with steps to check it yourself. — fig. 5 A card in Review, with an AI review that leaves the call to you. From the app’s interface tests, with sample data.

Every turn is a checkpoint.

Each turn an agent takes leaves a checkpoint, so you see exactly what that turn changed, file by file, down to the word. Checkpoints are kept in Wanigan’s own store, never in your repository’s .git.

Undo the last turn in a card’s own worktree once the agent is idle. Wanigan checkpoints first, so you can redo it, and refuses if anything else has changed since.

Turn 3 of a Claude Code session: 2 files changed, plus 15 and minus 1 lines. The diff of LowStockBadge.tsx adds a LOW_STOCK constant and uses it in place of the number 4, with the changed words highlighted. — fig. 6 One turn’s diff. The demo, with sample data.

One list says when you’re needed.

Needs you gathers what’s waiting on you in every project into one list, ranked by what it’s blocked on, and tells you in the window or with a notification.

A permission row spells out hidden or lookalike characters. Replying in place works with Claude Code; with Codex, not yet.

Ranked by what it’s blocked on

Asking permission: the exact command or file
Hasn’t started: an agent that never reported in
Two sessions, one file
A usage limit: continue on another account
Ready for review
Failed or interrupted
Gone quiet
A question: from an agent, on its card
Finished a turn: reply in place

Needs you: two agents asking permission, each showing its exact Bash command. The second warns “This command contains hidden characters” and shows a zero-width space as U+200B inside a download URL. Below, an agent that hit its usage limit, with Continue on Default and Wait for the reset. — fig. 7 Needs you, with a hidden character spelled out. From the app’s interface tests, with sample data.

The rest of the desk.

Watch shows up to four live terminals at once, the ones that most need you first. A tile never resizes its session; click one to type into it.

The Running view in its Watch layout: live terminals in tiles, each titled with its project key and card, such as “Low-stock badge on product cards”, Working, and “Search endpoint with cursor pagination”, Waiting. — fig. 8 Watch: up to four live terminals at once, the ones that most need you first. The demo, with sample data.

History and resume: Every earlier Claude Code and Codex conversation in a project, from any account. Read one, or resume it live.
Tokens: What each conversation used and has in context now, from the CLI’s own transcript. No dollars.
Attachments: Paste, drop or pick images and files into any session or reply. Kept in Wanigan’s data, never in the project.
Decisions: Rules for a project, like “use pnpm”, told to every session that starts there.
Search: ⌘K finds projects, cards, sessions and commands, and what agents said in their sessions.
Pull requests: An approved card’s branch, pushed and opened with gh, after showing exactly what goes where.
Talk to Wanigan: Ask what needs you. Claude Code answers from Wanigan’s records, read-only, using a turn of your plan.
Skills and MCP servers: Every skill and server your agents load, secrets hidden, changed only after you see what changes.

Built assuming agents read things you didn’t write.

Agents read web pages, issues and files from strangers. So Wanigan shows you exactly what an agent asks before you allow it, and gives each agent only the rights it needs on the board.

The exact command, spelled out.
A permission prompt in Needs you shows the exact command or file. Hidden characters, direction controls, terminal escapes and lookalike letters are spelled out, so a zero-width space in a URL shows up as ⟨U+200B⟩ instead of slipping past you.
Agents can’t approve or pick their own work.
An agent can file a card but can’t take one from the Inbox, and can’t move a card to Done. Wanigan’s core enforces this, not the window.
Each agent acts only as itself.
Every session gets its own token. Its wanigan command can act only as that session, inside its own project. The core keeps only the token’s hash.
The core is local only.
It listens on a Unix socket in a folder only your user can open (0700), and the socket itself is 0600. Nothing listens on the network, and every caller needs a token.
Your logins stay with the CLIs.
Wanigan never reads, copies or stores your Claude Code or Codex credentials. It asks each CLI who is signed in.
Nothing phones home.
No account, no cloud, no telemetry, no update check. Nothing spends a turn of your Claude or Codex plan without a click.

The honest limit

Agents run with your permissions, exactly as in your own terminal. Wanigan watches and records them; it does not sandbox them. Its rules stop a confused agent, not a hostile one: anything running as your user can read Wanigan’s data folder and talk to its core.

Found a security problem? Please report it privately from the repository’s Security tab, not in a public issue.

What leaves your Mac.

This is everything that does go out, and who sends it.

Wanigan itself

One kind of call, and only once you give it a TypeSafe key: Jev sends a card’s key, title, type, priority, description and criteria, the project’s name and the titles of up to five similar open cards to TypeSafe’s API. Never code, files or transcripts.

No analytics, no crash reports, no update check.

Your agents

Claude Code, Codex and gh run as you and talk to their own services: your prompts and code go to Anthropic or OpenAI under your account, and pull requests to GitHub.

Wanigan starts them when you start a session or click AI review, Draft or Talk to Wanigan. It also asks them who you’re signed in as and what’s left on your plan.

Your data

Stays on your Mac, in SQLite, in ~/Library/Application Support/Wanigan 2/.

Attachments and card worktrees are kept there too. Nothing is written into your projects to make Wanigan work; a card’s own branch is registered in your repository, as with any git worktree.

Check it yourself

Wanigan’s window and its core both run as Wanigan 2. While you work, in Terminal:

# Wanigan's open internet connections, right now
lsof -nP -i | grep -i '^wanigan'

# Bytes in and out for each Wanigan process
nettop -P -L 1 | grep -i wanigan

Or watch every connection, app by app, with a firewall such as LuLu or Little Snitch. The agents show up under their own names, claude, codex and gh, and that traffic is theirs.

Try it.

Wanigan 2 is an alpha for macOS on Apple silicon. For now you build it from source, which takes a few minutes.

You need

Xcode Command Line Tools (xcode-select --install). Installing compiles the terminal and database modules for Electron.
Node 22.23.2. With nvm, nvm install in the folder reads .nvmrc.
Claude Code or Codex, installed and signed in, to run real agents. The demo needs neither.
Optional: gh, signed in, for pull requests, and a TypeSafe API key for Jev.

Terminal

git clone https://github.com/DanePete/wanigan-2.git
cd wanigan-2
nvm install
npm install           # also compiles SQLite and node-pty for Electron
npm run dev           # the app, with hot reload

Start with the demo: Help › Open the Demo. It opens a second Wanigan with sample projects and stand-in agents, in its own data folder. Nothing real is touched and no model is called. Help › Leave the Demo closes it.
Then a real project: The + beside Projects in the sidebar, or ⌘K › Open a project. Pick its accounts with the gear beside its name, start a session on a card, and keep Needs you open.
Build the app: npm run dist:mac writes release/mac-arm64/Wanigan 2.app. Drag it to Applications; it sits beside the first Wanigan instead of replacing it.

Open source, MIT

The code, the design notes, and a feature matrix that ties each claim to the test that proves it.

github.com/DanePete/wanigan-2

There’s no download yet. When there is, it will be a GitHub Release, linked here with its checksum.

If something goes wrong

npm install fails compiling node-pty or better-sqlite3: install the Xcode Command Line Tools, then run npm run rebuild.
The window never opens: your shell may set ELECTRON_RUN_AS_NODE (VS Code’s terminal can). Run env -u ELECTRON_RUN_AS_NODE npm run dev.
Anything else: open an issue, with your macOS version, claude --version and codex --version.

Not done yet

Named, saved board views.
AI review, Draft with Claude and Talk to Wanigan have been checked against the real CLI’s flags but not yet run on a real model: each run spends a turn of a plan, so each waits for its first click.
Codex’s usage limit isn’t detected, and a Codex conversation resumes only in the account it lives in.
Replying from Needs you is Claude Code only.
Attachments, Remote Control and Codex’s token counts follow what the CLIs’ binaries show; none has been run against a real model.

Other good tools.

Wanigan isn’t the only tool doing this. T3 Code and BridgeMind are good, and I learned from both. Here is how they differ, as of 7 October 2026; each fact about another app links to where it was found.

Question	Wanigan	T3 Code	BridgeMind
Price	Free	Free	From $20 a month; no free plan
Account needed to run it	No	No; an account is optional, for remote use	Yes
Source code	MIT, public	MIT, public	App not public
Usage analytics in the app	None	On by default; off with an environment variable	On by default; opt out by email
Platforms	macOS on Apple silicon; built from source for now	macOS, Windows and Linux	macOS, Windows and Linux
Latest version	2.0.0-alpha.0	v0.0.45	0.3.4
On your phone	No	iOS and Android apps	Approvals from your phone
Agents	Claude Code, Codex and a shell	Six, including Claude Code and Codex	Six named, and “if it runs in a terminal”
Sessions outlive the window	Yes	Yes, as a background service	An optional beta

Who makes this.

I’m Dane Petersen, a web developer, mostly Drupal and WordPress, usually with several projects going at once. Claude Code and Codex do a big share of my typing now. Running a few at once made me faster. It also made me worse at keeping track.

I’d built two tools around this before: the first Wanigan, which runs agent sessions side by side, and a production board for a game project, where agents pick up cards and nothing counts as done without proof. The board was the part that worked. Wanigan 2 puts them together.

I’ve benefited from a lot that other developers chose to share, so it’s open source under MIT, like the first one. It’s an early alpha with plenty left to do. Try the workflow, pull it apart, and tell me what breaks.

Wanigan, at rest Dane Petersen

Questions.

Is it free?: Yes. Wanigan is open source under the MIT license. Your agents use your own Anthropic or OpenAI account, as they do in your terminal now.
Is there a download?: Not yet. For now you build it from source, which takes a few minutes; the steps are under Try it.
Do I need an account?: No. There’s no sign-up and no Wanigan account. Claude Code and Codex use the sign-ins they already have.
What does it send over the network?: Wanigan’s own code makes one kind of call: Jev, to TypeSafe’s API, and only if you add a TypeSafe key. The agents it starts talk to their own services as you. The details are under What leaves your Mac.
Which agents does it run?: Claude Code and Codex, and a plain shell. Other agents aren’t supported yet. Codex has gaps today: its usage limit isn’t detected, and replying from Needs you is Claude Code only.
Does it write anything into my repository?: Not into your working files, and checkpoints go to Wanigan’s own store, not your .git. If you give a card its own branch, git registers the branch and its worktree in your .git; the worktree’s files live in Wanigan’s data folder.
What happens to running sessions if I close it or restart?: Closing the window: they keep running. Quitting Wanigan’s core: they end. Restarting or logging out of your Mac: they end. An ended Claude Code or Codex conversation can be resumed from History.
Is it safe to let agents run in it?: As safe as running them in your own terminal, and no safer: Wanigan doesn’t sandbox them. What it does add is under Security.

Run several coding agents without losing track.

Two or three agents is where you lose the thread.

The workflow.

Decide what “done” means first.

Agents file work. They don’t pick it.

One agent per card, in a real terminal.

Nothing reaches review without evidence.

Only you mark it done.

One list says when you’re needed.

Claude Code or Codex, on your own accounts.

Jev triages the Inbox. It’s optional, and it’s advice.

Each project chooses

Evidence, a second opinion, then your call.

Every turn is a checkpoint.

One list says when you’re needed.

Ranked by what it’s blocked on

The rest of the desk.

Built assuming agents read things you didn’t write.

The exact command, spelled out.

Agents can’t approve or pick their own work.

Each agent acts only as itself.

The core is local only.

Your logins stay with the CLIs.

Nothing phones home.

The honest limit

What leaves your Mac.

Try it.

You need

Open source, MIT

If something goes wrong

Not done yet

Other good tools.

Who makes this.

Questions.