diff --git a/FLOW.md b/FLOW.md
index e50ffd7b8..629b8f8b8 100644
--- a/FLOW.md
+++ b/FLOW.md
@@ -771,6 +771,21 @@ Two shapes that surprise, both learned the hard way:
   (anomalyco/opencode#45424) which this fork's vendored core does not have yet: against an engine
   without it *and* without the config override above, those models read as runnable and still fail
   to dispatch. Drop the id list from `COMPATIBLE_PROVIDERS` if that PR is rejected.
+- **A Claude subscription is not a provider, and no feature should pretend otherwise.** Anthropic
+  does not allow Pro/Max to drive another app, and OpenRouter's BYOK takes API keys only. Claude
+  reaches a card by API key, direct or through OpenRouter (whose BYOK is also how Bedrock/Vertex
+  credits pay for it). README "Using Claude" is the user-facing account.
+- **A local model is declared, with four fields the engine gets wrong by default** (`lib/local.ts`):
+  a `local-` id (a models.dev id such as `lmstudio` is hidden until a key is stored), `tools: true`
+  (default off), a limit (default `{0,0}`), and a **zero price row** — priced at nothing, so the
+  unpriced-never-$0 rule and a gauntlet's cap both still hold. Never special-case local in
+  `usage.ts`; the config price is the whole mechanism.
+- **Every run has a spend cap** (`spendCapOf`; absent means the $5 default, unlike the toggles,
+  because absent-means-off would leave the common case uncapped). Non-gauntlet runs hard-stop in
+  `enforceCap` on the repriced step and end `error` with `RunLog.capped`; a gauntlet keeps its
+  graceful `exhausted()` path at its own cap. The pre-run estimate in `graph/estimate.ts` is the
+  one guessed number here — it stays a range, and seat advice (`weak-seat`) fires only on an
+  inversion inside the canvas, never on a model merely being cheap.
 - `bun test` has **no `localStorage`** (it is a browser global). When persisting a preference
   the browser stores there — custom roles, the default-model preference (`graph/default-model.ts`),
   the walkthrough-dismissed flag — make a Solid signal the source of truth and treat
diff --git a/packages/flow/README.md b/packages/flow/README.md
index 48380c5ff..a2bf6c21f 100644
--- a/packages/flow/README.md
+++ b/packages/flow/README.md
@@ -321,6 +321,75 @@ served to the browser.
 | `GET /flow/api/zen-models` | model ids opencode zen really serves, or `null` if unreadable |
 | `GET /flow/api/repackage` | which OpenAI-compatible providers the global config already repackages |
 | `POST /flow/api/repackage` | repackage them there (fixed id list only, backed up, restart required) |
+| `GET /flow/api/local` | local model servers, whether each answers, what it serves, what is declared |
+| `POST /flow/api/local` | `{ id, url? }` — declare that server's models at $0 (backed up, restart required) |
+| `DELETE /flow/api/local/:id` | remove a declared local server |
+
+### Using Claude
+
+Claude runs on a card through the paid API, billed per token. There are two
+ways to reach it:
+
+1. **An Anthropic API key** from `console.anthropic.com`. Connect **Anthropic**
+   in the provider panel and paste it. The runner routes `@ai-sdk/anthropic`
+   directly, so nothing else is needed.
+2. **Through OpenRouter.** Connect **OpenRouter**, then **Repackage** it. It
+   bills OpenRouter credits, or — with OpenRouter's BYOK (bring your own key)
+   setting — your own Anthropic key, or an **AWS Bedrock or Google Vertex**
+   key. That last one is how Claude spend comes out of cloud credits: this
+   engine cannot route Bedrock or Vertex on its own, but OpenRouter can.
+
+A Claude Pro or Max **subscription cannot be used**. Anthropic does not allow a
+consumer subscription to drive another application, and OpenRouter's BYOK takes
+API keys only, so routing through it does not change that.
+
+To keep a Claude run cheap: put the strong model where it pays off — the card
+that dispatches, the critic, the synthesizer — and a cheaper one (Haiku,
+Sonnet) on the cards that do the work. Preflight points out the reverse (a
+`weak-seat` warning) and never changes a model itself. The spend panel shows how
+much of the input came from the provider's prompt cache, which Anthropic bills
+at a tenth of the input rate.
+
+### Local models
+
+Ollama, LM Studio, or any server that speaks OpenAI chat (llama.cpp's server,
+vLLM) can run a card for nothing. Start the server and pull or load a model; the
+provider panel's **Local models** group lists what each one serves, and a click
+declares those models in the global config (`lib/local.ts`) and restarts the
+engine. Clicking again after pulling a new model picks it up.
+
+What is written, and why each part is not optional:
+
+- Ids are prefixed `local-` (`local-ollama/qwen3`). The catalog hides a provider
+  with a models.dev id until a key is stored, and `lmstudio` is one.
+- `tools: true`, because an undeclared model has tool calling switched off and
+  a card with no tools cannot read a file.
+- A context limit, because the engine's default is zero. LM Studio reports the
+  context each model is loaded with (`/api/v0/models`) and that is used; other
+  servers report none, so 32k is written. Raise it on the model in the config
+  file; a later refresh keeps the edit.
+- Only chat models. The OpenAI listing mixes in embedding models; LM Studio's
+  own route says which is which, and elsewhere an id naming `embed` is dropped.
+- A **price of zero**, written as a real price row. The model is priced, so
+  spend reads `$0` and a gauntlet's cap still works — the rule that an unpriced
+  model never shows as `$0` is unchanged.
+
+A small local model is weakest in the seat that writes a control block every
+turn (the orchestrator), which is where preflight's router warning fires for the
+same reason. Use one where a card does the work.
+
+### Spend cap and estimate
+
+Every run has a dollar cap, **$5 unless the canvas says otherwise** (`cap:` in
+the runbar; a gauntlet's own cap replaces it). The engine reprices on every step
+and stops the run the moment priced spend reaches it; the log records `capped`
+and the run ends as an error, not as `stopped`, because nobody decided it. A
+model with no published price makes the cap partial, and preflight says so.
+
+Beside it, the runbar shows a rough range before anything is spent
+(`graph/estimate.ts`): card turns counted from the graph, each priced between a
+short turn and a heavy one at list price. The turn count is exact; the turn size
+is a guess, which is why it is a range and the tooltip says what it assumed.
 
 `POST /api/session/{id}/wait` answers `503 Session wait is not available yet` on
 this server build, so idleness is derived from `/api/session/active` plus a
diff --git a/packages/flow/lib/local.test.ts b/packages/flow/lib/local.test.ts
new file mode 100644
index 000000000..200313e0c
--- /dev/null
+++ b/packages/flow/lib/local.test.ts
@@ -0,0 +1,139 @@
+import { describe, expect, test } from "bun:test"
+import { CUSTOM_LOCAL_ID, LOCAL_LIMIT, declare, declared, discover, normalizeUrl, runtimeFor, undeclare } from "./local"
+
+const ollama = runtimeFor("local-ollama")!
+
+describe("declare", () => {
+  test("writes a v2 provider with tools on, a limit, and a zero price row", () => {
+    const value = declare({ $schema: "x" }, ollama, ["llama3.2", "qwen3"])
+    const entry = value.providers["local-ollama"]
+    expect(entry.api).toEqual({ type: "aisdk", package: "@ai-sdk/openai-compatible", url: "http://localhost:11434/v1" })
+    expect(Object.keys(entry.models)).toEqual(["llama3.2", "qwen3"])
+    expect(entry.models.qwen3.capabilities.tools).toBe(true)
+    expect(entry.models.qwen3.limit).toEqual(LOCAL_LIMIT)
+    expect(entry.models.qwen3.cost).toEqual([{ input: 0, output: 0, cache: { read: 0, write: 0 } }])
+    expect(value.provider).toBeUndefined()
+  })
+
+  // One v1 key sends the whole file through the v1 migration, where
+  // `providers` is never read.
+  test("follows a v1 file's dialect", () => {
+    const value = declare({ plugin: ["./p.js"] }, ollama, ["llama3.2"])
+    const entry = value.provider["local-ollama"]
+    expect(entry.npm).toBe("@ai-sdk/openai-compatible")
+    expect(entry.api).toBe("http://localhost:11434/v1")
+    expect(entry.models["llama3.2"].tool_call).toBe(true)
+    expect(entry.models["llama3.2"].cost).toEqual({ input: 0, output: 0, cache_read: 0, cache_write: 0 })
+    expect(value.providers).toBeUndefined()
+  })
+
+  test("drops models the server no longer lists, keeps edits on the ones it does, and never keeps a price", () => {
+    const before = declare({}, ollama, ["old", "kept"])
+    before.providers["local-ollama"].models.kept.limit = { context: 131_072, output: 8_192 }
+    before.providers["local-ollama"].models.kept.cost = [{ input: 9, output: 9, cache: { read: 0, write: 0 } }]
+    const after = declare(before, ollama, ["kept"])
+    expect(Object.keys(after.providers["local-ollama"].models)).toEqual(["kept"])
+    expect(after.providers["local-ollama"].models.kept.limit.context).toBe(131_072)
+    expect(after.providers["local-ollama"].models.kept.cost[0].input).toBe(0)
+  })
+
+  test("undeclare removes it from either dialect and leaves the rest", () => {
+    const v2 = undeclare(declare({ providers: { openai: {} } }, ollama, ["m"]), "local-ollama")
+    expect(v2.providers).toEqual({ openai: {} })
+    const v1 = undeclare(declare({ plugin: [] }, ollama, ["m"]), "local-ollama")
+    expect(v1.provider).toEqual({})
+  })
+
+  test("declared reads back what was written, and nothing that is not local", () => {
+    const value = declare({ providers: { openrouter: { api: { url: "https://x" } } } }, ollama, ["m"])
+    expect(declared(value)).toEqual([{ id: "local-ollama", url: "http://localhost:11434/v1", models: ["m"] }])
+  })
+})
+
+describe("runtimeFor", () => {
+  test("accepts the fixed ids, with or without an address override", () => {
+    expect(runtimeFor("local-lmstudio")?.url).toBe("http://localhost:1234/v1")
+    expect(runtimeFor("local-ollama", "http://box:11434/v1/")?.url).toBe("http://box:11434/v1")
+  })
+
+  test("a custom server needs an http(s) address, and no other id is accepted", () => {
+    expect(runtimeFor(CUSTOM_LOCAL_ID)).toBeUndefined()
+    expect(runtimeFor(CUSTOM_LOCAL_ID, "file:///etc")).toBeUndefined()
+    expect(runtimeFor(CUSTOM_LOCAL_ID, "http://localhost:8000/v1")?.url).toBe("http://localhost:8000/v1")
+    expect(runtimeFor("openrouter", "http://localhost:8000/v1")).toBeUndefined()
+  })
+
+  test("normalizeUrl rejects what is not a url", () => {
+    expect(normalizeUrl("not a url")).toBeUndefined()
+    expect(normalizeUrl(42)).toBeUndefined()
+  })
+})
+
+describe("discover", () => {
+  test("reads model ids off an OpenAI-compatible listing", async () => {
+    const server = Bun.serve({
+      port: 0,
+      fetch: () => Response.json({ object: "list", data: [{ id: "qwen3" }, { id: "llama3.2" }, { id: "qwen3" }] }),
+    })
+    const found = await discover(`http://localhost:${server.port}/v1`)
+    server.stop(true)
+    expect(found).toEqual({ running: true, models: ["llama3.2", "qwen3"] })
+  })
+
+  // Measured against LM Studio: its OpenAI listing put an embedding model beside
+  // the chat ones, and its own /api/v0 route is what says which is which.
+  test("reads LM Studio's own listing to drop embedding models and take each loaded context", async () => {
+    const server = Bun.serve({
+      port: 0,
+      fetch: (request) =>
+        new URL(request.url).pathname === "/api/v0/models"
+          ? Response.json({
+              data: [
+                { id: "omnicoder-9b", type: "llm", loaded_context_length: 262_144 },
+                { id: "ornith-1.0-9b", type: "llm", max_context_length: 131_072 },
+                { id: "text-embedding-nomic-embed-text-v1.5", type: "embeddings" },
+              ],
+            })
+          : Response.json({
+              data: [{ id: "omnicoder-9b" }, { id: "ornith-1.0-9b" }, { id: "text-embedding-nomic-embed-text-v1.5" }],
+            }),
+    })
+    const found = await discover(`http://localhost:${server.port}/v1`)
+    server.stop(true)
+    expect(found.models).toEqual(["omnicoder-9b", "ornith-1.0-9b"])
+    expect(found.context).toEqual({ "omnicoder-9b": 262_144, "ornith-1.0-9b": 131_072 })
+  })
+
+  test("anywhere else, an id naming an embedding model is dropped", async () => {
+    const server = Bun.serve({
+      port: 0,
+      fetch: (request) =>
+        new URL(request.url).pathname === "/v1/models"
+          ? Response.json({ data: [{ id: "qwen3" }, { id: "nomic-embed-text:latest" }] })
+          : new Response("no", { status: 404 }),
+    })
+    const found = await discover(`http://localhost:${server.port}/v1`)
+    server.stop(true)
+    expect(found).toEqual({ running: true, models: ["qwen3"] })
+  })
+
+  test("declare writes a model's measured context in place of the floor", () => {
+    const value = declare({}, ollama, ["big"], { big: 262_144 })
+    expect(value.providers["local-ollama"].models.big.limit).toEqual({ context: 262_144, output: LOCAL_LIMIT.output })
+  })
+
+  test("a server that is not there is reported as not running, not thrown", async () => {
+    const server = Bun.serve({ port: 0, fetch: () => new Response("") })
+    const port = server.port
+    server.stop(true)
+    expect(await discover(`http://localhost:${port}/v1`)).toEqual({ running: false, models: [] })
+  })
+
+  test("an error status is running, with the reason", async () => {
+    const server = Bun.serve({ port: 0, fetch: () => new Response("no", { status: 404 }) })
+    const found = await discover(`http://localhost:${server.port}/v1`)
+    server.stop(true)
+    expect(found.running).toBe(true)
+    expect(found.error).toContain("404")
+  })
+})
diff --git a/packages/flow/lib/local.ts b/packages/flow/lib/local.ts
new file mode 100644
index 000000000..a4774a9c5
--- /dev/null
+++ b/packages/flow/lib/local.ts
@@ -0,0 +1,236 @@
+import { COMPATIBLE_PACKAGE, isV1Config } from "./repackage"
+
+/**
+ * Makes a model running on the user's own machine — Ollama, LM Studio, or any
+ * server that speaks OpenAI chat — a provider every card can run on.
+ *
+ * Nothing in models.dev describes a local server, so the provider has to be
+ * declared in config, with its models listed by hand. That is what this writes,
+ * into the *global* config for the reason `lib/repackage.ts` gives: a session's
+ * drain reads the engine's own config, never the target project's.
+ *
+ * Four things a declared provider needs that are not obvious, each because the
+ * engine's default for it is wrong for a local model:
+ *
+ * - **An id models.dev does not know.** `catalog.ts` treats a provider as
+ *   available only when it has a connection, *unless* no integration exists for
+ *   its id at all. `lmstudio` is a models.dev id, so a provider named that is
+ *   hidden until somebody stores a key a local server never asked for. Every id
+ *   here is prefixed `local-` so none can collide, now or when models.dev grows.
+ * - **Tool calling switched on.** An empty model's capabilities say
+ *   `tools: false`, and a card with no tools cannot read a file.
+ * - **A limit.** The empty default is `{ context: 0, output: 0 }`. The servers'
+ *   `/models` listing does not report a context size, so a conservative one is
+ *   written and the user can raise it in the file.
+ * - **A price of zero.** Written as a real price row, so `server/usage.ts`
+ *   prices it exactly like any other model and a gauntlet's cap stays
+ *   enforceable — the "unpriced is never $0" rule is untouched, because this
+ *   model is priced, at nothing.
+ */
+
+export type LocalRuntime = { id: string; name: string; url: string }
+
+/** Default addresses, from each runtime's own documentation. */
+export const LOCAL_RUNTIMES: LocalRuntime[] = [
+  { id: "local-ollama", name: "Ollama", url: "http://localhost:11434/v1" },
+  { id: "local-lmstudio", name: "LM Studio", url: "http://localhost:1234/v1" },
+]
+
+/** The one id a user-supplied address is written under. */
+export const CUSTOM_LOCAL_ID = "local-custom"
+
+export const LOCAL_PREFIX = "local-"
+
+/** Written for every model: the listing reports no context size, so this is a floor. */
+export const LOCAL_LIMIT = { context: 32_768, output: 8_192 }
+
+export function isLocalProvider(id: string) {
+  return id.startsWith(LOCAL_PREFIX)
+}
+
+/**
+ * The base URL a user typed, normalised, or undefined when it is not one.
+ *
+ * Only http(s). Trailing slashes are dropped so `…/v1/` and `…/v1` are one
+ * address — the runner appends `/chat/completions` itself.
+ */
+export function normalizeUrl(input: unknown) {
+  if (typeof input !== "string") return undefined
+  const trimmed = input.trim().replace(/\/+$/, "")
+  const parsed = URL.canParse(trimmed) ? new URL(trimmed) : undefined
+  if (!parsed || (parsed.protocol !== "http:" && parsed.protocol !== "https:")) return undefined
+  return trimmed
+}
+
+/**
+ * Model ids an OpenAI-compatible server lists at `GET <url>/models`.
+ *
+ * Ollama, LM Studio, llama.cpp's server and vLLM all answer this route the same
+ * way. A server that is not running answers nothing, which is reported rather
+ * than thrown: "Ollama is not running" is the common case, not an error.
+ *
+ * That listing does not say what a model *is*, and servers list embedding
+ * models beside chat ones — measured against LM Studio, which listed
+ * `text-embedding-nomic-embed-text-v1.5` as a peer of its chat models. A card
+ * dispatched to one fails on its first turn. LM Studio answers a richer route,
+ * `/api/v0/models`, with each model's type and the context it was loaded with,
+ * so that is read when it is there; anywhere else an id naming an embedding
+ * model is dropped, which is the convention every runtime's catalog follows.
+ */
+export async function discover(url: string, fetcher: typeof fetch = fetch): Promise<Discovered> {
+  const response = await fetcher(`${url}/models`, { signal: AbortSignal.timeout(3_000) }).catch(() => undefined)
+  if (!response) return { running: false, models: [] as string[] }
+  if (!response.ok) return { running: true, models: [] as string[], error: `${url}/models answered ${response.status}` }
+  const body: any = await response.json().catch(() => undefined)
+  const listed: string[] = Array.isArray(body?.data)
+    ? body.data.map((entry: any) => entry?.id).filter((id: unknown): id is string => typeof id === "string" && !!id)
+    : []
+  const detail = await lmStudioDetail(url, fetcher)
+  const models = [...new Set(listed)]
+    .filter((id) => (detail.has(id) ? detail.get(id)!.chat : !/embed/i.test(id)))
+    .sort()
+  const context = Object.fromEntries(
+    models.flatMap((id) => (detail.get(id)?.context ? [[id, detail.get(id)!.context!] as const] : [])),
+  )
+  return { running: true, models, ...(Object.keys(context).length ? { context } : {}) }
+}
+
+/**
+ * LM Studio's own listing, keyed by model id: whether it is a chat model, and
+ * the context it is loaded with (or can be, when it is not loaded yet). Empty
+ * for any other server, which answers this route with a 404.
+ */
+async function lmStudioDetail(url: string, fetcher: typeof fetch) {
+  const origin = url.replace(/\/v1$/, "")
+  const response = await fetcher(`${origin}/api/v0/models`, { signal: AbortSignal.timeout(3_000) }).catch(() => undefined)
+  const body: any = response?.ok ? await response.json().catch(() => undefined) : undefined
+  const entries: any[] = Array.isArray(body?.data) ? body.data : []
+  return new Map(
+    entries
+      // An entry with no `type` is some other server echoing its OpenAI listing
+      // back on this route, and says nothing about what the model is.
+      .filter((entry) => typeof entry?.id === "string" && typeof entry?.type === "string")
+      .map((entry) => [
+        entry.id as string,
+        {
+          chat: entry.type === "llm" || entry.type === "vlm",
+          context: Number(entry.loaded_context_length ?? entry.max_context_length) || undefined,
+        },
+      ]),
+  )
+}
+
+/** Local providers this config declares, with the url and models each one lists. */
+export function declared(config: any) {
+  const v1 = Object.entries(config?.provider ?? {}).map(([id, entry]: [string, any]) => ({
+    id,
+    url: entry?.api,
+    models: Object.keys(entry?.models ?? {}),
+  }))
+  const v2 = Object.entries(config?.providers ?? {}).map(([id, entry]: [string, any]) => ({
+    id,
+    url: entry?.api?.url,
+    models: Object.keys(entry?.models ?? {}),
+  }))
+  return [...v1, ...v2].filter((entry) => isLocalProvider(entry.id) && typeof entry.url === "string")
+}
+
+/**
+ * Declares one local provider with exactly these models, in whichever dialect
+ * the file is written in (see `isV1Config` — one v1 key sends the whole file
+ * through the v1 migration, where `providers` is never read).
+ *
+ * The models map is *replaced*, not merged: it is the server's own listing, and
+ * a model the user deleted from Ollama should stop being offered to cards.
+ * What the user edited on a model that is still listed — a raised context
+ * limit, most often — is kept. The price is not: it is always zero.
+ */
+export function declare(config: any, runtime: LocalRuntime, models: string[], context: Record<string, number> = {}) {
+  const value = { ...config }
+  const limit = (id: string) => (context[id] ? { ...LOCAL_LIMIT, context: context[id] } : LOCAL_LIMIT)
+  if (isV1Config(config)) {
+    const previous = config?.provider?.[runtime.id]?.models ?? {}
+    value.provider = {
+      ...value.provider,
+      [runtime.id]: {
+        ...value.provider?.[runtime.id],
+        name: label(runtime),
+        npm: COMPATIBLE_PACKAGE,
+        api: runtime.url,
+        models: Object.fromEntries(
+          models.map((id) => [
+            id,
+            {
+              name: id,
+              tool_call: true,
+              modalities: { input: ["text"], output: ["text"] },
+              limit: limit(id),
+              ...previous[id],
+              cost: { input: 0, output: 0, cache_read: 0, cache_write: 0 },
+            },
+          ]),
+        ),
+      },
+    }
+    return value
+  }
+
+  const previous = config?.providers?.[runtime.id]?.models ?? {}
+  value.providers = {
+    ...value.providers,
+    [runtime.id]: {
+      ...value.providers?.[runtime.id],
+      name: label(runtime),
+      api: { type: "aisdk", package: COMPATIBLE_PACKAGE, url: runtime.url },
+      models: Object.fromEntries(
+        models.map((id) => [
+          id,
+          {
+            name: id,
+            capabilities: { tools: true, input: ["text"], output: ["text"] },
+            limit: limit(id),
+            ...previous[id],
+            cost: [{ input: 0, output: 0, cache: { read: 0, write: 0 } }],
+          },
+        ]),
+      ),
+    },
+  }
+  return value
+}
+
+/** Removes a local provider from either dialect. */
+export function undeclare(config: any, id: string) {
+  const value = { ...config }
+  if (value.provider?.[id]) {
+    value.provider = { ...value.provider }
+    delete value.provider[id]
+  }
+  if (value.providers?.[id]) {
+    value.providers = { ...value.providers }
+    delete value.providers[id]
+  }
+  return value
+}
+
+/** The runtime an id names, with the address the caller supplied for a custom one. */
+export function runtimeFor(id: string, url?: string): LocalRuntime | undefined {
+  const known = LOCAL_RUNTIMES.find((runtime) => runtime.id === id)
+  const address = normalizeUrl(url)
+  if (known) return { ...known, url: address ?? known.url }
+  if (id === CUSTOM_LOCAL_ID && address) return { id, name: "Local server", url: address }
+  return undefined
+}
+
+/** What the model menu heads this provider with. */
+function label(runtime: LocalRuntime) {
+  return runtime.id === CUSTOM_LOCAL_ID ? runtime.name : `${runtime.name} (local)`
+}
+
+export type Discovered = {
+  running: boolean
+  models: string[]
+  /** Context each model is loaded with, when the server says (LM Studio does). */
+  context?: Record<string, number>
+  error?: string
+}
diff --git a/packages/flow/lib/store.test.ts b/packages/flow/lib/store.test.ts
index a18164ada..5b2eb1696 100644
--- a/packages/flow/lib/store.test.ts
+++ b/packages/flow/lib/store.test.ts
@@ -1196,6 +1196,59 @@ describe("custom roles", () => {
   })
 })
 
+/** Declaring a local model server also writes the global config — same isolation. */
+describe("routes: local model servers", () => {
+  let target: string
+  let server: ReturnType<typeof Bun.serve>
+
+  beforeEach(() => {
+    process.env.XDG_CONFIG_HOME = path.join(dir, "xdg")
+    target = path.join(dir, "xdg", "opencode", "opencode.json")
+    server = Bun.serve({ port: 0, fetch: () => Response.json({ data: [{ id: "qwen3" }] }) })
+  })
+
+  afterEach(() => {
+    delete process.env.XDG_CONFIG_HOME
+    server.stop(true)
+  })
+
+  test("declares what the server serves, at $0, and asks for a restart", async () => {
+    const url = `http://localhost:${server.port}/v1`
+    const response = await call("POST", "/flow/api/local", { body: { id: "local-custom", url } })
+    expect(response!.body).toMatchObject({ changed: true, models: ["qwen3"], restart: true })
+    const entry = JSON.parse(await read(target)).providers["local-custom"]
+    expect(entry.api.url).toBe(url)
+    expect(entry.models.qwen3.cost[0]).toMatchObject({ input: 0, output: 0 })
+    const status = (await call("GET", "/flow/api/local"))!.body as any
+    expect(status.runtimes.find((runtime: any) => runtime.id === "local-custom")).toMatchObject({
+      running: true,
+      models: ["qwen3"],
+      declared: ["qwen3"],
+    })
+  })
+
+  test("a server that is not answering is refused, and nothing is written", async () => {
+    const port = server.port
+    server.stop(true)
+    const response = await call("POST", "/flow/api/local", { body: { id: "local-custom", url: `http://localhost:${port}/v1` } })
+    expect(response!.status).toBe(409)
+    expect((response!.body as any).error).toContain("nothing is answering")
+    await expect(read(target)).rejects.toThrow()
+  })
+
+  test("an id outside the fixed list is refused, so no provider or package can be named", async () => {
+    const response = await call("POST", "/flow/api/local", { body: { id: "openrouter", url: "http://localhost:1/v1" } })
+    expect(response!.status).toBe(400)
+  })
+
+  test("removing one takes it out and leaves the rest of the file", async () => {
+    await call("POST", "/flow/api/local", { body: { id: "local-custom", url: `http://localhost:${server.port}/v1` } })
+    const response = await call("DELETE", "/flow/api/local/local-custom")
+    expect(response!.body).toMatchObject({ changed: true })
+    expect(JSON.parse(await read(target)).providers).toEqual({})
+  })
+})
+
 /**
  * The one route that writes *outside* the project: repackaging a provider edits
  * opencode's global config, because that is the only file a run reads (see
diff --git a/packages/flow/lib/store.ts b/packages/flow/lib/store.ts
index a7ab05f88..3f8efea8f 100644
--- a/packages/flow/lib/store.ts
+++ b/packages/flow/lib/store.ts
@@ -6,6 +6,7 @@ import { recallPipeline, rememberPipeline, rememberProject } from "./last-sessio
 import { hasNativePicker, pickFolderNative } from "./native-picker"
 import type { Supervisor } from "./opencode-process"
 import { COMPATIBLE_PROFILES, globalConfigCandidates, repackage, repackaged } from "./repackage"
+import { CUSTOM_LOCAL_ID, LOCAL_RUNTIMES, declare, declared, discover, isLocalProvider, runtimeFor, undeclare } from "./local"
 import { install, installed, uninstall } from "./dispatch-tool"
 import { checkpoint, dropCheckpoints } from "./checkpoint"
 import { dropScratch, openScratch } from "./scratch"
@@ -63,6 +64,10 @@ import { zenModels } from "./zen"
  *                                             already repackages
  *   POST   /flow/api/repackage             -> { providers: [...] } repackages them there, so the
  *                                             runner can dispatch their models
+ *   GET    /flow/api/local                 -> { path, runtimes: [{ id, name, url, running, models,
+ *                                             declared }] } — local model servers and what each lists
+ *   POST   /flow/api/local                 -> { id, url? } declares that server's models as a $0
+ *                                             provider in the global config; DELETE /local/:id removes it
  *   GET    /flow/api/server                -> { managed, running, url, command, pid, ... } — the
  *                                             `opencode serve` this host proxies
  *   POST   /flow/api/server/restart        -> restarts it, when this host owns it (loopback only)
@@ -342,6 +347,25 @@ export async function handleFlow(paths: FlowPaths, request: FlowRequest): Promis
     }
   }
 
+  if (segments[0] === "local") {
+    if (method === "GET" && segments.length === 1) return ok(await localStatus())
+    if (method === "POST" && segments.length === 1) {
+      const body = await request.json().catch(() => ({}))
+      // Only the fixed ids are accepted, and the package is always the
+      // OpenAI-compatible one, so no request can name an npm package to load.
+      const runtime = runtimeFor(String(body?.id ?? ""), body?.url)
+      if (!runtime) return { status: 400, body: { error: "name a local runtime, or give local-custom an http(s) url" } }
+      const result = await applyLocal(runtime)
+      if ("error" in result) return { status: 409, body: result }
+      return ok(result)
+    }
+    if (method === "DELETE" && segments.length === 2 && isLocalProvider(segments[1])) {
+      const result = await removeLocal(segments[1])
+      if ("error" in result) return { status: 409, body: result }
+      return ok(result)
+    }
+  }
+
   if (segments[0] === "server") {
     if (!request.serve) return { status: 501, body: { error: "this host does not track `opencode serve`" } }
     if (segments.length === 1 && method === "GET") return ok(await request.serve.status())
@@ -1126,6 +1150,64 @@ async function applyRepackage(ids: string[]) {
   })
 }
 
+/**
+ * Every known local runtime, probed, plus any declared at an address of the
+ * user's own. A runtime that is declared but not running is still listed — its
+ * cards will fail to dispatch, and the panel has to be able to say why.
+ */
+async function localStatus() {
+  const config = await readGlobalConfig()
+  const present = "error" in config ? [] : declared(config.value)
+  const custom = present.find((entry) => entry.id === CUSTOM_LOCAL_ID)
+  const runtimes = [
+    ...LOCAL_RUNTIMES.map((runtime) => ({ ...runtime, url: present.find((entry) => entry.id === runtime.id)?.url ?? runtime.url })),
+    ...(custom ? [{ id: CUSTOM_LOCAL_ID, name: "Local server", url: custom.url as string }] : []),
+  ]
+  const probed = await Promise.all(
+    runtimes.map(async (runtime) => ({
+      ...runtime,
+      ...(await discover(runtime.url)),
+      declared: present.find((entry) => entry.id === runtime.id)?.models,
+    })),
+  )
+  return { path: config.target, runtimes: probed, ...("error" in config ? { error: config.error } : {}) }
+}
+
+/**
+ * Lists what the server serves right now and declares exactly that.
+ *
+ * A server that is not running, or that serves nothing, is refused rather than
+ * written as an empty provider — a provider with no models is one the panel
+ * would show as connected and no card could use.
+ */
+async function applyLocal(runtime: { id: string; name: string; url: string }) {
+  const found = await discover(runtime.url)
+  if (!found.running) return { error: `nothing is answering at ${runtime.url} — start ${runtime.name} first` }
+  if (!found.models.length)
+    return { error: found.error ?? `${runtime.name} at ${runtime.url} lists no models — pull or load one first` }
+  return writeGlobal((value) => declare(value, runtime, found.models, found.context), { models: found.models })
+}
+
+async function removeLocal(id: string) {
+  return writeGlobal((value) => undeclare(value, id), {})
+}
+
+/** Rewrites the global config through `edit`, backing it up first. */
+async function writeGlobal(edit: (value: any) => any, extra: Record<string, unknown>) {
+  const config = await readGlobalConfig()
+  if ("error" in config) return { error: config.error, path: config.target }
+  const value = edit(config.value)
+  if (JSON.stringify(value) === JSON.stringify(config.value))
+    return { path: config.target, changed: false, restart: false, ...extra }
+  if (config.comments) return { error: CONFIG_HAS_COMMENTS, path: config.target }
+  return serialize(config.target, async () => {
+    const backup = config.raw === undefined ? undefined : await backupConfig(config.target, config.raw)
+    await fs.mkdir(path.dirname(config.target), { recursive: true })
+    await writeAtomic(config.target, JSON.stringify(value, null, 2) + "\n")
+    return { path: config.target, changed: true, backup, restart: true, ...extra }
+  })
+}
+
 const CONFIG_HAS_COMMENTS =
   "existing opencode.json has comments, and saving would strip them — remove the comments, or make this change in opencode.json by hand"
 
diff --git a/packages/flow/src/app.tsx b/packages/flow/src/app.tsx
index 940602df5..1ac312b7c 100644
--- a/packages/flow/src/app.tsx
+++ b/packages/flow/src/app.tsx
@@ -1,9 +1,11 @@
 import { For, Show, createMemo, createSignal, onCleanup, onMount } from "solid-js"
 import { Canvas } from "./canvas/canvas"
 import {
+  DEFAULT_MAX_SPEND,
   depthOf,
   dispatchesOf,
   gauntletOf,
+  spendCapOf,
   MAX_DEPTH,
   MAX_DISPATCHES,
   MAX_ROUNDS,
@@ -14,6 +16,7 @@ import {
   type Pipeline,
   type RunLog,
 } from "./graph/types"
+import { estimate, estimateLabel } from "./graph/estimate"
 import { MCP_REACHES_SESSIONS } from "./graph/dispatch"
 import { layer, preflight, type Preflight } from "./graph/validate"
 import { isPipeline } from "./graph/pipeline-io"
@@ -125,6 +128,11 @@ const ISOLATE_OPTIONS: SelectOption[] = [
   { value: "off", label: "off", hint: "one shared working directory" },
   { value: "on", label: "on", hint: "a git worktree per card, merged after each batch" },
 ]
+const CAP_OPTIONS: SelectOption[] = [1, 2, 5, 10, 25, 50, 100, 250, 500].map((amount) => ({
+  value: String(amount),
+  label: `$${amount}`,
+  hint: amount === DEFAULT_MAX_SPEND ? "default" : undefined,
+}))
 const VERIFY_OPTIONS: SelectOption[] = [
   { value: "off", label: "off", hint: "the run ends when its cards do" },
   { value: "on", label: "on", hint: "a reviewer card judges the result and the run reports its verdict" },
@@ -244,6 +252,14 @@ export function App() {
    * gating on `unlockedRows` here would block a first-timer's run outright.
    */
   const unlockedModels = () => new Set(availableModels(providers()).map((model) => model.value))
+  /** Base list price per model the catalog quotes one for — the estimate and the seat check read it. */
+  const prices = createMemo(
+    () =>
+      new Map(
+        providers().flatMap((row) => row.models.flatMap((model) => (model.price ? [[model.value, model.price] as const] : []))),
+      ),
+  )
+  const runEstimate = createMemo(() => estimate(state.pipeline, prices()))
 
   /**
    * Every error this file reports goes through here rather than through
@@ -792,6 +808,7 @@ export function App() {
     const pre = preflight(state.pipeline, {
       unlockedModels: unlockedModels(),
       engineReachable: state.engineReachable,
+      prices: prices(),
     })
     setIssues(pre.blocking.length || pre.warnings.length ? pre : undefined)
     if (pre.blocking.length) {
@@ -1294,6 +1311,37 @@ export function App() {
               onChange={(value) => actions.setIsolate(value === "on")}
             />
           </Show>
+          {/* Every mode. A gauntlet shows its own cap in its settings button,
+              and that one wins (`spendCapOf`), so it is not offered twice. */}
+          <Show when={!gauntletOf(state.pipeline)}>
+            <Select
+              variant="ghost"
+              prefix="cap: "
+              width={300}
+              title="the most this run may spend at list price before it is stopped — on by default, because nobody watches a run the whole way through"
+              value={String(spendCapOf(state.pipeline))}
+              options={CAP_OPTIONS}
+              onChange={(value) => actions.setMaxSpend(Number(value))}
+            />
+          </Show>
+          <Show when={state.pipeline.nodes.length}>
+            <span
+              class="hint runbar-estimate"
+              title={`Rough list-price range before any cache discount: ${runEstimate().turns.low}${
+                runEstimate().turns.high === undefined
+                  ? "+"
+                  : runEstimate().turns.high === runEstimate().turns.low
+                    ? ""
+                    : `–${runEstimate().turns.high}`
+              } card turns, each between a short turn and a heavy one. A turn's real size depends on the task and the repo.${
+                runEstimate().unpriced.length
+                  ? ` No published price for ${runEstimate().unpriced.join(", ")}, so that part is not counted.`
+                  : ""
+              }`}
+            >
+              {estimateLabel(runEstimate())}
+            </span>
+          </Show>
           {/* Every mode, unlike the two above it: a gauntlet is the one canvas
               that already ends on a verdict, and `verifyOf` ignores it there. */}
           <Show when={!gauntletOf(state.pipeline)}>
diff --git a/packages/flow/src/graph/estimate.test.ts b/packages/flow/src/graph/estimate.test.ts
new file mode 100644
index 000000000..3742c74d9
--- /dev/null
+++ b/packages/flow/src/graph/estimate.test.ts
@@ -0,0 +1,83 @@
+import { describe, expect, test } from "bun:test"
+import { TURN_TOKENS, estimate, estimateLabel, turnsOf } from "./estimate"
+import { pipeline } from "./test-support"
+import type { Pipeline } from "./types"
+
+const PRICE = { input: 2, output: 10 }
+const prices = new Map([["openai/gpt-x", PRICE]])
+
+function onModel(graph: Pipeline, model = "openai/gpt-x"): Pipeline {
+  return { ...graph, nodes: graph.nodes.map((node) => ({ ...node, agent: { ...node.agent, model } })) }
+}
+
+const turnLow = (TURN_TOKENS.low.input * PRICE.input + TURN_TOKENS.low.output * PRICE.output) / 1_000_000
+const turnHigh = (TURN_TOKENS.high.input * PRICE.input + TURN_TOKENS.high.output * PRICE.output) / 1_000_000
+
+describe("turnsOf", () => {
+  test("a pipeline card answers once", () => {
+    expect([...turnsOf(pipeline("a->b", "b->c")).values()]).toEqual([
+      { low: 1, high: 1 },
+      { low: 1, high: 1 },
+      { low: 1, high: 1 },
+    ])
+  })
+
+  test("a swarm peer answers once a round, the synthesizer once", () => {
+    const graph = { ...pipeline("a", "b", "synthesizer"), mode: "swarm" as const, rounds: 3 }
+    const turns = turnsOf(graph)
+    expect(turns.get("a")).toEqual({ low: 3, high: 3 })
+    expect(turns.get("synthesizer")).toEqual({ low: 1, high: 1 })
+  })
+
+  test("an orchestration's ceiling multiplies down the tree, like worstCase", () => {
+    const graph = { ...pipeline("root->mid", "mid->leaf"), mode: "orchestration" as const, dispatches: 2 }
+    const turns = turnsOf(graph)
+    expect(turns.get("root")).toEqual({ low: 2, high: 3 })
+    expect(turns.get("mid")).toEqual({ low: 2, high: 6 })
+    expect(turns.get("leaf")).toEqual({ low: 1, high: 4 })
+  })
+
+  test("a gauntlet has no ceiling but the cap", () => {
+    const graph: Pipeline = { ...pipeline("root->builder", "root->reviewer"), mode: "orchestration", gauntlet: {} }
+    expect(turnsOf(graph).get("builder")!.high).toBeUndefined()
+  })
+
+  test("verification adds a turn per reviewer card", () => {
+    const graph: Pipeline = { ...pipeline("coder->reviewer"), verify: {} }
+    expect(turnsOf(graph).get("reviewer")).toEqual({ low: 2, high: 2 })
+  })
+})
+
+describe("estimate", () => {
+  test("prices each turn at both ends", () => {
+    const value = estimate(onModel(pipeline("a->b")), prices)
+    expect(value.low).toBeCloseTo(2 * turnLow)
+    expect(value.high).toBeCloseTo(2 * turnHigh)
+    expect(value.unpriced).toEqual([])
+  })
+
+  test("an unpriced model is named, never counted as free", () => {
+    const value = estimate(onModel(pipeline("a")), new Map())
+    expect(value.unpriced).toEqual(["openai/gpt-x"])
+    expect(estimateLabel(value)).toBe("unpriced")
+  })
+
+  test("a model priced at zero — a local one — is free, not unpriced", () => {
+    const value = estimate(onModel(pipeline("a->b"), "local-ollama/qwen3"), new Map([["local-ollama/qwen3", { input: 0, output: 0 }]]))
+    expect(value.unpriced).toEqual([])
+    expect(estimateLabel(value)).toBe("$0")
+  })
+
+  test("the label shows the range, clipped at the cap", () => {
+    expect(estimateLabel(estimate(onModel(pipeline("a")), prices))).toBe(
+      `≈ $${turnLow.toFixed(2)}–$${turnHigh.toFixed(2)}`,
+    )
+    const capped = estimate({ ...onModel(pipeline("a")), maxSpend: 1 }, new Map([["openai/gpt-x", { input: 100, output: 100 }]]))
+    expect(estimateLabel(capped)).toEndWith("(capped)")
+  })
+
+  test("an open run says it runs to the cap", () => {
+    const graph: Pipeline = { ...onModel(pipeline("root->builder", "root->reviewer")), mode: "orchestration", gauntlet: { maxSpend: 7 } }
+    expect(estimateLabel(estimate(graph, prices))).toEndWith("up to the $7 cap")
+  })
+})
diff --git a/packages/flow/src/graph/estimate.ts b/packages/flow/src/graph/estimate.ts
new file mode 100644
index 000000000..1210ee84b
--- /dev/null
+++ b/packages/flow/src/graph/estimate.ts
@@ -0,0 +1,141 @@
+import { isCritic, orchestrationShape } from "./orchestration"
+import { swarmShape } from "./swarm"
+import { dispatchesOf, gauntletOf, modeOf, roundsOf, spendCapOf, verifyOf, type Pipeline } from "./types"
+
+/**
+ * What a run is likely to cost, said before anything is spent.
+ *
+ * This is the one number in OpenFlow that is a guess, so it is built to be an
+ * honest one rather than a precise-looking one:
+ *
+ * - **A range, never a point.** A card's turn is a whole agentic loop — read
+ *   files, call tools, write — and its size depends on the task and the repo,
+ *   which nothing here can see. The two ends are a short turn and a heavy one
+ *   at list price, and the label says "rough".
+ * - **Turns are counted from the graph.** That part is not a guess: a pipeline
+ *   card answers once, a swarm peer once a round, and an orchestration's ceiling
+ *   is `worstCase`'s arithmetic. The low end assumes every orchestrator hands
+ *   each child one task; the high end assumes it uses every dispatch it has.
+ * - **An unpriced model is named, not counted as free.** Same rule as
+ *   `server/usage.ts`. A local model is priced — at zero — by its config.
+ * - **A gauntlet has no high end.** It loops until the bar clears, so the only
+ *   honest ceiling is the cap.
+ *
+ * Measured spend always beats this: once a canvas has run, the runbar shows the
+ * last run's real number beside it.
+ */
+
+/** USD per 1M tokens, the base row of a catalog price. */
+export type TurnPrice = { input: number; output: number }
+
+/**
+ * Tokens one card turn uses, at the two ends. Input dominates an agentic turn:
+ * every tool step re-sends the growing context, which is also what a provider's
+ * prompt cache discounts — so this is list price before any cache hit.
+ */
+export const TURN_TOKENS = {
+  low: { input: 15_000, output: 1_500 },
+  high: { input: 150_000, output: 8_000 },
+}
+
+export type Estimate = {
+  /** USD at the light end, priced models only. */
+  low: number
+  /** USD at the heavy end; undefined when the run has no ceiling but the cap. */
+  high?: number
+  /** Card turns at each end. */
+  turns: { low: number; high?: number }
+  /** `providerID/modelID` of every model with no published price. */
+  unpriced: string[]
+  cap: number
+}
+
+export function estimate(pipeline: Pipeline, prices: Map<string, TurnPrice>): Estimate {
+  const turns = turnsOf(pipeline)
+  const unpriced = new Set<string>()
+  let low = 0
+  let high = 0
+  for (const node of pipeline.nodes) {
+    const count = turns.get(node.id)
+    if (!count) continue
+    const model = node.agent.model
+    const price = model ? prices.get(model) : undefined
+    if (!price) {
+      if (model) unpriced.add(model)
+      continue
+    }
+    low += count.low * cost(TURN_TOKENS.low, price)
+    high += (count.high ?? 0) * cost(TURN_TOKENS.high, price)
+  }
+  const open = [...turns.values()].some((count) => count.high === undefined)
+  const total = (pick: (count: { low: number; high?: number }) => number | undefined) =>
+    [...turns.values()].reduce((sum, count) => sum + (pick(count) ?? 0), 0)
+  return {
+    low,
+    high: open ? undefined : high,
+    turns: { low: total((count) => count.low), high: open ? undefined : total((count) => count.high) },
+    unpriced: [...unpriced],
+    cap: spendCapOf(pipeline),
+  }
+}
+
+/**
+ * How many turns each card can take, at each end.
+ *
+ * Verification adds one turn per reviewer card, in every mode it applies to.
+ */
+export function turnsOf(pipeline: Pipeline) {
+  const result = new Map<string, { low: number; high?: number }>()
+  const mode = modeOf(pipeline)
+
+  if (mode === "swarm") {
+    const shape = swarmShape(pipeline)
+    const rounds = roundsOf(pipeline)
+    for (const node of shape.agents) result.set(node.id, { low: rounds, high: rounds })
+    for (const node of shape.synthesizers.slice(0, 1)) result.set(node.id, { low: 1, high: 1 })
+  }
+
+  if (mode === "orchestration") {
+    const shape = orchestrationShape(pipeline)
+    const open = !!gauntletOf(pipeline)
+    const dispatches = dispatchesOf(pipeline)
+    // `runs` is how many assignments a card can receive; a card with children
+    // takes one turn per dispatch it makes, plus the one that answers.
+    const walk = (id: string, runs: { low: number; high: number }, guard: Set<string>) => {
+      if (guard.has(id)) return
+      guard.add(id)
+      const children = shape.children(id)
+      const own = children.length
+        ? { low: runs.low * 2, high: runs.high * (dispatches + 1) }
+        : { low: runs.low, high: runs.high }
+      result.set(id, open ? { low: own.low } : own)
+      for (const child of children) walk(child, { low: runs.low, high: runs.high * dispatches }, guard)
+      guard.delete(id)
+    }
+    if (shape.roots.length === 1) walk(shape.root.id, { low: 1, high: 1 }, new Set())
+  }
+
+  if (mode === "pipeline") for (const node of pipeline.nodes) result.set(node.id, { low: 1, high: 1 })
+
+  if (verifyOf(pipeline))
+    for (const node of pipeline.nodes.filter(isCritic)) {
+      const count = result.get(node.id) ?? { low: 0, high: 0 }
+      result.set(node.id, { low: count.low + 1, high: count.high === undefined ? undefined : count.high + 1 })
+    }
+
+  return result
+}
+
+function cost(tokens: { input: number; output: number }, price: TurnPrice) {
+  return (tokens.input * price.input + tokens.output * price.output) / 1_000_000
+}
+
+/** One line for the runbar: "≈ $0.04–$0.61", or "up to the $5 cap" for an open run. */
+export function estimateLabel(value: Estimate) {
+  const money = (amount: number) => (amount === 0 ? "$0" : amount < 0.01 ? "<$0.01" : `$${amount.toFixed(2)}`)
+  // Part of the run has no price, so whatever is shown is a floor.
+  const floor = value.unpriced.length ? "≥ " : "≈ "
+  if (value.high === undefined) return `${floor}${money(value.low)}+, up to the $${value.cap} cap`
+  if (value.high === 0 && value.low === 0) return value.unpriced.length ? "unpriced" : "$0"
+  return `${floor}${money(value.low)}–${money(Math.min(value.high, value.cap))}${value.high > value.cap ? " (capped)" : ""}`
+}
diff --git a/packages/flow/src/graph/types.ts b/packages/flow/src/graph/types.ts
index 69c2830ee..f69573266 100644
--- a/packages/flow/src/graph/types.ts
+++ b/packages/flow/src/graph/types.ts
@@ -130,6 +130,16 @@ export type Pipeline = {
    * an answer that has been judged.
    */
   verify?: Verify
+  /**
+   * USD the whole run may spend before the engine stops it, in every mode.
+   *
+   * Unlike the toggles above, absent does **not** mean off: it means the default
+   * cap. Every mode here spends real money with nobody watching — a swarm is
+   * `agents × rounds + 1` sessions — and a run with no ceiling is how a per-token
+   * bill turns into a surprise. A gauntlet keeps its own `gauntlet.maxSpend`,
+   * which wins there; read only through `spendCapOf`.
+   */
+  maxSpend?: number
 }
 
 /**
@@ -380,6 +390,13 @@ export type RunLog = {
    * user's command to run, not the engine's.
    */
   best?: { round: number; card: string; ref?: string }
+  /**
+   * The spend cap, in USD, that ended this run — present only when it did.
+   *
+   * Recorded because a capped run and a run the user stopped both leave cards
+   * marked `stopped`, and only one of them was somebody's decision.
+   */
+  capped?: number
 }
 
 export function emptyPipeline(name = "untitled"): Pipeline {
@@ -499,6 +516,17 @@ export function verifyOf(pipeline: Pipeline) {
   return { bar: pipeline.verify.bar?.trim() ?? "" }
 }
 
+/**
+ * The dollar ceiling on this run, in every mode.
+ *
+ * A gauntlet's own cap wins, so one canvas never carries two numbers that both
+ * claim to bound it. Clamped like every other budget, so a hand-edited file
+ * cannot lift it past what the UI can ask for.
+ */
+export function spendCapOf(pipeline: Pipeline) {
+  return gauntletOf(pipeline)?.maxSpend ?? money(pipeline.maxSpend, DEFAULT_MAX_SPEND, MAX_MAX_SPEND)
+}
+
 /**
  * A hand-edited store file must not be able to talk the engine into a bigger
  * run than the UI can ask for, so every budget is clamped where it is read
diff --git a/packages/flow/src/graph/validate.test.ts b/packages/flow/src/graph/validate.test.ts
index 621252b21..6e2e24494 100644
--- a/packages/flow/src/graph/validate.test.ts
+++ b/packages/flow/src/graph/validate.test.ts
@@ -484,6 +484,55 @@ describe("preflight", () => {
   })
 })
 
+describe("preflight: prices", () => {
+  const cards = (graph: Pipeline, models: Record<string, string>) => {
+    for (const node of graph.nodes) {
+      node.agent.model = models[node.id]
+      node.agent.tools = { read: true, edit: false, bash: false }
+    }
+    return graph
+  }
+  const prices = new Map([
+    ["openai/big", { input: 5, output: 25 }],
+    ["openai/small", { input: 0.5, output: 2 }],
+  ])
+  const ctx = { unlockedModels: new Set(["openai/big", "openai/small", "local-ollama/q"]), prices }
+  const kinds = (graph: Pipeline) => preflight(graph, ctx).warnings.map((problem) => [problem.kind, problem.nodeId])
+
+  test("an orchestrator cheaper than a card it dispatches is pointed out, naming both models", () => {
+    const graph = { ...cards(pipeline("root->coder"), { root: "openai/small", coder: "openai/big" }), mode: "orchestration" as const }
+    expect(kinds(graph)).toEqual([["weak-seat", "root"]])
+    expect(preflight(graph, ctx).warnings[0].message).toContain("openai/big")
+  })
+
+  test("the strong model in the seat and cheap ones in the leaves is the intended shape — silent", () => {
+    const graph = { ...cards(pipeline("root->coder"), { root: "openai/big", coder: "openai/small" }), mode: "orchestration" as const }
+    expect(kinds(graph)).toEqual([])
+  })
+
+  test("a cheap model everywhere is the user's choice — silent", () => {
+    const graph = { ...cards(pipeline("root->coder"), { root: "openai/small", coder: "openai/small" }), mode: "orchestration" as const }
+    expect(kinds(graph)).toEqual([])
+  })
+
+  test("a reviewer only counts as a judging seat when something judges", () => {
+    const plain = cards(pipeline("coder->reviewer"), { coder: "openai/big", reviewer: "openai/small" })
+    expect(kinds(plain)).toEqual([])
+    // Verification raises warnings of its own about this shape; only the seat is under test.
+    expect(kinds({ ...plain, verify: {} }).filter(([kind]) => kind === "weak-seat")).toEqual([["weak-seat", "reviewer"]])
+  })
+
+  test("a model with no published price makes the cap partial, and says so", () => {
+    const graph = cards(pipeline("a->b"), { a: "openai/big", b: "local-ollama/q" })
+    expect(kinds(graph)).toEqual([["unpriced-cap", undefined]])
+  })
+
+  test("no prices passed, no price checks", () => {
+    const graph = cards(pipeline("root->coder"), { root: "openai/small", coder: "openai/big" })
+    expect(preflight({ ...graph, mode: "orchestration" }, { unlockedModels: ctx.unlockedModels }).warnings).toEqual([])
+  })
+})
+
 describe("wouldCycle", () => {
   test("refuses a node connecting to itself", () => {
     expect(wouldCycle(pipeline("a->b"), "a", "a")).toBe(true)
diff --git a/packages/flow/src/graph/validate.ts b/packages/flow/src/graph/validate.ts
index c651afa79..8e08bd907 100644
--- a/packages/flow/src/graph/validate.ts
+++ b/packages/flow/src/graph/validate.ts
@@ -1,7 +1,7 @@
 import { agentKey, toolMap } from "../server/store"
 import { isCritic, orchestrationShape } from "./orchestration"
 import { swarmShape } from "./swarm"
-import { depthOf, dispatchesOf, gauntletOf, modeOf, verifyOf, type Pipeline } from "./types"
+import { depthOf, dispatchesOf, gauntletOf, modeOf, spendCapOf, verifyOf, type Pipeline } from "./types"
 
 export type Validation = { ok: true; layers: string[][] } | { ok: false; error: string }
 
@@ -77,7 +77,12 @@ export type Preflight = { blocking: Problem[]; warnings: Problem[] }
  */
 export function preflight(
   pipeline: Pipeline,
-  ctx: { unlockedModels: Set<string>; engineReachable?: boolean },
+  ctx: {
+    unlockedModels: Set<string>
+    engineReachable?: boolean
+    /** Base list price per model; omitted, the price-based checks stay silent. */
+    prices?: Map<string, { input: number; output: number }>
+  },
 ): Preflight {
   const blocking: Problem[] = []
   const warnings: Problem[] = []
@@ -135,6 +140,24 @@ export function preflight(
       })
   }
 
+  if (ctx.prices) {
+    warnings.push(...seatProblems(pipeline, ctx.prices))
+    // A gauntlet already stops on this (`exhausted`), so it is only said for the
+    // modes where the run would carry on with part of its spend uncounted.
+    const unpriced = [
+      ...new Set(
+        pipeline.nodes
+          .map((node) => node.agent.model)
+          .filter((model): model is string => !!model && ctx.unlockedModels.has(model) && !ctx.prices!.has(model)),
+      ),
+    ]
+    if (unpriced.length && !gauntletOf(pipeline))
+      warnings.push({
+        kind: "unpriced-cap",
+        message: `${unpriced.join(", ")} has no published price, so the $${spendCapOf(pipeline)} cap cannot count what it spends — the run is capped on the other cards only`,
+      })
+  }
+
   // Two nodes generating the same agent id collapse into one merged agent, and
   // the last one written decides both nodes' tool permissions — a node the user
   // restricted would run with the other's edit/bash access. The key is unique
@@ -429,6 +452,52 @@ function orchestrationProblems(pipeline: Pipeline): Preflight {
   return { blocking, warnings }
 }
 
+/**
+ * A seat that decides, dispatches or judges, running on a cheaper model than a
+ * card it is deciding about.
+ *
+ * Suggests, never sets: a user's model choice is theirs, and this only fires on
+ * an *inversion inside the canvas* — the orchestrator cheaper than its
+ * subagents, the critic cheaper than the builder it grades, the synthesizer
+ * cheaper than the peers it reads. Not "this model is cheap", which would fire
+ * on every canvas built to save money and train the user to skip the list.
+ * Price stands in for strength because it is the one number the catalog gives
+ * every model; within one canvas the ordering is usually right, and the message
+ * names both models so the user can judge. Most of a run's spend is in the
+ * leaves, so the fix it suggests usually costs little.
+ */
+function seatProblems(pipeline: Pipeline, prices: Map<string, { input: number; output: number }>): Problem[] {
+  const mode = modeOf(pipeline)
+  const shape = mode === "orchestration" ? orchestrationShape(pipeline) : undefined
+  const judging = !!gauntletOf(pipeline) || !!verifyOf(pipeline)
+  const seat = (node: Pipeline["nodes"][number]) => {
+    if (shape?.children(node.id).length) return "dispatches"
+    if (mode === "swarm" && swarmShape(pipeline).synthesizers.includes(node)) return "decides"
+    if (judging && isCritic(node)) return "judges"
+    return undefined
+  }
+  const priced = (model?: string) => (model ? prices.get(model) : undefined)
+  const workers = pipeline.nodes.filter((node) => !seat(node) && priced(node.agent.model))
+  const strongest = workers.reduce<Pipeline["nodes"][number] | undefined>(
+    (best, node) => (!best || priced(node.agent.model)!.output > priced(best.agent.model)!.output ? node : best),
+    undefined,
+  )
+  if (!strongest) return []
+  const top = priced(strongest.agent.model)!.output
+  return pipeline.nodes.flatMap((node) => {
+    const role = seat(node)
+    const own = priced(node.agent.model)
+    if (!role || !own || own.output >= top) return []
+    return [
+      {
+        nodeId: node.id,
+        kind: "weak-seat",
+        message: `Card '${node.role}' ${role}, and it runs on ${node.agent.model} — cheaper than ${strongest.agent.model} on '${strongest.role}'. The card that ${role} is where a strong model pays off; the others can run cheaper. Consider swapping them.`,
+      },
+    ]
+  })
+}
+
 /**
  * Whether a `providerID/modelID` names a router rather than a model.
  *
diff --git a/packages/flow/src/server/engine.test.ts b/packages/flow/src/server/engine.test.ts
index d3b36d813..77aa0d23f 100644
--- a/packages/flow/src/server/engine.test.ts
+++ b/packages/flow/src/server/engine.test.ts
@@ -2647,6 +2647,48 @@ describe("gauntlet mode", () => {
     expect(h.dispatched.filter((id) => id === "builder").length).toBe(1)
   })
 
+  test("a pipeline is stopped when it reaches its spend cap, and the cards after it never run", async () => {
+    const h = harness({
+      models: ["openai/gpt-x"],
+      prices: { "openai/gpt-x": [{ input: 2, output: 10, cache: { read: 0.5, write: 4 } }] },
+      steps: {
+        a: [
+          {
+            messageID: "m1",
+            model: "openai/gpt-x",
+            tokens: { input: 4_000_000, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0 },
+          },
+        ],
+      },
+    })
+    // $8 of input against a $3 cap, spent by the first card.
+    const log = await h.run({ ...pipeline("a->b"), maxSpend: 3 }).done
+
+    expect(log.capped).toBe(3)
+    expect(log.status).toBe("error")
+    expect(h.dispatched).not.toContain("b")
+  })
+
+  test("the cap is on by default, and a run under it records nothing", async () => {
+    const h = harness({
+      models: ["openai/gpt-x"],
+      prices: { "openai/gpt-x": [{ input: 2, output: 10, cache: { read: 0.5, write: 4 } }] },
+      steps: {
+        a: [
+          {
+            messageID: "m1",
+            model: "openai/gpt-x",
+            tokens: { input: 1_000, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0 },
+          },
+        ],
+      },
+    })
+    const log = await h.run(pipeline("a->b")).done
+
+    expect(log.capped).toBeUndefined()
+    expect(log.status).toBe("done")
+  })
+
   test("a model the catalog cannot price stops the run rather than running uncapped", async () => {
     const h = harness({
       behavior: {
diff --git a/packages/flow/src/server/engine.ts b/packages/flow/src/server/engine.ts
index 3b0270daf..b794e68e1 100644
--- a/packages/flow/src/server/engine.ts
+++ b/packages/flow/src/server/engine.ts
@@ -50,6 +50,7 @@ import {
   isolationOf,
   modeOf,
   roundsOf,
+  spendCapOf,
   verifyOf,
 } from "../graph/types"
 import { ancestors, downstream, layer, upstream } from "../graph/validate"
@@ -433,6 +434,7 @@ export function start(
    * already does.
    */
   const verify = verifyOf(pipeline)
+  const cap = spendCapOf(pipeline)
   const verifiers = verify ? pipeline.nodes.filter((node) => isCritic(node)) : []
   // The same shape as the gauntlet check above, and for the same reason: the
   // engine is callable without preflight, and a run that cannot be verified
@@ -561,6 +563,27 @@ export function start(
     record.steps = steps
     patch(id, { usage: spend })
     log.usage = mergeSpend(log.nodes.map((node) => node.usage))
+    enforceCap()
+  }
+
+  /**
+   * Stops the run the moment its priced spend reaches the cap.
+   *
+   * Checked on every repriced step, because a pipeline or swarm has no moment
+   * between turns where an orchestrator could be asked to wrap up — the only
+   * bound that can hold is a hard stop. A gauntlet is left to `exhausted()`,
+   * which asks its orchestrator for an answer at the same number rather than
+   * cutting it off mid-thought. An unpriced model leaves the cap unenforceable;
+   * preflight warns about that before the run, since stopping here would end
+   * every run on such a model on its first step.
+   */
+  function enforceCap() {
+    if (gauntlet || log.capped !== undefined || controller.signal.aborted) return
+    if ((log.usage?.cost ?? 0) < cap) return
+    log.capped = cap
+    hooks.onNotice?.("error", `the run reached its $${cap} spend cap and was stopped`)
+    controller.abort()
+    void Promise.all([...active].map((sessionID) => api.interrupt(sessionID).catch(() => {})))
   }
 
   /**
@@ -2082,7 +2105,11 @@ ${serve.command}`
       // reported the truth about itself, and paying a critic to confirm it is
       // the one verdict nobody needs.
       if (verify && !controller.signal.aborted && !log.nodes.some((node) => node.status === "error")) await verifyRun()
-      log.status = controller.signal.aborted
+      // A cap firing is a bound the run hit, not a decision anybody made, so it
+      // reads as a failure — the same way a gauntlet reports its own cap.
+      log.status = log.capped !== undefined
+        ? "error"
+        : controller.signal.aborted
         ? "stopped"
         : log.nodes.some((node) => node.status === "error")
           ? "error"
diff --git a/packages/flow/src/server/providers.ts b/packages/flow/src/server/providers.ts
index 20b709af4..9e0b67fac 100644
--- a/packages/flow/src/server/providers.ts
+++ b/packages/flow/src/server/providers.ts
@@ -35,6 +35,12 @@ export type ModelOption = {
    * are fine. See [isFreeModel].
    */
   free: boolean
+  /**
+   * The catalog's base list price, USD per 1M tokens — undefined when it quotes
+   * none, which is unknown and never free. Only the pre-run estimate and the
+   * seat check read it; real spend is priced from the full rows in `usage.ts`.
+   */
+  price?: { input: number; output: number }
 }
 
 /**
@@ -122,6 +128,7 @@ export type RawModel = {
   providerID: string
   name?: string
   api?: { type?: string; package?: string; url?: string }
+  cost?: ReadonlyArray<{ input: number; output: number; tier?: unknown }>
 }
 
 /**
@@ -150,7 +157,9 @@ export function providerRows(
     if (listed && !listed.has(model.id)) continue
     const list = byProvider.get(model.providerID) ?? []
     const routed = runnable(model.api, model.providerID)
+    const base = model.cost?.find((row) => !row.tier) ?? model.cost?.[0]
     list.push({
+      ...(base ? { price: { input: base.input, output: base.output } } : {}),
       value: `${model.providerID}/${model.id}`,
       id: model.id,
       name: model.name || model.id,
diff --git a/packages/flow/src/server/store.ts b/packages/flow/src/server/store.ts
index a5b822018..e5a7a8570 100644
--- a/packages/flow/src/server/store.ts
+++ b/packages/flow/src/server/store.ts
@@ -33,6 +33,17 @@ export type MergeReport = {
 }
 /** One file's line counts. `null` files means the project is not a git repository. */
 export type TreeStat = { files: { path: string; added: number; removed: number; binary?: boolean }[] | null }
+export type LocalRuntimeStatus = {
+  id: string
+  name: string
+  url: string
+  running: boolean
+  /** What the server lists right now. */
+  models: string[]
+  /** What the global config declares for it, or undefined when it is not set up. */
+  declared?: string[]
+  error?: string
+}
 export type BrowseEntry = { name: string; path: string }
 export type BrowseResult = { path: string | null; parent: string | null; entries: BrowseEntry[] }
 export type FlowPaths = {
@@ -198,6 +209,22 @@ export const store = {
       method: "POST",
       body: JSON.stringify({ providers }),
     }),
+  /**
+   * Local model servers (Ollama, LM Studio, a custom address), whether each is
+   * answering, what it serves, and which models the global config already
+   * declares for it. See [../../lib/local.ts].
+   */
+  localStatus: () => request<{ path: string; runtimes: LocalRuntimeStatus[]; error?: string }>("/local"),
+  /** Declares what that server serves right now, at $0. The engine must restart before it applies. */
+  addLocal: (id: string, url?: string) =>
+    request<{ path: string; changed: boolean; models: string[]; backup?: string; restart: boolean }>("/local", {
+      method: "POST",
+      body: JSON.stringify({ id, url }),
+    }),
+  removeLocal: (id: string) =>
+    request<{ path: string; changed: boolean; restart: boolean }>(`/local/${encodeURIComponent(id)}`, {
+      method: "DELETE",
+    }),
   /**
    * Whether the *global* opencode config starts OpenFlow's dispatch MCP server,
    * and whether the command it holds still points at this checkout. See
diff --git a/packages/flow/src/server/usage.test.ts b/packages/flow/src/server/usage.test.ts
index 9f10347c9..006301426 100644
--- a/packages/flow/src/server/usage.test.ts
+++ b/packages/flow/src/server/usage.test.ts
@@ -4,6 +4,7 @@ import {
   NO_TOKENS,
   addTokens,
   byProvider,
+  cacheShare,
   contextSize,
   costLabel,
   costOf,
@@ -196,3 +197,13 @@ describe("formatting", () => {
     )
   })
 })
+
+describe("cacheShare", () => {
+  test("is cache reads over the whole input context, writes included", () => {
+    expect(cacheShare(tokens({ input: 100, cacheRead: 300, cacheWrite: 100 }))).toBeCloseTo(0.6)
+  })
+
+  test("is undefined when nothing was read, not zero", () => {
+    expect(cacheShare(NO_TOKENS)).toBeUndefined()
+  })
+})
diff --git a/packages/flow/src/server/usage.ts b/packages/flow/src/server/usage.ts
index 5294ebf5f..78afcca9d 100644
Binary files a/packages/flow/src/server/usage.ts and b/packages/flow/src/server/usage.ts differ
diff --git a/packages/flow/src/state.ts b/packages/flow/src/state.ts
index 0f5d26974..6b532f7f7 100644
--- a/packages/flow/src/state.ts
+++ b/packages/flow/src/state.ts
@@ -342,6 +342,12 @@ export const actions = {
     setState("pipeline", "dispatches", dispatches)
   },
 
+  /** The run's dollar ceiling. Clamped where it is read (`spendCapOf`), not here. */
+  setMaxSpend(maxSpend: number) {
+    setState("dirty", true)
+    setState("pipeline", "maxSpend", maxSpend)
+  },
+
   /**
    * Turns the gauntlet on or off.
    *
diff --git a/packages/flow/src/styles.css b/packages/flow/src/styles.css
index 994714899..4012f18b3 100644
--- a/packages/flow/src/styles.css
+++ b/packages/flow/src/styles.css
@@ -939,6 +939,13 @@ input[type="checkbox"] {
   border-bottom: 1px solid var(--v2-border-border-muted);
 }
 
+/* a guess, so it reads as a hint and never squeezes the controls */
+.runbar-estimate {
+  flex-shrink: 0;
+  white-space: nowrap;
+  font-variant-numeric: tabular-nums;
+}
+
 /* the task is the point of the bar, so it keeps a floor the settings cannot
    squeeze it past — past that the settings ellipsise their labels */
 .runbar-task {
@@ -2095,6 +2102,24 @@ main {
   white-space: nowrap;
 }
 
+/* a row with a trailing action (remove a local server) beside it */
+.oc-item-row {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+}
+
+.oc-inline-form {
+  flex-direction: row;
+  align-items: center;
+  gap: 8px;
+  padding: 4px 12px;
+}
+
+.oc-inline-form input {
+  flex: 1;
+}
+
 .oc-item-hint {
   flex-shrink: 0;
   max-width: 50%;
diff --git a/packages/flow/src/ui/providers-panel.tsx b/packages/flow/src/ui/providers-panel.tsx
index 84509d766..a478ee1d0 100644
--- a/packages/flow/src/ui/providers-panel.tsx
+++ b/packages/flow/src/ui/providers-panel.tsx
@@ -7,7 +7,7 @@ import {
   usableCount,
   type ProviderRow,
 } from "../server/providers"
-import { store } from "../server/store"
+import { store, type LocalRuntimeStatus } from "../server/store"
 import { state } from "../state"
 import { IconBack, IconCheck, IconClose, IconSearch } from "./icons"
 
@@ -69,11 +69,53 @@ export function ProvidersPanel(props: {
     return props.rows.filter((row) => row.unlocked && offered.has(row.id) && !applied.has(row.id)).map((row) => row.id)
   })
 
+  const [local, setLocal] = createSignal<LocalRuntimeStatus[]>([])
+  const [customUrl, setCustomUrl] = createSignal<string>()
+
   onMount(async () => {
     setCli(await store.cliKeys().catch(() => undefined))
     setRepack(await store.repackageStatus().catch(() => undefined))
+    setLocal((await store.localStatus().catch(() => undefined))?.runtimes ?? [])
   })
 
+  /**
+   * Declares what a local server serves right now, then restarts the engine —
+   * config is read once at boot, so the models do not exist for any card until
+   * it does. Re-running it on a declared server is how a newly pulled model gets
+   * picked up. See [../../lib/local.ts].
+   */
+  async function useLocal(id: string, url?: string) {
+    setBusy(true)
+    try {
+      const result = await store.addLocal(id, url)
+      setLocal((await store.localStatus().catch(() => undefined))?.runtimes ?? [])
+      setCustomUrl(undefined)
+      if (!result.changed) return props.onNotice("info", `${result.models.length} local models already set up`)
+      props.onNotice("info", `added ${result.models.length} local model${result.models.length === 1 ? "" : "s"} at $0 in ${result.path}`)
+      if (result.restart && props.onRestart) await props.onRestart()
+      await props.onChanged()
+      if (result.restart && !props.onRestart) props.onNotice("info", "restart `opencode serve` for the local models to appear")
+    } catch (failure) {
+      props.onNotice("error", api.describe(failure))
+    } finally {
+      setBusy(false)
+    }
+  }
+
+  async function dropLocal(id: string) {
+    setBusy(true)
+    try {
+      const result = await store.removeLocal(id)
+      setLocal((await store.localStatus().catch(() => undefined))?.runtimes ?? [])
+      if (result.restart && props.onRestart) await props.onRestart()
+      await props.onChanged()
+    } catch (failure) {
+      props.onNotice("error", api.describe(failure))
+    } finally {
+      setBusy(false)
+    }
+  }
+
   /**
    * Escape backs out one step, then closes — the same two-step retreat
    * opencode's dialog gives you, so a mistyped provider does not force a
@@ -238,6 +280,40 @@ export function ProvidersPanel(props: {
             <div class="oc-group">Connected</div>
             <For each={connected()}>{(row) => <Row row={row} />}</For>
           </Show>
+          <Show when={!query() && local().length}>
+            <div class="oc-group">Local models · free, on this machine</div>
+            <For each={local()}>{(runtime) => <LocalRow runtime={runtime} />}</For>
+            <Show
+              when={customUrl() !== undefined}
+              fallback={
+                <button type="button" class="oc-item" onClick={() => setCustomUrl("http://localhost:8000/v1")}>
+                  <span class="oc-item-label">Other OpenAI-compatible server…</span>
+                  <span class="oc-tag oc-faint">llama.cpp, vLLM</span>
+                </button>
+              }
+            >
+              <form
+                class="oc-form oc-inline-form"
+                onSubmit={(event) => {
+                  event.preventDefault()
+                  void useLocal("local-custom", customUrl())
+                }}
+              >
+                <input
+                  autofocus
+                  class="mono"
+                  value={customUrl()}
+                  spellcheck={false}
+                  autocomplete="off"
+                  aria-label="Base URL"
+                  onInput={(event) => setCustomUrl(event.currentTarget.value)}
+                />
+                <button type="submit" class="oc-button" disabled={busy()}>
+                  Add
+                </button>
+              </form>
+            </Show>
+          </Show>
           <Show when={rest().popular.length}>
             <div class="oc-group">Popular</div>
             <For each={rest().popular}>{(row) => <Row row={row} />}</For>
@@ -291,9 +367,74 @@ export function ProvidersPanel(props: {
     )
   }
 
+  /**
+   * One local server. A click sets it up — or, when it is set up, picks up any
+   * model pulled since — and the tag says which of those a click will do.
+   */
+  function LocalRow(item: { runtime: LocalRuntimeStatus }) {
+    const fresh = () => {
+      const declared = item.runtime.declared
+      return !!declared && declared.length === item.runtime.models.length && declared.every((id) => item.runtime.models.includes(id))
+    }
+    return (
+      <div class="oc-item-row">
+        <button
+          type="button"
+          class="oc-item"
+          disabled={busy() || !item.runtime.running || !item.runtime.models.length}
+          title={item.runtime.error ?? item.runtime.url}
+          onClick={() => useLocal(item.runtime.id, item.runtime.url)}
+        >
+          <span class="oc-item-label">{item.runtime.name}</span>
+          <span class="oc-tag oc-faint mono">{item.runtime.url.replace(/^https?:\/\//, "")}</span>
+          <Show when={item.runtime.declared}>
+            <span class="oc-check">
+              <IconCheck />
+            </span>
+          </Show>
+          <span class="oc-tag">
+            {!item.runtime.running
+              ? "not running"
+              : !item.runtime.models.length
+                ? "no models"
+                : fresh()
+                  ? `${item.runtime.models.length} models · $0`
+                  : item.runtime.declared
+                    ? "new models — update"
+                    : `use ${item.runtime.models.length} models`}
+          </span>
+        </button>
+        <Show when={item.runtime.declared}>
+          <button
+            type="button"
+            class="oc-clear"
+            aria-label={`Remove ${item.runtime.name}`}
+            disabled={busy()}
+            onClick={() => dropLocal(item.runtime.id)}
+          >
+            <IconClose />
+          </button>
+        </Show>
+      </div>
+    )
+  }
+
   function KeyForm(item: { row: ProviderRow }) {
     return (
       <form class="oc-form" onSubmit={save}>
+        <Show when={item.row.id === "anthropic"}>
+          <p class="oc-note">
+            Claude runs here on an API key from <span class="mono">console.anthropic.com</span>, billed per token. A
+            Claude Pro or Max subscription cannot be used by other apps. To pay from AWS or Google Cloud credits
+            instead, connect OpenRouter and add your Bedrock or Vertex key under its BYOK settings.
+          </p>
+        </Show>
+        <Show when={item.row.id === "openrouter"}>
+          <p class="oc-note">
+            Claude through OpenRouter bills OpenRouter credits, or your own Anthropic, Bedrock or Vertex key if you add
+            one under its BYOK settings. Repackage it after connecting so this engine can dispatch it.
+          </p>
+        </Show>
         <p class="oc-note">
           <Show
             when={item.row.envSet.length}
diff --git a/packages/flow/src/ui/spend-panel.tsx b/packages/flow/src/ui/spend-panel.tsx
index dc8b85faf..8c05ef4a9 100644
--- a/packages/flow/src/ui/spend-panel.tsx
+++ b/packages/flow/src/ui/spend-panel.tsx
@@ -1,7 +1,7 @@
 import { For, Show, createMemo, createSignal, onCleanup, onMount } from "solid-js"
 import type { Spend } from "../graph/types"
 import { store, type RunEntry } from "../server/store"
-import { byProvider, costLabel, formatCost, formatTokens, mergeSpend } from "../server/usage"
+import { byProvider, cacheShare, costLabel, formatCost, formatTokens, mergeSpend } from "../server/usage"
 import { state } from "../state"
 import { IconClose } from "./icons"
 
@@ -103,6 +103,14 @@ function Total(props: { label: string; spend?: Spend }) {
       <span class="spend-total-value">{props.spend?.steps ? costLabel(props.spend) : "—"}</span>
       <span class="hint">
         {formatTokens(props.spend ? tokenCount(props.spend) : 0)} tokens · {props.spend?.steps ?? 0} steps
+        <Show when={props.spend && cacheShare(props.spend.tokens)}>
+          {(share) => (
+            <span title="share of input context served from the provider's prompt cache, which is billed at a fraction of the input rate">
+              {" "}
+              · {Math.round(share() * 100)}% cached
+            </span>
+          )}
+        </Show>
       </span>
     </div>
   )