One API for Every Model, With a Router You Can Actually Control

If you've ever wired up an agent workflow, you know the mess: one key for OpenAI, another for Anthropic, a third for whatever local model you're testing, and no easy way to say "this agent gets this model and no more than this much money." Experiential is an open-source gateway and router that tries to collapse all of that into a single OpenAI-compatible API.

What It Does

Experiential sits between your code and your models. It's a gateway that serves an OpenAI-compatible API (and, on the hosted platform, an Anthropic Messages API too), so you can point existing SDKs and coding agents at it without rewriting anything. Behind that single endpoint, it routes across hosted, bring-your-own-key, and local models.

The project also wraps access control and spend management around those models. You define which users and agents can use which models, for which use cases, and how much they can spend. Then there's the part that makes it more than a proxy: it turns production traffic into a custom router or model optimized for quality, speed, and cost. The local gateway runs via exp (or exp run), and the README notes the compiled native data plane serves every route on loopback. There's also a hosted platform at platform.experientiallabs.ai that serves the same API if you'd rather not run it yourself.

Why It's Cool

• One endpoint, many providers. The setup wizard walks you through provider, model, and reasoning-effort selectors, persists each provider connection, and then hands you a one-time key. You pick a public alias (the README uses opus-5 as an example) and start sending requests. That alias layer is a nice touch — your app code talks to a stable name, not a specific vendor's model string.

• Budgets and identities built in. The setup flow shows defaults for a public alias, an identity, and a $50.00 command budget before issuing the key. Being able to scope spend per agent is the kind of thing you usually end up bolting on yourself, badly, after the first surprise invoice.

• Your traffic becomes your router. This is the most interesting idea here. Rather than guessing which model to send requests to, you can use production traffic as telemetry and fit a custom router to it. The Python API reflects this: exp.load_router("my-project") returns an official OpenAI client backed by its own private gateway, so a fitted router behaves like any other model in your code.

• Agent-friendly onboarding. The README points to SETUP.md with copy-paste prompts you hand to Claude Code, Cursor, Codex, or similar — the agent runs the setup for you. Given how many people now configure infrastructure through a coding agent, that's a practical decision rather than a cute one.

• It ships its own coding agent. exp code runs exp-code, an open-source coding and cowork agent built on Pi, which uses your running local gateway or the hosted one after exp login. It requires Node.js 22.19 or newer, and every argument passes through to exp-code, so its print, JSON, and RPC modes work too.

How to Try It

1. Install and run the local gateway:

pip install experiential
exp

1. On first run, the setup wizard steps through provider, model, and reasoning-effort selection, persists your provider connections, and shows defaults for the public alias, identity, and $50.00 budget before printing a one-time key.

2. Pick a public alias, capture the key, and send a request:

export EXP_GATEWAY_KEY=...
curl http://127.0.0.1:8000/v1/chat/completions \
  -H "Authorization: Bearer $EXP_GATEWAY_KEY" \
  -H 'Content-Type: application/json' \
  -d '{"model":"opus-5","messages":[{"role":"user","content":"Help me"}]}'

1. If you'd rather not run it locally, the hosted platform serves the same API at https://api.experientiallabs.ai/v1. The SETUP.md prompts cover uploading traces as telemetry, connecting your own provider keys (OpenAI, Anthropic, Gemini, Azure, Bedrock, Fireworks, OpenRouter), making your first /v1 call with an xpl_ key, and repointing your coding agents.

The repo is at github.com/experientiallabs/experiential, with docs at platform.experientiallabs.ai/docs.

Final Thoughts

Experiential is aimed at teams running agent workflows at some scale — the point where managing keys, budgets, and model choices by hand stops scaling. The combination of a single OpenAI-compatible endpoint, per-agent spend controls, and the ability to train a router on your own traffic is a coherent set of pieces. The README is truncated past the traffic-capture section, so there's more to dig into than what's shown here — worth a look at the repo if the routing and telemetry angle sounds like your problem.