A native macOS deck for orchestrating AI coding agents.

Claude Code, Codex, OpenCode, Gemini CLI, Grok, Kilo Code: every agent in its own terminal, every terminal in its own git worktree, all in one window.

Why

Terminal agents multiplied, and running four of them across ad hoc terminal tabs, each one fighting the others for the same working tree, is chaos. ork gives each agent its own terminal and its own git worktree, organized per project, in a single native window. Pure Swift and SwiftUI, no Electron.

Features

• Workspaces and organizations: register project folders and group them by company or context; each workspace runs its own agent fleet. Drag to reorder projects and organizations in the sidebar.
• Agent sessions: spawn Claude Code, Codex, OpenCode, Gemini CLI, Grok, Kilo Code or a plain shell in one click; add your own agents via agents.json.
• Agent teams: join terminals into a team; Ork routes terminal-to-terminal messages, a shared board.md holds common context, and a team pane shows members, a kanban strip, board and message log. Message shapes, a char cap, per-recipient batching and duplicate suppression keep the token spend low, and delivery waits until the recipient's CLI is quiet so injected text never fights a TUI repaint. The coordinator reviews each delivery in the owner's worktree before accepting it, free members pull the next task from a shared backlog (with (after <id>) dependencies), approved work lands as one PR per task, agents park themselves when done, and finished demands archive to a history folder. A member leaving with open tasks flags them to the coordinator, and a watchdog nudges stalled owners. A standing protocol.md lets agents recover the messaging recipe after context compaction, and a Rebrief button pushes protocol updates to a live team. On Claude Code sessions the team speaks through MCP tool calls (team_send, team_board, team_members) served by a bundled ork-mcp server; other CLIs use the file-based protocol. A pencil chip per member edits its standing role in place. Messages over the cap are never bounced or cut: they land whole in the team's artifacts/ and the recipient gets the path. The team pane renders the log as a Discord-style chat with a deterministic color and avatar per member, member chips carry agent, model, effort and role, and an Archive board button snapshots a finished demand into history/ when the coordinator never closed it; the log rotates itself into history/ past 150KB, so nothing accumulates unbounded.
• Team manager: spawn a manager from the team pane and tell it what the project needs; it reads the repo, designs the smallest team for the demand (roles and skills per member) and staffs it through orchestration tools (ork_spawn_member, ork_configure_member, ork_disband_member), every mutation waiting for your approval in Ork.
• Autopilot: a per-team toggle asks the coordinator for improvement proposals on a configurable cycle. Each proposal shows up in the team pane for approve or reject; only approved ones become board tasks, PRs still gate the landing, cycles pause above a 5h token ceiling, and learnings.md carries what cycles discover.
• Worktree isolation: each session runs on its own branch in a dedicated worktree, created with plain git worktree add.
• Git pane: commit graph, worktree strip and diff viewer; merge a worktree into its base branch or prune it without leaving the app. Session cards show uncommitted diff stats, commits ahead and commits behind base (time to rebase).
• Terminal grid, stack and focus mode: all sessions side by side, or a tab strip with one terminal expanded and the rest collapsed but alive; isolate one terminal over a dimmed backdrop, live PTY intact.
• Flow view and agent canvas: workspace and agents as a connected topology, or a Blueprints-style canvas: minimalist activity cards (live tool call, current board task, output tokens, branch, model) with a crown on the coordinator, a traveling packet for every team message, a golden flash when a 'done' reaches the lead, and open PRs with CI state hanging above the coordinator (via the gh CLI, silently absent without it). Pinch zooms the canvas; clicking a card opens the terminal in focus mode.
• Session persistence: open sessions survive a relaunch, reattach to the same worktree and resume the agent conversation where the CLI supports it.
• Idle freeze, sleep and hibernate: a session idling for ten minutes is suspended with SIGSTOP and stops burning CPU; any interaction wakes it. Right-click a terminal to sleep it manually, or hibernate it to free the CLI's memory and resume the conversation later; an optional setting hibernates long-frozen sessions automatically.
• Data pane per project: register the Postgres and Redis each project talks to, with a live reachability probe and built-in query consoles; each connection keeps a recallable query history.
• Usage dashboard: token usage from your Claude Code transcripts, 14 day chart and a per-project breakdown.
• Menu bar companion and notch glance: running agents, today's tokens and exit notifications in the menu bar; hover the MacBook notch for a panel with every session's live tool call, model, token counts and git stats, plus rate windows and estimated month spend in the header. When a claude session asks a question, the prompt appears on its row: click an option or press its number key, esc declines, all without switching windows. Hover a row to sleep, wake or hibernate the session, and message a live team as 'user' from the built-in field.
• Agent-friendly input: Shift+Enter inserts a newline, Ctrl+Backspace deletes a word, Cmd+Backspace kills the line; paste (Ctrl+V) or drop an image and its path is typed into the prompt, ready for the agent to read. Scrollback stays where you put it while agents stream; Shift+wheel and Shift+drag reach ork's scrollback and selection even when the CLI captures the mouse, and Cmd+click opens links.
• Privacy mode: one toggle narrows the sidebar, menu bar and notch to the current project's organization, so a screen recording for one client never shows the others.
• Settings (Cmd+,): dark or light theme, terminal font and size, worktree default, idle freeze, notifications, custom agents.

Install

Requires macOS 14 or newer on Apple Silicon.

One-liner, installs Ork.app into /Applications:

curl -fsSL https://raw.githubusercontent.com/rodrigooler/ork/main/install.sh | sh

Or grab the latest zip from Releases, unpack it and drag Ork.app into Applications. Releases are ad-hoc signed, not notarized, so browser downloads need the quarantine flag cleared once:

xattr -dr com.apple.quarantine /Applications/Ork.app

ork checks GitHub for a newer release on launch; when one is out, an update button shows up in the sidebar footer and swaps the app in place.

Build from source

Requirements: macOS 14+, Xcode 15+ (any recent Swift toolchain).

git clone https://github.com/rodrigooler/ork.git
cd ork
swift run -c release

Or open Package.swift in Xcode and hit Run.

Always run with -c release. Terminal emulation parses every byte the agents print; a debug build skips optimization and makes busy TUIs feel sluggish.

Sessions run inside an interactive zsh login shell, so any agent CLI on your shell PATH (claude, codex, opencode, ...) resolves exactly as in your terminal, including exports from ~/.zshrc.

Built-in agents

Agent	Command	Accent
Claude Code	claude	coral
Codex	codex	green
OpenCode	opencode	cyan
Gemini CLI	gemini	blue
Grok CLI	grok	silver
Kilo Code	kilocode	yellow
Shell	zsh	amber

Custom agents live in ~/Library/Application Support/Ork/agents.json, one entry per agent with slug, name and command, plus optional symbol (SF Symbol), tint (#RRGGBB) and resumeCommand. Edit and reload from Settings.

How worktree isolation works

When you spawn a session with the worktree switch on, ork runs:

git -C <workspace> worktree add -b ork/<agent>-<id> <parent>/.ork-worktrees/<repo>/<agent>-<id>

The agent starts inside that fresh worktree, on its own branch, so two agents never fight over the same files. Closing a session keeps the worktree on disk (no work is ever lost); merge it into the base branch or prune it from the git pane when you are done.

Architecture

Sources/Ork/
├── OrkApp.swift            entry point, window chrome, font registration
├── Theme.swift             design tokens, motion voice, backdrop, panel styles
├── Models.swift            AgentProfile, Workspace, TerminalSession, DBConnection
├── AppStore.swift          app state + JSON persistence (Application Support)
├── AgentConfig.swift       custom agents from agents.json
├── WorktreeService.swift   git worktree plumbing
├── TerminalRegistry.swift  PTY lifecycle, focus tracking, terminal font stack
├── FreezeService.swift     SIGSTOP/SIGCONT for idle sessions
├── TeamService.swift       team messaging: outbox watcher, routing, board
├── TeamChat.swift          log.md parsed into chat entries for the team pane
├── GitHubService.swift     open PRs and CI state via the gh CLI (canvas hub)
├── MCPBridge.swift         wires claude sessions to the ork-mcp team server
├── ToolTimelineService.swift  tool calls and live telemetry from Claude Code transcripts
├── PromptWatchService.swift   pending choice prompts in terminal buffers
├── LimitsService.swift     rate-limit windows from agent CLI session logs
├── GitService.swift        git plumbing for the git pane (log, diff, merge)
├── GitGraph.swift          commit graph lane assignment
├── QueryService.swift      Postgres and Redis query consoles
├── NotchPanel.swift        notch glance panel (borderless NSPanel)
├── UsageService.swift      token usage from Claude Code transcripts
├── Notifier.swift          exit notifications (osascript)
├── Reachability.swift      TCP probe for data endpoints
├── Logo.swift              brand mark, Dock icon, bundled Orbitron face
└── Views/                  SwiftUI: sidebar, grid, flow topology, git pane, team pane, data pane, usage, menu bar panel

External dependencies: SwiftTerm for terminal emulation, PostgresNIO and RediStack for the query consoles.

Design decisions and trade-offs live in docs/DESIGN.md.

Roadmap

The plan lives in ROADMAP.md. Next up: the tool timeline on session cards, the MCP bridge beyond claude, and prompt watch for more CLIs.

Inspiration

paperclip.ing, The Maestri, AgentPeek and the whole wave of agent-native tooling.

License

MIT