Providers & models

Main agent providers

OpenCode Go

One subscription key, generous limits, a curated catalogue where every model has been tested with Briglia's tools and reasoning replay. Endpoint https://opencode.ai/zen/go/v1. Every request carries the x-opencode-session header OpenCode requires (see security); it is sent only when the request goes to opencode.ai directly — a proxy or gateway you place in front of OpenCode will not receive it and must add its own. Since CLI 0.2.17 requests carry no provider-specific reasoning flag (reasoning_history): OpenCode's newer backends reject it and, measured with Briglia's request shapes, it never changed what any backend did; the replay of stored reasoning on earlier assistant messages is unchanged. Since 0.2.20 the DeepSeek models additionally get a reasoning_content field on every assistant message ("" when there is nothing to replay): DeepSeek's thinking mode refuses a current-turn assistant message without it, which ended long DeepSeek turns right after a compaction on 0.2.19. Other models are unchanged on the wire.

The curated list (CLI 0.2.30) is ordered by upstream company, newest version first. Older entries were retired from the picker on 2026-09-19 — glm-5.3 (text-only), deepseek-v4-pro, deepseek-v4-flash, deepseek-v4-flash-vision-exp — but OpenCode still serves them: type the id into /model and Briglia uses it exactly as before.

Since CLI 0.2.31 the GPT models on OpenCode Go (today only gpt-5.6-luna) run over the Responses API, the transport OpenCode's own client uses for them, instead of chat completions: Luna sees images and PDFs, replays its encrypted reasoning across rounds, streams, and takes the reasoning efforts none, low, medium, high, xhigh and max (minimal is not accepted; /model replaces it with low when you switch). The protocol follows the model, so /model between GLM and Luna switches transport with it, and a cheap subagent lane on the other model keeps its own. Every other model on the Go gateway stays on chat completions exactly as before.

CLI 0.2.32 adds Xiaomi's MiMo 2.6 Pro and MiMo 2.6 Flash (1M context, vision, reasoning replayed like the other chat-completions models). MiMo accepts the reasoning efforts low, medium and high only; Briglia folds the others (minimal → low, xhigh and max → high) per request, so a stored setting never fails on them. The OpenCode web-search backend moved from mimo-v2.5 to mimo-v2.6-flash in the same release (since CLI 0.2.44 OpenCode page reading uses GPT-6 Luna instead, see below).

OpenRouter (recommended)

Pay-per-token access to almost any model; enter any model id. Since CLI 0.2.54 OpenRouter is the recommended provider for new setups in briglia menu, Quick Setup and briglia setup: the default model is DeepSeek V4.1 Flash (deepseek/deepseek-v4.1-flash), and a new OpenRouter setup on it is pinned to the Together host, the fastest when tested, the same as /orprovider together. The pin is written only when OpenRouter's host list confirms Together serves the model; otherwise setup says so and OpenRouter picks the host. Changing the model in setup or the menu keeps the pin if Together serves the new model and releases it, with a notice, if not. Existing installs keep their provider and pin. The wizard asks whether the model can see images (Enter = yes).

Custom OpenAI-compatible endpoint

Any server speaking the OpenAI chat-completions API: base URL, model id and API key. Reasoning models are supported, with per-provider replay of their reasoning across turns.

Local server

vLLM, Ollama, LM Studio and friends on your own hardware — no key, default http://localhost:1234/v1. Prefix caching on the server helps a lot with Briglia's long contexts.

ChatGPT subscription

Since CLI 0.2.10 the main agent can run on your own ChatGPT account over the Responses API, while Briglia keeps its own tools, history, memory and agent loop. Choose ChatGPT subscription in briglia setup or Quick Setup, or run briglia subscription login (device-code sign-in); from the paired Telegram chat: /subscription login, then /provider chatgpt. Streaming tool calls and encrypted reasoning replay work within the same model and login scope, and you can switch between this and any Chat Completions provider inside one conversation. It uses the public OAuth-client compatibility route also used by Pi and OpenCode, with Briglia attribution: it is not an official OpenAI client, and availability depends on your account, workspace permissions and the upstream service. Voice, OCR and image generation still use their own API keys, and the main agent never falls back to a paid API automatically. Since CLI 0.2.35 web research follows the subscription (see below). /cachestats reports how much input the provider served from its prompt cache (token statistics, not credits). The Ubuntu Touch app adds the matching setup screens from 0.8.5.

Since CLI 0.2.34 the subscription catalogue is GPT-6 Sol, GPT-6 Luna and GPT-6 Astra, then GPT-5.6 Luna, Terra and Sol, and new ChatGPT setups default to GPT-6 Sol (it was GPT-5.6 Luna). GPT-6 Sol and Luna see images, call tools, replay their encrypted reasoning and take the efforts none to max (minimal is not accepted). An existing setup keeps its model; switch with /model gpt-6-sol. OpenCode Go now serves GPT-6 Luna (over the Responses API only); since CLI 0.2.44 Briglia uses it there for page reading, not yet as a main-agent model.

Since CLI 0.2.44 the catalogue starts with GPT-6.1 Sol, and new ChatGPT setups default to it at high effort. It sees images, calls tools and replays its encrypted reasoning. It takes the efforts low to max only: none and minimal are not accepted, so /model gpt-6.1-sol turns a stored none or minimal into low and says so. An existing setup keeps its model; switch with /model gpt-6.1-sol.

Since CLI 0.2.35, while /provider is chatgpt, web page reading runs on the subscription too: page extraction and web_fetch page compression use GPT-6 Luna on your ChatGPT account, with no OpenAI API key needed and no per-request cost (since CLI 0.2.37 the Web researcher itself runs your main subscription model, see below). Switching to another provider switches page reading back to your /websearch choice. If the subscription reports that its usage limit is reached, web research stops with the same usage message as the main agent; nothing moves to your API key.

Side services

OpenAI image generation uses GPT Image 2.5 Flare by default. For careful edits that preserve subjects, faces, text or layout, Bree can choose Sunburst. Quality defaults to auto; xhigh and max are reserved for explicit requests for maximum detail. Transparent backgrounds are supported with PNG or WebP. Both models use the same token rates, but their cost per image can differ. Image generation uses your OpenAI API key, including when the main agent uses a ChatGPT subscription. OpenAI may require organisation verification for GPT Image 2.5; if it refuses a render for that reason, Briglia renders it once with gpt-image-2 instead (quality capped at high, background auto), says so in the result, and tries GPT Image 2.5 again after 15 minutes, so images work without any account approval.

OpenRouter without an OpenAI key

Since CLI 0.2.37, when OpenRouter is your provider and no OpenAI key is set, Briglia needs only the OpenRouter key (plus Serper, Jina and Telegram). Everything the OpenAI key used to do goes through OpenRouter: voice messages and transcribe_media use openai/gpt-transcribe (subtitles use openai/whisper-1, with the SRT file built by Briglia); scanned documents for a text-only model use GPT-6 Luna (zero-data-retention hosts); and images use Google's Gemini image models — Gemini 3 Pro Image (Nano Banana Pro) by default, or Gemini 3.1 Flash Image when Bree picks the quick engine, with aspect ratios from 1:1 to 21:9, 1K/2K/4K sizes and editing of a stored image. The cost of each image is what OpenRouter reports (about $0.07 on Flash and $0.14 on Pro at 1K when tested). GPT Image 2.5 is not available on OpenRouter. If you add an OpenAI key, it wins: voice, images and OCR go back to OpenAI exactly as before. The choice is made on every request, so switching /provider follows at once.

Since CLI 0.2.37 the Web researcher runs on your main model: the same provider, model and reasoning effort as the main agent (ChatGPT subscription, OpenAI, OpenCode, OpenRouter including an /orprovider pin, a custom endpoint or a local server), fixed for the whole run when it starts — a /model change applies from the next research run. The legacy web_search loop (/websubagent off) does the same for its planning and answer rounds. It always runs the main model: a cheap subagent lane requested for a Web call is ignored (the result says so). Research tokens count toward your spend like the main agent's; on the paid OpenAI API, which reports only token counts, they are priced at the model's published rates. What /websearch chooses is now only the page-reading backend: page extraction and web_fetch compression; OCR is unchanged.

Since CLI 0.2.37, while /provider is openrouter, page reading follows it: page extraction and web_fetch compression use DeepSeek V4 Flash (deepseek/deepseek-v4-flash-0731) at low reasoning effort on your OpenRouter key, and OpenRouter routes each request to the fastest host serving it. Since CLI 0.2.39 that choice is limited to hosts that passed repeated live extraction tests, and OpenRouter picks the fastest of them; some other hosts stalled for about 90 seconds and returned nothing, which slowed research runs by minutes. Since CLI 0.2.42 those hosts are Reka and DigitalOcean (Makora was dropped: it looped and often refused for capacity), no output token cap is sent (the old 8,000-token cap let DeepSeek spend it all thinking and return nothing), a retry goes to a host that has not failed yet, and each page-reading call has a 5-minute total time limit — it limits time, not thinking; a call that runs out is cancelled and retried, up to 3 attempts. OpenRouter may still bill a call Briglia stopped waiting for or whose connection dropped, so such a call is recorded as an unknown charge in /spend (the real cost is filled in if OpenRouter reports it later); with a daily or monthly limit set, it pauses paid work until /spend accept-unknown. The cost is what that host charges, as OpenRouter reports it. Since CLI 0.2.43 page reading on OpenRouter uses GPT-6 Luna (openai/gpt-6-luna, medium effort — the same model and effort as the OpenAI and ChatGPT lanes) instead of DeepSeek V4 Flash: the model now only picks numbered passages of the page, so its speed decides, and on 16 test pages Luna took a median 5.5 seconds a page where DeepSeek took 23, with no stuck calls. OpenRouter sends it to OpenAI or Azure at list price ($0.10 per million input tokens, $0.50 per million output); the cheaper “flex” and pricier “fast” endpoints are not used. If your OpenRouter account has its own OpenAI key (BYOK), OpenAI bills that key and Briglia counts the amount OpenRouter reports for it, plus OpenRouter's own fee when it charges one. An /orprovider pin applies to the main model only (and the researcher, which runs it); page reading ignores it, since the pinned host may not serve this model. Switching to another provider switches page reading back to your /websearch choice.

Since CLI 0.2.43 page reading works the same way on every backend (OpenAI, the ChatGPT subscription, OpenCode, OpenRouter): each page is read in one call — there is no longer a separate call for links and images. Briglia splits the page into numbered passages of up to about 1,500 characters (paragraphs, headings, list items, table rows, images, code), numbers every link and image inside them, and the model answers only with the numbers of the passages, links and images that matter for the question. Briglia then copies those passages word for word from the page, links in place, so quotes are always exact. Menus and footers are kept as passages too, so a question like “where are the dealers?” can still find its link. Pages of 8,000 characters or less skip the model and go to the researcher whole. No temperature is sent on any web request. Compared with CLI 0.2.42, a research run was about 20% faster and slightly cheaper in tests (same model, 14 questions); the researcher receives somewhat more page text (complete passages rather than fragments).

Since CLI 0.2.44 every page-reading call — page extraction and web_fetch compression, on every backend (OpenAI, the ChatGPT subscription, OpenCode, OpenRouter) — has a 2-minute total time limit (it was 5 minutes, and only on OpenRouter while it was your provider). The model now answers with passage numbers only, so a healthy call finishes in seconds (the slowest GPT-6 Luna extraction seen in tests took 64 seconds; a 291,000-token page took up to 29). The limit counts time, not thinking: no output cap is sent, and keep-alive bytes from the server don't reset it. A call that runs out is cancelled and retried, up to 3 attempts. On the backends billed per request (OpenRouter and the OpenAI API key) a cancelled call may still be billed, so it is recorded as an unknown charge in /spend; OpenRouter may report the real cost later, while OpenAI does not, so an OpenAI one stays unknown. With a daily or monthly limit set, an unknown charge pauses paid work until /spend accept-unknown. The ChatGPT subscription and OpenCode Go have no per-request cost, so nothing is recorded there. Also since CLI 0.2.44, OpenCode page reading uses GPT-6 Luna (gpt-6-luna, medium effort) instead of MiMo 2.6 Flash, over OpenCode's Responses API (the only way OpenCode Go serves Luna). On 16 test pages it took a median 6.0 seconds a page against 11.7 for MiMo, with the same facts found, no errors, and about 30% less text for the researcher to read. It is included in your OpenCode Go plan.

The web page-reading backend (which model extracts and compresses the pages research reads) can be OpenAI, OpenRouter or OpenCode — /websearch shows or switches it. Since CLI 0.2.35 the default page-reading and OCR model is GPT-6 Luna (it was GPT-5.6 Luna; half the price), and while the main provider is the ChatGPT subscription page reading follows it automatically; /websearch then sets the backend used on other providers. Since CLI 0.2.27 the optional Web subagent (/websubagent on|off, default off in 0.2.27–0.2.28 and on since 0.2.29, with the legacy tools kept for /websubagent off) ran every request of a research run on that same backend with its own key until CLI 0.2.36 (on OpenAI the configured openai/… web model, on OpenRouter the configured slug, on OpenCode the pinned research model); since CLI 0.2.37 it runs on the main model as described above. From CLI 0.2.28 to 0.2.36 the researcher ran at high reasoning effort; since 0.2.37 it uses the main agent's effort (page extraction stays at medium). Its prompt carries only the assistant's name — no user name, no profile and no status of other running work reaches the web backend, on any request of a run including compaction summaries — and ordinary subagents (general-purpose, Browse, custom agents that had the legacy web tools) delegate to it one level deep instead of searching themselves.

Subagent lanes

Briglia can delegate to subagents (exploration, planning, browsing, watcher triage). Each runs on a lane: inherit (the main model, default), cheap-vision or cheap-text. Configure the two cheap lanes once with /subagentmodels per provider; unset lanes fail loudly rather than silently falling back. /subagents off removes delegation entirely.

Costs

Briglia has no subscription of its own — you pay your providers. It is built to be frugal: exact token accounting from provider telemetry, prompt-cache-friendly request shapes, compaction instead of blind truncation, and optional per-turn, daily and monthly spend limits you set from chat (/spend) — none are on by default.