GoModel is an MIT-licensed AI gateway, control plane and proxy written in Go that exposes one OpenAI-compatible endpoint at /v1 and one Anthropic-compatible endpoint at /v1/messages in front of OpenAI, Anthropic, Gemini, Groq, xAI, Ollama, vLLM and many other providers, for teams that run their own LLM traffic and want routing, caching, spend control and observability in a single self-hosted service.

What it is

GoModel sits between an application and a set of LLM providers. It is a Go binary that accepts requests in two wire formats, so the official OpenAI and Anthropic SDKs work unchanged once their base URLs point at it: http://localhost:8080/v1 for the OpenAI SDK and http://localhost:8080 for the Anthropic SDK, which appends /v1/messages itself. Behind that facade it speaks to a long provider list, including OpenAI, Anthropic, xAI (Grok), Google Gemini, Cohere, Vertex AI, DeepSeek, Groq, Fireworks AI, Meta (Muse Spark), OpenRouter, Z.ai, Alibaba Cloud Model Studio (Bailian), Kilo AI, MiniMax, Xiaomi MiMo, OpenCode Go, Azure OpenAI, Oracle, Ollama, SGLang, vLLM, llm-d, Amazon Bedrock Runtime, Bedrock Mantle, the ChatGPT Codex backend and Claude, ElevenLabs for text-to-speech and speech-to-text, and any OpenAI-compatible provider.

The concrete problem is provider sprawl. Without a gateway, every model vendor means another SDK, another key to rotate, another place where spend and failure are invisible. GoModel replaces LiteLLM, which the README states was hacked recently, and Portkey, which the README states is no longer maintained on GitHub. It centralises keys, routing and configuration in one process: settings resolve through good defaults, then config.yaml, then .env, then exported environment variables, and the most important settings can be edited in the dashboard at /admin/dashboard. The repository has 1,167 stars, 101 forks and 80 open issues.

Key capabilities

• Serves both compatibility surfaces at once: OpenAI-compatible at /v1 and Anthropic-compatible at /v1/messages, so existing SDK code and base-URL configuration carry over.
• Exact and semantic response caching, so repeated prompts are answered without a new upstream call and cost nothing.
• Cost tracking with per-request cost estimates, usage analytics and spending breakdowns shown in the dashboard.
• Budgets that enforce hard spend limits per user, per team or per key, alongside rate limits.
• Intelligent routing, sticky sessions and failover across the configured providers.
• Observability and real-time logs with usage tracking for every request passing through the gateway.
• Guardrails and streaming support, with configuration through .env.template, config/config.example.yaml, a config.yaml file or the dashboard.

Who uses it and how

• Teams that already use the OpenAI or Anthropic SDKs and only need to repoint a base URL to move traffic through one gateway.
• Self-hosters running a single container with docker run --rm -p 8080:8080 -e OPENAI_API_KEY="your-openai-key" enterpilot/gomodel, or installing on macOS and Linux with the shell installer and on Windows with the PowerShell installer.
• Platform and FinOps-minded operators who need per-user, per-team and per-key budgets, cost dashboards and real-time logs as governance over LLM spend.
• Local and GPU-backed workloads, where Ollama, vLLM, SGLang and llm-d are routed through the same interface as hosted providers.
• Infrastructure-heavy deployments that run the supplied Docker Compose profiles, bringing up Redis, PostgreSQL, MongoDB and Adminer as infrastructure only, or the full stack with GoModel and Prometheus added.

Getting started

Install and start GoModel with curl -fsSL https://gomodel.enterpilot.io/install.sh | sh on macOS or Linux, irm https://gomodel.enterpilot.io/install.ps1 | iex on Windows, or the container image with docker run --rm -p 8080:8080 -e OPENAI_API_KEY="your-openai-key" enterpilot/gomodel, then open http://localhost:8080/admin/dashboard.

How it compares

The README positions GoModel against LiteLLM and Portkey as the gateway it replaces. The licence is MIT, so the software itself carries no per-seat or per-request fee beyond the provider API costs a user already pays, whereas the alternatives are the products the project names as either compromised or abandoned upstream. Because GoModel runs as a local process, a Docker container or a compose stack, request content, keys and configuration stay on infrastructure the operator controls, with .env, config.yaml and the dashboard as the only configuration surfaces.

When to use it — and when not to

Pick GoModel when you are willing to operate a gateway: the full compose profile stands up Redis, PostgreSQL, MongoDB, Adminer and Prometheus, so there is real state and monitoring to run even though the binary itself is small. Do not pick it if you want a fully managed, zero-operations service, if a single provider and a direct API call already meet your needs, or if you need long-term stability signals stronger than the current 80 open issues suggest. The README excerpt is also thin in places, with some feature sections cut off mid-list, so read the linked documentation before committing to a production rollout.

curl -fsSL https://gomodel.enterpilot.io/install.sh | sh
# OPENAI_API_KEY="your-openai-key" # (optional)
gomodel

irm https://gomodel.enterpilot.io/install.ps1 | iex
# $env:OPENAI_API_KEY = "your-openai-key" # (optional)
gomodel

docker run --rm -p 8080:8080 \
  -e OPENAI_API_KEY="your-openai-key" \
  enterpilot/gomodel

http://localhost:8080/admin/dashboard

curl http://localhost:8080/v1/responses \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5-chat-latest",
    "input": "Hello!"
  }'

cp .env.template .env
# Add your API keys to .env
docker compose up -d
# or: make infra

docker compose --profile app up -d
# or: make image