Inside Magpie, the Universal Remote for AI Coding Agents

The Parallel-Agent Workflow Has a Configuration Problem

Simon Willison recently documented a development practice that would have seemed excessive a year ago: engineers running multiple Claude Code or Codex CLI instances simultaneously, sometimes against the same repository or across git worktrees [6]. The agents handle distinct tasks—researching unfamiliar libraries, tracing codepaths across large systems, resolving deprecation warnings, or implementing detailed specifications—while the human reviews the output. It is an efficient division of labor, but it multiplies configuration friction. Each agent stores its model preferences in a different file format, in a different corner of the filesystem, and speaks to a different API endpoint. Claude Code uses a JSON file in its own directory. Codex uses TOML. Gemini CLI splits settings between JSON and environment variables. OpenCode uses JSONC. Switching from one model to another means editing all of these files by hand, hoping that no tool strips comments or reorders keys in the process. The overhead scales with the number of agents, which is exactly the wrong direction for a workflow meant to reduce cognitive load.

A Switchboard, Not Another IDE

Magpie, an open-source project by yetone, responds to this fragmentation with a deliberately narrow scope. It is a single screen—available as a menu bar drop-down, a resizable window, a terminal user interface, or a plain command-line interface—that lists every installed agent and the model it currently targets. Click a value, pick a model, and the change is written back. The desktop binary weighs under fifteen megabytes and uses the system webview through Wails, so nothing heavy is bundled. A terminal-only build shrinks to seven megabytes and cross-compiles anywhere. The interface is plain HTML over the native webview, with brand icons pulled from an open-source set. It is utilitarian by design, showing only agents that are actually installed or configured, and offering nothing in the way of chat, history, or editing features. In the terminal view, arrow keys navigate between agents and fields, enter opens a filtered picker, and typing searches or accepts custom values. Profiles appear as chips at the bottom of the screen. The aesthetic is that of a system preference pane, not a productivity suite.

What elevates it above a simple dashboard is that Magpie writes back to the agent’s own configuration files surgically. When you change a model, it touches only the key that changed inside the agent’s settings JSON, TOML, JSONC, or YAML, leaving comments, ordering, and indentation intact. Writes are atomic. For developers who version-control their dotfiles, this precision matters; a tool that reformats JSON or drops TOML comments will quickly be uninstalled.

The Gateway Is the Real Product

The genuinely special architecture lives at a local loopback address. Magpie runs a gateway on port 3425 that exposes paths matching OpenAI chat completions, OpenAI Responses, Anthropic Messages, Google Gemini generate-content endpoints, and a catalog listing. Every agent on the machine is pointed at this single URL. The gateway translates between protocols, handling streaming responses and tool calls in both directions. Models are addressed in a unified namespace, provider slash model, so the caller does not need to know whether the backend speaks OpenAI or Anthropic protocol.

This turns Magpie into an API mesh for local development. Codex, which expects an OpenAI-compatible endpoint, can consume a DeepSeek model without caring about DeepSeek’s native API shape. Claude Code, which expects Anthropic’s Messages API, can be aimed at a Gemini model because Magpie handles the translation. Requests pass straight through when the vendor already speaks the agent’s native protocol and are translated otherwise, streaming and tool calls included. The gateway fetches live model lists from vendors, refreshes a background catalog from models.dev, and exposes exactly what is available. A model released this morning appears in the picker on the next refresh. Custom providers need only a name and a base URL; presets cover several dozen vendors from Anthropic to SiliconFlow to Ollama. Vendors can even hand users a ready-made import link that pre-fills the endpoint and key, though nothing is saved until the user confirms.

Subscription Sharing Without Key Extraction

Perhaps the cleverest trick is how Magpie treats existing agent logins as first-class providers. If you have signed in to Claude Code, Codex, GitHub Copilot, or Devin, Magpie reads those credentials from their standard storage and exposes the subscription’s models to every other agent. Claude Code credentials live in the macOS Keychain or a dotfile in its home directory. Codex keeps its ChatGPT login in an auth JSON file. Copilot stores a GitHub login in the GitHub Copilot apps file. Devin keeps credentials in a TOML file. No API key is copied; no new OAuth flow is required. The gateway proxies the request using the original agent’s token, refreshes rotated tokens back to where the agent expects them, and stores nothing but your model selections.

This is not always clean. Anthropic classifies another agent’s system prompt as third-party traffic even when the OAuth request otherwise looks legitimate, so Magpie drives the genuine local Claude Code binary for every Claude-subscription generation, bridging the caller’s tools into that live turn over MCP and resuming the same process afterward. For Devin, Magpie communicates over ACP in an isolated home directory, sharing only the sign-in. The ChatGPT backend only supports streaming and rejects certain parameters, so Magpie translates non-streaming requests and drops what the backend would refuse. A Gemini CLI Google account integration is listed as planned but not yet implemented. These are elaborate workarounds, documented as constraints rather than afterthoughts.

Profiles and Portability

Beyond per-agent tweaks, Magpie offers profiles: snapshot every agent’s settings under a name and restore them all in one move. This turns a multi-agent setup into a reproducible configuration. Backup and restore are encrypted on the machine with AES-256-GCM, so provider keys and model selections can move between workstations without leaving plaintext on disk. A backup can also be written without keys, allowing settings and profiles to travel while credentials stay behind.

The Landscape: Menu-Bar Utilities and Multi-Agent Frameworks

Magpie is not the only menu-bar utility chasing the AI-assisted developer. ClaudeBar is a native macOS client focused specifically on Claude, offering menu-bar readouts, Touch Bar support, and a provider extension system; it has accumulated 1.5k stars [11]. ControlTower tracks usage and quotas across Claude, Cursor, Copilot, and Gemini [5]. The App Store offers One Chat, a floating menu-bar browser for pinning favorite chatbots and websites [8]. These tools are useful, but they are single-purpose: consumption, tracking, or browsing. Magpie is infrastructure. It sits below the agents, normalizing their access to models and authentication.

The timing aligns with a broader push toward multi-agent orchestration. One recent framework proposes a three-phase workflow—Plan, Build, Review—where a lead agent delegates to specialist sub-agents working in parallel with non-overlapping file ownership [12]. As these patterns mature, the assumption that a developer manually configures each agent’s endpoint and key becomes untenable. Magpie treats agents like interchangeable consumers of a unified model catalog, which is the configuration layer that parallel-agent workflows implicitly require.

Visible Rough Edges

The documentation is candid about limitations. Windows and Linux builds are not yet signed, so Windows SmartScreen will challenge the first run. The ChatGPT backend translation is lossy for non-streaming requests. Claude subscription support requires the Claude Code binary to be installed and signed in locally. The Gemini CLI Google account integration is still on the roadmap. These are not fatal flaws, but they are real constraints that keep Magpie in the power-user camp for now.

Outlook

Magpie’s bet is that the number of AI coding agents will continue to proliferate faster than any single vendor can unify them. By providing a local gateway, a live model catalog, and a way to reuse existing subscriptions across tools, it turns a fragmented mess of config files into something resembling a system preference pane for LLM access. The import links and vendor presets suggest an ambition to make provider onboarding as portable as sharing a URL. The seven-megabyte terminal build, which cross-compiles anywhere, suggests the gateway could run on headless development servers as easily as on a laptop. Whether Magpie becomes a standard depends on how quickly agents themselves adopt multi-provider support, but the auth fragmentation—OAuth flows, proprietary CLI sessions, API keys in disparate formats—gives its broker role plenty of runway. For now, it is one of the few tools acknowledging that the future of coding is not one agent, but many, and that someone needs to manage the wiring.