โโโโโโโ โโโโโโ โโโโโโโ โโโโโโโโโ โโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโ โโโ โโโ โโโ โโโโโโโ โโโโโโ โโโ โโโ โโโ โโโ โโโโโโโโโโโโโโโโโโโโ โโโ โโโ โโโโโโโโโโโ โโโโโโโ โโโ
AI that ships your tickets while you sleep
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?
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) โ
โโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโ
brew tap qf-studio/pilot
brew install pilotgo install github.com/qf-studio/pilot/cmd/pilot@latestgit clone https://github.com/qf-studio/pilot
cd pilot
make build
sudo make install-globalDownload 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 |
- Go 1.22+ (build only)
- Claude Code CLI 2.1.17+
- OpenAI API key (optional, for voice transcription)
# 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 botThat's it. Go grab coffee. โ
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 ๐
133 features implemented across execution, intelligence, integrations, and infrastructure.
| 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) |
| 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 |
| 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 |
| 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 |
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 --githubTalk 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.
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 --githubPilot 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 --githubConfig 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}"
github:
enabled: true
token: "${GITHUB_TOKEN}"
repo: "owner/repo"
pilot_label: "pilot"
polling:
enabled: true
interval: 30s
orchestrator:
execution:
mode: sequential # "sequential" or "parallel"
wait_for_merge: true # Wait for PR merge before next task
poll_interval: 30s
pr_timeout: 1h
projects:
- name: "my-project"
path: "~/Projects/my-project"
navigator: true
default_branch: main
daily_brief:
enabled: true
schedule: "0 8 * * *"
timezone: "Europe/Berlin"
alerts:
enabled: true
channels:
- name: telegram-alerts
type: telegram
severities: [critical, error, warning]
executor:
backend: claude-code # "claude-code" or "opencode"pilot start # Start with configured inputs
pilot stop # Stop daemon
pilot status # Show running tasks
pilot init # Initialize configuration
pilot version # Show version infopilot start # Config-driven
pilot start --telegram # Enable Telegram polling
pilot start --github # Enable GitHub issue polling
pilot start --linear # Enable Linear webhooks
pilot start --telegram --github # Enable both
pilot start --dashboard # With TUI dashboard
pilot start --no-gateway # Polling only (no HTTP server)
pilot start --sequential # Sequential execution mode
pilot start --autopilot=stage # Autopilot mode (dev/stage/prod)
pilot start -p ~/Projects/myapp # Specify project
pilot start --replace # Kill existing instance firstpilot task "Add user authentication" # Run in cwd
pilot task "Fix login bug" -p ~/Projects/myapp # Specify project
pilot task "Refactor API" --verbose # Stream output
pilot task "Update docs" --dry-run # Preview only
pilot task "Implement feature" --backend opencode # Use OpenCodepilot upgrade # Check and upgrade
pilot upgrade check # Only check for updates
pilot upgrade rollback # Restore previous version
pilot upgrade --force # Skip task completion wait
pilot upgrade --no-restart # Don't restart after upgrade
pilot upgrade --yes # Skip confirmationpilot brief # Show scheduler status
pilot brief --now # Generate and send immediately
pilot brief --weekly # Generate weekly summary
pilot metrics summary # Last 7 days overview
pilot metrics summary --days 30 # Last 30 days
pilot metrics daily # Daily breakdown
pilot metrics projects # Per-project stats
pilot usage summary # Billable usage summary
pilot usage daily # Daily breakdown
pilot usage export --format json # Export for billing
pilot patterns list # List learned patterns
pilot patterns search "auth" # Search by keywordโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ PILOT โ
โโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค
โ Gateway โ HTTP/WebSocket server, routing โ
โ Adapters โ Telegram, Slack, GitHub, Jira, Linear, Asana โ
โ Executor โ Claude Code process management โ
โ Orchestrator โ Task planning, phase management โ
โ Memory โ SQLite + cross-project knowledge graph โ
โ Briefs โ Scheduled reports, multi-channel delivery โ
โ Alerts โ Failure detection, cost monitoring โ
โ Metrics โ Token usage, execution analytics โ
โโโโโโโโโโโโโโโโดโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
make deps # Install dependencies
make build # Build binary
make test # Run tests
make lint # Run linter
make dev # Development mode with hot reloadIs this safe?
Pilot runs in your environment with your permissions. It can only access repos you configure. All changes go through PR review (unless you enable auto-merge). You stay in control.
How much does it cost?
Pilot is free. You pay for Claude API usage (~$0.50-2.00 per typical task). Set budget limits to control costs.
What tasks can it handle?
Best for: bug fixes, small features, refactoring, tests, docs, dependency updates.
Not ideal for: large architectural changes, security-critical code, tasks requiring human judgment.
Does it learn my codebase?
Yes. Pilot uses Navigator to understand your patterns, conventions, and architecture. Cross-project memory shares learnings across repositories.
Business Source License 1.1 ยฉ Aleksei Petrov
| Use Case | Allowed |
|---|---|
| Internal use | โ |
| Self-hosting | โ |
| Modification & forking | โ |
| Non-competing products | โ |
| Competing SaaS | โ (requires license) |
Converts to Apache 2.0 after 4 years.
Contributions welcome. Please open an issue first for major changes.
git checkout -b feature/my-feature
make test
# Submit PRStop agonizing over tickets. Let Pilot ship them.
Built with Claude Code + Navigator