ProxyPilot is a Mac app, headless CLI, and MCP control layer for routing Xcode Agent traffic through a local proxy to the upstream endpoint you choose. The v1.10.2 release tightens the built-in local proxy's network surface: the listener now binds only to the macOS loopback interface at the kernel layer, adding defense-in-depth on top of the existing in-process check.
$ curl -fsSL https://micah.chat/downloads/proxypilot-install.sh | bash
ProxyPilot's built-in local proxy now binds only to the macOS loopback interface (lo0) at the kernel layer. The in-process loopback check that already rejected non-loopback clients stays in place, so this is straightforward defense-in-depth. CLI version reporting also returns to parity with the Mac app version.
The built-in local proxy now sets requiredInterfaceType = .loopback on its listener, so only connections arriving on the loopback interface are accepted at the OS layer. The existing application-layer guard that rejected non-loopback clients remains. The CLI --version output is back in sync with the Mac app.
Point ProxyPilot at a 9Router gateway and route Xcode Agent traffic through it. 9Router is treated as a local/helper provider on its local /v1 endpoint, needs no upstream provider key by default, and can store an optional endpoint token for gateways that require one.
Saved custom OpenAI-compatible providers now appear in the upstream picker, show an active state in Keys & Providers, persist across relaunch, and route with their own base URL and stored key. Custom-provider model lists and defaults stay separate from the built-in OpenAI provider.
Session History loads report-card metadata first and only decrypts prompt and output records for the session you open, instead of publishing every retained body into the UI on entry. Browsing long histories with large saved logs no longer stalls the screen.
Session-report import now runs as a background, fingerprint-gated task, so unchanged report files are skipped and decode work stays off the main actor. Refreshes feel lighter and resetting session stats cleanly cancels stale in-flight imports.
Qwen is now a direct cloud provider through Alibaba Cloud Model Studio's OpenAI-compatible DashScope route. The app keeps international and China-region key guidance separate, makes Qwen visible for existing customized provider lists, and labels the new route clearly in provider settings.
ProxyPilot defaults supported routes to Auto cache mode, gives you Auto, Observe Only, and Off controls, and keeps cache accounting disabled when caching is off. Observe Only lets you see provider-reported cache behavior without changing outbound requests.
DeepSeek requests feed token and cost data into the shared session report surfaces, including cache-aware token counts when the provider returns them. Home and menu bar cost surfaces distinguish calculated provider cost from estimates.
Anthropic /v1/messages structured-output title generation routed through OpenRouter to Gemini keeps its schema constraint instead of returning Markdown-fenced JSON. MCP tool function parameter schemas containing enum on object or array nodes are cleaned for both direct Google routing and OpenRouter→Gemini routing, so Google's validator stops rejecting the request.
Streaming requests now opt into stream_options.include_usage so OpenRouter and other OpenAI-compatible providers actually emit token counts in stream chunks and session cost can be computed. Fetch Live Models gets a search + provider + tier filter bar, which makes the ~263-item OpenRouter catalog usable instead of one long scroller.
Closes the first batch of confirmed audit issues from the v1.8.1 review: CLI daemon key exposure, unsafe JSON error fallback construction, and world-readable local log creation.
The app-open heartbeat stays minimal and version-focused, while broader diagnostics remain opt-in. Keys & Providers now guides unauthenticated Copilot users through login, distinguishes missing Copilot entitlement after GitHub auth, and offers a live sidecar check from inside the app.
The GUI can now stop CLI-owned proxies. CLI session metrics feed into the GUI Session Report Card via a shared event store. Z.ai credential verification runs before agent launch — a stored-but-rejected key stops the session before opening Claude Code. Strict MCP argument validation returns structured errors for malformed types, out-of-range ports, and invalid filters. Missing-PID process discovery ensures correct status even without a PID file. Z.ai API key minimum length (20 chars) is enforced across GUI, CLI, and MCP auth paths. The built-in proxy rejects non-loopback clients before serving any response.
A live Xcode-visible models panel refreshes /v1/models and shows the count and source. The Home dashboard now shows the running proxy's active model and flags picker changes as pending restart. A Last Xcode Agent Live Proof panel shows the most recent agent request model, status, and timestamp from the current session.
The built-in GUI proxy rejects non-loopback client connections before parsing any request, so the proxy cannot answer /v1/models on the Mac's LAN address.
The app moved to a NavigationSplitView sidebar and native grouped toolbar with macOS 26 Liquid Glass on supporting systems and solid macOS 15-safe fallbacks. A Customization hub controls appearance, accent color, default section, Home section visibility, Launch at Login, and menu bar composition.
A full Home dashboard shows running state, active provider/model, request count, tokens, cost estimates, latency, issue status, recent requests, CSV export, and reset. The CLI/MCP contract gained schema-versioned JSON output, preflight and auth_status MCP tools, and Xcode 26.5 Locally Hosted copy for local provider setup.
GitHub Copilot provider routes through xcode-copilot-server with launchd/socket activation, install/remove controls, and explicit GitHub billing boundary copy. Direct OpenAI GPT-5.x and o-series token parameter compatibility ensures translated Xcode traffic reaches the new model family correctly.
Xcode talks to a local proxy endpoint. ProxyPilot owns the routing layer: translating protocol shape, remapping model names, storing provider keys, checking setup, and keeping the selected upstream inspectable.
Uses Xcode Agent configuration to send model requests to the ProxyPilot endpoint on your Mac.
Runs on 127.0.0.1:4000, translates Anthropic and OpenAI-shaped traffic, remaps requested model names, tracks routing state, and records provider-reported usage details.
Route to z.ai, OpenRouter, OpenAI, Qwen, Gemini, Ollama/LM Studio, a Copilot sidecar, or your own OpenAI-compatible endpoint.
See running state, current provider/model, Xcode routing status, cache status, recent requests, tokens, latency, cost estimates, and CSV export from the same first screen.
Each provider has its own Keychain-backed credential state. Local providers do not ask for cloud keys, Qwen includes region-aware key guidance, and custom providers can point to your own OpenAI-compatible endpoint.
Choose appearance, accent treatment, default window section, Home dashboard sections, Launch at Login, Liquid Glass control-strip behavior, and menu bar composition.
ProxyPilot can run headless for terminal workflows, and the MCP server gives agents explicit recovery paths instead of forcing them to infer state from human strings.
Use start, stop, status --json --require-running, auth, config, models --metadata, logs, launch, and update from scripts or agent workflows.
$ proxypilot status --json --require-running
$ proxypilot models --metadata --filter tool-calling
$ proxypilot serve --mcpAgents can preflight setup, check auth state, guardedly store secrets, verify local routing, start/stop/restart the proxy, install/remove Xcode config, list upstream models, read logs, and inspect session stats.
ProxyPilot keeps provider choice explicit. It does not pretend every upstream behaves the same, and it keeps local/no-key routes separate from cloud-key flows.
| Route | Providers | Best fit |
|---|---|---|
| Cloud APIs | z.ai, OpenRouter, OpenAI, Google Gemini, xAI, Chutes, Groq, DeepSeek, Mistral, MiniMax, MiniMax CN, Qwen | Fast setup with your own provider keys and live model discovery. |
| Local gateways | Ollama, LM Studio, 9Router | No cloud API key. ProxyPilot detects localhost and avoids irrelevant key prompts. |
| Helper sidecar | GitHub Copilot sidecar via xcode-copilot-server |
OpenAI-compatible Copilot routing with clear billing/access boundaries. |
| Bring your own | Custom OpenAI-compatible endpoint | Private gateways, local labs, company proxies, or provider previews. |
GUI-owned proxy state, CLI/external listeners, cache reporting, and current-session metadata are labeled separately, so a single green light is not stretched into more certainty than it deserves.
ProxyPilot shows provider-reported cache counters when they exist. It does not claim total savings unless the provider/model response gives enough information to support that claim.
Provider keys are stored via Keychain on macOS. File-backed fallbacks use restricted permissions, and logs/diagnostics redact bearer tokens.
The default view stays short for humans. The model-routing answers are still available when someone needs to confirm a specific upstream path.
ProxyPilot runs a local Mac control layer so Xcode Agent requests can route to the upstream endpoint you choose, including cloud APIs, local Ollama or LM Studio servers, GitHub Copilot sidecars, and custom OpenAI-compatible endpoints.
No. ProxyPilot forwards model requests only to the upstream provider you configure. The app runs locally on 127.0.0.1, and broader debugging analytics remain opt-in.
ProxyPilot supports z.ai, OpenRouter, OpenAI, Google Gemini, xAI, Chutes, Groq, DeepSeek, Mistral, MiniMax, MiniMax CN, Qwen, 9Router, Ollama, LM Studio, GitHub Copilot via sidecar, and custom OpenAI-compatible endpoints.
Yes. ProxyPilot is free to download and use. You bring your own upstream provider keys, or use local providers such as Ollama and LM Studio without cloud keys.
Yes. The CLI provides start, stop, status, auth, config, models, logs, launch, update, and MCP server commands for agent workflows.
Yes. ProxyPilot translates Anthropic-style agent traffic to OpenAI-compatible upstreams, including streaming and tool-call paths, while keeping provider credentials separate.
Point Xcode Agent at ProxyPilot's local endpoint. ProxyPilot then forwards the LLM call to the upstream you choose, including z.ai, OpenAI, Ollama, a custom OpenAI-compatible URL, or any other supported provider; Xcode itself still drives the agent the same way.
Choose z.ai as the provider, add your z.ai API key, select the GLM model you want, and install the Xcode Agent configuration through ProxyPilot.
Choose a provider that hosts DeepSeek, such as Chutes or OpenRouter, add the provider key, and let ProxyPilot translate Xcode Agent requests to the selected OpenAI-compatible model route.
Yes. Qwen is available as a direct provider through Alibaba Cloud Model Studio's OpenAI-compatible DashScope route, and you can still use Qwen through OpenRouter or another compatible upstream.
Use Groq for fast hosted Llama inference, OpenRouter for broad model coverage, or any OpenAI-compatible endpoint that serves the Llama model you want.
Yes. Route through OpenRouter, Groq, Mistral-compatible gateways, or a custom OpenAI-compatible endpoint that exposes the Mistral model.
Yes. Choose OpenAI as the provider, add your OpenAI API key, and select the target GPT or o-series model. ProxyPilot handles the translated Xcode Agent request path.
Choose xAI as the provider, add the xAI API key, select the Grok model, and install or refresh the Xcode Agent route.
Yes. Choose Google Gemini directly or route Gemini through OpenRouter, then select the Gemini variant from the live model list.
ProxyPilot targets the current Xcode Agent configuration path and validates support during setup, instead of assuming every Xcode install exposes the same agent features.
No. Ollama and LM Studio routes are local no-key flows. ProxyPilot detects localhost providers and avoids irrelevant cloud-key prompts.
ProxyPilot can route through the xcode-copilot-server sidecar for OpenAI-compatible Copilot access, with clear billing and access boundaries tied to GitHub.
Yes. Bring a private gateway, lab server, company proxy, or provider preview as long as it exposes an OpenAI-compatible endpoint.
No. ProxyPilot only sits in the LLM request path. Xcode's native build, test, log, and preview integration with the agent continues to work exactly as Apple shipped it.
Yes; that is the default flow. You add your own key for the upstream provider you want, or use Ollama or LM Studio locally with no key at all, and ProxyPilot routes Xcode Agent traffic through it.
Signed, notarized, and stapled with Gatekeeper verification. Sparkle auto-update is enabled for future releases.
Settings UI, Xcode Agent setup, provider keys, Home dashboard, session stats, Sparkle updates, and menu bar controls.
$ curl -fsSL https://micah.chat/downloads/proxypilot-install.sh | bashSingle binary for terminal workflows and MCP control. Use it when you want setup, proxy control, logs, and status without opening the GUI.
$ curl -fsSL https://micah.chat/downloads/proxypilot-cli-install.sh | bash