---
slug: ask-the-route-what-it-offers
title: "Ask the route what it offers"
tag: Sovereignty
date: 2026-11-10
published: 2026-11-17
receipts:
  - https://github.com/supernovae-st/nika-spec/commit/b4c692f538834db5733f972cd8f52b558c18926a
  - https://github.com/supernovae-st/nika/commit/9f5c7bc2fd37a7abb4be4d70100f4888edc64577
  - https://github.com/supernovae-st/nika/commit/47f277883a257dc480a5aa228d33a4f392f6e381
  - https://github.com/supernovae-st/nika/commit/eb634b408dba7d982f3979771541b24a8bc5b32b
  - https://github.com/supernovae-st/nika/commit/7cc1384b59e6aab87041b790cc1166b8fd1ed9c0
  - https://github.com/supernovae-st/nika/commit/198da9f85f6d3e9e01bdc6fbf300393780bcd8f7
description: "Nika v0.124.2 lets a workflow ask its route for a service tier and refuses what it cannot confirm; v0.124.3 reads a route's offer without a prompt."
---

Since v0.123.0, a Nika workflow can say how it reaches its model, not only which model it wants, as told in [The file says how it reaches its model](/blog/the-file-says-how-it-reaches-its-model). The `run.access` block names the route (`via`: an agent application such as `codex`, or an API provider), the protocol (`api`, or `acp`, the Agent Client Protocol used to talk to agent applications) and the fallback, which is `none`: the declared selection is honored exactly or refused. `run.reasoning.effort` asks the route for one of its own effort levels.

Two questions stayed open. A route can serve the same model at different speeds, and the file had no word for that. And an application that drives Nika through its server could not learn what a route offers without starting a run. The [harness guide](https://github.com/supernovae-st/nika/blob/main/docs/usage/harness-agents.md) describes how a run finds out: "A run learns what its session offers on the way to its prompt, and says so only when it refuses."

v0.124.2 and v0.124.3, both published on 10 November 2026, answer one question each.

## A speed in the file

v0.124.2 adds one optional key, `run.access.service_tier`, with two words: `standard` and `fast`. The guide shows it beside the route and the effort. This is a fragment of a workflow's top level, not a complete file:

```text fragment
run:
  access:
    via: codex
    protocol: acp
    fallback: none
    service_tier: fast   # or: standard
  reasoning:
    effort: low
```

The two words belong to the language, not to a vendor. Codex's own values (`on`, `off`, `priority`) are refused in the file. A route that offers a speed control binds each word to its own setting: on the Codex seat, `fast` is sent as codex-acp's `fast-mode: on` and `standard` as `off`.

The [spec](https://github.com/supernovae-st/nika-spec/blob/main/spec/01-envelope.md) is strict about what an engine may do with them. It "MUST NOT translate a word into another model, another effort or another route's control, and it MUST NOT serve `fast` as `standard`." A route that has no such control refuses both words: "`standard` is never assumed where nothing states it."

Leaving the key out is a third state, not a default. The 0.124.2 notes: "Omitting the key is not `standard`: nothing is sent, the route keeps its own tier, and the file keeps its resume identity and its receipt."

## Selected, then read back

On the Codex seat, Nika selects the model, the effort, the tier and the session mode in that order, then reads the whole selection back before the first prompt. If the selected model's session offers no such option, or the read-back does not hold the value, the task fails `NIKA-1805` before any prompt is sent. A tier no route can carry (an API or local route, a seat with no measured speed control, an `infer:` task outside `protocol: acp`) is refused before the first task, by `nika check` and by the run, with `NIKA-1800`.

The record is honest about what it can see. When the file declares a tier, each such task's `access_selection` receipt gains a `service_tier` block. The guide's example:

```json
{
  "requested": "fast",
  "option": "fast-mode",
  "offered": ["off", "on"],
  "transmitted": "on",
  "configured": "on",
  "configured_source": "confirmed_selection",
  "turn": { "value": null, "evidence": "unknown" },
  "effective": { "value": null, "evidence": "unknown" }
}
```

`configured` is what the session reported after the selection. `turn`, the tier carried on the turn, and `effective`, the tier that served it, read `unknown`, because no ACP answer names either. The guide draws the conclusion itself: "A configured `on` is not proof that a given turn ran on the fast tier."

The same release starts an ACP task's adapter once instead of twice. The notes give the saving with its scope: "Measured on one codex seat with codex-acp 1.13.1 on 2026-11-10: the single start saves about 1.6 s per task". They close their timings with: "These are observations of one seat, not a promise of the tier."

## Asking before running

v0.124.3 adds a route to `nika serve`, Nika's HTTP server: `GET /v1/access-offers/{name}`, where `{name}` is the served name of a workflow. It needs the same Bearer token as the other routes. The guide's example:

```sh
curl -s http://127.0.0.1:8787/v1/access-offers/workflows/brief.nika \
  -H "Authorization: Bearer $(cat .nika/serve.token)"
```

The server opens the sessions a run of that file would open, selects the file's model in each, reads the models, the exact reasoning efforts and the service tiers the route lists for that model, and ends. The 0.124.3 notes: "the path holds no `session/prompt`, so an offer uses no turn". The answer is a `nika/access-offer@1` document with `"prompts_sent": 0` and one row per session shape and model: `completion` for the models `infer:` tasks resolve to, `agent` for those of `agent:` tasks.

Each row is an observation with a time, `observed_at` and `fresh_until`. "Rows are kept 60 seconds (15 when unavailable)", so a page that asks often opens a session rarely. One reading runs at a time, and a ninth concurrent request answers `503 access_offer_busy`.

The answer does not fill gaps. A model the session does not list is `not_offered`, and its efforts and tiers stay `unobserved`: in the guide's words, "they are never read from another model's configuration." A session that gives no offer is a row marked `unavailable`, with the code a run would meet before its prompt: `NIKA-1803` when the adapter is absent, silent or outside its version pin, `NIKA-1804` when the session dies, `NIKA-1805` when it refuses. A workflow that declares no `via` under `protocol: acp` answers `not_applicable` and opens no session. `/health` lists `accessSessionOffer` when the server has this route.

One follow-up shipped in v0.124.4: when an adapter stays silent, the row now reads `NIKA-1803` whichever timer is observed first. Before, a late poll could report it as `NIKA-1804`.

## Why it matters

A route chosen in a file only means something if the choice is kept. Here the file states the speed, the engine applies exactly that or refuses, and the record keeps apart what was asked, what was confirmed and what nobody can see. On `nika serve`, the notes add, "the tier is a field of the file, never of the request".

The offer route gives an application something honest to show before any turn is spent: what this route had for this model at this time, with the time attached. The person's choice then goes into the workflow file, where `nika check` and the run judge it again.

## What it does not do

- One route, as of these releases. "The binding is held for codex-acp 1.13.1 only" (0.124.2 notes). Another release of the adapter refuses a declared tier until it is measured. `claude-code` has no measured speed control today, and tiers in an offer read `unobserved` on anything but codex-acp 1.13.1.
- The run cannot observe which tier served a turn. `turn` and `effective` stay `unknown`.
- Codex applies a tier only while its own `fast_mode` feature is enabled, which Nika cannot see. The guide suggests `codex features list` on the seat.
- A fast tier uses more of your subscription's allowance per turn. On a short answer, the guide says, "the tier changes little".
- "An offer authorizes nothing." A model, an effort or a tier can leave a seat between the offer and the run; the run selects, reads back and refuses on its own session exactly as before.
- An editor served by an older `nika lsp` refuses the new key and loses hover and navigation on the file until it is updated.
- This post quotes one timing only. The other timings in both release notes come from the same seat on the same day; those of 0.124.3 were taken "with a debug build of the engine", and its notes call them "observations of one seat on one day, not a description of the route."

Read the [v0.124.2 release](https://github.com/supernovae-st/nika/releases/tag/v0.124.2) and the [v0.124.3 release](https://github.com/supernovae-st/nika/releases/tag/v0.124.3), or go back to [The access layer is an operating contract](/blog/the-access-layer-is-an-operating-contract).
