Wanigan

Wanigan 2 · alpha · for macOS

Run several coding agents without losing track.

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.

Download for MacSource on GitHub
  • Free and open source, MIT
  • No account, no telemetry
  • macOS 13 or later, Apple silicon
  • Alpha, version 2.0.0-alpha.12
Wanigan: a clear glass globe, half full of blue water, with two dark eyes.

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

Wanigan 2’s launch video

01The problem

Two or three agents is where you lose the thread.

  1. An agent sits on a permission prompt, and you don’t notice.
  2. Another says it’s done, and it isn’t.
  3. 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.

02The workflow

The workflow.

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

  1. Decide what “done” means first.

    Write acceptance criteria on the card before anyone starts. The agent is told its card when it starts.

  2. 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.

  3. 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.

  4. Nothing reaches review without evidence.

    A file, a link or a note: a test log, a screenshot, a URL. No evidence, no Review.

  5. 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.

  6. One list says when you’re needed.

    Needs you gathers permission prompts, reviews, questions, failures and finished turns from every project, most urgent first.

The lineup.

You decide what gets built and what counts as done. Agents file cards and do the work in real terminals, Jev reads what comes in, and nothing reaches Done until you approve it.

  • YouYou file a card. Yours go straight to Ready, unless you put them in the Inbox.
  • AgentsAgents file what they find. What an agent files always lands in the Inbox, for you.
  • JevJev reads each new card. What to do with it, how much it matters, and whether it repeats another card. Advice, unless this project lets Jev accept confident cards.
  1. You

    Inbox

    Accept it to Ready, archive it, or start a session on it, which accepts it. Agents cannot take a card from the Inbox.

    Rule 2you accept
  2. The board

    Ready

    Accepted work. Acceptance criteria say what done means, and the agent is told them when it starts.

    Rule 1a session takes it
  3. Agents

    Working

    Claude Code, Codex or a shell, in a real terminal that keeps running when the window closes. It claims the card for 30 minutes at a time, renewed while it runs.

    Rule 3with evidence
  4. You

    Review

    Only with evidence: a file, a link or a note. Ask Claude to check it against each criterion if you like; that is advice.

    Rule 4you approve
  5. The board

    Done

    Only you approve. An agent can never mark its own work done.

    Rule 5

When it goes wrong

  • A session stops back to Ready

    Its claim is released and the card returns to Ready. Notes, evidence and history stay on the card.

  • Send back back to Ready

    Not right yet? It goes back to Ready with your note, and the next session is told it.

  • Reopen back to Ready

    Done, but not fixed? Reopen it and say what is still wrong; that becomes a new criterion.

  • Needs you Rule 6

    Permission prompts, questions, failures, finished turns and quiet sessions, 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.

How this works, lane 3. The demo, sample data
Lane 3 of Wanigan’s How this works panel, The work: A session takes it, 3 sessions running; Working, 3 in progress; then, with evidence, Review, 0 for you to review; then, you approve, Done, 2 done.
  1. Nothing moves to Review without evidence.
  2. The numbers are live from the board.

03Your agents

Claude Code or Codex, on your own accounts.

Wanigan runs your installed agent CLIs in real terminals. They use your existing accounts or the local model you select; Wanigan does not sell model usage.

  • Each project has its own accounts, and each session can pick its agent, account, model and effort.
  • Claude Code and Codex accounts in recognized folders are found on disk and shown with their reported sign-in.
  • 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 does not yet detect a running session hitting its usage limit, and replying from Needs you is Claude Code only. Gemini CLI and a plain shell work too. Restarting your Mac, or quitting Wanigan’s core, ends running sessions; a Claude Code or Codex conversation can then be resumed from History.

Starting a session. Interface tests, sample data
The New session dialog: Project Northstar Storefront, Agent Claude Code, Codex or Shell, Account Default, Model Default, and Effort from Low to Max.
  1. The agent: Claude Code, Codex or a shell.
  2. Its account, model and effort, per session.

04Jev, optional

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

Jev is TypeSafe’s decision model. With a TypeSafe key, it advises what to do with each new card, how much it matters, and whether it repeats another.

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 reads card fields and similar cards’ titles, never files or transcripts; entered text may contain code. Calls are recorded, and missing usage or cost stays unknown.

Jev’s read on a card. Interface tests, sample data
Jev suggests Later at 74%, with Ready, Later and Close probability bars, a Read again button, and an explanation that entered card fields may contain code while project files and transcripts are not read.

05Review

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.

A card in Review. Interface tests, sample data
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.
  1. Only you approve it, or send it back with a note.
  2. AI review is advice. It never moves the card.

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.

One turn’s diff, word by word. The demo, sample data
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.

06Needs you

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

  1. Asking permission: the exact command or file
  2. Hasn’t started: an agent that never reported in
  3. Two sessions, one file
  4. A usage limit: continue on another account
  5. Ready for review
  6. Failed or interrupted
  7. Gone quiet
  8. A question: from an agent, on its card
  9. Finished a turn: reply in place
Needs you. Interface tests, sample data
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.
  1. A zero-width space in the URL, spelled out as U+200B.
  2. A usage limit: continue on another account.

07The desk

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.

Watch: a live terminal. The demo, sample data
The Running view in its Watch layout, 6 live sessions: the live terminal of “Low-stock badge on product cards”, Working, on the Default account.
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.

08On your phone

Answer it from your phone.

Optional. See what needs you and answer it, type into a running session or start a new one, and work your boards, from your phone. It reaches your Mac over your own Tailscale network: nothing is put on the internet, and there is no Wanigan server in between.

  1. Install Tailscale on your Mac and on your phone, signed in to the same account. It is free for personal use.
  2. In Wanigan, Settings › Phone › Turn on phone access. It shows the one command it runs before it runs it.
  3. Show a pairing code and point your phone’s camera at it. On an iPhone, add Wanigan to your Home Screen and enter the code there.
  4. On the phone, This phone › Turn on notifications.
Settings › Phone. Wanigan 2
The pairing panel in Wanigan’s settings on the Mac: a QR code, three steps, and the one-time code.
What a phone reaches
Needs you, sessions and their terminals, new sessions on any project, account and model, and your boards. Never settings, accounts, git, keys or files on your Mac.
Pairing
A code works once, for ten minutes. Forget cuts a phone off at once; turn Can act off and it can only read.
Notifications
Encrypted to your phone, saying what the Mac’s banners say. On an iPhone they come to the Home Screen app.
What it needs
Your Mac awake, and Wanigan’s core running; it stays up while phone access is on. Nothing to install from an app store.

New in alpha.9. Tested end to end in a phone-sized browser against the real phone page; not yet seen on a real phone over a real Tailscale address.

09Git

Git, in the same window.

Review what an agent did, then commit it, push it and resolve its merge conflicts without leaving Wanigan.

Stage
Whole files, one hunk, or only the lines you tick. Discarding asks first.
Commit
With a secret scan first: a key in what you staged stops the commit until you say it isn’t real. Write with Claude drafts the message from the staged diff, on a click.
History
A graph of every branch and merge. Commits from a card’s branch carry its key.
Branches and stash
Create, switch, merge and delete branches. Stash with untracked files, then apply, pop or drop.
Fetch, pull and push
Pull fast-forwards unless you choose to merge. Push shows exactly which commits go where, scans them, and is never forced.
Merge conflicts
Ours, theirs and where both started, side by side. Pick per conflict, edit by hand, or ask the card’s agent. Abort puts everything back.
Pull requests
The branch’s pull request with its checks and reviews, through your own gh, and a new one in one step.
Agents at work
Anything that would change files under a running agent waits until it stops, and says why.
Commits, on every branch. The demo, sample data
The Changes view’s Commits tab for Northstar Storefront: a graph of branches beside 16 commits, several tagged with card keys such as NS-10 and NS-3 and branch names such as wanigan/ns-10. A banner says two Claude Code sessions are working in the project folder, so switching, merging, pulling, stashing and discarding wait until they stop. On the right, the selected commit “Search suggestions”, not pushed yet.
  1. Every branch and merge, as a graph.
  2. A commit from a card’s branch carries its key.
A merge conflict. The demo, sample data
Conflict 1 of 3 in src/cart/copy.ts, where both sides changed it: Ours, Where both started and Theirs side by side, the choice “Both, ours first”, and its result below. Above, buttons take ours or theirs for the whole file, or mark it resolved.
  1. Ours, theirs, and where both started, side by side.
  2. Pick per conflict, or edit it by hand.
A commit, stopped by the secret scan. The demo, sample data
The commit box with three staged files and the message “Give the pay button an accessible name”. Below it a warning: 1 possible secret in the staged changes, nothing has been committed, a Stripe live key in src/checkout/stripe.ts line 4, a checkbox “I have read it, and none is a real credential.”, and Commit anyway.
  1. A key in what you staged stops the commit.
  2. It goes through only once you say it isn’t real.

10Security

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 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.

The connections Wanigan makes, and the services its agents use.

Wanigan and Phone

Update checks use GitHub’s public releases; Jev uses TypeSafe when enabled or testing its connection. Jev card reads send card fields, the project name and up to five similar cards’ keys, titles and statuses. Those requests read no files or transcripts, though entered fields may contain code.

Phone is off until enabled. Paired devices read boards, Needs you and selected terminal output, normally over your Tailscale network; Can act permits sessions and typing. Separately enabled notifications send device-encrypted text through the browser’s push service. Protect an acting phone like your terminal.

Your agents

Claude Code, Codex and Gemini CLI run as you, using configured services; gh sends pull requests to GitHub. Local models route Claude Code or Codex to LM Studio or Ollama on this Mac. Wanigan queries both for models and uses LM Studio for requested downloads. Agents and tools can still make other network connections.

Desktop actions start sessions, AI review, Draft and Talk to Wanigan. Can act permits Phone sessions and input too. Account and usage checks use Claude Code’s and Codex’s own CLIs.

Your data

SQLite, attachments and card worktrees stay in ~/Library/Application Support/Wanigan 2/. Local storage does not stop the connections above.

Routine launches keep runtime configuration outside projects. Chosen MCP settings, skill copies, setup commands and Git actions can change files. Git registers card worktrees.

11Try it

Try it.

Wanigan 2 is an alpha for macOS on Apple silicon. Download the build, or build it from source in a few minutes.

Download DMG
Version
2.0.0-alpha.12
Size
161 MB, a disk image
Requires
macOS 13 or later on Apple silicon (M1 or later). Intel Macs and Windows aren’t supported in this release.
SHA-256
335e6f93976e3696ae4041085e5efd9013d219ba82fdf9f94d91f0c3ff1ecbc9

The first time you open it

This build is ad-hoc signed and isn’t notarized by Apple. macOS may block it when you first open it. Check the file with shasum -a 256 "Wanigan-2-2.0.0-alpha.12-mac-arm64.dmg", then:

  1. Open the disk image and drag Wanigan 2 onto the Applications shortcut.
  2. Open it. macOS says it couldn’t verify Wanigan 2 is free of malware. Click Done.
  3. Open System Settings › Privacy & Security, scroll to Security, and click Open Anyway beside the note about Wanigan 2.
  4. Enter your password or use Touch ID if asked, then confirm that you want to open the app. Your Mac saves an exception for this copy.

This build is ad-hoc signed and not notarized. Apple’s instructions for opening it explain the security setting.

On your Mac it’s called Wanigan 2. Use Check for Updates in the app, or check once a day after you say yes. Read what changed, then download the latest build here. Installing it may require restarting the core, which ends live sessions.

To build it from source, 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 --branch v2.0.0-alpha.12 --depth 1 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
Build the app
npm run dist:mac writes release/mac-arm64/Wanigan 2.app. Drag it to Applications. Saved projects, boards and history live separately from the app.

Open source, MIT

The code and design notes for 2.0.0-alpha.12, with a feature matrix that ties each claim to its test.

Source for 2.0.0-alpha.12
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.

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.
  • Codex’s usage limit isn’t detected, and a Codex conversation resumes only in the account it lives in.
  • For a new Codex session, answer startup questions and send the first message in its terminal. The composer opens once Codex reports that it is ready.
  • Replying from Needs you is Claude Code only.
  • Remote Control and Codex’s token counts follow what the CLIs’ binaries show; neither has been run against a real model.

12Release notes

What’s new & bug fixes.

2.0.0-alpha.12

Latest release

Steadier startup. Clearer configuration.

  • Core. Waits for native cleanup and refuses late readiness when shutdown interrupts startup.
  • Git. Keeps diff and stash previews consistent with Git 2.40 and 2.55 prefix settings. Failed reads refuse commit-message drafts.
  • MCP. Reports unreadable configuration, keeps healthy entries visible, and masks credential-like fallback defaults in fields and diagnostics. Removal failures stay visible. The audit continues.
Full release notes for 2.0.0-alpha.12
Earlier releases (11)

2.0.0-alpha.11

Earlier release
Safer shutdown. Clearer permissions. — show changes for 2.0.0-alpha.11
  • Phone. Rechecks held actions after permission changes, bounds event streams, and keeps On/Off in order. Delayed push failures preserve replacement subscriptions.
  • Models. Prevents duplicate downloads and refuses unknown disk space or failed memory estimates.
  • Sessions. Refuses prepared and new starts as shutdown begins, before waiting for Phone to close.
  • Jev. Explains that card text may contain code; files and transcripts are not read. The illustration comes from the updated app.
  • Reliability. Reports failed native restoration during packaging. Adds exact Git refusal and retry checks. The audit continues.
Full release notes for 2.0.0-alpha.11

2.0.0-alpha.10

Earlier release
Honest costs. Safer conversations. — show changes for 2.0.0-alpha.10
  • History. Refuses out-of-account links and non-regular transcripts. Caps retained caches and copies foreign indexes in fixed-size chunks.
  • Jev. Keeps missing usage and unknown costs visibly unknown. Validates confidence and preserves older recorded usage.
  • Your work. Blocks Undo with an unreadable preview and commit-message drafts with unreadable staged changes.
  • Phone. Orders terminal keys and pauses on uncertain delivery. Off closes local connections before Tailscale cleanup; notifications recover after re-enabling.
  • Reliability. Caps socket requests and queued output; parses fragmented hooks incrementally. Strengthens account, skill and undo tests. The audit continues.
Full release notes for 2.0.0-alpha.10

2.0.0-alpha.9

Earlier release
On your phone. Models on this Mac. — show changes for 2.0.0-alpha.9
  • On your phone. Optional. Settings › Phone pairs your phone by QR code over your own Tailscale network: see what needs you and answer it, type into a session or start one, and move cards. Notifications are encrypted to the phone.
  • Models on this Mac. Optional. Claude Code on Qwen3-Coder through LM Studio, downloaded only when you choose, and models a running Ollama offers, with Claude Code or Codex.
  • Gemini CLI. Runs as an agent, its turns, tools and questions in Needs you. Your own Gemini settings are never written.
  • Accounts. Every account picker shows what each plan has left, a bar per limit.
Full release notes for 2.0.0-alpha.9

2.0.0-alpha.8

Earlier release
Older conversations. Safer publishing. — show changes for 2.0.0-alpha.8
  • History. Finds older matching conversations before applying the result limit. Keeps search available with no matches, bounds transcript previews, and refuses ambiguous conversation IDs and unreadable indexes.
  • Git consent. Requires a fresh push plan when its destination or tracked history changes. An incomplete secret check is acknowledged for the exact work that was checked.
  • Publishing. Prevents repository settings from silently adding annotated tags or pushing dependency commits to another remote when you approve a branch push.
  • Reliability. Bounds Jev and update response bodies while reading them. Strengthens real-repository and History checks. The independent audit continues.
Full release notes for 2.0.0-alpha.8

2.0.0-alpha.7

Earlier release
Safer sessions. Clearer failures. — show changes for 2.0.0-alpha.7
  • Your work. Keeps drafts you edit while a message sends, even if you return to the original text. Delayed terminal output keeps focus where you put it.
  • Sessions. Refuses to resume a missing worktree in the main checkout. Blocks late launches during shutdown and cleans up failed starts.
  • Reliability. Bounds socket connections, requests and queued output. Reports failed Git and checkpoint reads instead of showing an empty or healthy result.
  • Keyboard & checks. Makes focus rings visible in both themes and adds arrow-key selection to segmented controls. Strengthens attachment and click-crawl tests. The independent audit continues.
Full release notes for 2.0.0-alpha.7

2.0.0-alpha.6

Earlier release
Safer reads. Clearer choices. — show changes for 2.0.0-alpha.6
  • Your work. Confirms branch removal before acting. Keeps new session, chat and criterion drafts while the last one sends.
  • Reliability. Bounds file previews, rejects malformed socket messages, and releases the store after a failed start.
  • Interface. Reports project-change read errors, fixes dialog keyboard focus, and corrects update checks across versions.
  • Checks. Strengthens undo and Retry tests, fixes another slow Markdown case, and splits large modules. The independent audit continues.
Full release notes for 2.0.0-alpha.6

2.0.0-alpha.5

Earlier release
Safer undo. Steadier editing. — show changes for 2.0.0-alpha.5
  • Your work. Undo refuses when its safety check cannot finish. Large hand-edited conflicts need a marker check or your explicit acknowledgement.
  • Editing. Fixes duplicate comments, keeps a new comment draft while the last one sends, and shows branch-read errors with Retry.
  • Reliability. Hardens database startup, validates settings before changing them, and bounds unusually large Markdown and update responses.
  • Updates. Checks later release pages, respects the installed release channel, and prevents repeated menu clicks from stacking dialogs. The independent audit continues.
Full release notes for 2.0.0-alpha.5

2.0.0-alpha.4

Earlier release
It tells you when there’s a new one. — show changes for 2.0.0-alpha.4
  • Updates. Check for Updates, in the Wanigan 2 menu and in Settings, says when a newer version is out. A daily check runs only after you say yes, and sends no project or conversation data to GitHub. GitHub receives normal connection metadata.
  • Installation. This release checks for updates; installation is manual. Download the new version and replace the app. Saved projects and history stay.
Full release notes for 2.0.0-alpha.4

2.0.0-alpha.3

Earlier release
Staging refresh, corrected. — show changes for 2.0.0-alpha.3
  • Git staging. Fixes alpha.2’s brief error when a newly staged file refreshes. Whole-file and selected-line staging keep the index and remaining edits intact.
  • Checks. Stops Git 2.55 background maintenance from racing the project-write test. Its checks for unwanted file changes remain in place.
Full release notes for 2.0.0-alpha.3

2.0.0-alpha.2

Earlier release
A closer look. A sturdier desk. — show changes for 2.0.0-alpha.2
  • Your work. Keeps hand edits when a conflict view gets stale. Queues overlapping git actions and respects running agents across project folders.
  • Before publishing. Checks more outgoing history for secrets, including merge resolutions and card pull requests. Shows the actual push destinations.
  • Sessions. Waits for Codex to be ready before opening its composer. Preserves background work during core replacement. Sign-in output stays in memory, and keyboard focus stays inside open dialogs.
  • Jev & your setup. Jev respects Off for queued calls and retries, and counts every attempt. Codex settings are preserved. The Wanigan 1 import is removed.
Full release notes for 2.0.0-alpha.2

2.0.0-alpha.1

Earlier release
The first public alpha. — show changes for 2.0.0-alpha.1
  • On the desk. Project boards, Claude Code and Codex terminals, review and checkpoints, Needs you, the git workbench, and an isolated demo. For Apple silicon Macs.
Full release notes for 2.0.0-alpha.1

13Other tools

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.

QuestionWaniganT3 CodeBridgeMind
PriceFreeFreeFrom $20 a month; no free plan
Account needed to run itNoNo; an account is optional, for remote useYes
Source codeMIT, publicMIT, publicApp not public
Usage analytics in the appNoneOn by default; off with an environment variableOn by default; opt out by email
PlatformsmacOS on Apple silicon; Windows coming soonmacOS, Windows and LinuxmacOS, Windows and Linux
Latest version2.0.0-alpha.12v0.0.450.3.4
On your phoneOptional, over your own Tailscale networkiOS and Android appsApprovals from your phone
AgentsClaude Code, Codex, Gemini CLI and a shellSix, including Claude Code and CodexSix named, and “if it runs in a terminal”
Sessions outlive the windowYesYes, as a background serviceAn optional beta

14Who makes this

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 restDane Petersen

15Questions

Questions.

Is it free?
Yes. Wanigan is open source under the MIT license. Cloud agents use your own provider accounts; local models use a runtime on your Mac.
Is there a download?
Yes: a disk image for Apple silicon, with its SHA-256, under Try it. This build is ad-hoc signed and not notarized. Apple’s instructions for opening it explain the security setting.
Do I need an account?
No Wanigan account or sign-up. Claude Code, Codex and Gemini CLI use their own sign-in flows; supported local models use a runtime on your Mac.
What does it send over the network?
Update checks use GitHub; Jev uses TypeSafe when configured. Optional Phone access uses your Tailscale network, and enabled phone notifications send encrypted payloads through the browser’s push service. Agents use their configured cloud or local backends, and requested model downloads use LM Studio. See What leaves your Mac.
Which agents does it run?
Claude Code, Codex, Gemini CLI and a plain shell. Supported local models run through Claude Code or Codex. Codex does not yet detect a running session hitting its usage limit; replying from Needs you is Claude Code only.
Does it write anything into my repository?
Routine launches do not add harness configuration to your working files. Agents and actions you choose, such as project MCP settings, skill copying, setup commands and Git operations, can change repository files. Checkpoints live in Wanigan’s store; Git registers a card’s worktree in your repository.
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.