For most of v1.x, the only way to operate Prism — change cache settings, set routing policy, cap a budget, audit who did what — was through the web dashboard. That was fine when the product was an OpenAI-compatible chat endpoint plus a small marketing site. It stopped being fine the moment we asked customers to live with Prism in production.
v1.8 closes that gap. Three new surfaces, all backed by the same underlying API:
prismCLI —pip install ssimplifi-cli, 19 commands, every operational action from the dashboard scriptable.
prism-mcpserver —npm install -g ssimplifi-prism-mcp, runs in Claude Desktop / Cursor / Zed / Continue / Cline, exposes Prism's tools to whatever AI is running there.
Python + Node SDKs —pip install ssimplifi/npm install ssimplifi-prism, drop-in replacements for the OpenAI SDK in each language, with Prism kwargs added.
Plus the API itself — every dashboard route now accepts a regular API key, the OpenAPI spec is publishable at https://api.ssimplifi.com/v1/openapi.json, and Swagger UI is mounted at /v1/docs. The dashboard remains the friendliest surface; it just no longer the only one.
Why three, and why now
The honest reason is friction. I find myself running half my own dev work through CLIs. So do the engineers I've shown Prism to. Telling a developer "log into the web dashboard to update your cache TTL" when they're knee-deep in a deployment is the wrong UX. If the product is built for developers, every operational surface needs to be programmable.
MCP was the harder call. Anthropic launched the protocol in October 2024; by mid-2026 every serious AI-coding client speaks it. That's a distribution channel — when an AI assistant can call your gateway directly as a tool, the question shifts from "should I integrate Prism" to "Prism is already there." Three months ago this would have been speculative. Now it's table-stakes for any developer-facing AI infrastructure product.
SDKs were the lowest-cost win. We've been telling customers "we're OpenAI-compatible — just change the base URL." That's technically correct, but in practice the X-Prism-* headers (mode, session_id, cache) require extra_headers={"X-Prism-Mode": "..."} ceremony on every call. A first-party SDK that exposes them as Python kwargs or TypeScript fields makes the API feel like a real product instead of "OpenAI plus weird headers."
What's new in the API
v1.8 P1 (the API completeness pass) is the prerequisite for everything else. Two real changes:
Dual auth on every dashboard route. Before P1a, account-management endpoints — cache, policy, budget, audit, workspaces — required a Supabase JWT (i.e. a web login). After P1a, they accept either the JWT or a regular prism_sk_* API key. The key path is tier-gated: Pro/Team get programmatic access; Free/PAYG get a clean 402 tier_upgrade_required error with an upgrade URL. This is the dividing line we locked: consumption + your own usage data is universal, operational orchestration is Pro+.
OpenAPI spec + Swagger UI. Every route has a tag, a description, and a response model. Webhooks are explicitly hidden so they don't leak into the public spec. The result is publishable docs at https://api.ssimplifi.com/v1/openapi.json that auto-generated SDK clients can consume directly. The Swagger UI at /v1/docs gives prospects an interactive surface before they sign up.
This is the boring half of v1.8. It's also the half that unlocked everything else — every other piece below is a thin layer over the API surface that P1 made cleanly programmable.
The CLI
pip install ssimplifi-cli
prism configure # paste your prism_sk_... key
prism chat "What is..." # one-shot completion, any tier
prism models --provider groq
prism usage --days 7
prism cache stats
Nineteen commands, ~40 sub-commands. Some are universal (chat, models, whoami, balance, usage, keys list). Most are Pro+ (cache, policy, budget, audit, orgs, projects, members, invites, subscription, provider-health).
The tier check happens cleanly. If you try prism cache stats on a Free account, the CLI prints:
Tier upgrade required.
Current tier: free
Programmatic access to this endpoint requires Pro ($19/mo) or Team ($49/mo).
Upgrade: https://ssimplifi.com/pricing
Not a 401 with a JSON dump. Not a half-broken state. A clean, actionable message telling you exactly what to do.
The CLI also has a soft-gate posture: prism chat and prism models work on every tier. You can install the CLI on Free, use chat from your terminal, discover that admin commands exist, and upgrade when you actually need them. That feels right — gating the tool entry point would push curious developers away before they've tried the product.
The MCP server
This is the piece I'm most excited about. Once you've got Claude Desktop (or Cursor, or Zed, or Continue, or Cline) configured with Prism's MCP server, the AI can call Prism's catalog, estimate costs, check your usage, submit feedback, and — with the optional write-scope key — change cache settings, revoke API keys, set routing policy. All from inside the conversation.
// ~/Library/Application Support/Claude/claude_desktop_config.json
{
"mcpServers": {
"prism": {
"command": "prism-mcp",
"env": {
"PRISM_API_KEY": "prism_sk_..."
}
}
}
}
22 tools total — 12 read-only, 10 write. The write tools are gated by two coordinated layers:
Layer 1 — Per-tool confirmation. Every write tool takes a confirmed: boolean argument that defaults to false. Without it, the tool returns a structured confirmation_required response describing the action + its specific consequences. The AI client surfaces the consequences to you in natural language ("This will revoke the API key created on March 14 that's currently in production. Are you sure?"). You agree; the AI re-calls with confirmed: true; the action executes. Standard MCP destructive-tool shape — Anthropic's reference servers use the same pattern for file deletion and git operations.
Layer 2 — Separate write-scope key. Your regular prism_sk_* API key cannot mutate state via MCP. Period. To enable writes, you run prism mcp enable-writes in the CLI, receive a confirmation email, click the link, get a separate prism_msk_* key, and add it to your MCP config as PRISM_MCP_WRITE_KEY. Two-step opt-in. Without it, write tools return a clean write_disabled response with a link to enable.
Threat-model-wise: prompt injection convincing the AI to revoke your key gets blocked at Layer 2 (no write key in scope). A malicious actor stealing your MCP config file leaks only read access. The AI accidentally calling a write tool mid-conversation gets caught at Layer 1 (consequence text surfaces; you don't blindly agree). Together they're belt + suspenders.
I went back and forth on whether MCP should be read-only-only. The argument for restriction: AI clients are inherently noisy environments — a bad prompt-injection or a misread instruction shouldn't be able to mutate production state. The argument against: limiting MCP to read tools means the AI can answer "what's my cache hit rate" but not "lower it to 50% TTL" — half a product. The two-layer design splits the difference: the capability exists, but you have to opt in explicitly, and even after opting in, every destructive call asks first.
For the read half, no opt-in needed beyond PRISM_API_KEY. The MCP server checks /v1/whoami on startup, refuses to register any tools if your account isn't on Pro+ (Free/PAYG see "0 tools available" + an explicit upgrade message), and otherwise lights up all 12 read tools immediately.
The SDKs
ssimplifi (PyPI) and ssimplifi-prism (npm). Both are thin wrappers over the official openai SDK in their respective languages — the canonical client for OpenAI-compatible APIs. We extend rather than re-implement, so you get the OpenAI SDK's streaming, retries, type safety, and response shape for free.
from ssimplifi import Prism
client = Prism(api_key="prism_sk_...")
response = client.chat.completions.create(
messages=[{"role": "user", "content": "Hello"}],
mode="balanced", # Prism kwarg → X-Prism-Mode header
session_id="user-abc", # Prism kwarg → X-Prism-Session header
)
That's the entire diff from plain openai.OpenAI. Change two import lines, get auto-routing + multi-turn memory + caching + multi-provider failover. The mode, session_id, model_prefer, cache, and request_tags kwargs translate to X-Prism-* headers; you never have to remember the header names.
Plus the admin surface: client.models.list(), client.usage.summary(days=7), client.cache.stats(days=7), client.keys.create(name="staging"), client.whoami(). These hit the dashboard endpoints directly — the same ones the CLI talks to — through an httpx side-channel.
Node SDK is structurally identical. import { Prism } from "ssimplifi-prism", new Prism({ apiKey }), same kwargs.
This closes the third item from our into Claude Desktop or Cursor, restart, and the tools appear.
The live spec, with every endpoint documented: https://api.ssimplifi.com/v1/docs.
SOCIAL SHARE CARD GENERATOR