Implemented · Automated verification passed

Fast inside the thinking panel

For OpenProgram users choosing how a model request is processed. The thinking panel’s header carries a GaugeIcon Fast toggle, with the panel’s question-mark help tip to its right, and distinguishes supported API and Grok 4.6 subscription routes from unverified gateways. Thinking effort stays independent.

Interactive preview

Preview connection

Effort XHigh

FasterSmarter

Create / run / edit or ask anything…

Auto modeOptionsGrok 4.6XHigh

The preview uses the supplied SVG paths with a CSS approximation of the Motion spring; the React implementation reuses the supplied GaugeIcon component. The preview makes no network requests. Change the route, then use the speed button with a pointer, Enter, or Space. The panel is shown open for review; the effort slider and GaugeIcon toggle operate independently.

Behavior contract

The thinking panel’s header holds the effort heading, then, right-aligned, a GaugeIcon button followed by the question-mark help tip specified in effort-picker.html; the slider stays below. Use the user-supplied GaugeIcon paths and spring animation (stiffness 160, damping 17, mass 1) in the React implementation. The idle needle means off; the advanced needle remains visible while Fast is on. The icon stays outlined. Fast activation turns the gauge to the theme danger colour; off restores the inherited muted colour. Activation adds no border, glow, or flame effect. A focus ring appears only for keyboard focus, independently of the selected state. Hover animates the needle and tints a 24px hit target; keyboard focus exposes the state and provider-specific usage note. Remove the duplicate Fast menu item; do not add a separate speed pill. The closed effort control shows only the effort label. Fast lives in the open panel. No fixed speed multiplier is copied from the reference screenshot.
Default is Standard. Save the selection per session and route/model identity. An unseen route starts at Standard; changing models must not silently enable a paid tier. Restore existing session preferences only for the original supported route.
An unverified route keeps a visible, focusable, unavailable control with an explanation. It must not be described as a model that categorically lacks Fast. Explicitly unsupported and unknown are distinct capability states.
Changing speed applies to the next submitted turn. Queued messages retain their submitted setting; a running request is unchanged. Fast does not change Xhigh or another thinking setting.
Standard explicitly overrides an agent’s priority default. Do not represent “off” merely by omitting the field, because the current loop can then inherit that default.

Capability and request mapping

Connection	Evidence and decision	Request
xAI official API / Grok 4.6	Priority is documented. Add a provider-and-endpoint-scoped declaration for the verified model; do not enable every name containing “grok”.	Fast → service_tier: priority; Standard → default.
Grok subscription / Grok 4.6	The CLI chat proxy accepts the same service_tier values as the official API for grok-4.6. Other subscription models stay unknown until verified or explicitly declared.	Fast → service_tier: priority; Standard → default.
Custom gateway	No capability inherited solely from model name. Explicit route-specific configuration can declare support; honor explicit false.	Use the configured adapter mapping only when supported.
Existing Codex / Claude support	Preserve existing evidence sources and protocol adapters. The new UI consumes the same resolved capability as dispatch.	Preserve the existing priority or speed + beta mapping.

Use a small capability projection: supported / unsupported / unknown, reason, and source. Keep chat.fast as a compatibility projection. Official account data takes precedence; explicit route configuration can disable or supply missing support; static official declarations precede catalogue fallback. A network failure must not erase a valid cached declaration.

Resolve capability on the backend for the actual turn provider and model, then validate again before dispatch. The frontend is not the authorization boundary. Fast applies to the selected chat request path; a different execution model must resolve its own capability and never inherit support just from the chat badge.

Requested speed and actual speed

The control expresses a request preference. Record the response’s actual service tier separately: priority, default, or unreported. A default response to a priority request is displayed as Standard served. Missing metadata means unconfirmed, not successful acceleration. Preserve cancellation and existing error handling; do not issue an automatic second billable request when priority fails.

xAI documents a 2× priority premium. Show the provider-specific cost note before the toggle is used. Actual billing follows the returned tier and provider-reported usage; do not apply a blanket multiplier to other vendors or invent a latency guarantee.

Implementation sequence and acceptance

Capability resolution: agent settings exposes supported xAI API and supported Grok 4.6 subscription separately from unknown subscription models. Switching routes updates the visible reason. Explicit false wins. Catalogue failure preserves known support.
Composer: keyboard and pointer can select speed, session reload preserves it, a different model starts at Standard, and narrow layouts remain usable. No duplicate toggle exists. Gauge activation keeps the panel open and does not move the slider. The closed effort control does not show a Fast glyph. Models without an effort slider retain the same settings popover with the speed control and omit the slider. Opening the panel hides the Jump to latest chip so the two do not stack.
Dispatch: public message submission produces priority only for the selected supported route. Standard overrides an agent priority default. Queued turn settings remain stable. Reasoning parameters are unchanged.
Response evidence: synthetic priority, default, absent-tier, error, and cancellation responses preserve accurate status without a duplicate request or invented price. Paid live verification requires a selected account and a bounded request.

Implementation touches the existing model-listing resolver, provider metadata, session settings, composer controls and submit path, dispatcher fallback, and response usage projection. Update the existing Fast product documentation with the same behavior. Run affected backend and composer checks, documentation links, then the repository’s implementation review and full verification gates before release.

Verified gaps and references

The current trigger renders an Options icon even though internal identifiers say plusMenu. The thinking panel keeps a visible GaugeIcon and explains unavailable Fast support. The resolver handles Codex and Claude specially; other providers rely on models.dev. The xAI adapter already uses OpenAI-compatible Chat Completions, whose builder passes service_tier. The current Responses pricing hook does not implement priority pricing; existing documentation must not be treated as proof of correct billing.

Adopt xAI’s request/actual-tier separation and reuse OpenProgram’s existing adapter. Modify the hidden-toggle UI. Reject a global Grok name-prefix override and reject reduced reasoning as a substitute for Fast.

xAI Priority Processing: request parameters, supported endpoints, actual tier.
xAI pricing: premium and billing conditions.
Capability resolver
Current composer controls

Implementation status

Gauge, capability, request preference, saved response tier, and actual xAI cost are implemented. Independent specification and quality reviews pass. Full Python verification passes (8,981 tests), Web verification passes (714 tests, typecheck, checks and production build), and both browser acceptance tests pass. Installed-App acceptance is recorded in the task report. Implementation is authorized. Paid live calls and remote upload remain outside this delivery.