@@ -37,7 +37,10 @@ itself driving one of them.
 
 - `apps/desktop` — the Electron app (`src/main` process + backends, `src/renderer` React UI,
   `e2e/` Playwright). `packages/core` — the offline scripted engine used by demos and tests.
-- Real models run only through the `claude` and `codex` CLIs. There is no API mode; do not
-  add one.
+- Real models run only through the `claude` and `codex` CLIs. There is no API mode for
+  coding turns; do not add one. The one network call outside the CLIs is the optional Auto
+  routing judge (Jev, `apps/desktop/src/main/engine/routing/`), which answers typed questions
+  about a request and never runs a turn or sees file contents; without `TYPESAFE_API_KEY`
+  it is replaced by a built-in heuristic. See `docs/auto-routing.md`.
 - Scratch scripts go in `apps/desktop/.probes/` (git-ignored). Playwright wipes
   `apps/desktop/test-results/` on every run.
@@ -24,6 +24,13 @@ modex/
   the CLI reports (`model/list` for Codex — every current GPT model with its reasoning-effort
   row; the `fable`/`opus`/`sonnet`/`haiku` latest aliases for Claude), default preselected, no
   free-text entry.
+- **⚡ Auto routing.** Turn on Auto and a fast judge — TypeSafe's Jev, or a built-in
+  heuristic when no `TYPESAFE_API_KEY` is set — reads each request before the turn and picks
+  the model, reasoning effort, and fast mode within the bounds you set (posture, effort
+  ceiling, daily premium-turn budget, confidence floor). Every turn gets a one-line receipt
+  explaining the pick; picking a model by hand teaches Auto your preference for that kind of
+  task. The coding turn itself still runs only through the CLIs. See
+  [docs/auto-routing.md](docs/auto-routing.md).
 - **Projects & threads.** Open any local folder as a project. Each project holds threads;
   threads run **in parallel** and independently, each with its own backend, model, and mode.
 - **Worktree threads.** `⑂` starts a thread in a fresh `git worktree` so agents never step on
 
@@ -43,7 +43,7 @@ let repo: string;
 
 test.beforeAll(async () => {
   ({ home, repo } = seedHome());
-  app = await electron.launch({ args: [appDir], cwd: appDir, env: { ...process.env, MODEX_HOME: home, MODEX_E2E: "1" } });
+  app = await electron.launch({ args: [appDir], cwd: appDir, env: { ...process.env, MODEX_HOME: home, MODEX_E2E: "1", MODEX_NO_LOGIN_PATH: "1", TYPESAFE_API_KEY: "" } });
   page = await app.firstWindow();
   await page.waitForLoadState("domcontentloaded");
 });
@@ -173,11 +173,51 @@ test("⇧⌘N creates a worktree thread and the header shows its branch and path
 
 test("state survives a relaunch: the thread and its transcript are restored", async () => {
   await app.close();
-  app = await electron.launch({ args: [appDir], cwd: appDir, env: { ...process.env, MODEX_HOME: home } });
+  app = await electron.launch({ args: [appDir], cwd: appDir, env: { ...process.env, MODEX_HOME: home, MODEX_NO_LOGIN_PATH: "1", TYPESAFE_API_KEY: "" } });
   page = await app.firstWindow();
   await expect(page.locator(".threads .thread")).toHaveCount(2);
   await page.locator(".threads .thread").nth(1).click();
   await expect(page.locator(".approval .approval-answer")).toHaveText("Approved");
   await expect(page.locator(".msg.assistant").last()).toContainText("added CONTRIBUTING.md");
   await expect(page.locator(".pill.plan")).toHaveText(/Plan/);
 });
+
+test("⚡ Auto: the judge picks a model before the turn and leaves an expandable receipt", async () => {
+  // A fresh thread (default mode: chat). No TypeSafe key in this environment, so the built-in heuristic judges.
+  await page.keyboard.press("Meta+n");
+  await expect(page.locator(".threads .thread")).toHaveCount(3);
+  await expect(page.locator(".btn.toggle.auto")).not.toHaveClass(/on/);
+  await expect(page.locator(".pill.auto")).toHaveCount(0);
+  await page.locator(".btn.toggle.auto").click();
+  await expect(page.locator(".btn.toggle.auto")).toHaveClass(/on/);
+  await expect(page.locator(".pill.auto")).toHaveText(/Auto/);
+  await page.locator(".composer textarea").focus();
+  await page.keyboard.type("What does this repo do?");
+  await page.keyboard.press("Meta+Enter");
+  const route = page.locator(".route").first();
+  await expect(route).toBeVisible();
+  await expect(route.locator(".route-label")).toContainText("Auto picked");
+  await expect(route.locator(".route-label")).toContainText("Mock · mock");
+  await expect(route.locator(".route-meta")).toContainText("quick answer · heuristic");
+  await expect(route.locator(".route-body")).toHaveCount(0);
+  await route.locator(".route-head").click();
+  await expect(route.locator(".route-body")).toContainText("No TypeSafe API key found; used the built-in heuristic.");
+  await expect(route.locator(".route-body")).toContainText("quick answer · complexity");
+  await page.screenshot({ path: path.join(appDir, "test-results", "e2e-auto-route.png") });
+  // The receipt sits between the user message and the agent's first reply.
+  await expect(page.locator(".transcript > *").nth(0)).toHaveClass(/msg user/);
+  await expect(page.locator(".transcript > *").nth(1)).toHaveClass(/route/);
+  // Stop the scripted run; the Auto pill and the receipt survive.
+  await page.keyboard.press("Meta+.");
+  await expect(page.locator(".pill.status")).toHaveText("Idle");
+  await expect(page.locator(".route")).toHaveCount(1);
+  await expect(page.locator(".pill.auto")).toHaveText(/Auto/);
+  // Settings explains why the heuristic judged, counts the auto turn, and exposes the policy knobs.
+  await page.locator(".sidebar button", { hasText: "Settings" }).click();
+  const status = page.locator("[data-testid=routing-status]");
+  await expect(status).toContainText("No TYPESAFE_API_KEY found");
+  await expect(status).toContainText("1 auto turn so far");
+  await expect(page.locator(".modal select").filter({ has: page.locator("option[value=economy]") })).toHaveValue("balanced");
+  await page.locator(".modal button", { hasText: "Cancel" }).click();
+  await expect(page.locator(".modal")).toHaveCount(0);
+});
@@ -12,13 +12,16 @@ export class ClaudeBackend implements Backend {
   readonly id = "claude" as const;
   constructor(private readonly bin = process.env.MODEX_CLAUDE_BIN ?? "claude", private readonly spawnImpl = spawn) {}
 
+  /** `claude --effort` levels (from `claude --help`); no default so the CLI's own setting applies. */
+  static readonly EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+
   static readonly MODELS: ModelInfo[] = [
     // Aliases always point at the newest model of each family (resolved by the CLI on every run);
     // a full model id such as "claude-fable-5-1" can be typed as well.
-    { id: "fable", label: "Fable (latest)", description: "Newest Fable — currently claude-fable-5-1", isDefault: true },
-    { id: "opus", label: "Opus (latest)", description: "Newest Opus — currently claude-opus-5-5" },
-    { id: "sonnet", label: "Sonnet (latest)", description: "Newest Sonnet — currently claude-sonnet-5" },
-    { id: "haiku", label: "Haiku (latest)", description: "Newest Haiku — currently claude-haiku-4-5" },
+    { id: "fable", label: "Fable (latest)", description: "Newest Fable — currently claude-fable-5-1", isDefault: true, efforts: ClaudeBackend.EFFORTS },
+    { id: "opus", label: "Opus (latest)", description: "Newest Opus — currently claude-opus-5-5", efforts: ClaudeBackend.EFFORTS },
+    { id: "sonnet", label: "Sonnet (latest)", description: "Newest Sonnet — currently claude-sonnet-5", efforts: ClaudeBackend.EFFORTS },
+    { id: "haiku", label: "Haiku (latest)", description: "Newest Haiku — currently claude-haiku-4-5", efforts: ClaudeBackend.EFFORTS },
   ];
 
   async listModels(): Promise<ModelInfo[]> {
@@ -35,6 +38,9 @@ export class ClaudeBackend implements Backend {
     else if (opts.mode === "agent") args.push("--permission-mode", "acceptEdits");
     else args.push("--permission-mode", "bypassPermissions");
     if (opts.model) args.push("--model", opts.model);
+    if (opts.effort) args.push("--effort", opts.effort);
+    // Fast mode is a settings key in Claude Code; `--settings` accepts inline JSON for this session only.
+    if (opts.fast) args.push("--settings", JSON.stringify({ fastMode: true }));
     if (opts.resume) args.push("--resume", opts.resume);
     for (const d of opts.addDirs ?? []) args.push("--add-dir", d);
     return args;
 
@@ -95,7 +95,11 @@ export class CodexBackend implements Backend {
     const res = await this.request<{ data: CodexModel[] }>("model/list", {});
     return res.data
       .filter((m) => !m.hidden)
-      .map((m) => ({ id: m.id, label: m.displayName || m.id, description: m.description, isDefault: m.isDefault, efforts: m.supportedReasoningEfforts?.map((e) => e.reasoningEffort), defaultEffort: m.defaultReasoningEffort }));
+      .map((m) => ({
+        id: m.id, label: m.displayName || m.id, description: m.description, isDefault: m.isDefault,
+        efforts: m.supportedReasoningEfforts?.map((e) => e.reasoningEffort), defaultEffort: m.defaultReasoningEffort,
+        serviceTiers: m.serviceTiers?.map((t) => t.id), defaultServiceTier: m.defaultServiceTier ?? undefined,
+      }));
   }
 
   async dispose(): Promise<void> {
@@ -258,6 +262,8 @@ export class CodexBackend implements Backend {
         sandboxPolicy: pol.sandboxPolicy,
         model: opts.model || null,
         effort: opts.effort ?? null,
+        // "fast" is the Codex fast-mode service tier; only this turn, the thread's tier is untouched.
+        serviceTierForTurn: opts.fast ? "fast" : null,
       })
         .then((r) => {
           turnId = r.turn.id;
@@ -310,6 +316,8 @@ interface CodexModel {
   isDefault: boolean;
   supportedReasoningEfforts?: { reasoningEffort: string }[];
   defaultReasoningEffort?: string;
+  serviceTiers?: { id: string; name?: string; description?: string }[];
+  defaultServiceTier?: string | null;
 }
 interface CodexItem {
   type: string;
 
@@ -1,4 +1,6 @@
-import type { ApprovalAnswer, BackendId, Mode } from "../../../shared/types.js";
+import type { ApprovalAnswer, BackendId, Mode, ModelInfo } from "../../../shared/types.js";
+
+export type { ModelInfo };
 
 export interface ToolStart {
   id: string;
@@ -45,8 +47,10 @@ export interface TurnOptions {
   /** Plan mode: think and propose, never edit. */
   plan: boolean;
   model: string;
-  /** Reasoning effort (Codex). */
+  /** Reasoning effort (Codex `effort`, Claude `--effort`). */
   effort?: string;
+  /** Fast mode for this turn (Codex "fast" service tier, Claude fastMode setting). */
+  fast?: boolean;
   /** Resumable handle from a previous turn on this thread. */
   resume?: string;
   /** Extra directories the agent may write to (worktree threads pass the project root). */
@@ -67,15 +71,6 @@ export interface Backend {
   dispose(): Promise<void>;
 }
 
-export interface ModelInfo {
-  id: string;
-  label: string;
-  description?: string;
-  isDefault?: boolean;
-  efforts?: string[];
-  defaultEffort?: string;
-}
-
 /** Splits a byte stream into complete lines; keeps the trailing partial line. */
 export class LineBuffer {
   private buf = "";
 
@@ -31,7 +31,8 @@ export async function runDemo(o: DemoOptions): Promise<void> {
   // A second, finished thread so the sidebar shows history.
   const earlier = await o.runner.createThread(project.id, { mode: "agent", backend: "mock" });
   o.runner.updateThread(earlier.id, { title: "Explain the approval policy module" });
-  const thread = await o.runner.createThread(project.id, { mode: "chat", backend: "mock" });
+  // Auto is on for the demo thread so the transcript shows a routing decision (heuristic when no key).
+  const thread = await o.runner.createThread(project.id, { mode: "chat", backend: "mock", auto: true });
   const turn = o.runner.send(thread.id, "Add a CONTRIBUTING.md with the three-step workflow (install, test, PR).");
   await waitFor(() => o.runner.status(thread.id) === "waiting" || o.runner.status(thread.id) === "idle" || o.runner.status(thread.id) === "error");
   await settle();
 
@@ -0,0 +1,73 @@
+import type { BackendId, ModelInfo } from "../../../shared/types.js";
+
+/**
+ * The routing catalogue: every model a backend's CLI lists, placed on a capability ladder.
+ *
+ * Tier 0 = fastest/cheapest, 3 = most capable. The CLIs report names and descriptions but not
+ * cost or capability, so tiers come from a small table of known families plus description
+ * hints; unknown models land in the middle. The ladder is rebuilt from the live `model/list`
+ * each time the catalogue refreshes, so new models appear without a Modex release.
+ */
+export type Tier = 0 | 1 | 2 | 3;
+
+export interface Candidate {
+  backend: BackendId;
+  model: string;
+  label: string;
+  tier: Tier;
+  efforts: string[];
+  defaultEffort?: string;
+  /** Service tier id that means "fast mode" for this model (Codex), if any. */
+  fastTier?: string;
+  isDefault?: boolean;
+}
+
+const KNOWN: { re: RegExp; tier: Tier }[] = [
+  // Claude Code aliases and full ids. Aliases resolve to the newest model of each family.
+  { re: /^(claude-)?haiku/, tier: 0 },
+  { re: /^(claude-)?sonnet/, tier: 1 },
+  { re: /^(claude-)?opus/, tier: 2 },
+  { re: /^(claude-)?fable/, tier: 3 },
+  // Codex catalogue (Sept 2026). Ordering within GPT-6 follows the CLI's own descriptions when present.
+  { re: /^gpt-5\.5/, tier: 0 },
+  { re: /^gpt-5\.6/, tier: 1 },
+  { re: /^gpt-6-luna/, tier: 2 },
+  { re: /^gpt-6-sol/, tier: 2 },
+  { re: /^gpt-6-astra/, tier: 3 },
+  { re: /mini|nano|small|lite|flash/, tier: 0 },
+  { re: /^mock$/, tier: 1 },
+];
+
+/** Description hints only move a model when the name is unknown. */
+function hintTier(description: string | undefined): Tier | null {
+  const d = (description ?? "").toLowerCase();
+  if (!d) return null;
+  if (/most (capable|intelligent|powerful)|frontier|hardest|complex/.test(d)) return 3;
+  if (/fast(est)?|cheap|quick|lightweight|latency|everyday|simple tasks/.test(d)) return 0;
+  return null;
+}
+
+export function tierOf(model: ModelInfo): Tier {
+  const id = model.id.toLowerCase();
+  for (const k of KNOWN) if (k.re.test(id)) return k.tier;
+  return hintTier(model.description) ?? 2;
+}
+
+export function toCandidate(backend: BackendId, m: ModelInfo): Candidate {
+  const fastTier = m.serviceTiers?.find((t) => /^fast$|fast/i.test(t));
+  return { backend, model: m.id, label: m.label, tier: tierOf(m), efforts: m.efforts ?? [], defaultEffort: m.defaultEffort, fastTier, isDefault: m.isDefault };
+}
+
+/** Candidates for a backend, lowest tier first; within a tier the CLI default wins. */
+export function ladder(backend: BackendId, models: ModelInfo[]): Candidate[] {
+  return models.map((m) => toCandidate(backend, m)).sort((a, b) => a.tier - b.tier || Number(Boolean(b.isDefault)) - Number(Boolean(a.isDefault)));
+}
+
+/** The best candidate at or below `tier`; if the ladder has nothing that low, its lowest rung. */
+export function pick(rungs: Candidate[], tier: Tier): Candidate | undefined {
+  if (!rungs.length) return undefined;
+  const atOrBelow = rungs.filter((c) => c.tier <= tier);
+  if (!atOrBelow.length) return rungs[0];
+  const top = atOrBelow[atOrBelow.length - 1]!.tier;
+  return atOrBelow.find((c) => c.tier === top && c.isDefault) ?? atOrBelow.find((c) => c.tier === top);
+}