╔══════╗ ╔══╗		██╗ ██████╗ ██████╗ █████╗ ██╗ ██████╗ ██╗██╗ ██████╗ ████████╗
║ >_ █ ║ ║██║║		██║ ██╔═══██╗██╔════╝██╔══██╗██║ ██╔══██╗██║██║ ██╔═══██╗╚══██╔══╝
╚══╦═══╝ ║██║║		██║ ██║ ██║██║ ███████║██║ ██████╔╝██║██║ ██║ ██║ ██║
 ══╩══ ╚══╝║		██║ ██║ ██║██║ ██╔══██║██║ ██╔═══╝ ██║██║ ██║ ██║ ██║
═════════════╝		███████╗╚██████╔╝╚██████╗██║ ██║███████╗██║ ██║███████╗╚██████╔╝ ██║
					╚══════╝ ╚═════╝ ╚═════╝╚═╝ ╚═╝╚══════╝╚═╝ ╚═╝╚══════╝ ╚═════╝ ╚═╝

LocalPilot gives local and hosted models the loop they need to do useful software work: inspect files, use tools, edit safely, run checks, recover from bad output, and keep going across sessions. The core is provider-neutral and the risky parts stay behind explicit permission boundaries.

LocalPilot is built so the complete coding-agent loop can run on your machine, against a model endpoint you control.

• No usage telemetry is sent. LocalPilot does not report your prompts, code, tool calls, transcripts, or usage to us.
• Local is the default. The default provider targets a local endpoint, and files, logs, transcripts, and memory remain under your control.
• Remote providers are explicit. If you configure a hosted provider, the relevant requests go to that provider—not to LocalX—and you can return to the local-only path at any time.
• You control access. Workspace boundaries, permission gates, secret redaction, and review-gated memory keep sensitive actions visible and reversible.

# Linux / macOS
curl -fsSL https://raw.githubusercontent.com/C0deGeek-dev/LocalPilot/main/install/install.sh | sh

# Windows
irm https://raw.githubusercontent.com/C0deGeek-dev/LocalPilot/main/install/install.ps1 | iex

No toolchain needed. This downloads the prebuilt localx for your platform, checks it against the published SHA-256 before unpacking, and lets it install the whole stack — localpilot, localmind, localbox, localbench — and the llama.cpp engine, at one version. The installer prints the directory to add to PATH.

localx is the stack's front door afterwards:

localx update # update every tool + the engine to the newest release
localx update --prerelease # or build each app from its latest main (dev channel)
localx status # what is installed

PowerShell users can optionally restore the compact llm* compatibility commands after installation with localx install powershell-shortcuts. The installer respects Chris Titus Tech's separate custom profile.ps1 convention and prints a manual load line instead of changing any other custom profile.

Prefer to read the script first, or build from a checkout? See docs/install.md.

Check the environment:

localpilot doctor

Create .localpilot.toml and point it at a local OpenAI-compatible server:

[provider]
default = "local"
[providers.local]
kind = "openai-compatible"
base_url = "http://localhost:8080/v1"
model = "your-local-model"

Then start a conversation:

localpilot chat

Or ask one question without tools:

localpilot ask --model your-local-model "explain this repo's error handling"

Hosted APIs use the same configuration model; add api_key_env and keep the credential in the named environment variable. The provider guide covers local servers, hosted providers, context windows, authentication, and reasoning settings.

The model is only one part of a coding agent. In a pinned comparison across 225 Aider-polyglot exercises, the same local model solved 25% of tasks raw and 92% through LocalPilot: a 67-point uplift from tools, iteration, test feedback, and recovery. With learning on it reached 95% — out-solving the Claude Code harness driving the same pinned local model (88%); a harness comparison on one model, not a model claim.

LocalPilot harness versus the raw model

All four arms on the same local model — raw 25%, LocalPilot harness 92%, Claude Code 88%, LocalPilot with learning 95%

Additional surfaces include MCP tools, rpc, acp, mcp serve, project knowledge ingestion, memory search, skill inspection, handoffs, self-review, and redacted session exports. localpilot mcp serve turns the session runtime itself into an MCP server another agent host drives: prompt (with mid-turn steer/follow_up dispositions), cancel, status, transcript, a cursor-paged events feed, and reply_permission, with --continue/--resume to pick an earlier session back up and --no-approvals for watch-and-steer coaching (the reply tool is withheld, so every ask denies). Corrections the driver makes become review-gated lesson candidates. localpilot serve + localpilot connect are an opt-in local-IPC server (a Unix socket or Windows named pipe, never a network server) that hosts sessions in one process so several clients can attach to the same session at once; it runs only when you start it, and the default in-process path is unchanged. Run localpilot --help for the complete command tree.

• Enter sends; Alt+Enter, Ctrl+J, or a trailing \ inserts a newline.
• ↑ / ↓ recalls project-scoped prompt history.
• Ctrl-C cancels the current turn or ingest run. At the prompt it is staged like a shell: with text typed (or an autocomplete overlay open), the first press clears the composer and dismisses the overlay; on an empty composer it quits.
• / opens slash-command completion; @ mentions a workspace file.
• /model changes provider or model without losing the conversation.
• /localbox serve <model> starts that exact LocalBox catalog model, adopts its provider, and switches the current idle conversation; the older /localbox adopt --serve <model> spelling remains compatible.
• /selfimprove shows the persisted self-improvement stage. Use /selfimprove start [finding-rank] to review/select and propose, /selfimprove approve <reviewer> for the explicit human gate, and /selfimprove next for each subsequent build/reload step.
• /name names the session so it can be resumed by name.
• /default, /relaxed, /bypass, and /unrestricted switch the permission profile mid-turn, taking effect from the running turn's next tool call.

The full-screen chat host runs in an alternate screen buffer and captures the mouse, so it owns timeline scrolling, text selection, and copy/paste within the application. Tool work stays compact but inspectable: its visible action names the target, completed work includes up to three indented result rows, and clicking the tool's status glyph expands or collapses the complete bounded result. Timeline search also reveals a match inside collapsed tool output. For tool-heavy sessions, [terminal] group_successful_tools = true optionally collapses runs of three or more successful tools into one expandable summary; the default remains off, and search, copy disclosure, persistence, and export stay grounded in the original tool rows. Assistant status prose is quieter too: if a later tool call proves a segment was intermediate, its filled answer dot becomes a hollow progress dot in place; the final answer keeps the filled dot, and screen readers announce progress explicitly.

The embedded LocalMind engine distills decisions, fixes, conventions, and tool recipes from your sessions — on by default as of this release, and local-only (it never leaves your machine). Candidates enter a review queue; only accepted lessons become durable, machine-wide memory and return as context in future sessions. It is review-gated and redacted, so this is disclosure, not a data grab — opt out any time with [learning] enabled = false in the project's .localmind.toml (the learning engine's config, not .localpilot.toml; see localmind-integration.md).

When embeddings are configured, a session-bearing command owns their lifecycle: LocalPilot may start LocalBox, while both LocalPilot and standalone LocalMind commands share exact endpoint/PID leases. A server you started yourself remains user-managed and is never stopped by this lifecycle. If another leased command outlives the session, a detached LocalPilot reaper waits for it before stopping only the server LocalPilot registered.

session ──> candidate lessons ──> your review ──> project memory ──> later sessions

In a controlled uplift evaluation, accepted lessons moved a deliberately headroom-rich task set from 0% to 100%, and the effect held on a second model. By default ([review] mode = "manual") nothing is written to durable memory without human review; the opt-in trusted/automatic review modes auto-promote high-confidence candidates without prompting — see localmind-integration.md.

The opt-in local server can host several agents working on one plan in one working tree. It is off unless you ask for it: nothing on the ordinary single-agent path changed.

• A task graph holds the plan. A task can decompose into children instead of doing the work, review gates can raise findings by adding work, and each completion hands on what it established so the next task reads it instead of redoing it.
• Agents message each other — one peer, or the agents you spawned. Scope is the spawn tree, so nobody can cost everyone else a turn.
• Conflict alerts are advisory, and we say so plainly. If another agent changes a file you are working in, you are told mid-turn. Nothing is locked, nothing is blocked, nothing is rolled back — both edits land, and git remains the merge substrate. What this buys you is finding out now instead of at merge time.
• When a worker dies, its unfinished work returns to the plan (bounded, so a task that keeps failing fails loudly instead of cycling), its children are reparented, and a departed coordinator is replaced deterministically. The plan and membership survive a restart.

coordinator ──seeds──> task graph ──dispatch──> workers ──handoffs──> downstream tasks
 ^ │
 └──────────── reports, conflict alerts ──────┘

cargo fmt --check
cargo clippy --workspace --all-targets -- -D warnings
cargo test --workspace
cargo check --workspace
cargo build -p localpilot --features tui
cargo clippy -p localpilot --features tui --all-targets -- -D warnings
cargo machete
cargo deny check
cargo audit

cargo build -p localpilot --features tui,keychain

LocalPilot is an original implementation, not a fork or redistribution of a vendor CLI. It uses official APIs or local servers, keeps project state local, and requires explicit approval for risky actions. Windows, Linux, and macOS are first-class platforms.

Created Maintained by C0deGeek.dev (David Ben-Yishai and Bram Hammer).

LocalPilot is the agent layer in the LocalX toolchain:

License: PolyForm Noncommercial 1.0.0

LocalX-owned source is available under the PolyForm Noncommercial License 1.0.0. Commercial use requires a separate license. See LICENSING.md for the commercial contact, the 30 August 2026 licensing boundary, and third-party terms.