Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Fast mode
Status: owner-approved design, 2026-10-30. The menu uses option B: a Fast toggle beside the effort heading, with a hover explanation. The trigger uses mark ②: a slim light-amber bolt beside the chevron. Revised 2026-10-31, by owner decision: relays are asked for the fast tier too, and each response confirms whether it ran.
Goal
OpenAI and Anthropic each sell a faster processing tier for some models: the same model, more output tokens per second, a higher price. A user can turn it on for a Session from the Web model picker and turn it off at any time. The closed picker shows a small mark while the Session runs fast. A new Web Session starts with the choice the user made last.
- OpenAI calls it Fast mode, formerly priority processing. A Responses or Chat
Completions request sets
service_tier: "priority". ChatGPT plans offer it to Codex as the "Fast" service tier, which uses more of the plan's quota. - Anthropic calls it fast mode: a Messages request sets
speed: "fast"on Claude Opus 5.5, and on 5 and 4.8 with a beta header. Claude subscriptions pay for it from usage credits only.
Contract
Intent
- A Session stores its processing tier in its row's
metadata.speed:"fast", or absent for the standard tier. The Session payload exposes it as top-levelspeed("fast"ornull).POST /api/sessionsacceptsspeed, and so doesPATCH /api/sessions/<id>, including on the fixed main Session. A fork copies the source Session's metadata, so it inherits the tier with the model and effort. - The remembered default is a global Workbench preference,
state_meta["workbench.fast_mode_default"], read and written through/api/workbench/prefsasfast_mode_default. The Web picker writes it on every toggle, and the Web new-session composer starts from it. Sessions created by IM, Tasks, Watches andvibe agent runstart at the standard tier: those surfaces show no mark, so they never pay more unseen. - Dispatch copies the Session row onto the turn's context.
resolve_model_hub_launchreads the tier from there and passes it to the Hub router, which records it on the gateway turn the launch prepares (TurnTrace.speed). The turn keeps the first value it is given, like its hosted tools, so a change applies from the next turn.
Where the tier is asked for
The gateway reads the turn's tier for each request it can attribute to a turn
and carries it on ModelHubRequest.speed. Each attempt adds the vendor's field
where its exact (Source, model) can carry it
(core/handlers/model_hub/fast_mode.py):
- the model's first-party vendor, by
vibe/data/model_vendors.jsonfamily prefix, is OpenAI or Anthropic, and the Source is a Hub API key or a subscription held by the Model Hub that speaks that vendor's protocol. Where an API key points does not matter: the official endpoint and a relay are both asked, and the response says whether the tier ran. Anative_cliSource never reaches the gateway; - the request speaks the Source's protocol, so the tier is never reached through a translation;
- the vendor's models.dev entry for that model names the field under
experimental.modes.fast.provider.body. The entry's body must be exactly the vendor's one field (service_tierfor OpenAI,speedfor Anthropic); any other body is not applied. The engine adds the beta header the Anthropic model needs. The catalog is the cached copy, read off the controller loop and rebuilt only when that copy changes. Reading it never fetches.
A fallback to a hop without the tier runs at the standard tier. OpenCode's shared server names no turn on its requests, so its turns never carry a Session's tier. Direct-mode Agents never reach the gateway. For both, the picker reports fast mode as not offered.
Refusal
A vendor refuses the fast tier without a code of its own. For example,
Anthropic answers an account without usage credits with 429
rate_limit_error, and a relay that validates the body may answer 422. So a
fast attempt that fails with 400, 403, 422 or 429 before any output is retried
once on the same hop at the standard tier. Only that retry's outcome is
classified, so a refused tier never cools down a healthy Source. A real rate
limit costs one extra immediate request before it is classified as usual.
Confirmation
Asking is not getting: a relay may drop the field, or pass it to an account that serves the standard tier. The vendors report the tier they served, and the Hub believes that report rather than the request:
- Anthropic reports
usage.speed(fastorstandard). OpenAI reportsservice_tieron the completed response or on every Chat chunk (priorityfor its fast tier). In a Responses stream only the completed event counts:response.createdmay echo the request even where the field was dropped. The stream tracker and the buffered projection read it (stream_wire.ServedTierPaths) intoProtocolSSEState.served_tierandRawCallOutcome.served_tier. - The resolution marks a hop whose request asked for the tier
(
ResolvedInvocation.fast_requested, also after a refused attempt's standard retry). When the gateway settles that call as served, it records whether the response named the fast tier inModelHubService.fast_tier_observations, keyed by Source and model. A response that names another tier or none counts as not confirmed. - Only the latest answer counts, and the field keeps being sent for a Session that asks for it, so a relay that starts honouring the field is confirmed by its next fast response. The record is process memory, bounded; after a restart, a hop is unknown until its next fast response.
Usage
The usage ledger bills what the response said, like the confirmation does. A
call whose response named the fast tier is recorded in its own row
(speed: "fast", beside the context tier in the row's identity; standard rows
keep the released shape). Valuation prices a fast row at the model's models.dev
experimental.modes.fast.cost rates, in the row's context tier, or at its
standard rates as a lower bound where the table lists none. Every published
aggregate (totals, Sources, models, days and buckets) counts fast_requests
beside requests, present only once a fast request joins it. A released reader
treats a fast row as a standard one, merging it into that day's standard row
without losing a count. Pricing details: docs/plans/model-hub-capability-model.md §6.2.
Picker
- The Hub Agent read states, on each catalog model, whether a fast turn on it
asks for the tier on the hop that normally serves it (
fast_mode), and what that hop's last fast response said (fast_mode_confirmed: true, false, or null when none was served yet). The model menu remembers both per backend, beside the model labels (avibe.fast-models.v2), and the chat page reads them again when a fast turn ends. - The compact picker's Fast toggle sits beside the effort heading. Its hover and keyboard-focus tooltip says what it does. While fast mode is on, a touch screen shows the same line under the efforts. On a model without the tier, the toggle keeps the Session's choice but is disabled, the trigger shows no mark, and the tooltip says so.
- Where the model's hop is asked for the tier but its last fast response did not confirm it ran (owner decision, 2026-10-31), the toggle stays switchable: the user may try it, or stop paying for it. While fast mode is on there, the trigger shows the bolt hollow, the toggle's bolt is hollow too, and a line under the efforts says the provider did not confirm it, on every device. The field keeps being sent, so the bolt fills in once a reply confirms it.
- The trigger's mark, a slim bolt in light amber, sits beside the chevron, outside the parts a narrow row drops. It is filled while the Session asks for the fast tier and its model's hop last confirmed it (or has not answered yet), and hollow while that hop's last fast response did not confirm it.
Not in this change
- Per-turn cost estimates. The tooltip says the price is higher; the multiplier differs by vendor and plan.
- Fast mode for Direct-mode Agents, OpenCode, and the IM settings surfaces.
Validation
- Scenario tests:
MH-FAST-001(a fast Session's turn reaches the hop that offers the tier, and only that hop),MH-FAST-002(a refused tier is served at the standard tier, and its Source stays routable),MH-FAST-003(the menu marks the models that would run fast), andMH-FAST-004(a relay is asked too, and its buffered or streamed responses decide whether the menu says the tier ran). - Units: the served tier each protocol reports, streamed and buffered
(
tests/test_model_hub_served_tier.py), and the observation record. - Fast-tier usage (
tests/test_model_hub_fast_usage.py): fast rates, rows,fast_requestsin every aggregate, the schema, and both metering owners.MH-FAST-004also checks that only the call that ran fast is billed as fast. - Units: the hop rule (
tests/test_model_hub_fast_mode.py), the Session field and its dispatch read, the preference, the picker, and the new-session flow. - Browser: the mark stays visible on a crowded 320px phone row.