API Gateway. AI Gateway.
Service Mesh.
One Rust-Powered Binary.

One Endpoint. Eleven AI Providers.

Point your applications at a single OpenAI-compatible endpoint. Ferrum Edge routes each buffered request to OpenAI, Anthropic, Google Gemini/Vertex, Azure OpenAI, AWS Bedrock, Mistral, Cohere, xAI, DeepSeek, Meta Llama, or Hugging Face, normalizes the response, and supports fallback between matching providers. Streaming fallback is limited to selection before a provider is committed; a failure after commitment does not trigger a second provider request.

• Model routing, priority fallback, and per-provider circuit breakers
• Opt-in federation streaming for OpenAI-compatible providers; Anthropic and Gemini normalization through ai_stream_router
• Token budgets per consumer with Redis-coordinated enforcement
• Semantic caching, prompt firewall, PII shield, and output guardrails
• Tool-call governance and configurable transcript audit
• MCP tool gateway and Agent-to-Agent (A2A) gateway for agent traffic

version: "1"
proxies:
  - id: ai-api
    listen_path: /v1/chat/completions
    backend_scheme: https
    backend_host: api.openai.com
    backend_port: 443
    plugins:
      - plugin_config_id: ai-gateway
      - plugin_config_id: token-budget
plugin_configs:
  - id: "ai-gateway"
    plugin_name: "ai_federation"
    scope: proxy
    proxy_id: ai-api
    config:
      streaming:
        enabled: true
      providers:
        - name: openai
          provider_type: openai
          api_key: "replace-with-your-openai-api-key"
          model_patterns: ["gpt-*"]
        - name: anthropic
          provider_type: anthropic
          api_key: "replace-with-your-anthropic-api-key"
          model_patterns: ["claude-*"]
      fallback_enabled: true
  - id: "token-budget"
    plugin_name: "ai_rate_limiter"
    scope: proxy
    proxy_id: ai-api
    config:
      limit_by: consumer
      token_limit: 500000
      window_seconds: 3600
      sync_mode: redis
      redis_url: "redis://redis:6379/0"

Replace the provider keys and Redis URL before use. File specs do not expand shell environment placeholders. Add an authentication plugin and consumers to enforce budgets by authenticated consumer identity. This example streams OpenAI responses; Anthropic streams require ai_stream_router.

Built to Be Invisible

In the repository’s historical local benchmarks, Ferrum Edge delivered 102,183 RPS on HTTP/1.1 and over 108K on HTTP/2 and raw TCP — and in one historical local Docker run it recorded higher throughput than Envoy, Kong, and Tyk on authenticated API traffic. The goal: your backend is your bottleneck, not your gateway.

• 102,183 RPS on HTTP/1.1 (Apple Silicon, 200 concurrent)
• 108,841 RPS on raw TCP proxy; 103,830 RPS on WebSocket
• Authentication throughput was comparable in that historical workload
• Historical key-auth run: 4% above Envoy, 12% above Kong, 46% above Tyk — not a current-release ranking
• Separate scale harnesses exercise large configurations; results depend on hardware and workload

Meet Ferrum Foundry

The admin panel for your Ferrum Edge gateway. Manage proxies, consumers, plugins, and upstreams through a modern web UI — with periodically refreshed metrics, circuit breaker alerts, and health monitoring built in.

• Full CRUD for proxies, consumers, plugins, and upstreams
• Metrics dashboard with configurable auto-refresh
• Circuit breaker states and connection pool monitoring
• Multi-namespace support for tenant isolation
• Dark and light themes

Prefer No UI? Ship Config by Pull Request.

GitForgeOps turns a plain GitHub repository into the control plane for your gateway fleet. Declare proxies, consumers, upstreams, and plugins as YAML — every change is validated, policy-checked, and reviewed in the pull request before it's applied to any environment.

• Multi-environment applies from one repo with per-environment overlays
• Policy-as-code reviews that block bad changes before they merge
• Encrypted credential brokering — no secrets in Git, no Vault required
• Nightly drift detection between declared and live configuration
• Full audit trail in Git; roll back by reverting a commit through the same review and apply pipeline (secret rotation is not undone)
• GitHub-native Actions, Environments, Secrets, and APIs — no external secret manager; plan requirements depend on repository visibility

Publish APIs with Ferrum Nexus

Turn the APIs behind your gateway into a product. Providers publish OpenAPI specs, clients browse the catalog, request access and issue their own credentials — and every gateway change goes through the Nexus backend with role checks and an audit trail.

• OpenAPI catalog with rendered documentation and invoke URLs
• Access requests approved, denied or revoked as gateway ACL grants
• Show-once API keys, basic auth and JWT secrets with rotation
• Client-to-provider messaging, notifications and broadcasts
• White-label branding, audit history and emergency god mode

Put Your APIs to the Test with Ferrum Anvil

A desktop API client for Windows, macOS and Linux. Build requests, run repeatable tests, inspect performance, and troubleshoot Ferrum Edge with explanations grounded in what actually happened.

• Works with any API; deeper, explicitly bounded diagnostics for declared Ferrum Edge 0.9.8, 0.9.7 and 0.9.5 gateways
• Findings state their confidence and what the evidence does not prove
• HTTP/1.1, HTTP/2, HTTP/3, WebSocket, gRPC, gRPC-Web, SSE, TCP/TLS and UDP/DTLS, plus HBONE mesh tunnels, CONNECT-UDP (MASQUE), PROXY protocol, SPIFFE Workload API identities and opt-in 0-RTT early data
• Load tests in a separate worker process, with a load unit and counts for each protocol: requests, calls, streams, sessions and exchanges
• Runs offline with no account; start without a password (OS keychain) or protect it with a passphrase and recovery key

Ferrum Anvil v0.1.1 is an unsigned preview. Verify downloads with SHA256SUMS. macOS installers are not Developer ID signed or notarized and Windows installers have no code-signing certificate. In-app updates use verified minisign signatures; this does not code-sign the installers. Preview downloads →

Build the Services Behind Your Gateway with Ferrum Alloy

A pre-release toolkit for Axum services. Alloy handles configuration, RFC 9457 errors, health, limits, graceful shutdown and request telemetry, and behind Ferrum Edge it shares one verified request story with the gateway.

• Handlers, extractors, routers and Tower middleware stay ordinary Axum
• Trace context trusted only from a verified gateway identity
• Deterministic diagnosis of where a request's time went
• Exports Ferrum Edge file-mode YAML or a GitForgeOps tree