Neon Pilot Download

Make Neon Pilot
your own.

Extensions are self-contained packages that add tools, surfaces, automations, hardware support, or integrations to Neon Pilot. The app ships with 30+ bundled system extensions, optional first-party extensions can be installed from release artifacts, and experimental system integrations stay opt-in until their upstream dependencies are ready. You can build your own in minutes — just ask your agent.

Build an extension Reference →
⊞

Add agent tools

Teach the agent new capabilities by registering executable tools. Tools appear in the agent's toolbelt alongside built-in commands like bash and read — no special prompting needed.

  • Query your database schema or run read-only queries
  • Create Jira / Linear / Asana tickets from conversation
  • Trigger CI pipelines and fetch build results
  • Search internal wikis, runbooks, or incident databases
  • Post Slack messages or page on-call engineers
  • Override built-in tools with safer or domain-specific replacements
☰

Build custom surfaces

Extensions own full pages, side panels, and workbench detail views — anything beyond the conversation. Render custom React components that feel native to the app.

  • A kanban board for agent-managed tasks and workflows
  • A build-dashboard page showing test results and deploy status
  • A right-rail file browser or database schema explorer
  • A diff inspector that pairs with git branch context
  • Custom settings panels with their own controls
  • A workbench detail pane paired with a compact rail selector
⌘

Create composer workflows

Add slash commands, composer buttons, shelves above the input, attachment providers, and hover-reveal message actions. Change how the user interacts with the agent.

  • /triage — paste a CI failure, get root-cause analysis
  • One-click "Summarize this thread" on any message
  • A context shelf showing the active PR or ticket above the composer
  • "Add screenshot" that captures a browser window as context
  • Drawing input tool for sketching architecture diagrams inline
  • Attachment providers that import from Notion, Google Docs, or clipboard
◉

Integrate hardware & input

Physical input devices can drive composer controls, toolbar actions, and commands — the same extension surfaces software actions use.

  • Push-to-talk dictation via a USB foot pedal or Stream Deck
  • Hardware controllers mapped to app commands
  • Elgato Stream Deck profiles for agent commands
  • MIDI controllers mapped to composer actions
  • Bluetooth button remotes for "new chat" or "summarize"
  • Eye-tracker or head-triggered actions for accessibility
◷

Automate & schedule

Backend services, scheduled tasks, lifecycle hooks, and turn-context providers let extensions run code on their own schedule or in response to events.

  • Daily summary digests emailed or posted to Slack
  • Auto-compact long conversations after a threshold
  • Background service that indexes your codebase
  • Health check monitors that page you when something breaks
  • Add inspectable prompt context before every turn
  • Contribute instruction layers through prompt assembly providers
⇌

Connect your stack

MCP servers, custom protocol handlers, and inter-extension calls let extensions bridge into your existing toolchain.

  • Wire in Jira, Confluence, PagerDuty, or Datadog
  • Register gateways for Discord, Slack, or other external channels
  • Export/import conversations between instances
  • Orchestrate multiple extensions together
  • Add quick-open scopes for your domain objects
  • Global search across tickets, docs, and code
✦

Adapt the agent per model

Model profiles let extensions switch tool surfaces, instructions, and hooks based on which model is running — without global config changes.

  • Expose Codex-style patch tools for OpenAI coding models
  • Replace edit with a safer diff tool for cheap models
  • Add vision-only tools when a vision model is active
  • Disable network tools for local-only model profiles
  • Apply domain-specific instructions per model tier
◇

Go deeper with agent workers

Extensions can spawn hidden or visible agent conversations — parallel research, background code review, or multi-turn automation tasks.

  • Spawn a research agent that explores a topic while you work
  • Run background code review on a PR diff
  • Batch-generate documentation, tests, or release notes
  • Orchestrate a multi-agent workflow: plan → implement → review
  • Monitor a long-running task and report results to the active conversation

Bundled with the app

System extensions cover the product surface.

These extensions ship from the Neon Pilot app repo and represent the current built-in feature set. Core stays small; the extension host, app shell, routing, persistence, and security boundaries make these product surfaces feel native.

Artifacts

Review rendered artifacts beside the active conversation.

Automations

Manage scheduled and conversation-bound automations.

Background Work

Inspect background commands and subagents linked to the active conversation.

Caffeinate

Toggle macOS caffeinate from the top bar to keep the computer awake.

Codex Compatibility

Codex-compatible tool profiles and apply_patch support for GPT coding models.

Composer Attachments

Add attachment controls to the composer.

Context Hardening

Bounds oversized tool outputs before they enter agent context.

Context Usage

Show current conversation context-window usage in the composer status bar.

Conversation Tools

Agent tools and CLI commands for conversation inspection, titles, and working directories.

Diffs

Inspect conversation checkpoints and workspace diffs.

Dynamic Workflows

Run model-authored JavaScript workflow coordinators that fan out daemon-backed subagents.

Excalidraw input

Sketch diagrams and visual context directly from the composer.

Extension Manager

Inspect, validate, reload, enable, disable, import, export, and diagnose extensions.

File Explorer

Browse workspace files beside the active conversation.

Gateways

Attach external messaging gateways to Neon Pilot conversations.

Git Status

Show the current workspace branch and diff summary in the composer status bar.

Goal Mode

Persisted goal tracking with automatic continuation across turns.

Image Probe

Inspect image attachments with a host-owned vision agent.

Local Dictation

Local Whisper.cpp dictation with composer controls, model management, and settings.

MCP

Inspect, authenticate, and call configured MCP servers, including skill-local servers.

AI Gateway

Opt-in local Responses API proxy for external coding agents; disabled by default while Codex Desktop custom-model picker fixes are pending upstream.

Model Picker

Composer model, thinking-level, and service-tier controls.

Neon Pilot CLI

Unified CLI control plane for internal agents and external callers.

OpenAI Desktop Plugin

Install the external Codex/OpenAI Desktop plugin with a Neon Pilot CLI skill and focused delegated-agent MCP bridge.

Onboarding

Create the one-time onboarding conversation for new installs.

Prompt Assembly

Inspect prompt layers, capabilities, tools, skills, diagnostics, and runtime inputs.

Reply Actions

Transcript selection reply actions and emoji draft starters.

Scratchpad

Conversation-scoped markdown scratchpad for agents and users.

Settings panels

Native extension routes for first-party settings and provider configuration.

Skills

Backend compatibility actions for agent skills; management lives in Prompt Assembly.

Telemetry

Inspect app traces, model usage, tool health, and runtime performance.

Terminal

Built-in terminal panel with PTY-backed shell integration.

Todos

Conversation-scoped execution todos for agents and users.

Web fetch

Fetch web content from agent conversations.

Extension repositories

Install more from GitHub release artifacts.

Extension repositories are GitHub repos with a root neon.extensions.json source manifest. A repo can publish one package or many. Neon Pilot reads the manifest, shows the packages in Settings → Extensions, then installs immutable .neon-extension.zip assets from GitHub releases.

1Source manifest

neon.extensions.json declares the publisher, GitHub repo, package ids, paths, channels, versions, and release tags.

2Built package

Each package contains one extension directory with extension.json, docs, assets, and prebuilt dist/ files.

3Release catalog

Releases can include neon-extension-catalog.json with versions, checksums, compatibility, permissions, and artifact names.

4User install

Users add a repo source, review compatibility and permissions, install selected packages, then update from newer release artifacts.

First-party optional repo

patleeman/neon-pilot-extensions

Neon Pilot ships with the first-party optional extension repo as the built-in source. It is the reference implementation for multi-package extension repos, release catalogs, and user-installed first-party capabilities.

Open extension repo →

Optional first-party extensions

Additional capabilities from the extension repo.

These packages are distributed from patleeman/neon-pilot-extensions and install as user extensions, so they can be enabled, disabled, updated, or removed independently of the app bundle.

Agent Browser

Control browsers and Electron apps with the agent-browser CLI.

Kitty Litter Mobile Pairing

Pair the Kitty Litter iOS app with Neon Pilot through an Alleycat-compatible bridge.

Auto Router

Composer auto-router controls and policy settings for judge-based model routing.

Browser

Browse web pages beside the active conversation and expose browser automation tools.

DS4

DeepSeek V4 Flash local model profile and DS4-shaped tools for antirez/ds4.

DuckDuckGo Search

Agent web search backed by DuckDuckGo HTML results.

Exa Search

Agent web search through Exa with extension-managed secrets.

Hermes Agent

Connect to Hermes Agent API deployments and use Neon Pilot as the session interface.

Local Models

Manage local MLX and GGUF model runtimes from one workspace.

Self Preservation

Blocks the agent from killing its own process.

Suggested Context

Suggest related conversations as pointer context for new prompts.

Video Probe

Analyze videos with a video-capable model, local mlx-vlm runtime, or OpenRouter.

Writing Studio

Document-first collaborative markdown editor with replay, suggestions, annotations, and chat.

How it works

Ask your agent to build it

You don't need to learn a new framework. Just describe the feature you want, and Neon Pilot generates the extension — manifest, frontend, backend, and all — then builds and reloads it.

Build a Neon Pilot extension that lets me browse Docker containers, view logs, and restart services from a right-rail panel.

That's the whole prompt. The agent creates the extension, registers the manifest, adds the nav item, wires the backend actions, builds, reloads, and visually verifies the result.

Learn how to build one

Common questions

Do I need to know React or TypeScript?

No. Describe the feature in plain language and the agent writes the code. You can edit the source later if you want, but it's not required. The agent handles the full loop: scaffold → implement → build → reload → verify.

How are extensions different from Pi skills or tools?

Skills are markdown instructions the agent reads. Tools are callable backend actions. Extensions are the full package — they can include skills, tools, UI surfaces, backend services, storage, permissions, and lifecycle hooks all in one self-contained bundle.

Can I share an extension with my team?

Yes. Extensions package into a single .neon-extension.zip file with everything needed. Install or import released packages through Settings → Extensions. The Extension Manager handles package installation, import/export, and diagnostics.

Are extensions safe?

Extensions are local code with declared permissions shown in the Extension Manager. Backend code runs through the extension host boundary, uses host capabilities such as ctx.shell for process execution, and is isolated from direct core or desktop internals. Review what an extension declares before enabling it.

What if the extension I want already exists?

Check Settings → Extensions. Neon Pilot ships with 30+ bundled system extensions covering tools, surfaces, integrations, and runtime features. You can also install optional first-party extensions from the GitHub repo.

Ready to build something?

Describe a feature and let your agent handle the rest.

Build an extension