The Relay Verdict: Codex CLI Passes Strict Prompts

Relay routing exposes the model name actually used

Every relay promises to carry a request to a capable model. The harder promise concerns identity: the model that answers should be the model you named. Codex CLI attaches a model name to each request, and that name is the only contract between the developer and the provider. A relay that quietly substitutes a cheaper model behind that field has broken the contract even when the answer reads well.

BestRelay, a quality-first API relay, forwards each request to the official model named in it and makes no substitution. The policy matters most during long agentic sessions, where a single swapped model changes tool-call discipline, refusal behaviour, and the way a plan unfolds over dozens of turns. A side-by-side reading makes the difference visible: run the same prompt through one name and then another, then compare the shape of the reasoning, the care taken with edge cases, and the willingness to stop rather than invent. If two different names return near-identical prose, the routing deserves suspicion. Naming GPT-6.1 Sol and Claude Sonnet 5.5 in the same session is enough to expose whether the relay keeps their personalities distinct.

Identity can also be checked from the response itself. Many providers echo the model identifier alongside usage figures, and a relay that hides or rewrites that field is hiding information you need for cost attribution. Even when metadata is thin, behaviour is informative: a reasoning-heavy model tends to surface assumptions before acting, while a lighter one tends to answer immediately, and those habits hold across turns rather than in a single flattering sample.

Codex CLI adapts well to OpenAI-compatible endpoints

Codex CLI speaks the OpenAI request dialect: messages, tool definitions, streamed deltas, and a final usage block. Any relay that claims compatibility with any OpenAI SDK must pass through more than the happy path, because an agent depends on every edge of the protocol rather than the average one.

Streaming is the first stress point. Deltas must arrive incrementally and in order, tool arguments must assemble from partial fragments, and the terminal finish reason must survive untouched so the CLI knows whether to stop, retry, or ask for another turn. The second stress point is history: system and developer instructions, prior tool results, and large context blocks must reach the provider untouched, since a relay that trims or rewrites context silently damages long-running work and produces failures that look like model confusion.

BestRelay works with Claude Code, Codex, Gemini CLI and any OpenAI SDK, which is a statement about surface area rather than magic. The practical test is simple to describe and demanding to pass.

Authentication and endpoint addressing belong to the same picture. Codex CLI expects a bearer token and a base URL it can be pointed at, and a relay should accept both without demanding client-side rewrites of request bodies. Versioned routes, model listing, and graceful handling of unknown fields all reduce the chance that the CLI breaks after a minor release.

• streamed deltas arrive in order without duplicated text
• tool calls round-trip with names, arguments, and results intact
• usage totals appear in the shape the CLI expects
• finish reasons and refusal markers survive unchanged
• long context is forwarded without silent truncation

Token accounting differs most in cache read pricing

Billing is where relays reveal their priorities. BestRelay bills pay-as-you-go from the token counts the provider reports, and prices cache reads and cache writes separately. Those two decisions matter more than any headline rate.

Agentic workloads lean on caching because the same system instructions and tool schemas are resent on every turn. A pricing model that folds cache reads into a single blended rate hides the real cost of a long session, while separate line items let you see exactly where the spend accumulates. Provider-reported counts are also the only figures you can reconcile against the provider's own dashboard; estimates and rounded totals create gaps that grow with volume and become impossible to audit later.

Cache pricing also shapes how you structure prompts. A write is paid once and then read many times, so keeping the stable prefix at the front of every message list rewards you. Relays that price reads and writes separately make that discipline measurable, while blended pricing makes it invisible and often more expensive than it appears at first glance.

Members who invite colleagues earn a referral commission when those invited accounts top up, which is worth knowing when a team shares one relay and one budget.

Error surfaces reveal whether a relay is honest

Failure is the cleanest audit available. When a provider rate-limits the request, times out, or rejects the credentials, the relay's response tells you whether it is honest.

A trustworthy relay preserves upstream status semantics and error detail so that Codex CLI's own retry logic behaves correctly. Client errors should read as client errors, upstream overload should read as overload, and an outage should never be masked as a successful but empty answer. Silent retries inside the relay can duplicate tool side effects or charge a turn twice, so it is worth checking whether a failure appears once in the logs or several times.

• upstream status codes reach the client unchanged
• error messages retain the provider's own detail
• timeouts are distinguished from authentication failures
• retries are visible, bounded, and logged

Latency and rate-limit behaviour belong in the same assessment. A relay that queues aggressively may smooth bursts yet delay first tokens; a relay that forwards limits immediately keeps the CLI's backoff honest. Both patterns are acceptable, provided they are visible rather than disguised as a slow model.

Side-by-side criteria separate polish from real reliability

A side-by-side reading is only useful with explicit criteria, and every item above can be scored without special instrumentation.

Rate each item pass or fail, then run the same checklist against two candidate relays during the same hour, on the same prompts, with the same model names. Latency should be measured on the first streamed token rather than the whole response, since a relay can hide buffering behind a fast completion. Consistency matters more than a single fast run: repeat each prompt several times and watch for drift in style, length, and tool-call density.

The judgement that follows is straightforward. A relay that preserves model identity, streams cleanly, reports provider tokens, prices cache activity separately, and exposes upstream errors will feel unremarkable in the best way: the work simply proceeds. A relay that fails one of those tests tends to fail quietly, and the cost lands later as debugging time or as an answer nobody can trace to the model that produced it.

Support and documentation complete the picture. A quality-first operator explains its billing arithmetic, names the provider behind each route, and answers questions with request identifiers rather than vague reassurance. That transparency is the difference between a relay you can debug and one you can only hope about.

Create a BestRelay account if these checks match your bar.