Pilot
Pilot claims tickets from GitHub, Linear, Jira, or Asana, plans the implementation, writes the code, runs tests, and opens a PR — shipping your backlog while you sleep.
User confirmation is documented (prod mode requires human approval, Telegram plan Execute/Cancel buttons), external effects are bounded via PR review with optional auto-merge, and `pilot upgrade rollback` exists — each scores 2. least_privilege rests on a single README assertion ("It can only access repos you configure") with no code evidence; data-flow transparency, sensitive-data handling (tokens via env vars but no rotation/leak guidance), and dependency security (pinned go.mod but no audit story, plus two private qf-studio deps) are documentation-only — each deducted to 1.
Self-consistency is undermined by a README/go.mod contradiction (README says Go 1.22+, go.mod requires go 1.25.0) and the unverifiable '133 features implemented' claim — 1. Heavy external dependencies (Claude Code CLI 2.1.17+, Anthropic API, Telegram/GitHub services) have no fallback or availability discussion — 1. Alerts, stuck-detection, and failure notification are described but not evidenced in implementation — 1.
The FAQ explicitly delineates suitable tasks (bug fixes, small features) from unsuitable ones (large architecture, security-critical code), giving clear capability boundaries; audience/scenarios, trigger precision (pilot label, five Telegram interaction modes), and environment fit (three desktop platforms, Bedrock/Vertex backends) are concretely documented — 2 each. Full marks withheld because everything rests on documentation promises without code-level verification.
README architecture is complete (install, quick start, config, CLI reference, FAQ, license) and naming is consistent (pilot prefix across labels, branches, config); FAQ covers known limitations — 2 each. Install notes are thorough but contradict go.mod's Go version — 2. LICENSE is a complete BSL 1.1 text with named licensor and change terms — 2. No CHANGELOG file (only a release badge), and maintenance responsibility is a single individual plus Discord with no governance commitments — 1 each.
Outputs (linked PRs, dry-run preview, TUI dashboard) and cost controls (budget hard limits, ~$0.50-2.00/task estimates) are adequately documented — 2 each. Marginal value (ticket-to-PR closed loop) is real and differentiated — 2. No full marks because all effectiveness claims are unverified by execution.
Many claims (133 features, Opus 4.6 routing, cross-project memory) have no traceable implementation in the provided files — 1. README and go.mod partially corroborate each other but conflict on the Go version — 1. Marketing phrasing is interleaved with factual statements without separation — 1. Two CI workflows (benchmark, token canary) provide modest process corroboration but do not substantiate core product claims.
- Docs require Go 1.22+ but go.mod declares go 1.25.0 — verify your toolchain before building from source.
- The agent creates branches, commits code, and opens PRs autonomously; dev mode skips CI and auto-merges — always use prod mode with human approval in production.
- All safety claims (least privilege, access limited to configured repos) come from README prose and are unverified at the code level; audit the permission scope yourself before deployment.
- Two private, non-public modules (qf-studio/grom, qf-studio/studio-sdk) are dependencies, introducing supply-chain and availability risk.
- Licensed under BSL 1.1, not an open-source license; registry metadata is NOASSERTION. Hosted commercial use is restricted; converts to Apache 2.0 only after four years.
- Hard dependency on Claude Code CLI and Anthropic API means outages or model changes can break the automation pipeline.
What does this agent do, and when should you use it?
Pilot is a Go CLI tool (with a companion desktop app) from qf-studio that turns tickets into mergeable pull requests. It pulls tasks via polling or webhooks from GitHub Issues, Telegram, GitLab, Azure DevOps, Linear, Jira, and Asana, then drives the Claude Code CLI to plan, implement, and quality-check the work before opening a PR for human review. Core components include a Gateway (HTTP/WebSocket), multi-platform Adapters, an Executor managing Claude Code processes, an Orchestrator, a SQLite-backed persistent memory, plus daily brief and alerting modules. Three Autopilot modes (dev/stage/prod) control how much autonomy it gets, and a TUI dashboard shows queue depth, token usage, and cost. It runs entirely in your local environment with your own Anthropic credentials (including Bedrock/Vertex), and all changes go through PR review before merging by default.
Workflow: after you label an issue pilot, Pilot claims it (adds pilot/in-progress), creates a pilot/GH-{number} branch, analyzes the codebase and designs a solution, writes code with Claude Code, runs quality gates (test/lint/build), then opens a PR linked to the issue and marks it pilot/done. Complex tasks are auto-split into sequential subtasks via the Haiku API (Epic Decomposition), a Self-Review pass runs before pushing, and model routing auto-selects between Haiku and Opus based on task complexity. You can dispatch work directly with pilot task "Fix login bug", or via Telegram using natural-language chat, question, research, planning, or task modes (voice and images supported). Integrations include GitHub polling, GitLab/Azure DevOps adapters, Linear/Jira/Asana webhooks, Slack/email/Telegram daily briefs, and failure/cost alerting. Persistent metrics (tokens, cost, task counts) live in SQLite, and pilot upgrade provides self-update.
- Solo developers or small teams with a backlog of small bug fixes and dependency updates who want overnight batch processing and daytime PR review only
- Teams already using Linear, Jira, or Asana who want new tickets to flow into code changes automatically via webhooks
- Heavy Telegram users who want to issue development instructions by voice message or screenshot and confirm generated plans
- Engineering teams needing granular control over autonomy (skip CI, wait for CI then auto-merge, or require human approval) across dev/stage/prod
- Engineering managers who need per-project AI coding cost analytics with hard budget enforcement
What are this agent's strengths and limitations?
- End-to-end coverage from claim, branch, plan, implement, and quality gates to PR — no step-by-step human prompting required
- Tunable autonomy via Autopilot modes (dev skips CI with auto-merge, stage waits for CI, prod requires human approval)
- BYOK with Anthropic direct, AWS Bedrock, and Google Vertex, plus built-in cost metrics and hard budget limits in the dashboard
- Beyond GitHub, adapters for GitLab, Azure DevOps, Linear, Jira, Asana, and Telegram make task sources flexible
- Core execution depends on Claude Code CLI 2.1.17+, a strong vendor lock-in; it cannot run on other coding models (except OpenCode)
- Licensed under BSL 1.1: competing SaaS use is prohibited, and the license only converts to Apache 2.0 after four years
- The README explicitly states it is not suited to large architectural changes, security-critical code, or tasks requiring human judgment
- Typical API cost is ~$0.50–2.00 per task and budget controls must be configured yourself; the repo's license field is NOASSERTION, so read LICENSE to confirm terms
How do you install or deploy this agent?
Homebrew: brew tap qf-studio/pilot && brew install pilot. Go install: go install github.com/qf-studio/pilot/cmd/pilot@latest (requires Go 1.22+). From source: git clone https://github.com/qf-studio/pilot && cd pilot && make build && sudo make install-global. Desktop apps are available from GitHub Releases for macOS (universal .dmg), Windows (x64 .exe), and Linux (x64 .tar.gz). Hard requirement: Claude Code CLI 2.1.17+; optional: OpenAI API key (for voice transcription).
How do you use this agent?
1) Run pilot init to generate ~/.pilot/config.yaml with your Telegram bot_token/chat_id, GitHub token/repo, project paths, and execution mode. 2) Start with pilot start --github for issue polling, pilot start --telegram --github for both sources, add --dashboard for the TUI and --env=dev|stage|prod to pick an Autopilot mode. 3) Label a GitHub issue pilot, message your Telegram bot, or run pilot task "Add user authentication". 4) Review and merge the PRs Pilot opens. Optional environment variables: ANTHROPIC_API_KEY (BYOK), ANTHROPIC_BASE_URL, CLAUDE_CODE_USE_BEDROCK=1, CLAUDE_CODE_USE_VERTEX=1.
How does this agent compare with similar options?
The README names OpenCode as a switchable execution backend (--backend opencode); no other competitors are named.