From 3430299d078f453769c05b359f1908925de61a15 Mon Sep 17 00:00:00 2001
From: ECuteri <155808593+ECuteri@users.noreply.github.com>
Date: Sun, 1 Nov 2026 09:50:07 +0000
Subject: [PATCH 1/3] feat: new threads switch to another account when the
 default is out of usage

When the default model's account has hit a 5-hour or weekly limit and no
usable fallback model is configured, new threads now pick another account
of the same provider with usage left (same model and options), then another
provider's default model. Only accounts that report limits are candidates,
ordered by remaining headroom. The composer notice names the account used.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 apps/web/src/components/ChatView.tsx          | 13 +++-
 .../components/chat/ComposerUsageLimits.tsx   |  4 +-
 .../settings/ProjectDefaultsSettings.tsx      |  2 +-
 docs/user/usage.md                            |  6 ++
 packages/shared/src/usageLimits.test.ts       | 56 ++++++++++++++
 packages/shared/src/usageLimits.ts            | 76 ++++++++++++++-----
 6 files changed, 130 insertions(+), 27 deletions(-)

diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index 55d951d1bdf80..42bf58a27f45d 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -2577,6 +2577,9 @@ export default function ChatView(props: ChatViewProps) {
     const fallbackWindow = fallback
       ? `${fallback.provider.instanceId}:${fallback.resetsAt ?? ""}`
       : null;
+    const fallbackProvider = providerStatuses.find(
+      (provider) => provider.instanceId === fallbackSelection?.instanceId,
+    );
     const fallbackItems: ComposerBannerStackItem[] =
       fallback &&
       fallbackSelection &&
@@ -2585,10 +2588,12 @@ export default function ChatView(props: ChatViewProps) {
         ? [
             modelFallbackBannerItem({
               fallbackModelName:
-                providerStatuses
-                  .find((provider) => provider.instanceId === fallbackSelection.instanceId)
-                  ?.models.find((model) => model.slug === fallbackSelection.model)?.name ??
-                fallbackSelection.model,
+                fallbackProvider?.models.find((model) => model.slug === fallbackSelection.model)
+                  ?.name ?? fallbackSelection.model,
+              fallbackProviderName:
+                fallbackProvider?.displayName ??
+                fallbackProvider?.driver ??
+                fallbackSelection.instanceId,
               defaultProviderName: fallback.provider.displayName ?? fallback.provider.driver,
               defaultModelName:
                 fallback.provider.models.find((model) => model.slug === defaultSelection.model)
diff --git a/apps/web/src/components/chat/ComposerUsageLimits.tsx b/apps/web/src/components/chat/ComposerUsageLimits.tsx
index b46614a8b418d..6aab26765600c 100644
--- a/apps/web/src/components/chat/ComposerUsageLimits.tsx
+++ b/apps/web/src/components/chat/ComposerUsageLimits.tsx
@@ -71,6 +71,7 @@ export function usageLimitsBannerItem(
 
 export function modelFallbackBannerItem({
   fallbackModelName,
+  fallbackProviderName,
   defaultProviderName,
   defaultModelName,
   resetsAt,
@@ -79,6 +80,7 @@ export function modelFallbackBannerItem({
   onDismiss,
 }: {
   readonly fallbackModelName: string;
+  readonly fallbackProviderName: string;
   readonly defaultProviderName: string;
   readonly defaultModelName: string;
   readonly resetsAt: string | null;
@@ -90,7 +92,7 @@ export function modelFallbackBannerItem({
     id: "fallback-model",
     variant: "info",
     icon: <GaugeIcon />,
-    title: `Using ${fallbackModelName}`,
+    title: `Using ${fallbackModelName} on ${fallbackProviderName}`,
     description: `${defaultProviderName} is out of usage${resetsAt ? ` · resets ${formatUpcomingTimestamp(resetsAt, timestampFormat)}` : ""}`,
     actions: (
       <Button size="xs" variant="ghost" onClick={onUseDefault}>
diff --git a/apps/web/src/components/settings/ProjectDefaultsSettings.tsx b/apps/web/src/components/settings/ProjectDefaultsSettings.tsx
index 3d6ad58d1d957..f0325bb9c49c5 100644
--- a/apps/web/src/components/settings/ProjectDefaultsSettings.tsx
+++ b/apps/web/src/components/settings/ProjectDefaultsSettings.tsx
@@ -254,7 +254,7 @@ export function ProjectDefaultsSettings({ category }: { category: ProjectSetting
       settingKeys={["fallbackModelSelection"]}
       mixed={mixedFallback}
       {...searchableSetting("fallback-model")}
-      description="Used for new threads when the default model's provider is out of usage."
+      description="Used for new threads when the default model's provider is out of usage. Without one, another account with usage left is picked."
       resetAction={
         mixedFallback || settings.fallbackModelSelection !== null ? (
           <SettingResetButton
diff --git a/docs/user/usage.md b/docs/user/usage.md
index 447924a072eff..7e9feac76affd 100644
--- a/docs/user/usage.md
+++ b/docs/user/usage.md
@@ -111,6 +111,12 @@ and a partly spent session may only regain its unused portion when the week rese
 stale reset times have no refill estimate; refresh Limits for a new reading. Claude's
 model-specific weekly allowances keep their reported values.
 
+When the default model's account is out of usage, new threads start on another account
+instead. A **Fallback model** set in **Settings → New threads** is tried first. Otherwise T3 Code
+picks another account of the same provider with usage left, keeping the model, and then another
+provider's default model. Only accounts that report limits under **Usage → Limits** are picked.
+The composer names the account it switched to; choose the default model there to keep it.
+
 Opening Limits checks the selected connected environments automatically. Each client waits at
 least five minutes between automatic checks of an environment, including after a failed check.
 If a window still looks stale, refresh Limits to re-check every provider and hub.
diff --git a/packages/shared/src/usageLimits.test.ts b/packages/shared/src/usageLimits.test.ts
index 23447ae7930b0..2950f29d16b66 100644
--- a/packages/shared/src/usageLimits.test.ts
+++ b/packages/shared/src/usageLimits.test.ts
@@ -110,6 +110,62 @@ describe("new thread model fallback", () => {
       }).selection,
     ).toEqual(selection);
   });
+  describe("without a usable configured fallback", () => {
+    const limits = (usedPercent: number) => ({
+      checkedAt: limited.checkedAt,
+      windows: [{ ...window, usedPercent }],
+    });
+    const model = (slug: string, isDefault = false) => ({
+      slug,
+      name: slug,
+      isCustom: false,
+      isDefault,
+      capabilities: null,
+    });
+    const codexAccount = (id: string, usedPercent: number) =>
+      provider({
+        instanceId: ProviderInstanceId.make(id),
+        models: [model("gpt-6.1-luna", true), model(selection.model)],
+        usageLimits: limits(usedPercent),
+      });
+    const claude = provider({
+      instanceId: fallback.instanceId,
+      driver: ProviderDriverKind.make("claudeAgent"),
+      models: [model("claude-sonnet-5-5"), model("claude-opus-5-5", true)],
+      usageLimits: limits(0),
+    });
+    const resolve = (providers: ServerProvider[]) =>
+      resolveNewThreadModelSelection({
+        defaultSelection: { ...selection, options: [{ id: "reasoningEffort", value: "high" }] },
+        fallbackSelection: null,
+        providers: [limited, ...providers],
+        now,
+      }).selection;
+
+    it.each([
+      [
+        "another account of the same provider with the most headroom, keeping model and options",
+        [claude, codexAccount("codex_a", 90), codexAccount("codex_b", 20)],
+        {
+          instanceId: ProviderInstanceId.make("codex_b"),
+          model: selection.model,
+          options: [{ id: "reasoningEffort", value: "high" }],
+        },
+      ],
+      [
+        "another provider's default model when every same-provider account is spent",
+        [codexAccount("codex_a", 100), claude],
+        { instanceId: claude.instanceId, model: "claude-opus-5-5" },
+      ],
+      [
+        "nothing when no other account reports limits",
+        [{ ...claude, usageLimits: undefined }],
+        selection,
+      ],
+    ] as const)("switches to %s", (_name, providers, expected) => {
+      expect(resolve([...providers])).toMatchObject(expected);
+    });
+  });
   it.each([undefined, "invalid"])("treats an unknown reset as exhausted: %s", (resetsAt) => {
     expect(
       exhaustedUsageWindow(
diff --git a/packages/shared/src/usageLimits.ts b/packages/shared/src/usageLimits.ts
index bf7dfea4e04bf..7f953a67324d2 100644
--- a/packages/shared/src/usageLimits.ts
+++ b/packages/shared/src/usageLimits.ts
@@ -72,34 +72,68 @@ export function resolveNewThreadModelSelection(input: {
 }) {
   const selection = input.explicitSelection ?? input.defaultSelection;
   const unchanged = { selection, fallback: null };
-  if (input.explicitSelection || !selection || !input.fallbackSelection) return unchanged;
+  if (input.explicitSelection || !selection) return unchanged;
   const provider = input.providers.find((entry) => entry.instanceId === selection.instanceId);
   const window = exhaustedUsageWindow(provider, input.now, selection.model);
-  const fallback = input.providers.find(
-    (entry) => entry.instanceId === input.fallbackSelection?.instanceId,
-  );
-  if (
-    !provider ||
-    !window ||
-    !fallback?.enabled ||
-    !fallback.installed ||
-    fallback.auth.status === "unauthenticated" ||
-    !isProviderAvailable(fallback) ||
-    exhaustedUsageWindow(fallback, input.now, input.fallbackSelection.model) ||
-    (input.settings &&
-      !resolveProjectProviderInstanceEnabled(
-        input.settings,
-        input.projectId ?? null,
-        fallback.instanceId,
-      ))
-  )
-    return unchanged;
+  if (!provider || !window) return unchanged;
+  const usable = (candidate: ModelSelection) => {
+    const entry = input.providers.find((item) => item.instanceId === candidate.instanceId);
+    return (
+      entry !== undefined &&
+      entry.enabled &&
+      entry.installed &&
+      entry.auth.status !== "unauthenticated" &&
+      isProviderAvailable(entry) &&
+      !exhaustedUsageWindow(entry, input.now, candidate.model) &&
+      (!input.settings ||
+        resolveProjectProviderInstanceEnabled(
+          input.settings,
+          input.projectId ?? null,
+          entry.instanceId,
+        ))
+    );
+  };
+  const replacement =
+    (input.fallbackSelection && usable(input.fallbackSelection) ? input.fallbackSelection : null) ??
+    automaticFallbackSelections(selection, provider, input.providers).find(usable);
+  if (!replacement) return unchanged;
   return {
-    selection: input.fallbackSelection,
+    selection: replacement,
     fallback: { provider, resetsAt: window.resetsAt ?? null },
   };
 }
 
+/** Other accounts of the exhausted provider first, then other providers, most headroom first. */
+function automaticFallbackSelections(
+  selection: ModelSelection,
+  exhausted: ServerProvider,
+  providers: readonly ServerProvider[],
+): ModelSelection[] {
+  // Only accounts that report limits: an unknown balance could be pay-per-use or already spent.
+  const headroom = (entry: ServerProvider) => {
+    const windows = entry.usageLimits?.unavailable ? [] : (entry.usageLimits?.windows ?? []);
+    return windows.length === 0 ? null : Math.min(...windows.map(remainingPercent));
+  };
+  return providers
+    .flatMap((entry) => {
+      const left = headroom(entry);
+      if (entry.instanceId === exhausted.instanceId || left === null) return [];
+      const sameDriver = entry.driver === exhausted.driver;
+      const model =
+        (sameDriver ? entry.models.find((item) => item.slug === selection.model) : undefined) ??
+        entry.models.find((item) => item.isDefault) ??
+        entry.models[0];
+      if (!model) return [];
+      const candidate: ModelSelection =
+        sameDriver && model.slug === selection.model
+          ? { ...selection, instanceId: entry.instanceId }
+          : { instanceId: entry.instanceId, model: model.slug };
+      return [{ candidate, sameDriver, left }];
+    })
+    .sort((a, b) => Number(b.sameDriver) - Number(a.sameDriver) || b.left - a.left)
+    .map(({ candidate }) => candidate);
+}
+
 export const CHATGPT_USAGE_URL = "https://chatgpt.com/#settings/Usage";
 export const CHATGPT_USAGE_LIMIT_CODE = "subscription_sharing_usage_limit_exceeded";
 /** A ChatGPT Business admin caps plan use in other apps; only the admin can raise it. */

From 57fa6f16509c416ba881ee270c7f2539835fc3b1 Mon Sep 17 00:00:00 2001
From: ECuteri <155808593+ECuteri@users.noreply.github.com>
Date: Sun, 1 Nov 2026 10:05:54 +0000
Subject: [PATCH 2/3] feat: make switching to an account with usage left opt-in
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds the fallbackToAvailableAccounts server setting (off by default) and its
Settings → New threads switch, so the automatic account and provider fallback
only runs when the user asks for it, as proposed in discussion #27365.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../settings/ProjectDefaultsSettings.tsx      | 30 ++++++++++++++++++-
 .../src/components/settings/settingsSearch.ts |  8 +++++
 docs/user/usage.md                            |  7 +++--
 packages/contracts/src/settings.ts            |  4 +++
 packages/shared/src/usageLimits.test.ts       | 15 +++++++++-
 packages/shared/src/usageLimits.ts            |  4 ++-
 6 files changed, 62 insertions(+), 6 deletions(-)

diff --git a/apps/web/src/components/settings/ProjectDefaultsSettings.tsx b/apps/web/src/components/settings/ProjectDefaultsSettings.tsx
index f0325bb9c49c5..46cd15dc37b97 100644
--- a/apps/web/src/components/settings/ProjectDefaultsSettings.tsx
+++ b/apps/web/src/components/settings/ProjectDefaultsSettings.tsx
@@ -105,6 +105,7 @@ export function ProjectDefaultsSettings({ category }: { category: ProjectSetting
   const mixedWorkspace = useScopedSettingsMixed(["defaultThreadEnvMode"]);
   const mixedAutoPull = useScopedSettingsMixed(["defaultAutoPull"]);
   const mixedAgentCredits = useScopedSettingsMixed(["removeAgentCreditsOnMerge"]);
+  const mixedAvailableAccounts = useScopedSettingsMixed(["fallbackToAvailableAccounts"]);
   const mixedMergeMethod = useScopedSettingsMixed(["pullRequestMergeMethod"]);
   const modelSource = useScopedSettingSource(["defaultModelSelection"]);
   const isProjectScope = scope.kind === "project" || scope.kind === "checkout";
@@ -254,7 +255,7 @@ export function ProjectDefaultsSettings({ category }: { category: ProjectSetting
       settingKeys={["fallbackModelSelection"]}
       mixed={mixedFallback}
       {...searchableSetting("fallback-model")}
-      description="Used for new threads when the default model's provider is out of usage. Without one, another account with usage left is picked."
+      description="Used for new threads when the default model's provider is out of usage."
       resetAction={
         mixedFallback || settings.fallbackModelSelection !== null ? (
           <SettingResetButton
@@ -321,6 +322,31 @@ export function ProjectDefaultsSettings({ category }: { category: ProjectSetting
       }
     />
   ) : null;
+  const availableAccountsRow = !isProjectScope ? (
+    <SettingsRow
+      serverScoped
+      settingKeys={["fallbackToAvailableAccounts"]}
+      mixed={mixedAvailableAccounts}
+      {...searchableSetting("fallback-available-accounts")}
+      description="When the default model is out of usage and no fallback model is usable, new threads start on another account of the same provider with usage left, then on another provider."
+      resetAction={
+        settings.fallbackToAvailableAccounts ? (
+          <SettingResetButton
+            label="switching to available accounts"
+            onClick={() => updateSettings({ fallbackToAvailableAccounts: false })}
+          />
+        ) : null
+      }
+      control={
+        <Switch
+          aria-label="Switch to an account with usage left"
+          mixed={mixedAvailableAccounts}
+          checked={mixedAvailableAccounts ? false : settings.fallbackToAvailableAccounts}
+          onCheckedChange={(enabled) => updateSettings({ fallbackToAvailableAccounts: enabled })}
+        />
+      }
+    />
+  ) : null;
 
   return (
     <SettingsSection
@@ -331,12 +357,14 @@ export function ProjectDefaultsSettings({ category }: { category: ProjectSetting
         <>
           {modelRow}
           {fallbackRow}
+          {availableAccountsRow}
           {workspaceRow}
         </>
       ) : category === "general" ? (
         <>
           {modelRow}
           {fallbackRow}
+          {availableAccountsRow}
           <SettingsRow
             serverScoped
             settingKeys={["defaultRuntimeMode"]}
diff --git a/apps/web/src/components/settings/settingsSearch.ts b/apps/web/src/components/settings/settingsSearch.ts
index dda759f860e5b..352f5f7bbe773 100644
--- a/apps/web/src/components/settings/settingsSearch.ts
+++ b/apps/web/src/components/settings/settingsSearch.ts
@@ -284,6 +284,14 @@ export const SETTINGS_SEARCH_ITEMS = [
     searchTerms: ["fallback agent provider out of usage new threads"],
     environmentOnly: true,
   },
+  {
+    id: "fallback-available-accounts",
+    title: "Switch to an account with usage left",
+    to: "/settings/threads",
+    scope: "environment-defaults",
+    searchTerms: ["automatic account provider out of usage limit new threads"],
+    environmentOnly: true,
+  },
   {
     id: "default-permissions",
     title: "Permissions",
diff --git a/docs/user/usage.md b/docs/user/usage.md
index 7e9feac76affd..d9d607339cb7c 100644
--- a/docs/user/usage.md
+++ b/docs/user/usage.md
@@ -111,9 +111,10 @@ and a partly spent session may only regain its unused portion when the week rese
 stale reset times have no refill estimate; refresh Limits for a new reading. Claude's
 model-specific weekly allowances keep their reported values.
 
-When the default model's account is out of usage, new threads start on another account
-instead. A **Fallback model** set in **Settings → New threads** is tried first. Otherwise T3 Code
-picks another account of the same provider with usage left, keeping the model, and then another
+When the default model's account is out of usage, new threads start on the **Fallback model**
+set in **Settings → New threads**. Turn on **Switch to an account with usage left** there to also
+fall back automatically when no fallback model is set or it is out of usage too: T3 Code picks
+another account of the same provider with usage left, keeping the model, and then another
 provider's default model. Only accounts that report limits under **Usage → Limits** are picked.
 The composer names the account it switched to; choose the default model there to keep it.
 
diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.ts
index fff25149b2e3d..87638df02658d 100644
--- a/packages/contracts/src/settings.ts
+++ b/packages/contracts/src/settings.ts
@@ -1222,6 +1222,9 @@ export const ServerSettings = Schema.Struct({
   fallbackModelSelection: Schema.NullOr(ModelSelection).pipe(
     Schema.withDecodingDefault(Effect.succeed(null)),
   ),
+  fallbackToAvailableAccounts: Schema.Boolean.pipe(
+    Schema.withDecodingDefault(Effect.succeed(false)),
+  ),
   defaultRuntimeMode: RuntimeMode.pipe(
     Schema.withDecodingDefault(Effect.succeed(DEFAULT_RUNTIME_MODE)),
   ),
@@ -1586,6 +1589,7 @@ export const ServerSettingsPatch = Schema.Struct({
   defaultModelSelection: Schema.optionalKey(Schema.NullOr(ModelSelection)),
   defaultRuntimeMode: Schema.optionalKey(RuntimeMode),
   fallbackModelSelection: Schema.optionalKey(Schema.NullOr(ModelSelection)),
+  fallbackToAvailableAccounts: Schema.optionalKey(Schema.Boolean),
   /** Replaces each project's override set; null removes it. Omitted providerInstances retains its stored value. */
   projectSettingsOverrides: Schema.optionalKey(
     Schema.Record(
diff --git a/packages/shared/src/usageLimits.test.ts b/packages/shared/src/usageLimits.test.ts
index 2950f29d16b66..6b2e37da2e038 100644
--- a/packages/shared/src/usageLimits.test.ts
+++ b/packages/shared/src/usageLimits.test.ts
@@ -134,11 +134,21 @@ describe("new thread model fallback", () => {
       models: [model("claude-sonnet-5-5"), model("claude-opus-5-5", true)],
       usageLimits: limits(0),
     });
-    const resolve = (providers: ServerProvider[]) =>
+    const resolve = (providers: ServerProvider[], fallbackToAvailableAccounts = true) =>
       resolveNewThreadModelSelection({
         defaultSelection: { ...selection, options: [{ id: "reasoningEffort", value: "high" }] },
         fallbackSelection: null,
         providers: [limited, ...providers],
+        settings: {
+          ...DEFAULT_SERVER_SETTINGS,
+          fallbackToAvailableAccounts,
+          providerInstances: Object.fromEntries(
+            providers.map((entry) => [
+              entry.instanceId,
+              { driver: entry.driver, enabled: true, config: {} },
+            ]),
+          ),
+        },
         now,
       }).selection;
 
@@ -165,6 +175,9 @@ describe("new thread model fallback", () => {
     ] as const)("switches to %s", (_name, providers, expected) => {
       expect(resolve([...providers])).toMatchObject(expected);
     });
+    it("stays on the default while the setting is off", () => {
+      expect(resolve([codexAccount("codex_a", 0), claude], false)).toMatchObject(selection);
+    });
   });
   it.each([undefined, "invalid"])("treats an unknown reset as exhausted: %s", (resetsAt) => {
     expect(
diff --git a/packages/shared/src/usageLimits.ts b/packages/shared/src/usageLimits.ts
index 7f953a67324d2..5041a5661bdd7 100644
--- a/packages/shared/src/usageLimits.ts
+++ b/packages/shared/src/usageLimits.ts
@@ -95,7 +95,9 @@ export function resolveNewThreadModelSelection(input: {
   };
   const replacement =
     (input.fallbackSelection && usable(input.fallbackSelection) ? input.fallbackSelection : null) ??
-    automaticFallbackSelections(selection, provider, input.providers).find(usable);
+    (input.settings?.fallbackToAvailableAccounts
+      ? automaticFallbackSelections(selection, provider, input.providers).find(usable)
+      : undefined);
   if (!replacement) return unchanged;
   return {
     selection: replacement,

From a3665235288ed35a32bfab3f183401c60e8cc8c9 Mon Sep 17 00:00:00 2001
From: ECuteri <155808593+ECuteri@users.noreply.github.com>
Date: Sun, 1 Nov 2026 10:28:00 +0000
Subject: [PATCH 3/3] feat(server): move sends and limited threads to another
 account with usage left

With fallbackToAvailableAccounts on, a message whose account is out of usage
goes to the same model on another account of that provider (or another
provider), and a thread that just hit a usage limit continues there right away
instead of waiting for the reset. Accounts that just hit a limit are skipped
until they reset, and instances sharing one login count once.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../orchestration-v2/ProjectionStore.test.ts  | 14 +++
 .../src/orchestration-v2/ProjectionStore.ts   | 11 +++
 .../ThreadMessageIntake.test.ts               | 90 ++++++++++++++++++
 .../orchestration-v2/ThreadMessageIntake.ts   | 62 +++++++++++-
 .../UsageLimitRecoveryWorker.test.ts          | 84 +++++++++++++++-
 .../UsageLimitRecoveryWorker.ts               | 95 ++++++++++++++++++-
 apps/server/src/ws.ts                         |  1 +
 .../settings/ProjectDefaultsSettings.tsx      |  2 +-
 docs/user/usage.md                            | 14 ++-
 packages/shared/src/usageLimits.ts            | 89 +++++++++++------
 10 files changed, 423 insertions(+), 39 deletions(-)

diff --git a/apps/server/src/orchestration-v2/ProjectionStore.test.ts b/apps/server/src/orchestration-v2/ProjectionStore.test.ts
index 9bd3566e559a8..2a068fcda972d 100644
--- a/apps/server/src/orchestration-v2/ProjectionStore.test.ts
+++ b/apps/server/src/orchestration-v2/ProjectionStore.test.ts
@@ -4601,6 +4601,8 @@ it.layer(layerTest)("ProjectionStoreV2", (it) => {
         if (lastErrorClass === "usage_limit") {
           assert.deepEqual(candidate, {
             id: sqlShell.id,
+            projectId: sqlShell.projectId,
+            modelSelection: sqlShell.modelSelection,
             status: sqlShell.status,
             lastErrorClass: sqlShell.lastErrorClass,
             usageLimitResetAt: sqlShell.usageLimitResetAt,
@@ -4769,6 +4771,18 @@ it.layer(layerTest)("ProjectionStoreV2", (it) => {
           (row) => row.id === threadId,
         ),
       );
+      for (const [since, found] of [
+        [DateTime.subtract(now, { minutes: 1 }), true],
+        [DateTime.add(now, { minutes: 1 }), false],
+      ] as const) {
+        assert.strictEqual(
+          (yield* store.getLimitRecoveryCandidates({
+            ...recoveryOptions,
+            switchAccountsSince: since,
+          })).some((row) => row.id === threadId),
+          found,
+        );
+      }
       const reset = DateTime.makeUnsafe(limitItem.failure.resetAt);
       const recovery = {
         runId: original.id,
diff --git a/apps/server/src/orchestration-v2/ProjectionStore.ts b/apps/server/src/orchestration-v2/ProjectionStore.ts
index 95c0f7a4bae53..d834bea8ce1e5 100644
--- a/apps/server/src/orchestration-v2/ProjectionStore.ts
+++ b/apps/server/src/orchestration-v2/ProjectionStore.ts
@@ -171,6 +171,8 @@ export type ProjectionRecoveryKind =
 export type ProjectionLimitRecoveryCandidate = Pick<
   OrchestrationV2ThreadShell,
   | "id"
+  | "projectId"
+  | "modelSelection"
   | "status"
   | "lastErrorClass"
   | "latestRunId"
@@ -507,6 +509,8 @@ export interface ProjectionStoreV2Shape {
     readonly now: DateTime.Utc;
     readonly autoResume: boolean;
     readonly snooze: boolean;
+    /** Also returns limits hit since then whose window has not reset, to move to another account. */
+    readonly switchAccountsSince?: DateTime.Utc;
   }) => Effect.Effect<ReadonlyArray<ProjectionLimitRecoveryCandidate>, ProjectionStoreV2Error>;
   /** Epoch ms of the next armed reset or snooze end after `now`, when a waiting thread becomes a candidate. */
   readonly getLimitRecoveryWakeAt: (
@@ -3879,6 +3883,11 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
             AND julianday(json_extract(item.payload_json, '$.failure.resetAt')) > julianday(COALESCE(r.completed_at, json_extract(t.payload_json, '$.updatedAt')))
             AND (
               (
+                ${booleanInt(options.switchAccountsSince !== undefined)}
+                AND julianday(COALESCE(r.completed_at, json_extract(t.payload_json, '$.updatedAt'))) >= julianday(${DateTime.formatIso(options.switchAccountsSince ?? options.now)})
+                AND julianday(json_extract(item.payload_json, '$.failure.resetAt')) > julianday(${DateTime.formatIso(options.now)})
+              )
+              OR (
                 json_extract(t.payload_json, '$.limitRecovery.runId') IS r.run_id
                 AND json_extract(t.payload_json, '$.limitRecovery.resetAt') IS json_extract(item.payload_json, '$.failure.resetAt')
                 AND json_extract(t.payload_json, '$.limitRecovery.autoResume') = 1
@@ -3916,6 +3925,8 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
           if (summary.lastErrorClass !== "usage_limit") continue;
           candidates.push({
             id: thread.id,
+            projectId: thread.projectId,
+            modelSelection: thread.modelSelection,
             status: "failed",
             lastErrorClass: summary.lastErrorClass,
             usageLimitResetAt: summary.usageLimitResetAt,
diff --git a/apps/server/src/orchestration-v2/ThreadMessageIntake.test.ts b/apps/server/src/orchestration-v2/ThreadMessageIntake.test.ts
index ead417400e10f..74e92b6a04885 100644
--- a/apps/server/src/orchestration-v2/ThreadMessageIntake.test.ts
+++ b/apps/server/src/orchestration-v2/ThreadMessageIntake.test.ts
@@ -10,12 +10,16 @@ import {
   EventId,
   GuestMessageId,
   MessageId,
+  ProjectId,
+  ProviderDriverKind,
+  ProviderInstanceId,
   RuntimeRequestId,
   ThreadId,
   TurnItemId,
   type OrchestrationV2Command,
   type OrchestrationV2ServerCommand,
   type OrchestrationV2StoredEvent,
+  type ServerProvider,
   type UserInputAttachments,
 } from "@t3tools/contracts";
 import * as DateTime from "effect/DateTime";
@@ -27,6 +31,7 @@ import {
   resolveAttachmentPath,
 } from "../attachmentStore.ts";
 import * as ServerConfig from "../config.ts";
+import * as ProviderRegistry from "../provider/ProviderRegistry.ts";
 import * as ServerSettings from "../serverSettings.ts";
 import {
   OrchestratorCommandPreviouslyRejectedError,
@@ -40,6 +45,9 @@ const layerIntakeTest = ServerConfig.layerTest(process.cwd(), {
 }).pipe(
   Layer.provideMerge(DocumentText.layer.pipe(Layer.provideMerge(NodeServices.layer))),
   Layer.provideMerge(ServerSettings.layerTest()),
+  Layer.provideMerge(
+    Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }),
+  ),
 );
 
 const layerFailingDispatchHandler =
@@ -426,3 +434,85 @@ it.effect("sends a guest message with the guest's files, never ones the client n
     expect(command.attachments).toEqual([guestFile]);
   }).pipe(Effect.provide(layerIntakeTest)),
 );
+
+it.effect("sends on another account of the same provider when the chosen one is out of usage", () =>
+  Effect.gen(function* () {
+    const claude = (id: string, usedPercent: number): ServerProvider => ({
+      instanceId: ProviderInstanceId.make(id),
+      driver: ProviderDriverKind.make("claudeAgent"),
+      enabled: true,
+      installed: true,
+      version: null,
+      status: "ready",
+      auth: { status: "authenticated" },
+      checkedAt: "2026-09-13T00:00:00.000Z",
+      models: [{ slug: "claude-opus-5-5", name: "Opus 5.5", isCustom: false, capabilities: null }],
+      slashCommands: [],
+      skills: [],
+      usageLimits: {
+        checkedAt: "2026-09-13T00:00:00.000Z",
+        windows: [
+          {
+            id: "five_hour",
+            kind: "session",
+            label: "Session",
+            usedPercent,
+            resetsAt: "2099-01-01T00:00:00.000Z",
+          },
+        ],
+      },
+    });
+    const captured: OrchestrationV2ServerCommand[] = [];
+    const selection = {
+      instanceId: ProviderInstanceId.make("claude_work"),
+      model: "claude-opus-5-5",
+    };
+    yield* dispatchCommand({
+      type: "message.dispatch",
+      commandId: CommandId.make("send-limited"),
+      threadId: ThreadId.make("thread-limited"),
+      messageId: MessageId.make("message-limited"),
+      text: "go",
+      attachments: [],
+      dispatchMode: { type: "start_immediately" },
+      createdBy: "user",
+      creationSource: "web",
+    }).pipe(
+      Effect.provide(
+        Layer.mergeAll(
+          Layer.mock(ThreadManagementService.ThreadManagementService)({
+            dispatch: layerFailingDispatchHandler(captured),
+            getThreadSnapshotWindow: () =>
+              Effect.succeed({
+                projection: {
+                  thread: {
+                    projectId: ProjectId.make("project-limited"),
+                    modelSelection: selection,
+                  },
+                },
+              } as never),
+          }),
+          Layer.mock(ProviderRegistry.ProviderRegistry)({
+            getProviders: Effect.succeed([
+              claude("claude_work", 100),
+              claude("claude_personal", 30),
+            ]),
+          }),
+          ServerSettings.layerTest({
+            fallbackToAvailableAccounts: true,
+            providerInstances: Object.fromEntries(
+              ["claude_work", "claude_personal"].map((id) => [
+                ProviderInstanceId.make(id),
+                { driver: ProviderDriverKind.make("claudeAgent"), enabled: true },
+              ]),
+            ),
+          }),
+        ),
+      ),
+      Effect.result,
+    );
+    expect(captured[0]).toMatchObject({
+      modelSelection: { instanceId: "claude_personal", model: "claude-opus-5-5" },
+    });
+  }).pipe(Effect.provide(layerIntakeTest)),
+);
diff --git a/apps/server/src/orchestration-v2/ThreadMessageIntake.ts b/apps/server/src/orchestration-v2/ThreadMessageIntake.ts
index 987a1deb246b6..5c5d213b604ea 100644
--- a/apps/server/src/orchestration-v2/ThreadMessageIntake.ts
+++ b/apps/server/src/orchestration-v2/ThreadMessageIntake.ts
@@ -1,10 +1,19 @@
 import { remapComposerContextAttachments } from "@t3tools/shared/composerContextReferences";
 import { appendUserInputAttachmentPaths } from "../provider/userInputAttachments.ts";
-import type { ChatAttachment, OrchestrationV2Command } from "@t3tools/contracts";
+import type {
+  ChatAttachment,
+  ModelSelection,
+  OrchestrationV2Command,
+  ProjectId,
+} from "@t3tools/contracts";
+import { availableAccountSelection } from "@t3tools/shared/usageLimits";
+import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 import { resolveAttachmentPath } from "../attachmentStore.ts";
 import * as ServerConfig from "../config.ts";
+import * as ProviderRegistry from "../provider/ProviderRegistry.ts";
+import * as ServerSettings from "../serverSettings.ts";
 import * as Orchestrator from "./Orchestrator.ts";
 
 import * as AttachmentClaims from "./AttachmentClaims.ts";
@@ -81,11 +90,53 @@ const withGuestAttachments = Effect.fn("ThreadMessageIntake.withGuestAttachments
   return { ...command, attachments: message?.attachments ?? [] };
 });
 
+/** Null unless the user lets sends move off an account that is out of usage. */
+const readAccountChoice = Effect.fn("ThreadMessageIntake.readAccountChoice")(function* () {
+  const settings = yield* ServerSettings.ServerSettingsService.pipe(
+    Effect.flatMap((service) => service.getSettings),
+    Effect.orElseSucceed(() => null),
+  );
+  if (!settings?.fallbackToAvailableAccounts) return null;
+  const providers = yield* ProviderRegistry.ProviderRegistry.pipe(
+    Effect.flatMap((registry) => registry.getProviders),
+  );
+  const now = DateTime.toEpochMillis(yield* DateTime.now);
+  return (selection: ModelSelection, projectId: ProjectId) =>
+    availableAccountSelection({ selection, providers, now, settings, projectId }) ?? selection;
+});
+
+const withAvailableAccount = Effect.fn("ThreadMessageIntake.withAvailableAccount")(function* (
+  command: Extract<OrchestrationV2Command, { readonly type: "message.dispatch" }>,
+) {
+  // Steering stays on the active run's account; server continuations validate their own.
+  if (
+    command.dispatchMode.type === "steer_active" ||
+    command.dispatchMode.type === "restart_active" ||
+    command.usageLimitContinuationOfRunId !== undefined ||
+    command.restartContinuationOfRunId !== undefined
+  ) {
+    return command;
+  }
+  const choose = yield* readAccountChoice();
+  if (choose === null) return command;
+  const threads = yield* ThreadManagement.ThreadManagementService;
+  const window = yield* threads
+    .getThreadSnapshotWindow(command.threadId, { rowLimit: 1 })
+    .pipe(Effect.orElseSucceed(() => null));
+  if (window === null) return command;
+  const { thread } = window.projection;
+  const selection = command.modelSelection ?? thread.modelSelection;
+  const next = choose(selection, thread.projectId);
+  return next === selection ? command : { ...command, modelSelection: next };
+});
+
 export const dispatchCommand = Effect.fn("ThreadMessageIntake.dispatchCommand")(function* (
   incoming: OrchestrationV2Command,
 ) {
   const command =
-    incoming.type === "message.dispatch" ? yield* withGuestAttachments(incoming) : incoming;
+    incoming.type === "message.dispatch"
+      ? yield* withAvailableAccount(yield* withGuestAttachments(incoming))
+      : incoming;
   const threads = yield* ThreadManagement.ThreadManagementService;
   if (command.type === "runtime-request.respond" && command.attachmentsByQuestionId) {
     const config = yield* ServerConfig.ServerConfig;
@@ -207,9 +258,14 @@ export const sendToThread = Effect.fn("ThreadMessageIntake.sendToThread")(functi
 });
 
 export const launchThread = Effect.fn("ThreadMessageIntake.launchThread")(function* (
-  input: ThreadLaunch.ThreadLaunchInput,
+  requested: ThreadLaunch.ThreadLaunchInput,
 ) {
   const launches = yield* ThreadLaunch.ThreadLaunchService;
+  const choose = yield* readAccountChoice();
+  const input =
+    choose === null
+      ? requested
+      : { ...requested, modelSelection: choose(requested.modelSelection, requested.projectId) };
   yield* AttachmentClaims.validateAttachmentLimits(input.initialMessage?.attachments ?? []);
   if (!input.initialMessage?.attachments.some(AttachmentClaims.attachmentIsPendingUpload)) {
     return yield* launches.launch(input);
diff --git a/apps/server/src/orchestration-v2/UsageLimitRecoveryWorker.test.ts b/apps/server/src/orchestration-v2/UsageLimitRecoveryWorker.test.ts
index 430018adcb06a..aef259b8b7813 100644
--- a/apps/server/src/orchestration-v2/UsageLimitRecoveryWorker.test.ts
+++ b/apps/server/src/orchestration-v2/UsageLimitRecoveryWorker.test.ts
@@ -1,5 +1,14 @@
 import { assert, describe, it } from "@effect/vitest";
-import { RunId, ThreadId, type OrchestrationV2DomainEvent } from "@t3tools/contracts";
+import {
+  DEFAULT_SERVER_SETTINGS,
+  ProjectId,
+  ProviderDriverKind,
+  ProviderInstanceId,
+  RunId,
+  ThreadId,
+  type OrchestrationV2DomainEvent,
+  type ServerProvider,
+} from "@t3tools/contracts";
 import * as Clock from "effect/Clock";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
@@ -8,13 +17,14 @@ import * as Queue from "effect/Queue";
 import * as Stream from "effect/Stream";
 import * as TestClock from "effect/testing/TestClock";
 
+import * as ProviderRegistry from "../provider/ProviderRegistry.ts";
 import * as Scheduler from "../scheduling/Scheduler.ts";
 import * as ServerSettings from "../serverSettings.ts";
 import * as Orchestrator from "./Orchestrator.ts";
 import * as ProjectionStore from "./ProjectionStore.ts";
 import * as ThreadManagement from "./ThreadManagementService.ts";
 import * as UsageLimitRecoveryWorker from "./UsageLimitRecoveryWorker.ts";
-import { limitRecoveryCommand } from "./UsageLimitRecoveryWorker.ts";
+import { limitRecoveryCommand, limitSwitchCommand } from "./UsageLimitRecoveryWorker.ts";
 
 it.effect("idle sweeps skip SQL until the next wake time or a relevant event", () =>
   Effect.gen(function* () {
@@ -39,6 +49,7 @@ it.effect("idle sweeps skip SQL until the next wake time or a relevant event", (
               ),
           }),
           Layer.mock(ThreadManagement.ThreadManagementService)({}),
+          Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }),
           Layer.mock(Orchestrator.OrchestratorV2)({
             streamDomainEvents: Stream.fromQueue(events),
           }),
@@ -77,6 +88,11 @@ const failedThread = (failedAgoMs: number, resetAgoMs: number) => {
   const failedAt = DateTime.makeUnsafe(nowMs - failedAgoMs);
   const candidate: ProjectionStore.ProjectionLimitRecoveryCandidate = {
     id: ThreadId.make("thread:limited"),
+    projectId: ProjectId.make("project:limited"),
+    modelSelection: {
+      instanceId: ProviderInstanceId.make("claude_work"),
+      model: "claude-opus-5-5",
+    },
     status: "failed",
     lastErrorClass: "usage_limit",
     usageLimitResetAt: DateTime.formatIso(DateTime.makeUnsafe(nowMs - resetAgoMs)),
@@ -116,3 +132,67 @@ describe("limitRecoveryCommand arming", () => {
     assert.isNull(limitRecoveryCommand(thread, true, nowMs));
   });
 });
+
+describe("limitSwitchCommand", () => {
+  const claude = (id: string, usedPercent: number): ServerProvider => ({
+    instanceId: ProviderInstanceId.make(id),
+    driver: ProviderDriverKind.make("claudeAgent"),
+    enabled: true,
+    installed: true,
+    version: null,
+    status: "ready",
+    auth: { status: "authenticated" },
+    checkedAt: "2026-10-19T11:00:00.000Z",
+    models: [{ slug: "claude-opus-5-5", name: "Opus 5.5", isCustom: false, capabilities: null }],
+    slashCommands: [],
+    skills: [],
+    usageLimits: {
+      checkedAt: "2026-10-19T11:00:00.000Z",
+      windows: [{ id: "five_hour", kind: "session", label: "Session", usedPercent }],
+    },
+  });
+  const settings = {
+    ...DEFAULT_SERVER_SETTINGS,
+    fallbackToAvailableAccounts: true,
+    providerInstances: {
+      [ProviderInstanceId.make("claude_work")]: {
+        driver: ProviderDriverKind.make("claudeAgent"),
+        enabled: true,
+      },
+      [ProviderInstanceId.make("claude_personal")]: {
+        driver: ProviderDriverKind.make("claudeAgent"),
+        enabled: true,
+      },
+    },
+  };
+  // The work account's bars are stale: the turn that just failed is the proof it is spent.
+  const providers = [claude("claude_work", 40), claude("claude_personal", 20)];
+  const input = { providers, settings, nowMs, limitedUntil: new Map<ProviderInstanceId, number>() };
+  const justLimited = failedThread(60_000, -HOUR_MS);
+
+  it("continues the same model on another account with usage left", () => {
+    assert.deepInclude(limitSwitchCommand(justLimited, input), {
+      type: "message.dispatch",
+      manualContinuationOfRunId: RunId.make("run:limited"),
+      modelSelection: {
+        instanceId: ProviderInstanceId.make("claude_personal"),
+        model: "claude-opus-5-5",
+      },
+    });
+  });
+
+  it.each([
+    ["the setting is off", justLimited, { ...input, settings: DEFAULT_SERVER_SETTINGS }],
+    ["the limit was hit long ago", failedThread(HOUR_MS, -HOUR_MS), input],
+    [
+      "the other account hit its own limit here and has not reset",
+      justLimited,
+      {
+        ...input,
+        limitedUntil: new Map([[ProviderInstanceId.make("claude_personal"), nowMs + HOUR_MS]]),
+      },
+    ],
+  ])("waits when %s", (_name, thread, options) => {
+    assert.isNull(limitSwitchCommand(thread, options));
+  });
+});
diff --git a/apps/server/src/orchestration-v2/UsageLimitRecoveryWorker.ts b/apps/server/src/orchestration-v2/UsageLimitRecoveryWorker.ts
index e46ac34c8be61..4965b3f89352a 100644
--- a/apps/server/src/orchestration-v2/UsageLimitRecoveryWorker.ts
+++ b/apps/server/src/orchestration-v2/UsageLimitRecoveryWorker.ts
@@ -1,4 +1,12 @@
-import { CommandId, MessageId, type OrchestrationV2Command } from "@t3tools/contracts";
+import {
+  CommandId,
+  MessageId,
+  type OrchestrationV2Command,
+  type ProviderInstanceId,
+  type ServerProvider,
+  type ServerSettings as ServerSettingsValue,
+} from "@t3tools/contracts";
+import { availableAccountSelection } from "@t3tools/shared/usageLimits";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -6,6 +14,7 @@ import * as Stream from "effect/Stream";
 import type { OrchestrationV2DomainEvent } from "@t3tools/contracts";
 import * as DueHint from "../scheduling/DueHint.ts";
 import * as Scheduler from "../scheduling/Scheduler.ts";
+import * as ProviderRegistry from "../provider/ProviderRegistry.ts";
 import { forkParked } from "../serverActivation.ts";
 import * as ServerSettings from "../serverSettings.ts";
 import * as ProjectionStore from "./ProjectionStore.ts";
@@ -13,6 +22,61 @@ import * as Orchestrator from "./Orchestrator.ts";
 import * as ThreadManagement from "./ThreadManagementService.ts";
 
 const MAX_OVERDUE_ARM_MS = 24 * 60 * 60 * 1000;
+// Only limits hit this recently move accounts, so turning the setting on never wakes old threads.
+const ACCOUNT_SWITCH_WINDOW_MS = 10 * 60 * 1000;
+
+/** Continues a thread that just hit a usage limit on another account with usage left. */
+export function limitSwitchCommand(
+  thread: ProjectionStore.ProjectionLimitRecoveryCandidate,
+  input: {
+    readonly providers: ReadonlyArray<ServerProvider>;
+    readonly settings: ServerSettingsValue;
+    readonly nowMs: number;
+    /** Accounts that hit a limit here until the given reset, whatever their stale bars say. */
+    readonly limitedUntil: ReadonlyMap<ProviderInstanceId, number>;
+  },
+): OrchestrationV2Command | null {
+  if (
+    thread.status !== "failed" ||
+    thread.lastErrorClass !== "usage_limit" ||
+    !thread.latestRunId ||
+    thread.archivedAt !== null ||
+    thread.settledOverride === "settled" ||
+    thread.pendingRuntimeRequest !== null ||
+    input.nowMs - DateTime.toEpochMillis(thread.latestRunCompletedAt ?? thread.updatedAt) >
+      ACCOUNT_SWITCH_WINDOW_MS ||
+    (thread.snoozedUntil != null && DateTime.toEpochMillis(thread.snoozedUntil) > input.nowMs)
+  )
+    return null;
+  const selection = thread.modelSelection;
+  const next = availableAccountSelection({
+    selection,
+    providers: input.providers.filter(
+      (provider) =>
+        provider.instanceId === selection.instanceId ||
+        (input.limitedUntil.get(provider.instanceId) ?? 0) <= input.nowMs,
+    ),
+    now: input.nowMs,
+    settings: input.settings,
+    projectId: thread.projectId,
+    exhausted: true,
+  });
+  if (next === null) return null;
+  const identity = `${thread.id}:${thread.latestRunId}`;
+  return {
+    type: "message.dispatch",
+    commandId: CommandId.make(`limit-switch:${identity}`),
+    messageId: MessageId.make(`limit-switch:${identity}`),
+    threadId: thread.id,
+    manualContinuationOfRunId: thread.latestRunId,
+    modelSelection: next,
+    text: "Continue where you left off.",
+    attachments: [],
+    dispatchMode: { type: "start_immediately" },
+    createdBy: "user",
+    creationSource: "server",
+  };
+}
 
 export function limitRecoveryCommand(
   thread: ProjectionStore.ProjectionLimitRecoveryCandidate,
@@ -92,6 +156,10 @@ const makeSweep = Effect.gen(function* () {
   const threads = yield* ThreadManagement.ThreadManagementService;
   const orchestrator = yield* Orchestrator.OrchestratorV2;
   const settings = yield* ServerSettings.ServerSettingsService;
+  const registry = yield* ProviderRegistry.ProviderRegistry;
+  const limitedUntil = new Map<ProviderInstanceId, number>();
+  // A rejected switch is not retried every tick; the thread falls back to waiting for the reset.
+  const attemptedSwitches = new Set<string>();
   const due = DueHint.make();
   yield* forkParked(
     Stream.runForEach(orchestrator.streamDomainEvents, (event) =>
@@ -109,9 +177,34 @@ const makeSweep = Effect.gen(function* () {
       now,
       autoResume: preferences.autoResumeLimitedThreads,
       snooze: preferences.snoozeLimitedThreads,
+      ...(preferences.fallbackToAvailableAccounts
+        ? { switchAccountsSince: DateTime.makeUnsafe(nowMs - ACCOUNT_SWITCH_WINDOW_MS) }
+        : {}),
     });
+    const providers = preferences.fallbackToAvailableAccounts ? yield* registry.getProviders : [];
     let acted = false;
     for (const thread of candidates) {
+      const switchCommand = preferences.fallbackToAvailableAccounts
+        ? limitSwitchCommand(thread, { providers, settings: preferences, nowMs, limitedUntil })
+        : null;
+      if (switchCommand !== null && !attemptedSwitches.has(switchCommand.commandId)) {
+        attemptedSwitches.add(switchCommand.commandId);
+        acted = true;
+        const resetMs = Date.parse(thread.usageLimitResetAt ?? "");
+        limitedUntil.set(
+          thread.modelSelection.instanceId,
+          Number.isFinite(resetMs) ? resetMs : nowMs + ACCOUNT_SWITCH_WINDOW_MS,
+        );
+        yield* threads.dispatch(switchCommand).pipe(
+          Effect.catchCause((cause) =>
+            Effect.logWarning("orchestration-v2.limit-recovery.account-switch-failed", {
+              threadId: thread.id,
+              cause,
+            }),
+          ),
+        );
+        continue;
+      }
       const command = limitRecoveryCommand(
         thread,
         preferences.autoResumeLimitedThreads,
diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.ts
index abc7c71f4b8b2..36d40d6e40e28 100644
--- a/apps/server/src/ws.ts
+++ b/apps/server/src/ws.ts
@@ -1277,6 +1277,7 @@ export const layerWsRpc = (
         | FileSystem.FileSystem
         | ServerConfig.ServerConfig
         | ServerSettings.ServerSettingsService
+        | ProviderRegistry.ProviderRegistry
         | DocumentText.DocumentText
       >();
       const applicationEvents = yield* OrchestrationEventStore.OrchestrationEventStore;
diff --git a/apps/web/src/components/settings/ProjectDefaultsSettings.tsx b/apps/web/src/components/settings/ProjectDefaultsSettings.tsx
index 46cd15dc37b97..8c23b71f32a8d 100644
--- a/apps/web/src/components/settings/ProjectDefaultsSettings.tsx
+++ b/apps/web/src/components/settings/ProjectDefaultsSettings.tsx
@@ -328,7 +328,7 @@ export function ProjectDefaultsSettings({ category }: { category: ProjectSetting
       settingKeys={["fallbackToAvailableAccounts"]}
       mixed={mixedAvailableAccounts}
       {...searchableSetting("fallback-available-accounts")}
-      description="When the default model is out of usage and no fallback model is usable, new threads start on another account of the same provider with usage left, then on another provider."
+      description="When a model's account is out of usage, messages and threads that hit a limit continue with the same model on another account of that provider with usage left, then on another provider. New threads try the fallback model first."
       resetAction={
         settings.fallbackToAvailableAccounts ? (
           <SettingResetButton
diff --git a/docs/user/usage.md b/docs/user/usage.md
index d9d607339cb7c..7f26839871f8e 100644
--- a/docs/user/usage.md
+++ b/docs/user/usage.md
@@ -112,11 +112,15 @@ stale reset times have no refill estimate; refresh Limits for a new reading. Cla
 model-specific weekly allowances keep their reported values.
 
 When the default model's account is out of usage, new threads start on the **Fallback model**
-set in **Settings → New threads**. Turn on **Switch to an account with usage left** there to also
-fall back automatically when no fallback model is set or it is out of usage too: T3 Code picks
-another account of the same provider with usage left, keeping the model, and then another
-provider's default model. Only accounts that report limits under **Usage → Limits** are picked.
-The composer names the account it switched to; choose the default model there to keep it.
+set in **Settings → Threads**.
+
+If you have several accounts of the same provider, turn on **Switch to an account with usage
+left** there. When the account you picked is out of usage, your message goes to the same model
+on another account of that provider with usage left, or to another provider's default model when
+none has any. A thread that hits a 5-hour or weekly limit while working continues the same way
+right away instead of waiting for the reset; the thread shows the account switch. Only accounts
+that report limits under **Usage → Limits** are picked, and an account that just hit a limit is
+skipped until it resets. Pick the account in the model picker to move back.
 
 Opening Limits checks the selected connected environments automatically. Each client waits at
 least five minutes between automatic checks of an environment, including after a failed check.
diff --git a/packages/shared/src/usageLimits.ts b/packages/shared/src/usageLimits.ts
index 5041a5661bdd7..be8c8b0fb952c 100644
--- a/packages/shared/src/usageLimits.ts
+++ b/packages/shared/src/usageLimits.ts
@@ -61,43 +61,69 @@ export function exhaustedUsageWindow(
   }
 }
 
-export function resolveNewThreadModelSelection(input: {
-  readonly defaultSelection: ModelSelection | null;
-  readonly explicitSelection?: ModelSelection | null;
-  readonly fallbackSelection: ModelSelection | null;
+interface AccountChoiceInput {
   readonly providers: readonly ServerProvider[];
   readonly now: number;
   readonly settings?: ServerSettings;
   readonly projectId?: ProjectId | null;
-}) {
+}
+
+function isUsableSelection(candidate: ModelSelection, input: AccountChoiceInput) {
+  const entry = input.providers.find((item) => item.instanceId === candidate.instanceId);
+  return (
+    entry !== undefined &&
+    entry.enabled &&
+    entry.installed &&
+    entry.auth.status !== "unauthenticated" &&
+    isProviderAvailable(entry) &&
+    !exhaustedUsageWindow(entry, input.now, candidate.model) &&
+    (!input.settings ||
+      resolveProjectProviderInstanceEnabled(
+        input.settings,
+        input.projectId ?? null,
+        entry.instanceId,
+      ))
+  );
+}
+
+/**
+ * With `fallbackToAvailableAccounts` on and the selection's account out of usage (`exhausted`
+ * when a turn just said so), the same model on another account with usage left, else another
+ * provider's default model.
+ */
+export function availableAccountSelection(
+  input: AccountChoiceInput & { readonly selection: ModelSelection; readonly exhausted?: boolean },
+): ModelSelection | null {
+  if (!input.settings?.fallbackToAvailableAccounts) return null;
+  const provider = input.providers.find((entry) => entry.instanceId === input.selection.instanceId);
+  if (!provider) return null;
+  if (!input.exhausted && !exhaustedUsageWindow(provider, input.now, input.selection.model)) {
+    return null;
+  }
+  return (
+    automaticFallbackSelections(input.selection, provider, input.providers).find((candidate) =>
+      isUsableSelection(candidate, input),
+    ) ?? null
+  );
+}
+
+export function resolveNewThreadModelSelection(
+  input: AccountChoiceInput & {
+    readonly defaultSelection: ModelSelection | null;
+    readonly explicitSelection?: ModelSelection | null;
+    readonly fallbackSelection: ModelSelection | null;
+  },
+) {
   const selection = input.explicitSelection ?? input.defaultSelection;
   const unchanged = { selection, fallback: null };
   if (input.explicitSelection || !selection) return unchanged;
   const provider = input.providers.find((entry) => entry.instanceId === selection.instanceId);
   const window = exhaustedUsageWindow(provider, input.now, selection.model);
   if (!provider || !window) return unchanged;
-  const usable = (candidate: ModelSelection) => {
-    const entry = input.providers.find((item) => item.instanceId === candidate.instanceId);
-    return (
-      entry !== undefined &&
-      entry.enabled &&
-      entry.installed &&
-      entry.auth.status !== "unauthenticated" &&
-      isProviderAvailable(entry) &&
-      !exhaustedUsageWindow(entry, input.now, candidate.model) &&
-      (!input.settings ||
-        resolveProjectProviderInstanceEnabled(
-          input.settings,
-          input.projectId ?? null,
-          entry.instanceId,
-        ))
-    );
-  };
   const replacement =
-    (input.fallbackSelection && usable(input.fallbackSelection) ? input.fallbackSelection : null) ??
-    (input.settings?.fallbackToAvailableAccounts
-      ? automaticFallbackSelections(selection, provider, input.providers).find(usable)
-      : undefined);
+    (input.fallbackSelection && isUsableSelection(input.fallbackSelection, input)
+      ? input.fallbackSelection
+      : null) ?? availableAccountSelection({ ...input, selection, exhausted: true });
   if (!replacement) return unchanged;
   return {
     selection: replacement,
@@ -116,10 +142,19 @@ function automaticFallbackSelections(
     const windows = entry.usageLimits?.unavailable ? [] : (entry.usageLimits?.windows ?? []);
     return windows.length === 0 ? null : Math.min(...windows.map(remainingPercent));
   };
+  const exhaustedLogin = exhausted.usageLimits?.credentialFingerprint;
   return providers
     .flatMap((entry) => {
       const left = headroom(entry);
-      if (entry.instanceId === exhausted.instanceId || left === null) return [];
+      if (
+        entry.instanceId === exhausted.instanceId ||
+        left === null ||
+        // Two instances signed in to the same login share one quota.
+        (exhaustedLogin !== undefined &&
+          entry.usageLimits?.credentialFingerprint === exhaustedLogin)
+      ) {
+        return [];
+      }
       const sameDriver = entry.driver === exhausted.driver;
       const model =
         (sameDriver ? entry.models.find((item) => item.slug === selection.model) : undefined) ??