platform

One gateway for
API, MCP, and AI traffic.

SBproxy manages traffic in both directions: the models your apps call and the agents that call your APIs. Govern, transform, and secure every request, serve your own models, and run it all in your own perimeter, from one config.

what one gateway governs
Govern
Virtual keys, budgets, routing, and a signed audit log.
Transform
Provider dialects, your own weights, cache, content for agents.
Secure
Guardrails in and out, agent identity, TLS, WAF.
Deploy anywhere
Single binary, K8s operator, air-gapped, in your VPC.

The capabilities
behind one config.

The full data plane is open source and runs entirely inside your perimeter, from a single binary. No control plane to operate, no data leaving your network.

Identify

Agent identity and access.

Web Bot Auth verifies signed AI crawlers and agents using RFC 9421 HTTP Message Signatures with Ed25519 and HMAC. Virtual keys gate partner and customer APIs. mTLS, OAuth2 with DPoP and PKCE, and JWT with JWKS round out the auth surface.

  • + Web Bot Auth (RFC 9421, Ed25519, HMAC)
  • + Signature-Agent directory refresh
  • + OAuth2 with DPoP, PKCE, DCR
  • + JWT with JWKS rotation
  • + mTLS for client and upstream
  • + Forward auth and ext_authz
See agent identity
Secure

A live key plane that scales across the fleet.

Virtual keys are a runtime resource, not a line of YAML. Mint, rotate, and revoke them through the admin API with no reload, and a revoke takes effect on the next request. Keys are hashed at rest with HMAC-SHA256 and a server pepper, and upstream provider credentials are sealed with AES-256-GCM. Run more than one replica and a gossip mesh keeps the keys, budgets, and rate counters coherent across all of them, so the fleet coordinates itself without an external Redis.

  • + Runtime mint, rotate, and revoke over the admin API
  • + Keys hashed at rest with HMAC-SHA256 and a server pepper
  • + Upstream credentials sealed with AES-256-GCM
  • + Fail-closed cache, revoke effective on the next request
  • + OIDC and JWT claims mapped to a key
  • + Mesh clustering keeps spend and rate coherent, no Redis required
See dynamic key management
Transform

Content for agents.

AI agents pay tokens for HTML they did not need. Negotiate Markdown on demand, project JSON, validate against an OpenAPI spec, and emit a live OpenAPI document for buyers. Content negotiation is a transform, not a website rewrite.

  • + HTML to Markdown on Accept: text/markdown
  • + JSON projection and schema validation
  • + OpenAPI 3.0 emission from live config
  • + Per-host /.well-known/openapi.json
  • + Content-Signal headers
  • + CEL conditional response modifiers
See transforms
Expose

Make your APIs MCP-native.

Every B2B company is being asked whether their product is agent-ready. Most answer by writing an MCP server. SBproxy's OpenAPI-to-MCP bridge turns the project into a config change. Point the gateway at an OpenAPI spec and the agent gets one tool per (path, method) pair, with parameter schemas mapped, auth carried through, and rate limits applied. No new server. No new audit story.

  • + OpenAPI 3.0 spec to MCP tools, automatic
  • + Parameter schemas become tool input schemas
  • + Per-path include and exclude filters
  • + Auth and rate limits inherited from the API surface
  • + Pairs with MCP federation under one catalog
  • + Same audit log as the rest of the policy graph
See MCP federation
Govern

Outbound AI and MCP governance.

200+ models behind one OpenAI-compatible API. Fallback chains, weighted, latency-aware, and cost-optimized routing. Hierarchical budgets with cost attribution per workspace, team, and customer. PII redaction, prompt-injection v2, secret scanning, and toxicity guardrails on input and output. MCP gateway federates internal tools under one identity model.

  • + 200+ models, OpenAI-compatible
  • + Fallback chain and weighted routing
  • + Hierarchical budgets with downgrade actions
  • + PII, secrets, prompt injection, toxicity
  • + Local semantic cache, no prompt egress
  • + MCP gateway with federated tool servers
See enterprise AI governance
Observe

Metrics, logs, and traces from one process.

Every request carries one correlation id across all three signals. Prometheus metrics on /metrics, structured JSON logs to stdout or any OTLP collector, and OpenTelemetry traces. AI spans follow the GenAI and OpenInference conventions and carry per-request token counts and derived USD cost, so Phoenix, Langfuse, Grafana, or Datadog render the full LLM trajectory with no custom mapping.

  • + Prometheus metrics with a fixed label budget
  • + OpenTelemetry traces over OTLP
  • + Per-request token and USD cost on AI spans
  • + Multi-sink logs with field and PII redaction
  • + Five Grafana dashboards and SLO alert rules
  • + Liveness and readiness endpoints
See observability
Deploy

In-VPC, sovereign, and air-gapped.

Single binary on a server. Kubernetes operator on a fleet. Air-gapped install on a sovereign network. Same policy graph in every shape. Hot reload with no dropped connections. Bring your own Stripe, SSO, observability, and audit sink.

  • + Single static binary
  • + Kubernetes operator with full CRDs
  • + Air-gapped install with no phone-home
  • + Hot reload, zero dropped connections
  • + Helm chart and Docker images
  • + Open source on GitHub
See in-VPC deployment
04 / deploy

Runs where
governance has
to live.

Single binary on a server. Kubernetes operator on a fleet. Air-gapped install on a regulated network. Same policy graph in every shape.

  • + No forced SaaS edge. The data plane lives where you live.
  • + Bring your own Stripe, SSO, observability, audit sink.
  • + Policy hot-reloads in seconds without rebuilds or dropped connections.
Single binary

One static executable. Drop it on a server, point it at a YAML, route real traffic.

$ sbproxy serve -f sb.yml
Kubernetes operator

CRD-driven control plane. Reconciles policy, certs, and origins across the fleet.

$ kubectl apply -f sbproxy.yaml
Air-gapped

Sealed install. No phone-home, no licence call-out. Suitable for sovereign and defence networks.

$ sbproxy install --offline
06 / one config

One config.
One policy graph.

API access, content monetization, agent identity, AI routing, and MCP federation in the same YAML. Not five files glued together. Not five vendors stitched in middleware.

  • 01
    Inbound monetization
    Pay Per Crawl: meter the crawler, quote a price per route, answer with HTTP 402 advertising the x402, MPP, and Lightning rails.
  • 02
    Agent identity
    Web Bot Auth verifies signed crawlers via RFC 9421 message signatures.
  • 03
    Content for agents
    HTML negotiated to Markdown on demand. Cuts agent token costs.
  • 04
    Outbound AI governance
    Route 200+ models, cap spend, redact PII, federate MCP tools.
sb.yml·valid · one policy graph
live
# One policy graph: API + content + agents + AI + MCP
origins:

  # --- Public content with Pay Per Crawl + Web Bot Auth + Markdown ---
  "www.example.com":
    action:
      type: proxy
      url: https://origin.internal:8443
    authentication:
      type: bot_auth            # RFC 9421 signed agents
      agents:
        - name: openai-gptbot
          key_id: openai-2026-01
          algorithm: ed25519
          public_key: ${OPENAI_BOT_PUBKEY}
    policies:
      - type: ai_crawl_control     # Pay Per Crawl
        price: 0.001
        currency: USD
        header: crawler-payment
    transforms:
      - type: html_to_markdown     # Negotiated on Accept: text/markdown

  # --- Partner API with virtual keys + per-customer quotas ---
  "api.example.com":
    action:
      type: proxy
      url: https://backend.internal:8443
    authentication:
      type: virtual_key
    policies:
      - type: rate_limiting
        key: virtual_key
        requests_per_minute: 600
      - type: waf

  # --- Outbound AI gateway with budget + guardrails ---
  "ai.example.com":
    action:
      type: ai_proxy
      routing: fallback_chain
      providers:
        - name: anthropic
          api_key: ${ANTHROPIC_API_KEY}
        - name: openai
          api_key: ${OPENAI_API_KEY}
      guardrails:
        input:  [{type: pii}, {type: injection}]
      budget:
        limits:
          - {scope: team, max_usd: 5000, period: monthly}

  # --- MCP gateway federating internal tools ---
  "mcp.example.com":
    action:
      type: mcp
      mode: gateway
      federated_servers:
        - {origin: github.internal,   prefix: gh, rbac: read_only}
        - {origin: postgres.internal, prefix: db}
    authentication:
      type: oauth2                # DCR + DPoP + PKCE
hot reload, no dropped connectionsconfiguration reference →
06 / talk to us

Want to talk
before you install?

The gateway is on GitHub under Apache 2.0 and you can install it right now, so nothing here is gated behind a sales call. Use this form for deployment questions, migration scoping, or anything you would rather not file as a public issue.

01
Share your stack. A few details on providers, scale, and the gateway you might be replacing.
02
Talk to engineering. A real conversation about whether SBproxy fits the deployment shape you have in mind. No demo theatre.
03
Get a straight answer. Including when the answer is that SBproxy is the wrong fit and you should run something else.