Claude Code, routed through DIAL:eight models, 192 runs, and metering every request.

A cost answer, a failure taxonomy, and a place to measure from.

When finance asks what the agents cost and security asks whether they are on a governed path, you usually cannot answer both at once. This work produces one path that does: the same route that runs the agents also measures them, and that measurement is the part nobody set out to build.

• The adapter routes anything. An Anthropic-to-OpenAI translation adapter lets an unmodified coding agent talk to any upstream the gateway brokers; 192 trials produced zero authentication incidents and required no harness source changes.
• Open-source is the cost floor, at scale. At verified list pricing an open model is the cheapest model that passes every task, while several smaller open models fail with a shared, scale-driven signature.
• The adapter is one change from business telemetry. It already writes rich per-request records and is a single, client-free change away from joining that telemetry to project, team, and use-case context.

One adapter, eight upstreams, one compliant path.

The adapter accepts the request shape the coding agent emits, translates it to the gateway's OpenAI-style chat-completions, and streams the response back in the expected shape. A thin wrapper redirects the agent's three model slots at any gateway deployment without restarting the session. Traffic that would otherwise leave for the public API stays on the sanctioned inference path; the engineer-side change is a single environment variable. The adapter strips cache-control on every non-Anthropic upstream, a known gateway gap, and emits a structured record on every response, which is where the third finding comes from.

Eight models sort into three tiers, with the cutoff at scale.

Every cell is a fresh worktree seeded with identical files; the agent runs non-interactively through the adapter and a hidden validator asserts behaviour, with exit-zero the only pass signal. No LLM judge, a 300-second hard timeout. The eight models split cleanly into three tiers with a sharp boundary: a model either closes the agentic loop or it does not, and the only gradient is cost, inside the viable cluster.

Three failure modes, and a pricing trap in the tooling.

The non-viable runs fall into three cumulative failure modes. Prose emission: the model returns markdown instead of a structured tool call, falsely signalling success at about one turn; the fix is retraining. One-call stall: it emits one correct tool call then cannot ingest the result and continue, hitting the watchdog at about 1.6 turns; the fix is more active parameters, on the order of 100B. State loss: the loop sustains for ten to fifteen turns, but the model cannot carry forward what it changed to update an external surface; the fix is better instruction training. The single task that discriminates full from partial viability is the one that requires remembering a change across a tool boundary: the viable tier passes it every time, both partial models pass it never.

Every request passes through the adapter, so every request can be logged.

The adapter is the only component that sees the full request, the translated upstream call, and the full streamed response. On every response it writes a structured record: token counts, the tool-inventory hash, the MCP servers seen, the cache strategy, the latency, the stop reason, and a list-priced cost estimate. Nothing about that is exotic, and that is the point: an observation plane for AI-assisted development already exists in the request path, as a side effect of routing.

The hard part of measuring AI-assisted work is not collection. It is the join to business context.

What is recorded, what is in the wire, and what needs a header.

The telemetry separates into three layers, and being honest about which is which is the whole contribution. Layer A is what already reaches the time-series store and dashboards today, tagged only by client name and model family. Layer B is identifiers already in the wire but not yet promoted to tags, the session id, the request id, the tool-inventory hash, the MCP-servers list, the command name, a mechanical exporter change needing no client cooperation. Layer C is the business context, project, team, industry, use-case, that the proof of concept does not capture and that would require headers the agent does not send today.

The distance from Layer A to a per-project, per-team, per-use-case cost-and-quality view is one promotion of Layer B and one header convention for Layer C. The per-segment views in the proof of concept are illustrative placeholders, not a deployed system, and the note is careful to label them as such.

From a per-laptop adapter to a feature in the gateway.

The pattern the work supports is to move the validated translation inside the gateway itself, so any licensed developer can point the agent at it without running a local adapter, and per-project configuration decides which upstream each picker slot resolves to. The translation core is roughly 1500 lines in two functions plus a streaming bridge; porting it is a rewrite against existing auth and routing, not a new design, and the existing test suite carries forward as the conformance bar.

The routing was the task. The observation point was the find.

Two questions went into this work: does an unmodified coding agent route cleanly through the gateway, and can an open model keep up. Both are answered, the second turning on scale rather than vendor. The third thing, the one worth carrying forward, was not a question at all but a side effect: the adapter that makes routing work is the only place that sees the whole exchange, and so it is where AI-assisted development becomes measurable, once the data is joined to the work it belongs to.