Documentation

Everything you need to orchestrate AI coding agents with Orkest.

Orkest is a native desktop application for orchestrating multiple AI coding agents in parallel. Each agent runs in its own isolated Git worktree, so there are no merge conflicts, no file overwrites, and no waiting. You direct the work, review the diffs, and ship the results.

This documentation covers installation, configuration, and day-to-day usage of the Orkest desktop app. Whether you're a solo developer or part of a team, this guide will help you get the most out of parallel agent orchestration.


System Requirements

RequirementDetails
Operating SystemmacOS 13 (Ventura) or later. Windows support coming soon.
GitGit 2.20 or later (required for worktree support)
AI ProviderAnthropic account (Claude Code) and/or OpenAI account (Codex)
Disk Space~200 MB for the app, plus space for Git worktrees

Note

Each Git worktree creates a full copy of your working directory. Plan for additional disk space proportional to the size of your repository multiplied by the number of concurrent agents you want to run.

Installation

1. Download Orkest

Download the latest version of Orkest from the official site:

Download Orkest

2. Install the app

Open the downloaded .dmg file and drag Orkest into your Applications folder. On first launch, macOS may ask you to confirm opening an app from an identified developer.

3. Install Claude Code CLI

If you plan to use Claude Code as your agent, install the CLI globally:

npm install -g @anthropic-ai/claude-code

Then authenticate by running claude in your terminal and following the OAuth flow, or set your Anthropic API key.

4. Install Codex CLI (optional)

To use OpenAI Codex as an agent:

npm install -g @openai/codex

Authenticate with your OpenAI API key by running codex and completing the setup.


Quick Start

Get up and running in three steps.

01

Connect your repository

Open Orkest and click Open Project. Navigate to your Git repository. The Context Engine automatically detects your stack by reading project files like package.json, CLAUDE.md, and README.md.

02

Create a worktree and spin up an agent

Click New Worktree to create an isolated branch. Give it a name (e.g. feature/auth), select your agent (Claude Code or Codex), and describe the task. The agent starts working in its own isolated copy of the codebase.

03

Review, merge, and ship

Once the agent finishes, review the diffs in Orkest's built-in viewer. Stage changes, commit, push, and create a pull request — all from within the app. Merge when ready.

Tip

You can run multiple agents simultaneously. Create several worktrees with different tasks and let them work in parallel. Each one operates on its own branch with zero conflicts.

Core Concepts

Understanding these four concepts will help you get the most out of Orkest.

Agents

AI coding assistants (Claude Code, Codex) that can read, write, and modify code autonomously. Each agent runs in its own terminal session inside a worktree.

Worktrees

Isolated copies of your repository, each on its own Git branch. Worktrees allow multiple agents to work simultaneously without file conflicts.

Work Modes

Two modes of operation: Plan Mode for exploration and planning, and Agent Mode for autonomous coding.

Context Engine

Orkest's system for auto-detecting and injecting project context into every agent session. Reads CLAUDE.md, README, and project configuration files.


Agents

Orkest currently supports two AI coding agents. You can switch between them on a per-worktree basis.

Claude Code

Anthropic's autonomous coding agent. Claude Code can read and write files, run terminal commands, search codebases, and handle multi-step engineering tasks.

Authentication

Orkest supports two authentication methods for Claude Code:

  • Claude OAuth / CLI — Run claude in your terminal and complete the browser-based OAuth flow. Orkest detects the session automatically.
  • Anthropic API Key — Set your API key via the ANTHROPIC_API_KEY environment variable or in Orkest's settings.

Codex

OpenAI's coding agent. Codex can analyze codebases, write code, and execute multi-file changes.

Authentication

Connect your OpenAI account by setting the OPENAI_API_KEY environment variable or configuring it in Orkest's settings panel.

Switching agents

Each worktree can use a different agent. When creating a new worktree, select the agent from the dropdown. You can also change the agent for an existing worktree from the worktree settings panel.

Work Modes

Orkest offers two work modes to match different stages of your workflow.

Plan Mode

Explore first, code later

In Plan Mode, the agent explores your codebase, reads files, and proposes an implementation plan before writing any code. Use this when:

  • You're not sure how to approach a task
  • The task involves architectural decisions
  • You want to review the plan before the agent modifies files
Agent Mode

Autonomous execution

In Agent Mode, the agent goes fully autonomous — reading files, writing code, running commands, and iterating until the task is done. Use this when:

  • The task is well-defined and scoped
  • You trust the agent to make implementation decisions
  • You want maximum throughput with minimal intervention

Git Worktrees

Worktrees are the foundation of Orkest's parallel execution model. Each worktree is a fully independent copy of your repository on its own Git branch.

How worktrees work

Git worktrees (git worktree) let you check out multiple branches of the same repository simultaneously, each in its own directory. Orkest automates this:

  1. 1When you create a new worktree, Orkest runs git worktree add with a new branch
  2. 2The agent is launched inside the worktree directory with full access to the isolated copy
  3. 3Changes in one worktree never affect another, or your main branch
  4. 4When done, you review, merge, and clean up the worktree

Creating a worktree

Click New Worktree in the sidebar. Configure:

  • Branch name — The Git branch for this worktree (e.g. feature/auth, fix/api-bug)
  • Base branch — The branch to fork from (defaults to main)
  • Agent — Which AI agent to use (Claude Code or Codex)

Managing worktrees

The sidebar shows all active worktrees with status indicators: green for active agents, yellow for paused, and gray for idle. Click a worktree to switch to its view. Right-click to access options like deleting the worktree or changing the agent.

Best practice

Keep worktree tasks focused. Instead of one agent doing “refactor the entire app,” create three worktrees: one for the auth module, one for the API layer, and one for the frontend. Focused tasks produce better results.

Git Integration

Orkest has built-in Git operations so you never need to leave the app for version control.

Visual staging and diffs

After an agent makes changes, open the Git panel to see a list of modified files. Click any file to view a line-by-line diff. Stage individual files or all changes at once.

Commits and pushes

Write a commit message and commit staged changes directly from the app. Push to your remote in one click. Orkest also supports checkpoints — automatic intermediate commits that let you roll back if an agent goes off track.

Pull request creation

Create pull requests directly from Orkest. The app pushes the branch and opens a PR on your Git remote (GitHub, GitLab, or any standard Git host). No browser switching required.

Supported remotes

Orkest works with any Git remote that supports standard Git protocols:

  • GitHub (github.com and GitHub Enterprise)
  • GitLab (gitlab.com and self-hosted)
  • Bitbucket
  • Any remote supporting SSH or HTTPS Git protocols

Context Engine

The Context Engine is Orkest's system for automatically providing AI agents with relevant project context. Instead of manually pasting instructions, the engine detects and injects context into every agent session.

Auto-detected files

The Context Engine reads the following files from your project root:

FilePurpose
CLAUDE.mdProject-specific instructions for AI agents. Architecture, conventions, commands.
README.mdGeneral project overview, setup instructions.
package.jsonDependencies, scripts, project metadata.
tsconfig.jsonTypeScript configuration and path aliases.
.env.exampleEnvironment variable structure (not values).

Writing a CLAUDE.md

The CLAUDE.md file is the most important context file. It tells agents how to work with your specific project. A good CLAUDE.md includes:

  • Project overview and architecture
  • Build, test, and lint commands
  • Coding conventions and patterns to follow
  • Key files and their purposes
  • Things agents should avoid or be careful about

Example:

# CLAUDE.md

## Project
E-commerce API built with Express + TypeScript + Prisma.

## Commands
```bash
npm run dev     # Start dev server
npm test        # Run Jest test suite
npm run lint    # ESLint check
```

## Architecture
- src/routes/    — Express route handlers
- src/services/  — Business logic
- src/models/    — Prisma schema and types
- src/middleware/ — Auth, validation, error handling

## Conventions
- All routes return { data, error } shape
- Use Prisma transactions for multi-table writes
- Tests go in __tests__/ next to the source file

Per-worktree context

Context is injected per worktree. If your worktree is on a branch that has a modifiedCLAUDE.md, the agent will use that version. This is useful for feature branches that need specific instructions.


Integrated Terminal

Every worktree includes a fully-featured terminal powered by xterm.js. The terminal opens inside the worktree directory, so commands run in the correct context.

Features

  • Per-worktree isolation — Each terminal session is scoped to its worktree directory
  • Multi-session support — Open multiple terminal tabs in the same worktree
  • Full xterm.js — Colors, cursor movement, scrollback buffer, copy/paste
  • Shell integration — Uses your default shell (bash, zsh, fish)

Tip

Use the terminal to run tests, start dev servers, or execute any CLI command while your agent works. The terminal and agent operate independently within the same worktree.

Usage Metrics

Orkest tracks resource consumption across all your agent sessions so you have full visibility into your AI spend.

What's tracked

MetricDescription
TokensInput and output token count per session and per model
Cost (USD)Estimated cost based on provider pricing for each model used
TurnsNumber of agent turns (request/response cycles) per session
Per-model breakdownAnalytics split by model (e.g. Claude Opus vs Sonnet, GPT-4o)

Metrics are displayed in real-time in the worktree header and available in aggregate in the dashboard view. Team and Enterprise plans include advanced analytics with cross-workspace reporting.


Keyboard Shortcuts

Common keyboard shortcuts for navigating and operating Orkest.

ShortcutAction
⌘ NNew worktree
⌘ TNew terminal tab
⌘ 1-9Switch between worktrees
⌘ GOpen Git panel
⌘ EnterSend message to agent
⌘ .Stop agent execution
⌘ ,Open settings

Troubleshooting

Agent fails to start

Make sure the agent CLI is installed globally and accessible in your PATH. Run claude --version or codex --version in your terminal to verify. If using API keys, confirm they are set in your environment or in Orkest settings.

Worktree creation fails

Ensure Git 2.20+ is installed (git --version). The target branch name must not already exist. If you see permission errors, check that you have write access to the repository directory.

Context Engine not detecting files

The Context Engine reads files from the repository root. Make sure CLAUDE.md,README.md, and other config files are in the top-level directory of your Git repository, not in a subdirectory.

High disk usage

Each worktree creates a copy of your working directory. Delete unused worktrees when you're done with them. You can remove worktrees from the sidebar by right-clicking and selecting Delete Worktree.

Push or PR creation fails

Verify your Git remote is configured correctly (git remote -v). For PR creation, ensure you have the appropriate CLI tool installed (e.g. gh for GitHub). Check that your Git credentials (SSH key or token) are valid.


Support

Need help? Reach out through any of these channels.