I use more than one AI coding agent. Claude Code for some things, Codex for others, OpenCode when I want something lightweight. At some point I realized I was spending more time setting them up than actually coding.
Every agent wanted its own model settings, its own tool setup, and its own way of searching the web. Trying a new provider meant editing config files in several places, and every MCP server needed its own credentials in every agent.
So I built Prism to handle all of that in one place.
TL;DR
Prism is a free, open-source (MIT) app that sits between your AI coding agents and everything they connect to. It runs on Windows, macOS, and Linux, lives in your system tray, and gives you:
- Any agent with any model provider. Use Claude Code with a non-Anthropic model, or Codex with a different provider, without the two needing to be compatible.
- One MCP endpoint. Manage your MCP servers once and share them across agents, with credentials kept in Prism instead of copied into every config.
- Free web search. A built-in local search engine with no API keys, or your own hosted search provider if you prefer.
- One-click setup for 14 agents, plus a web admin page and a usage dashboard.
Download Prism · Docs · GitHub
The problem: everything is set up separately
If you use AI coding agents regularly, this probably sounds familiar:
- Each agent only works with certain model providers, because they speak different "languages."
- Every agent keeps its settings in a different file and format.
- Adding a new model means updating several tools by hand.
- MCP servers need to be configured, and given credentials, again in every agent.
- Web search usually means signing up for yet another paid API.
None of this is hard on its own. It just adds up, and it gets in the way every time you want to try a new model or a new agent.
Pain point 1: "Can I use my favorite agent with a different model provider?"
Often the answer is "not without a lot of work."
Prism acts as a translator. You point your agent at Prism, and Prism talks to the provider you choose. Everything is translated on the fly, including streaming, tool use, images, and reasoning.
Providers that work out of the box or with a custom setup:
- Ready on first run: Ollama Cloud and OpenCode Go
- Any OpenAI-compatible service: OpenRouter, Groq, Together AI, DeepSeek, Mistral, Cohere, Fireworks, Cerebras
- Local servers on your own machine: Ollama, LM Studio, llama.cpp, vLLM
- No API key at all: sign in with your Codex (OpenAI) account
You pick the agent you like and the model you want, and they just work together.
Pain point 2: MCP servers need credentials in every agent
MCP (Model Context Protocol) is how agents get extra abilities, like working with GitHub, databases, or browsers. The catch is that each agent has its own place to configure it, and each one needs its own copy of your keys.
Prism includes an MCP gateway that fixes this:
- One endpoint for everything. Point your agents at Prism and it serves every server you've enabled. You can also give each agent its own allowlist, so an agent only sees the servers you choose.
- Credentials stay in Prism. Agents authenticate with Prism's token. Prism holds the upstream OAuth tokens and API keys, and opens your browser to sign in the first time a server needs it.
- A built-in marketplace. Browse and install servers from the MCP tab. The catalog is cached locally, so browsing is instant and works offline.
- Works with both kinds of servers. Local processes and remote HTTP servers are both supported, started on demand and shut down when idle.
- No name clashes. Tools are labeled by server, so two servers can offer a tool with the same name without colliding.
You manage your tools in one place, and your secrets stay in one place too.
Pain point 3: every agent has its own settings
Even without MCP, each agent keeps its model settings somewhere different. Adding one model could mean editing several files.
Prism's Agents tab detects which agents you have installed and sets them up with one click. Each one gets its own config written for it, and Prism keeps everything in sync when you add or remove models later. A Disable button cleanly removes what it added.
Supported agents with one-click setup: Claude Code, Codex Desktop and CLI, Factory Droid, OpenCode, ZCode, Zed, Oh My Pi, Grok Build, Pi, Kimi Code, Prime Agent, Empryo, Hermes, and DeepSeek Harness.
Anything else that speaks the OpenAI or Anthropic format works too, including Cursor, Continue, Aider, Windsurf, Trae, and your own scripts.
Pain point 4: mixing different models in one workflow
Not every task needs the biggest, most expensive model. With Prism you can assign each model to its own provider and use them side by side. For example, a powerful model for hard problems and a faster, cheaper one for quick tasks or sub-agents.
If an app asks for a model your provider doesn't offer, Prism can quietly swap in one you've picked instead, so nothing breaks. Mapping an old Claude model name to a DeepSeek model, for instance, doesn't require touching any client settings.
Pain point 5: web search shouldn't need another subscription
Agents are far more useful when they can look things up, but search APIs usually mean another account, another key, and another bill.
Prism can run a free local search engine on your own computer. It pulls results from Google, Bing, DuckDuckGo, and dozens of other engines, with no keys and no limits. When an agent tries to search the web, Prism handles it automatically.
Prefer a hosted service? Point Prism at Exa, Tavily, Brave, Serper, or any custom search endpoint, and every agent switches over at once.
One honest note: the local search is optional, and the first-time setup takes a minute or two as Prism installs it in its own private environment.
Pain point 6: heavy tools for a simple job
I didn't want something that takes over my machine just to pass requests along. Prism is a single small app with no runtime to install: no Python, no Node, no Docker. It starts almost instantly and sits quietly in your system tray.
If you need a full server-side gateway for a big team, a tool like LiteLLM may suit you better. Prism is built for individual developers on their own machines. (There's a side-by-side comparison on the site.)
Pain point 7: no idea what you're using
When several agents share the same setup, it's hard to know where your usage goes. Prism includes a dashboard with live speed, token counts, a breakdown by client, and historical charts, all stored locally on your computer.
Adding a model is easy too. Type its name and Prism fills in the details (context size, vision support, reasoning, tool calling) from models.dev.
Works on Windows, macOS, and Linux
- Windows: a per-user installer that needs no admin rights, or a portable version.
- macOS: a disk image you drag into Applications.
- Linux: a portable AppImage. Make it executable and run it.
The tray icon, launch-at-login, and admin page work on all three.
Getting started
- Download Prism from the download section and run it. A tray icon appears.
- Open the admin page from the tray icon.
- Add a provider and your API key, or sign in with your Codex account.
- Add the models you want to use.
- Click Setup next to each agent you use, then install MCP servers from the MCP tab if you want shared tools.
The docs walk through each step in more detail.
What it can't do (yet)
- Some less common features aren't supported yet, such as prompt caching and a few built-in tools beyond web search.
- Cursor only allows custom providers on its paid plan. That's a Cursor limitation, not a Prism one.
- Prism is a young project that changes quickly, so expect some rough edges. If something breaks or is missing, tell me on the feedback board or open a GitHub issue.
A note on cost and privacy
Prism is free and MIT licensed, with no paid tier. You still pay your model providers as usual. If you'd like to support development, there's a GitHub Sponsors page.
Prism sends at most one anonymous heartbeat per day so I can count installs. It includes a random ID, the app version, your operating system, and a rough usage bucket. It never includes your prompts, model names, API keys, URLs, or file paths. It's on by default and you can turn it off in one click. The details are public in the telemetry document.
FAQ
What is Prism?
A free, open-source app that connects AI coding agents to any model provider, shares MCP servers between them, and gives them free local web search.
Can I use Claude Code with a non-Anthropic model?
Yes. Prism translates between Claude Code and the provider you choose, so you can use models from Ollama Cloud, OpenRouter, Groq, DeepSeek, and others.
What is an MCP gateway?
A single endpoint that gives AI agents access to MCP tool servers, so you set tools up and store credentials once instead of in every agent.
Does it work with local models?
Yes. Add Ollama, LM Studio, llama.cpp, or vLLM as a custom provider.
Do I need Python or Docker?
No. Prism is a single app with no runtime dependencies. Python is only used internally, in a private environment, if you turn on the optional local search.
Is Prism free?
Yes. It's MIT licensed and there's no paid tier. You still pay your model providers.
Which platforms does it support?
Windows, macOS, and Linux.
Try it
If this solves a problem you've run into, I'd love your feedback, bug reports, and stars:
Which agents or MCP servers should I support next? Let me know in the comments.
Top comments (0)