curl -fsSL https://gomodel.enterpilot.io/install.sh | sh
OPENAI_API_KEY="your-openai-key" gomodelirm https://gomodel.enterpilot.io/install.ps1 | iex
$env:OPENAI_API_KEY = "your-openai-key"; gomodeldocker run --rm -p 8080:8080 \
-e LOG_FORMAT=text \
-e OPENAI_API_KEY="your-openai-key" \
enterpilot/gomodelWhen provider switching, debugging, and usage tracking start leaking into application code, GoModel moves that logic into one gateway layer.
Switching vendors shouldn't be a code project. One stable API decouples provider choice from your app - swap models with a config change.
One path needs cache, another audit, another guardrails. Scoped workflows set behavior per provider, model, or user path.
Identical requests shouldn't pay full price twice. Exact-match response caching returns duplicates faster and cheaper.
Provider dashboards show one total. Per-request usage tracking maps spend to teams, tenants, and features.
A fallback fired and nobody knows why. Audit logs and runtime metadata make every request traceable.
Running the gateway shouldn't out-scale running the app. One binary with a built-in admin UI and storage that grows with the workload.
GoModel authenticates each request, applies the matching workflow - guardrails, cache, budgets, rate limits - and routes it to the right provider with automatic failover, behind OpenAI- and Anthropic-compatible APIs.
POST /v1/chat/completionsPOST /v1/responsesPOST /v1/messagesOpenAI- and Anthropic-compatible. Change the base URL, keep your SDK.
Everything the gateway does today, grouped by what you need it for. All of it ships in the single open-source binary - nothing here is a paid tier.
Routing & Providers
OpenAI, Anthropic, Gemini, Bedrock, Vertex, Azure, Groq, Ollama, vLLM, and more behind one endpoint - with round-robin rotation across multiple keys per provider.
Publish stable names like smart-chat and remap the real provider and model behind them - a config change, not an application change.
Spread a virtual model across targets with weighted round-robin, or let cost-based routing pick the cheapest capable model for each request.
Availability errors fail over to the next model or provider; retries with backoff and a circuit breaker absorb flaky upstreams.
Call any provider's native API through /p/:provider/* and keep GoModel's auth, usage tracking, and audit on the way through.
Control & Safety
Toggle cache, audit, usage, budgets, guardrails, and failover per provider, model, or user path - versioned, most specific scope wins.
Inject system prompts or rewrite messages with an LLM before dispatch, in ordered steps that run as parallel groups.
Hand teams managed keys bound to a user path and labels instead of raw provider credentials - revoke and rotate from the admin UI.
Cap request rate and concurrency per user path, provider, or model - saturated routes are routed around when alternatives exist, 429 + Retry-After when not.
Cost
Durable spend limits enforced before dispatch - shared across gateway instances, so a burst on one node can't blow the monthly cap.
Exact-match caching out of the box, plus semantic caching backed by Qdrant, pgvector, Pinecone, or Weaviate.
Token and dollar accounting per request, user path, and label - with per-model pricing overrides when list prices don't match your contract.
Observability
Every request with its resolved route, workflow, cache result, and provider attempts - bodies and headers logged only when explicitly enabled.
Embedded UI for live request logs, usage breakdowns, keys, budgets, workflows, and provider status - no separate deployment to run.
Labels from headers or key metadata flow into usage and audit, so spend and incidents map to teams, tenants, and features.
/metrics with request, provider, and circuit-breaker gauges, plus health endpoints and optional pprof profiling.
Beyond Chat
Chat, embeddings, the Responses API with gateway-managed conversations, files, and batches - not just /v1/chat/completions.
Native /v1/messages and token counting - point the Anthropic SDK at GoModel and route to any provider behind it.
Text-to-speech, transcription, and realtime speech over WebSocket and WebRTC, through the same gateway pipeline.
Aggregate MCP servers behind one endpoint with namespaced tools - every tool call gets usage tracking and audit like any other request.
Run It Anywhere
A single Go binary with Docker, Compose, and Helm recipes - the admin UI is embedded, so there is nothing else to deploy.
Start on SQLite with zero setup, move to PostgreSQL or MongoDB when traffic and retention demand it - same binary, different config.
SSE streaming with usage and audit recorded from the stream itself - no buffering, no lost accounting on long generations.
The same gateway, six different jobs.
A multi-tenant SaaS issues a virtual key per customer, tracks usage by user path, and enforces per-tenant budgets - invoices come from the dashboard, not guesswork.
A platform team publishes aliases like smart-chat with scoped workflows behind them - product teams ship features without ever holding provider keys.
Production traffic rides failover chains with retries and circuit breakers - a provider incident becomes a routing event, not a customer-facing one.
Caching absorbs duplicate prompts, cost-based routing picks the cheapest capable model, and budgets stop end-of-month surprises.
Compliance reviews replay any request: resolved route, guardrail versions, provider attempts, and full bodies where logging is explicitly enabled.
Developers run Ollama or vLLM locally behind the same endpoint the cloud providers serve in production - switching is config, not code.
Launch GoModel, open the dashboard, and send your first OpenAI-compatible request in three steps.
Install the binary with one command - or run it with Docker, either standalone or as the full local stack with Docker Compose.
curl -fsSL https://gomodel.enterpilot.io/install.sh | sh
OPENAI_API_KEY="your-openai-key" gomodelirm https://gomodel.enterpilot.io/install.ps1 | iex
$env:OPENAI_API_KEY = "your-openai-key"; gomodeldocker run --rm -p 8080:8080 \
-e LOG_FORMAT=text \
-e OPENAI_API_KEY="your-openai-key" \
enterpilot/gomodelcp .env.template .env
# Add your API keys to .env
docker compose up -dInspect models, aliases, workflows, usage, cache, and audit logs in the admin UI once the gateway is running.
http://localhost:8080/admin/dashboardOpen dashboardKeep the OpenAI-compatible request shape and point it at GoModel.
curl http://localhost:8080/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-5-chat-latest",
"messages": [{
"role": "user",
"content": "Hello!"
}]
}'A gateway sits on every request, so its runtime footprint charges rent forever. Numbers below are from the reproducible June 2026 benchmark - four gateways (GoModel, LiteLLM, Portkey, Bifrost), same mock backend, same AWS box. Read the full benchmark →
| Category | GoModel | LiteLLM |
|---|---|---|
| Measured on the hot path | ||
| Latency overhead (p50) | 1.8 ms | 30.6 ms |
| Latency tail (p99) | 6.9 ms | 39.3 ms |
| Sustained throughput | 4,900 req/s | 324 req/s |
| Peak RAM under load | 37 MB | 2.3 GB |
| Efficiency (req/s per CPU %) | 52 | 2.6 |
| Cold start to first request | 0.56 s | 25.5 s |
| Docker image (compressed) | 16 MB | 372 MB |
| Beyond the benchmark | ||
| Runtime & deployment | One Go binary | Python + per-vCPU workers |
| Provider coverage | 22 providers | 100+ providers |
| Config | Env vars + optional YAML | YAML config file |
| Audit logs | Included, MIT | Enterprise license |
| SSO & access control | On the roadmap | Enterprise license |
| Dependency surface | Small, std-lib-heavy Go tree | Large Python dependency graph |
| License | MIT | MIT core + enterprise license |
Benchmark: 8,000 requests per workload at concurrency 10, six API workloads, two randomized trials on an AWS c7i.large. LiteLLM ran its recommended two workers; retries and GoModel's circuit breaker were disabled for fairness. LiteLLM's broader provider catalog is a real advantage - the benchmark measures the request path, not product maturity.
All 22 supported providers behind one OpenAI-compatible endpoint - 700+ models measured across their live catalogs. Most need a single env var; the tricky ones have dedicated setup guides.
Model counts are approximate, read live from provider catalogs. Multiple API keys per provider rotate round-robin, and suffixed env vars register extra instances of the same provider type.
What already shipped, what is left before v0.2.0, and what comes right after - kept in sync with the project's public roadmap.
Intelligent routing, context compression, and cluster mode are planned as commercial features.
Common questions about deployment, provider switching, GoModel as a LiteLLM alternative, local models via Ollama, vLLM, and LM Studio, caching, usage tracking, and the v0.2.0 roadmap.
GoModel is an open-source AI gateway written in Go and released under the MIT license. Your apps talk to one OpenAI- and Anthropic-compatible endpoint, and the gateway handles provider routing, model aliases, scoped workflows, caching, failover, budgets, rate limits, audit logs, and usage tracking behind it. It ships as a single small binary with an embedded admin dashboard, so there is nothing else to deploy.
Yes - in most cases you only change the base URL. GoModel serves the OpenAI API (/v1/chat/completions, /v1/responses, embeddings, files, batches) and the Anthropic Messages API (/v1/messages) natively, so the OpenAI SDK, the Anthropic SDK, and plain HTTP clients all keep working while routing, caching, and usage visibility move into the gateway.
22 providers, including OpenAI, Anthropic, Google Gemini and Vertex AI, Azure OpenAI, Amazon Bedrock, OpenRouter, Groq, xAI, DeepSeek, Mistral-class open models through Ollama and vLLM, and more - roughly 700+ models read live from provider catalogs. You can register multiple API keys per provider for round-robin rotation, and any other OpenAI-compatible backend can join as its own provider instance.
In a reproducible June 2026 benchmark on the same AWS box, GoModel showed 1.8 ms median latency overhead vs 30.6 ms, sustained 4,900 req/s vs 324, used 37 MB of RAM under load vs 2.3 GB, and cold-started in 0.56 s vs 25.5 s. LiteLLM still supports more providers today - the trade-off is runtime footprint on the request path, which matters most at high volume, on small machines, or in front of fast local models.
A workflow toggles cache, audit logging, usage tracking, budgets, guardrails, and failover per provider, model, or user path - the most specific matching scope wins. Workflow versions are immutable, so you can see exactly which policy a given request ran under. One gateway, different runtime policies for different workloads.
Yes, two ways. Exact-match caching returns identical non-streaming requests straight from the gateway - no provider call, no cost. Semantic caching goes further by matching similar prompts, backed by Qdrant, pgvector, Pinecone, or Weaviate. Cache lookups run after alias and workflow resolution, so policy decisions still apply, and cache hits are visible in the dashboard.
Yes. Tag requests with X-GoModel-User-Path or labels from virtual API keys, and GoModel records tokens and dollar cost per request against that path. The dashboard breaks spend down by team, tenant, model, and label, pricing overrides keep numbers accurate when your contract differs from list prices, and budgets enforce hard spend limits before a request is ever dispatched.
GoModel retries with backoff, trips a circuit breaker on repeated failures, and fails over to the next configured model or provider - skipping routes that are rate-limited or saturated. Every attempt lands in the audit log with the resolved route, so an outage becomes a routing event you can reconstruct rather than a mystery.
Yes - point OLLAMA_BASE_URL or VLLM_BASE_URL at your server and local models sit behind the same endpoint as the cloud providers. LM Studio, llama.cpp, and similar servers connect the same way through their OpenAI-compatible endpoints. Because the gateway itself is a 16 MB image that runs in about 37 MB of RAM, it is cheap enough to run next to the models - on a laptop, an edge box, or a sidecar.
The fastest path is one docker run; Docker Compose, Kubernetes with the Helm chart, and the plain binary all work too. Storage starts on SQLite with zero setup and moves to PostgreSQL or MongoDB when traffic and retention grow. Operations run through the embedded admin dashboard and API, with Prometheus /metrics and health endpoints for your existing monitoring.
Most of the v0.2.0 scope has already shipped: budgets, pricing overrides, the full /responses lifecycle, Anthropic /messages, and prompt cache visibility including the dashboard view. Still open are broader provider support (Cohere Command A among others), the full /conversations lifecycle, a guardrails rework with custom and response-side guardrails, and passthrough for every provider. Right after the release come intelligent routing, context window compression, cluster mode, SSO, OAuth 2.0, and dashboard customization.
Need help deciding whether GoModel fits your project, or planning a switch between AI model providers? Join Discord, book a 30-minute call, or call directly.