Busbar
The fastest performing AI Control Plane · 100% Rust · every provider & capability

Your AI Control Plane

Busbar is a single binary you run in your own infrastructure, sitting between your applications and every AI provider. One endpoint to route and fail over chat, embeddings, images, audio, and rerank across providers, enforce hard budget caps, provision or revoke access, and see every request’s cost, latency, and traffic.

ChatEmbeddingsImagesAudioModerationsRerank
Any client · 6 protocols · 6 capabilities
OpenAI · Anthropic
Gemini · Bedrock
Cohere · Responses
TLS · mTLS
Busbar
TranslateRouteFailover
GovernanceSecurityObservabilityAI Middleware
one endpoint · :8080
Hooks: AI middleware on the path
Backends · any provider
Anthropic · OpenAI
Gemini · Bedrock
+ more
OpenAIAnthropicGeminiBedrockCohereResponses
Get started Download

Adopting it is a two-line swap.

Already speak OpenAI? Point the SDK at busbar and pick a pool by name. The request, left as OpenAI, may have been served by Anthropic and came back as OpenAI, translated both ways.

Already speak Anthropic? Point the Anthropic SDK at busbar and pick a pool by name. The request, left as Anthropic, may have been served by OpenAI and came back as Anthropic, translated both ways.

Already speak Gemini? Point the google-genai SDK at busbar and pick a pool by name. The request, left as Gemini, may have been served by Bedrock and came back as Gemini, translated both ways.

Already speak Amazon Bedrock? Point boto3 at busbar and pick a pool by name. The request, left as Bedrock, may have been served by Anthropic and came back as Bedrock, translated both ways.

Already speak Cohere? Point the Cohere SDK at busbar and pick a pool by name. The request, left as Cohere, may have been served by Gemini and came back as Cohere, translated both ways.

On the OpenAI Responses API? Same SDK, same two lines. The request, left as a Responses call, may have been served by Cohere and came back as Responses, translated both ways.

The model name is a config value, not a code dependency.

app.py 
# Already speak OpenAI? Just swap the base URL.
- client = OpenAI(api_key=OPENAI_KEY)
+ client = OpenAI(
+     api_key=BUSBAR_TOKEN,
+     base_url="http://busbar:8080",
+ )

  # "fast" = a pool you define in config:
  # 80% Claude / 20% GPT-4o, Gemini on failover.
  client.chat.completions.create(
      model="fast",
      messages=[{"role": "user", "content": "Hi!"}],
  )
app.py 
# Already speak Anthropic? Just swap the base URL.
- client = Anthropic(api_key=ANTHROPIC_KEY)
+ client = Anthropic(
+     api_key=BUSBAR_TOKEN,
+     base_url="http://busbar:8080",
+ )

  # "fast" = a pool you define in config:
  # 80% Claude / 20% GPT-4o, Gemini on failover.
  client.messages.create(
      model="fast", max_tokens=1024,
      messages=[{"role": "user", "content": "Hi!"}],
  )
app.py 
# Already speak Gemini? Just swap the base URL.
- client = genai.Client(api_key=GEMINI_KEY)
+ client = genai.Client(
+     api_key=BUSBAR_TOKEN,
+     http_options={"base_url": "http://busbar:8080"},
+ )

  # "fast" = a pool you define in config:
  # 80% Claude / 20% GPT-4o, Gemini on failover.
  client.models.generate_content(
      model="fast",
      contents="Hi!",
  )
app.py 
# Already speak Bedrock? Just swap the endpoint.
- bedrock = boto3.client("bedrock-runtime")
+ bedrock = boto3.client(
+     "bedrock-runtime",
+     endpoint_url="http://busbar:8080",
+ )

  # "fast" = a pool you define in config:
  # 80% Claude / 20% GPT-4o, Gemini on failover.
  bedrock.converse(
      modelId="fast",
      messages=[{"role": "user", "content": [{"text": "Hi!"}]}],
  )
app.py 
# Already speak Cohere? Just swap the base URL.
- co = cohere.ClientV2(api_key=COHERE_KEY)
+ co = cohere.ClientV2(
+     api_key=BUSBAR_TOKEN,
+     base_url="http://busbar:8080",
+ )

  # "fast" = a pool you define in config:
  # 80% Claude / 20% GPT-4o, Gemini on failover.
  co.chat(
      model="fast",
      messages=[{"role": "user", "content": "Hi!"}],
  )
app.py 
# The Responses API? Same swap, same client.
- client = OpenAI(api_key=OPENAI_KEY)
+ client = OpenAI(
+     api_key=BUSBAR_TOKEN,
+     base_url="http://busbar:8080",
+ )

  # "fast" = a pool you define in config:
  # 80% Claude / 20% GPT-4o, Gemini on failover.
  client.responses.create(
      model="fast",
      input="Hi!",
  )

A control plane you rent is still someone else’s. Busbar is one static binary in your infrastructure: inspect it, pin it, run it air-gapped. Nothing has to leave your network.

No model list to be on.

Busbar isn’t another proxy with a curated model catalog. You define a model name and the backends behind it. There’s no privileged protocol and no allowlist to wait for. Providers speak about six languages between them; Busbar speaks all six, so a new model works the day it ships, not the day we add it. See for yourself: pick your models, get the config.

Built reliability-first

Translate: lossless across six protocols

Six wire protocols, native on both sides, bridged through one internal format rich enough to hold every protocol’s features. Anthropic thinking blocks, structured-output schemas, and Bedrock tool use survive the hop. Nothing gets flattened to OpenAI shape.

Enables Point whatever SDK your code already speaks at one URL, and reach every model through it.

Failover: fault-aware, with circuit breaking

A circuit breaker on every provider lane knows whose fault each failure was (a provider outage, your bad request, a context overflow, a revoked key) and treats each one differently instead of retrying into a wall. A failed lane reroutes mid-flight, before your client sees a single byte.

Enables A flaky provider is pulled and probed back gently; a rate-limit storm on one lane never starves the healthy ones.

Route: a programmable request path

Routing is the first hook. Pick a built-in policy (weighted, cheapest, fastest, least_busy, usage) or bring your own as a webhook in any language, or as a sandboxed Rhai script. Policies see each member’s cost, latency, live concurrency, budget, and rate headroom. A slow or broken hook falls back; it never blocks a request.

Enables The same fail-safe machinery is built to carry PII-steering, audit, and guardrails: your own logic on the request path, in any language.

Governance: virtual keys & hard budget caps

Issue virtual keys with daily, monthly, or all-time spend caps and per-key RPM/TPM limits. A request that would break its cap is rejected before it is forwarded: the budget check and the charge are one atomic operation, so a concurrent burst can’t race past the limit. Scope keys to pools, revoke instantly, query spend via the admin API.

Enables Budgets enforced before the request runs, not discovered on the invoice.

Security: native TLS & mutual TLS

Busbar terminates TLS itself (cert and key in config, no reverse proxy required). Turn on mTLS and a client must present a certificate signed by your CA; anyone without one is rejected at the handshake, before any bearer-token check is reached.

Enables Zero-trust ingress without standing up a service mesh.

A single Rust binary you own

One static binary with no runtime, no sidecar, and no interpreter in the request path. It ships for Linux and macOS (Intel and ARM) and Windows (Intel). Provider keys move out of every app deployment into one place; your app carries only a Busbar token. Prometheus /metrics and OTLP traces built in.

Enables Your infrastructure, your keys, your data path. Rotating an upstream key is one restart, not a deploy sweep.

Program the path.

Reliability earns Busbar a spot between your app and your models. Hooks are what that spot becomes — a tap that watches, or a gate that decides: reject, restrict, route, or rewrite. Because hooks fire on Busbar’s normalized IR, you write one once and it runs against all six protocols and every provider, with failover and circuit breaking underneath it, in one hop. Busbar is where your AI middleware runs.

Tap: watch every request

Fire-and-forget observers on the path. A tap sees the full request and response and never blocks the hop — feed a SIEM, a compliance archive, custom alerting, and more. It runs alongside the request, so nothing waits on it.

Enables A SIEM feed or compliance archive that sees every call, across every provider, from one place.

Gate: decide on the path

Fire-and-wait deciders that run before the request leaves. A gate can reject a call, restrict it to certain models, re-order or route it, or rewrite the request body outright — a PII-redaction guard, a cost-and-latency router, or Headroom compressing context before it ships.

Enables Your policy enforced before the request runs, not reconstructed from logs after.

Write once, run anywhere

Hooks fire on Busbar’s normalized IR — the one internal representation every protocol is translated into, losslessly. Write a hook once and it runs against all six wire protocols and every provider, with failover and circuit-breaking underneath it, in one hop.

Enables One hook covers OpenAI, Anthropic, Gemini, Bedrock, Cohere, and Responses at once — no per-provider plumbing to maintain.

Already committed to one AI provider?

Busbar pays for itself before the second provider exists. Run it as a straight passthrough and your posture improves the same day: the provider key moves out of every app deployment, a runaway loop hits your cap instead of your bill, and every request shows up in your metrics. When the constraint moves, a new backend is a config lane, not a rewrite. Why add a control plane now · the day it paid off

Running in 60 seconds

One command pulls the binary and the provider catalog. Write a minimal config, point an SDK at it, and you’re serving. No sudo, no runtime, no virtualenv.

Full walkthrough →
install 
curl -fsSL https://getbusbar.com/install.sh | sh
config.yaml 
providers:
  anthropic:
    api_key_env: ANTHROPIC_KEY

models:
  claude-sonnet:
    provider: anthropic
    max_concurrent: 10
run 
export ANTHROPIC_KEY=sk-ant-...
BUSBAR_PROVIDERS=./providers.yaml \
BUSBAR_CONFIG=./config.yaml busbar   # serving on :8080
request 
curl localhost:8080/v1/chat/completions \
  -d '{"model":"claude-sonnet",
       "messages":[{"role":"user","content":"hi"}]}'
One binary
No Python runtime
Hardened
SSRF guards · constant-time auth
Cross-platform
Linux · macOS · Windows · ARM
Measured
38 µs added latency · verifiable per-request

Using Busbar? We’d love to put your logo here. hello@getbusbar.com