pilot

The Problem

You have 47 tickets in your backlog. You agonize over which to prioritize. Half are "quick fixes" that somehow take 2 hours each. Your PM asks for status updates. Sound familiar?

The Solution

Pilot picks up tickets from GitHub, Linear, Jira, or Asana—plans the implementation, writes the code, runs tests, and opens a PR. You review and merge. That's it.

┌─────────────┐      ┌─────────────┐      ┌─────────────┐      ┌─────────────┐
│   Ticket    │ ───▶ │   Pilot     │ ───▶ │   Review    │ ───▶ │   Ship      │
│  (GitHub)   │      │  (AI dev)   │      │   (You)     │      │  (Merge)    │
└─────────────┘      └─────────────┘      └─────────────┘      └─────────────┘

Install

Homebrew (recommended)

brew tap alekspetrov/pilot
brew install pilot

Go Install

go install github.com/alekspetrov/pilot/cmd/pilot@latest

From Source

git clone https://github.com/alekspetrov/pilot
cd pilot
make build
sudo make install-global

Desktop App

Download the desktop app from the latest release:

| Platform | Download | |----------|----------| | macOS (Universal) | Pilot-Desktop-macOS-universal.dmg | | Windows (x64) | Pilot-Desktop-Windows-amd64-setup.exe | | Linux (x64) | Pilot-Desktop-Linux-amd64.tar.gz |

Requirements

• Go 1.22+ (build only)
• Claude Code CLI 2.1.17+
• OpenAI API key (optional, for voice transcription)

Quick Start

# 1. Initialize config
pilot init

# 2. Start Pilot
pilot start --github              # GitHub issue polling
pilot start --telegram            # Telegram bot
pilot start --telegram --github   # Both

# 3. Create a GitHub issue with 'pilot' label, or message your Telegram bot

That's it. Go grab coffee. ☕

How It Works

You label issue "pilot"
        │
        ▼
┌───────────────────┐
│  Pilot claims it  │  ← Adds "pilot/in-progress" label
└───────┬───────────┘
        │
        ▼
┌───────────────────┐
│  Creates branch   │  ← pilot/GH-{number}
└───────┬───────────┘
        │
        ▼
┌───────────────────┐
│  Plans approach   │  ← Analyzes codebase, designs solution
└───────┬───────────┘
        │
        ▼
┌───────────────────┐
│  Implements       │  ← Writes code with Claude Code
└───────┬───────────┘
        │
        ▼
┌───────────────────┐
│  Quality gates    │  ← Test, lint, build validation
└───────┬───────────┘
        │
        ▼
┌───────────────────┐
│  Opens PR         │  ← Links to issue, adds "pilot/done"
└───────┬───────────┘
        │
        ▼
    You review
        │
        ▼
      Merge 🚀

Features

133 features implemented across execution, intelligence, integrations, and infrastructure.

Core Execution

| Feature | Description | |---------|-------------| | Autopilot | CI monitoring, auto-merge, feedback loop (dev/stage/prod modes) | | Epic Decomposition | Complex tasks auto-split into sequential subtasks via Haiku API | | Self-Review | Auto code review before PR push catches issues early | | Sequential Execution | Wait for PR merge before next issue (prevents conflicts) | | Quality Gates | Test/lint/build validation with auto-retry | | Execution Replay | Record, playback, analyze, export (HTML/JSON/MD) |

Intelligence

| Feature | Description | |---------|-------------| | Model Routing | Haiku (trivial) → Opus 4.6 (standard/complex), auto-detected | | Effort Routing | Maps task complexity to Claude thinking depth | | Research Subagents | Haiku-powered parallel codebase exploration | | Navigator Integration | Auto-detected .agent/, skipped for trivial tasks | | Cross-Project Memory | Shared patterns and context across repositories |

Integrations

| Feature | Description | |---------|-------------| | Telegram Bot | Chat, research, planning, tasks + voice & images | | GitHub Polling | Auto-pick issues with pilot label | | GitLab / Azure DevOps | Full polling + webhook adapters | | Linear/Jira/Asana | Webhooks and task sync | | Daily Briefs | Scheduled reports via Slack/Email/Telegram | | Alerting | Task failures, cost thresholds, stuck detection |

Infrastructure

| Feature | Description | |---------|-------------| | Dashboard TUI | Sparkline metrics cards, queue depth, autopilot status | | Persistent Metrics | Token/cost/task counts survive restarts via SQLite | | Hot Upgrade | Self-update with pilot upgrade or u key in dashboard | | Cost Controls | Budget limits with hard enforcement | | Multiple Backends | Claude Code + OpenCode support | | BYOK | Bring your own Anthropic key, Bedrock, or Vertex |

Autopilot Modes

Control how much autonomy Pilot has:

# Fast iteration - skip CI, auto-merge
pilot start --autopilot=dev --github

# Balanced - wait for CI, then auto-merge
pilot start --autopilot=stage --github

# Safe - wait for CI + human approval
pilot start --autopilot=prod --github

Telegram Integration

Talk to Pilot naturally - it understands different interaction modes:

| Mode | Example | What Happens | |------|---------|--------------| | 💬 Chat | "What do you think about using Redis?" | Conversational response, no code changes | | 🔍 Question | "What files handle authentication?" | Quick read-only answer | | 🔬 Research | "Research how the caching layer works" | Deep analysis sent to chat | | 📐 Planning | "Plan how to add rate limiting" | Shows plan with Execute/Cancel buttons | | 🚀 Task | "Add rate limiting to /api/users" | Confirms, then creates PR |

You: "Plan how to add user authentication"
Pilot: 📐 Drafting plan...
Pilot: 📋 Implementation Plan
       1. Create auth middleware...
       2. Add JWT token validation...
       [Execute] [Cancel]

You: [clicks Execute]
Pilot: 🚀 Executing...
Pilot: ✅ PR #142 ready: https://github.com/...

Send voice messages, images, or text. Pilot understands context.

Dashboard

Real-time visibility into what Pilot is doing:

┌─ Pilot Dashboard ─────────────────────────────────────────┐
│                                                           │
│  Status: ● Running    Autopilot: stage    Queue: 3        │
│                                                           │
│  Current Task                                             │
│  ├─ GH-156: Add user authentication                       │
│  ├─ Phase: Implementing (65%)                             │
│  └─ Duration: 2m 34s                                      │
│                                                           │
│  Token Usage          Cost                                │
│  ├─ Input:  124k      Today:    $4.82                     │
│  ├─ Output:  31k      This Week: $28.40                   │
│  └─ Total:  155k      Budget:    $100.00                  │
│                                                           │
│  Recent Tasks                                             │
│  ├─ ✅ GH-155  Fix login redirect      1m 12s   $0.45     │ 
│  ├─ ✅ GH-154  Add dark mode toggle    3m 45s   $1.20     │
│  └─ ✅ GH-153  Update dependencies     0m 34s   $0.15     │
│                                                           │
└───────────────────────────────────────────────────────────┘

pilot start --dashboard --github

Environment Variables

Pilot uses Claude Code for AI execution:

| Variable | Description | |----------|-------------| | ANTHROPIC_API_KEY | Custom Anthropic API key (uses your own account) | | ANTHROPIC_BASE_URL | Custom API endpoint (proxies, enterprise) | | CLAUDE_CODE_USE_BEDROCK | Set to 1 for AWS Bedrock | | CLAUDE_CODE_USE_VERTEX | Set to 1 for Google Vertex AI |

Example: Using AWS Bedrock

export CLAUDE_CODE_USE_BEDROCK=1
export AWS_REGION=us-east-1
pilot start --github

Configuration

Config location: ~/.pilot/config.yaml

version: "1.0"

gateway:
  host: "127.0.0.1"
  port: 9090

adapters:
  telegram:
    enabled: true
    bot_token: "${TELEGRAM_BOT_TOKEN}"
    chat_id: "${TELEGRAM_CHAT_ID