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
| Requirement | Details |
|---|---|
| Operating System | macOS 13 (Ventura) or later. Windows support coming soon. |
| Git | Git 2.20 or later (required for worktree support) |
| AI Provider | Anthropic account (Claude Code) and/or OpenAI account (Codex) |
| Disk Space | ~200 MB for the app, plus space for Git worktrees |
Note
Installation
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.
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.
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.
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
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
claudein 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_KEYenvironment 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
Work Modes
Orkest offers two work modes to match different stages of your workflow.
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
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:
- 1When you create a new worktree, Orkest runs
git worktree addwith a new branch - 2The agent is launched inside the worktree directory with full access to the isolated copy
- 3Changes in one worktree never affect another, or your main branch
- 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
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:
| File | Purpose |
|---|---|
CLAUDE.md | Project-specific instructions for AI agents. Architecture, conventions, commands. |
README.md | General project overview, setup instructions. |
package.json | Dependencies, scripts, project metadata. |
tsconfig.json | TypeScript configuration and path aliases. |
.env.example | Environment 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 filePer-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
Usage Metrics
Orkest tracks resource consumption across all your agent sessions so you have full visibility into your AI spend.
What's tracked
| Metric | Description |
|---|---|
| Tokens | Input and output token count per session and per model |
| Cost (USD) | Estimated cost based on provider pricing for each model used |
| Turns | Number of agent turns (request/response cycles) per session |
| Per-model breakdown | Analytics 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.
| Shortcut | Action |
|---|---|
| ⌘ N | New worktree |
| ⌘ T | New terminal tab |
| ⌘ 1-9 | Switch between worktrees |
| ⌘ G | Open Git panel |
| ⌘ Enter | Send 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.