Open Island: a menu-bar control surface for Claude Code, Codex and 13 other agents

The problem: agent sessions that block silently

A coding agent running in a terminal is a long-lived process that periodically stops and waits. Sometimes it waits for a tool permission. Sometimes it finishes a turn. Sometimes it dies. If you run one agent in one terminal, you notice. If you run Claude Code in one tab, Codex in another, and Gemini CLI in a third, the waiting process is invisible until you tab back to it.

Open Island targets that gap. The README frames it as an open-source answer to a closed-source paid app of the same shape, and its stated design goals are local-first, native macOS, and multi-agent. The intended user is a developer who already has two or more agents installed and wants one surface that says which session is blocked and which one is idle. It is not a terminal, not an editor, and not an agent launcher: it observes and routes you back.

The claim worth scrutinising is the breadth. The compatibility table lists 13 agents and more than 15 terminals and IDEs. Breadth in a tool like this comes from adapters, and adapters are where the support quality actually varies.

How the hooks and jump-back actually work

There is no daemon protocol between Open Island and your agents. Integration is through each agent's own hook or extension mechanism, which the app installs for you. For Claude Code the README describes hook integration plus JSONL session discovery and a status line bridge for usage tracking. For Codex it lists SessionStart, UserPromptSubmit and Stop as the default hooks, with PreToolUse and PostToolUse parseable but not enabled by default. OpenCode uses a JS plugin. Pi and Oh My Pi use a TypeScript extension written to `~/.pi/agent/extensions/open-island.ts` and `~/.omp/agent/extensions/open-island.ts` respectively.

Several agents are Claude Code forks and reuse the same hook payload, with configuration living in that fork's own file: `~/.qoder/settings.json`, `~/.qwen/settings.json`, `~/.factory/settings.json`, `~/.codebuddy/settings.json`. Cursor reads `~/.cursor/hooks.json` and Gemini CLI reads `~/.gemini/settings.json`. Kimi CLI uses `[[hooks]]` entries in `~/.kimi/config.toml`. Grok Build writes to `~/.grok/hooks/open-island.json`.

The second half is jump-back. Terminals with full support are targeted precisely: TTY matching for Terminal.app, ID matching for Ghostty, session ID or TTY for iTerm2, session/window/pane targeting for tmux, CLI pane targeting for WezTerm, Kaku and Zellij, a Unix socket API for cmux. Warp is handled differently again, via a SQLite pane lookup plus an accessibility menu click. IDEs sit at a lower tier labelled Workspace: VS Code, Cursor, Windsurf and Trae are activated through their own CLI, Zed activates the app or opens the project folder, and JetBrains IDEs are listed as a family.

That tiering is the honest part of the design. Precise pane targeting needs a terminal that exposes a way to address a pane. An IDE that only knows about workspaces cannot receive a pane-level jump, so Open Island activates the workspace and leaves you to find the tab. The README does not claim otherwise.

Installing Open Island and wiring up one agent

The README's Quick Start offers two paths. Option 1 is a DMG download from the releases page; the build is described as signed and notarised, with Sparkle handling automatic updates. Option 2 is the repository path, and the repository root contains `Package.swift`, `Sources/`, `Tests/` and a `scripts/` directory, so a Swift toolchain build is the intended route for anyone working from source.

If you build from source, the standard SwiftPM flow applies:

swift build
swift run

After the app is running, agent integration is not automatic. The README describes a Settings panel with hook install and uninstall actions, and that is where you enable a specific agent. For Claude Code the resulting configuration is a hooks entry in the agent's own settings file; the README does not print the exact JSON it writes, so inspect the file after installing rather than assuming the shape.

For the TypeScript-based agents the app writes a file you can read directly:

ls ~/.pi/agent/extensions/open-island.ts
ls ~/.omp/agent/extensions/open-island.ts

What you should see is a file at that path after enabling Pi or Oh My Pi in Settings. If it is absent, the extension was not installed and that agent will not report sessions.

The remaining configuration surfaces named in the README are the notification mode (an auto-height panel for permission requests and session events), configurable notification sounds with a mute toggle, and i18n for English and Simplified Chinese.

Where Open Island stops: macOS only, and hooks are the failure mode

The first constraint is stated plainly by the project itself: native macOS, SwiftUI plus AppKit. There is no Windows or Linux build described, and the notch overlay only makes sense on a notched Mac, with a top-centre bar as the fallback on other machines. If your agents run on a remote Linux box over SSH, Open Island is watching the wrong machine.

The second constraint is structural. Every agent integration depends on a hook firing. If an agent changes its hook schema, or a fork diverges from the Claude Code payload it was cloned from, the adapter breaks and the session simply stops appearing. The README already flags one such gap: Grok Build has session tracking and terminal jump-back but no permission round-trip yet, and it uses a camelCase payload rather than the Claude shape. That is a working integration with a missing feature, and it is the kind of note that tells you the table's Supported column is not uniform.

A subtler case is the Claude Code Desktop App. The README explains that Claude Desktop runs Claude Code as a TTY-less subprocess that process discovery cannot see, so liveness follows the running desktop app instead, and the usage panel is account-wide but seeded by the CLI status line. That is a real limitation of the discovery model, documented rather than hidden.

Finally, hook installation means the app writes into configuration files belonging to other tools. The README documents install and uninstall in Settings, but it does not document rollback for a partially applied hook set, and it does not describe what happens if two tools write the same hooks file. Back up those config files before enabling anything.

Open Island versus Vibe Island and versus doing nothing

The README names its reference point directly: an open-source take on Vibe Island, described as free, local-first, and yours to fork. The approach difference is licensing and distribution rather than features. Vibe Island is the closed-source app the README positions against; Open Island is GPL-3.0, ships as source in a Swift package, and carries a `PRIVACY_POLICY.md` at the repository root alongside a stated no-server, no-telemetry, no-account posture.

A second alternative is the one most people actually use: nothing. Terminal multiplexers already give you a session list, and both tmux and Zellij appear in the compatibility table as jump-back targets. The difference is what each one knows. tmux knows panes and windows; it does not know that a pane is blocked on a permission prompt, because that information lives in the agent's hook stream. Open Island's value is exactly that hook-derived state, and if you only ever run one agent in one window, the multiplexer already answers the question you have.

A third comparison is a general notification tool. Those can alert you that a process produced output, but they cannot route you back to a specific pane with TTY or session-ID targeting, and they cannot render an approve-or-deny panel for a permission request. The jump-back table is the part of Open Island that is hardest to reproduce with shell glue.

Maintenance, licence and what upgrading costs you

The last push to the default branch was on 2026-09-03, the same day v1.2.0 shipped, with v1.1.9 hours earlier and v1.1.8 on 2026-08-24. The release cadence in the recent window is tight, and the version notes are feature-shaped rather than fix-only: Grok Build, Pi and Oh My Pi in v1.2.0, usage windows and Conductor plus stability fixes in v1.1.9, Zed support and display reliability in v1.1.8.

That cadence has a cost for anyone who depends on it. Each new agent adapter is another hook file the app may write into, and each new terminal is another jump-back path that can regress when that terminal updates. The repository carries `appcast.xml`, so Sparkle auto-update is wired up, which means upgrades arrive without you choosing them. If you have customised an agent's settings file, an update that re-installs hooks can overwrite your edits. Pin a version if that matters.

The licence is GPL-3.0, per the repository's `LICENSE` file and the README badge. That matters if you intend to ship a modified build: GPL-3.0 is a copyleft licence, so distributing a derivative generally carries source-disclosure obligations. Using the app yourself is a different question from redistributing a fork, and the specifics depend on your situation; this is not legal advice, and the licence text is the authority.

Editorial conclusion

Adopt Open Island if you run several coding agents on a notched Mac and lose track of which terminal is waiting on a permission prompt; the hook-based integration is the whole product, so check that your agent is in the compatibility table before installing. Skip it if you work on Windows or Linux, or if you are unwilling to let a third-party app write hook entries into agent config files under your home directory. Before trusting it, install one agent's hooks, confirm the entries appear in that agent's own config file, and verify that uninstalling removes them again.

Frequently asked questions

Official sources

1. Issues
2. License: GPL-3.0
3. Octane0411/open-vibe-island on GitHub
4. README
5. Releases