routatic/proxy: a Go proxy that puts Claude Code on OpenCode Go, Zen or Bedrock

The problem routatic/proxy solves, and who actually has it

Claude Code speaks one wire format: Anthropic's. It reads ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN and sends Messages API requests there. That is the whole integration surface, and it is also the constraint. If your coding budget lives on OpenCode Go's flat-rate plan, or on OpenCode Zen's pay-as-you-go models, or on models you already run inside AWS Bedrock, Claude Code has no way to use them without something in the middle that accepts Anthropic-format JSON and emits something the upstream understands.

routatic/proxy is that middle. The README describes it as sitting between Claude Code and your chosen providers, intercepting Anthropic API requests, transforming them to the appropriate format (OpenAI, Anthropic, Responses, or Gemini), and forwarding them upstream. The intended audience is narrow and specific: developers who have already decided to use Claude Code as their terminal agent and have already bought capacity somewhere else. It is not a general-purpose LLM gateway for a team's internal services, and the README never pitches it as one.

The compatibility details matter for anyone with an existing setup. The binary was formerly called oc-go-cc, and the README states that oc-go-cc remains available as a compatibility alias, that existing OC_GO_CC_* environment variables still work, and that ~/.config/oc-go-cc/config.json files are still recognized. The Dockerfile confirms the alias by symlinking /usr/local/bin/oc-go-cc to the same binary. If you were running the older name, nothing in your shell profile has to change on day one.

How the request path works: transform, route, stream back

The mechanism is a format bridge with routing on top. An inbound request arrives in Anthropic shape. The proxy inspects it and picks a model according to context: the README lists default, thinking, long context, and background as the routing categories, and separately documents a streaming scenario routing mode in CONFIGURATION.md. The chosen provider's adapter then rewrites the payload into OpenAI, Anthropic, Responses, or Gemini format, and the response is translated back so Claude Code sees what it expects.

Tool calling is where a naive bridge usually breaks, and the README claims proper translation of Anthropic tool_use and tool_result into OpenAI and Gemini function calling. That is the part worth scrutinising in your own traffic, because a mangled tool result does not produce an error, it produces a plausible-looking wrong answer. Streaming is handled the same way: the README describes full SSE streaming with live format transformation rather than buffering the response first, so time-to-first-token is not gated on the upstream finishing.

Two mechanisms sit above the transform layer. Fallback chains try the next model when one fails, and a circuit breaker tracks model health and skips failing models to avoid latency spikes. There is also an anthropic-first failover mode, which keeps Claude on Anthropic and uses OpenCode only during rate limits or outages. That last mode is the most conservative configuration in the project, and it is the one to start with if you want the proxy in the path without moving your primary traffic.

The Go module list is consistent with this design rather than revealing more: cobra for the CLI, fsnotify for the config hot reload, modernc.org/sqlite for the request history the dashboard shows, and tiktoken-go for token counting. No HTTP framework appears, which suggests the server is built on the standard library.

Installing routatic-proxy and pointing Claude Code at it

The README's quick start is six commands, and it is worth following in order because step 2 creates the config that steps 3 and 4 depend on. Homebrew is the documented macOS path; INSTALLATION.md covers Scoop, Docker, and building from source.

brew tap routatic/tap && brew install routatic-proxy

Next, generate the default configuration file. The init command writes it to the location the binary expects, and validate checks it without starting anything.

routatic-proxy init
routatic-proxy validate

Set the API key. The README uses ROUTATIC_PROXY_API_KEY, and .env.example shows the same variable alongside ROUTATIC_PROXY_HOST and ROUTATIC_PROXY_PORT, with the legacy OC_GO_CC_* names commented out as migration fallbacks.

export ROUTATIC_PROXY_API_KEY=sk-opencode-your-key-here
routatic-proxy serve

serve runs the proxy headless. The default port is 3456, which the .env.example and the Dockerfile's EXPOSE line both confirm. The Dockerfile also sets ROUTATIC_PROXY_CONFIG to /etc/routatic-proxy/config.json and ROUTATIC_PROXY_HOST to 0.0.0.0, and its healthcheck polls http://localhost:3456/health, so /health is a real endpoint you can use to confirm the process is up.

Finally, redirect Claude Code. Both variables are required; the README sets the auth token to the literal string unused.

export ANTHROPIC_BASE_URL=http://127.0.0.1:3456
export ANTHROPIC_AUTH_TOKEN=unused
claude

If you want the dashboard instead of the headless server, use start rather than serve. The README states the dashboard is available at http://127.0.0.1:3445 when using start, and that this is specifically not the case with serve. The dashboard has three tabs: Overview for real-time metrics and model distribution, History for the last 1000 requests with filters, and Settings for editing config with hot reload. On Fedora and RHEL, each release ships x86_64 and aarch64 RPMs, and docs/fedora-setup.md documents the package contents and a systemd user service.

Where the proxy is the wrong layer, and what its docs do not promise

The first limitation is structural: this is a translation layer, and translation is lossy at the edges. The README lists four target formats (OpenAI, Anthropic, Responses, Gemini) but the provider table names five providers, and the fidelity of any given feature depends on which pairing you choose. Anthropic-to-Anthropic, which is what the anthropic-first failover mode does, has the least to lose. Anthropic-to-Gemini function calling has the most. Nothing in the README claims feature parity across all pairings, and you should read that silence as silence rather than as a guarantee.

The second is that the project is young and moving fast. The release history shows v0.6.5-beta.6, v0.6.5-beta.8, and v0.6.5 all published on 2026-09-11, with the stable release roughly sixteen minutes after the last beta. That cadence is normal for a pre-1.0 Go CLI, but it means the config schema is the kind of thing that changes between minor versions. The hot reload feature, which watches the config file with fsnotify, will pick up a schema change and reload it without warning you that a key is now meaningless. Run routatic-proxy validate after any upgrade.

The third is operational. A proxy in the request path is a new single point of failure between your editor and your model. The circuit breaker and fallback chains exist precisely because upstreams fail, but they also mean a request can be served by a model you did not intend, and the only place that is visible is the History tab in the dashboard, which requires start rather than serve. If you run headless in a container, you have given up that visibility.

Finally, the README does not document rollback. There is routatic-proxy update, update check, and update-channel (stable or beta), but no documented downgrade command. If a release changes behaviour you depend on, the path back is reinstalling a specific version yourself, and the README does not describe that procedure.

routatic/proxy versus a routing layer you build yourself

The obvious alternative is not another product, it is a small reverse proxy of your own: an HTTP handler that rewrites the JSON body and forwards it. That is genuinely a few hundred lines for the simple case, and it is what most people do before they discover they need the rest. The difference in approach is that a hand-rolled proxy handles one provider and one format, while routatic/proxy carries adapters for four formats and five providers, plus the routing categories, fallback chains, circuit breaker, and the SSE transform that keeps streaming live rather than buffered.

A second alternative, for people who want the provider switching without the request rewriting, is CC-Switch. The README describes it as a GUI for switching providers and links a section on using routatic-proxy with it, so the two are complementary rather than competing: CC-Switch changes which endpoint Claude Code talks to, and routatic-proxy is one of the things it can point at. If your only need is toggling between two Anthropic-compatible endpoints, CC-Switch alone is the smaller tool.

The third comparison is against Anthropic directly, and it is the one that decides whether you need this at all. If your workload fits inside Anthropic's pricing and you are not hitting rate limits, the proxy adds a hop, a config file, and a translation step for no benefit. The README's own framing supports this: the anthropic-first failover mode exists for exactly the case where Claude stays primary and OpenCode is the escape hatch.

Licence, upgrade cost and the beta channel

The repository is AGPL-3.0. The Dockerfile labels the image org.opencontainers.image.licenses as AGPL-3.0-only. The practical consequence for most readers is that running the binary locally, which is the documented use, does not trigger the network-copyleft clause. Modifying it and offering it to users over a network is the scenario the licence is written for, and if that is your plan, the licence text is the thing to read rather than this paragraph. Nothing here is legal advice.

The upgrade cost is mostly the release channel. routatic-proxy update-channel shows or switches between stable and beta, and routatic-proxy update installs the latest release on whichever channel you are on. Given that the beta releases and the stable release landed on the same day, the beta channel is not a quiet preview; it is the same code minutes earlier. Staying on stable is the cheaper default.

There is also a GUI to maintain, and its platform coverage is uneven. The README states macOS gets a native Cocoa window with system tray integration and requires CGO, Linux uses a browser-based GUI via xdg-open by default with no CGO, and Windows is CLI only with no GUI support. If your team is mixed-platform, the dashboard is not a shared experience.

Editorial conclusion

Adopt routatic/proxy if you already pay for OpenCode Go, Zen or Bedrock and want Claude Code's tooling pointed at those models, and you accept that the proxy is the component that can silently change your request shape. Do not adopt it if you need a documented rollback path or if you are running Claude Code against a provider the README does not list. Verify first that routatic-proxy validate accepts your config and that the model names in MODELS.md exist on the provider you configured, because a wrong model name is the failure the fallback chain is meant to absorb, not the one it prevents.

Frequently asked questions

Official sources

1. License: AGPL-3.0
2. Project website
3. README
4. Releases
5. routatic/proxy on GitHub