diff --git a/ui/litellm-dashboard/src/app/(dashboard)/models-and-endpoints/components/AutoRouters/autoRouterRows.test.ts b/ui/litellm-dashboard/src/app/(dashboard)/models-and-endpoints/components/AutoRouters/autoRouterRows.test.ts
index 2c433263c0f..79c4243271e 100644
--- a/ui/litellm-dashboard/src/app/(dashboard)/models-and-endpoints/components/AutoRouters/autoRouterRows.test.ts
+++ b/ui/litellm-dashboard/src/app/(dashboard)/models-and-endpoints/components/AutoRouters/autoRouterRows.test.ts
@@ -85,7 +85,7 @@ describe("autoRouterRows", () => {
 
   it.each([
     ["llm", "LLM Classifier"],
-    ["jev", "Decision Model"],
+    ["jev", "JEV Classifier"],
   ])("labels a router using the %s classifier", (classifierType, label) => {
     const row = toAutoRouterRow(
       {
diff --git a/ui/litellm-dashboard/src/app/(dashboard)/models-and-endpoints/components/AutoRouters/autoRouterRows.ts b/ui/litellm-dashboard/src/app/(dashboard)/models-and-endpoints/components/AutoRouters/autoRouterRows.ts
index 429bca3ab6f..1faf3408c23 100644
--- a/ui/litellm-dashboard/src/app/(dashboard)/models-and-endpoints/components/AutoRouters/autoRouterRows.ts
+++ b/ui/litellm-dashboard/src/app/(dashboard)/models-and-endpoints/components/AutoRouters/autoRouterRows.ts
@@ -57,7 +57,7 @@ const dedupe = (models: string[]): string[] => Array.from(new Set(models));
 
 const COMPLEXITY_TYPE_LABELS: Record<string, string> = {
   llm: "LLM Classifier",
-  jev: "Decision Model",
+  jev: "JEV Classifier",
   capability: "Capability",
   llm_v2: "Fuse v2",
   heuristic_first: "Heuristic first",
diff --git a/ui/litellm-dashboard/src/components/add_model/AutoRouterClassifierTabs.integration.test.tsx b/ui/litellm-dashboard/src/components/add_model/AutoRouterClassifierTabs.integration.test.tsx
index 137ba954f32..f843a472d15 100644
--- a/ui/litellm-dashboard/src/components/add_model/AutoRouterClassifierTabs.integration.test.tsx
+++ b/ui/litellm-dashboard/src/components/add_model/AutoRouterClassifierTabs.integration.test.tsx
@@ -68,7 +68,7 @@ describe("Auto-router classifier selection", () => {
         llm: "LLM",
         heuristic_first: "LLM",
         hybrid: "LLM",
-        jev: "Decision Model",
+        jev: "Jev",
       }[classifier_type];
       expect(screen.getByRole("radio", { name: new RegExp(`^${family}$`) })).toBeChecked();
       fireEvent.click(screen.getByRole("radio", { name: new RegExp(`^${family}$`) }));
diff --git a/ui/litellm-dashboard/src/components/add_model/AutoRouterClassifierTabs.tsx b/ui/litellm-dashboard/src/components/add_model/AutoRouterClassifierTabs.tsx
index b6997c3d4c4..92fc8d2a335 100644
--- a/ui/litellm-dashboard/src/components/add_model/AutoRouterClassifierTabs.tsx
+++ b/ui/litellm-dashboard/src/components/add_model/AutoRouterClassifierTabs.tsx
@@ -164,7 +164,7 @@ const AutoRouterClassifierTabs: React.FC<AutoRouterClassifierTabsProps> = ({ val
           {[
             { value: "heuristics", label: "Heuristics", description: "Classify locally, with no API call" },
             { value: "llm", label: "LLM", description: "Use a judge model to choose a solver" },
-            { value: "jev", label: "Decision Model", description: "Use Jev or open-source Nimble to choose a tier" },
+            { value: "jev", label: "Jev", description: "Use TypeSafe System One Choice to choose a tier" },
           ].map((option) => (
             <Label
               key={option.value}
diff --git a/ui/litellm-dashboard/src/components/add_model/ClassificationMethodConfig.tsx b/ui/litellm-dashboard/src/components/add_model/ClassificationMethodConfig.tsx
index 7741690dc30..ccd204aa521 100644
--- a/ui/litellm-dashboard/src/components/add_model/ClassificationMethodConfig.tsx
+++ b/ui/litellm-dashboard/src/components/add_model/ClassificationMethodConfig.tsx
@@ -642,8 +642,8 @@ const ClassificationMethodConfig: React.FC<ClassificationMethodConfigProps> = ({
             />
             <span className="text-xs text-muted-foreground">
               Number of prior user turns sent to the classifier provider, excluding tool output and harness reminders.
-              LLM and decision models default to 3 turns and send them to the configured classifier endpoint. Set to 0
-              to omit conversation history. The current message and selected system text are still sent.
+              LLM and Jev default to 3 turns; Jev sends them to the configured TypeSafe endpoint. Set to 0 to omit
+              conversation history. The current message and selected system text are still sent.
             </span>
           </div>
           <div>
diff --git a/ui/litellm-dashboard/src/components/add_model/ClassifierTypeRadios.tsx b/ui/litellm-dashboard/src/components/add_model/ClassifierTypeRadios.tsx
index f13155ab089..1fd6dfa6a20 100644
--- a/ui/litellm-dashboard/src/components/add_model/ClassifierTypeRadios.tsx
+++ b/ui/litellm-dashboard/src/components/add_model/ClassifierTypeRadios.tsx
@@ -54,8 +54,8 @@ const ClassifierTypeRadios: React.FC<ClassifierTypeRadiosProps> = ({ value, clas
         <Label className="items-start font-normal leading-normal">
           <RadioGroupItem value="jev" className="mt-0.5" />
           <span>
-            <strong className="font-semibold">Decision Model</strong>{" "}
-            <span className="text-muted-foreground">uses Jev or open-source Nimble to decide the tier</span>
+            <strong className="font-semibold">Jev Classifier</strong>{" "}
+            <span className="text-muted-foreground">uses TypeSafe System One Choice to decide the tier</span>
           </span>
         </Label>
         <SimpleTooltip content={scorerLockedReason}>
diff --git a/ui/litellm-dashboard/src/components/add_model/ComplexityRouterConfig.tsx b/ui/litellm-dashboard/src/components/add_model/ComplexityRouterConfig.tsx
index 50135d01ed2..32f9ebf97ad 100644
--- a/ui/litellm-dashboard/src/components/add_model/ComplexityRouterConfig.tsx
+++ b/ui/litellm-dashboard/src/components/add_model/ComplexityRouterConfig.tsx
@@ -237,7 +237,7 @@ const TierSetToolbar: React.FC<{
     {editing && (
       <span className="block mt-1 text-xs text-muted-foreground">
         Add or remove tiers to define your own set. Every custom tier needs a definition the classifier routes on, and
-        an edited set requires the LLM or Decision Model classification method
+        an edited set requires the LLM or Jev classification method
       </span>
     )}
     {editing && keywordRulesError && (
diff --git a/ui/litellm-dashboard/src/components/add_model/JevClassifierConfig.integration.test.tsx b/ui/litellm-dashboard/src/components/add_model/JevClassifierConfig.integration.test.tsx
index c2b6fd796cd..7da8b12c2d7 100644
--- a/ui/litellm-dashboard/src/components/add_model/JevClassifierConfig.integration.test.tsx
+++ b/ui/litellm-dashboard/src/components/add_model/JevClassifierConfig.integration.test.tsx
@@ -96,87 +96,14 @@ function Form() {
 
 describe("JEV classifier editor", () => {
   afterEach(() => vi.mocked(useAuthorized).mockReset());
-  it("creates Nimble connection settings and retains the provider after save and reload", () => {
-    renderWithProviders(<Form />);
-    fireEvent.click(screen.getByRole("radio", { name: "Decision Model" }));
-    fireEvent.click(screen.getByRole("radio", { name: "Nimble (open source)" }));
-    expect(screen.getByLabelText("Nimble Model")).toHaveValue("nimble-latest");
-    fireEvent.change(screen.getByLabelText("API Base"), { target: { value: "https://nimble.example.com" } });
-    fireEvent.change(screen.getByLabelText("API Key"), { target: { value: "new-nimble-key" } });
-    fireEvent.change(screen.getByLabelText("Nimble Timeout (ms)"), { target: { value: "20000" } });
-    fireEvent.click(screen.getByRole("button", { name: "Probe current config" }));
-    expect(testAutoRouterRouting).toHaveBeenLastCalledWith(
-      "token",
-      expect.objectContaining({
-        complexity_router_config: expect.objectContaining({
-          classifier_type: "jev",
-          jev_classifier_config: {
-            provider: "bespoke_nimble",
-            model: "nimble-latest",
-            timeout_ms: 20000,
-            api_base: "https://nimble.example.com",
-            api_key: "new-nimble-key",
-          },
-        }),
-      }),
-    );
-    fireEvent.click(screen.getByRole("button", { name: "Save and reload" }));
-    expect(screen.getByRole("radio", { name: "Nimble (open source)" })).toBeChecked();
-    expect(screen.getByLabelText("Nimble Timeout (ms)")).toHaveValue(20000);
-    expect(screen.getByLabelText("API Key")).toHaveValue("");
-    fireEvent.click(screen.getByText("Connection settings"));
-    fireEvent.click(screen.getByRole("button", { name: "Clear saved API key" }));
-    fireEvent.click(screen.getByRole("button", { name: "Probe current config" }));
-    expect(testAutoRouterRouting).toHaveBeenLastCalledWith(
-      "token",
-      expect.objectContaining({
-        complexity_router_config: expect.objectContaining({
-          jev_classifier_config: {
-            provider: "bespoke_nimble",
-            model: "nimble-latest",
-            timeout_ms: 20000,
-            api_key: null,
-          },
-        }),
-      }),
-    );
-    fireEvent.click(screen.getByRole("button", { name: "Use gateway connection" }));
-    fireEvent.click(screen.getByRole("button", { name: "Probe current config" }));
-    expect(testAutoRouterRouting).toHaveBeenLastCalledWith(
-      "token",
-      expect.objectContaining({
-        complexity_router_config: expect.objectContaining({
-          jev_classifier_config: {
-            provider: "bespoke_nimble",
-            model: "nimble-latest",
-            timeout_ms: 20000,
-            api_key: null,
-            api_base: null,
-          },
-        }),
-      }),
-    );
-  });
-
-  it.each(["Internal User", "Admin Viewer", "org_admin"])("hides connection overrides for %s", (userRole) => {
-    vi.mocked(useAuthorized).mockReturnValue({ ...useAuthorized(), userRole });
-    renderWithProviders(<Form />);
-    fireEvent.click(screen.getByRole("radio", { name: "Decision Model" }));
-    fireEvent.click(screen.getByRole("radio", { name: "Nimble (open source)" }));
-    expect(screen.getByLabelText("Nimble Model")).toHaveValue("nimble-latest");
-    expect(screen.queryByText("Connection settings")).not.toBeInTheDocument();
-    expect(screen.queryByLabelText("API Key")).not.toBeInTheDocument();
-    expect(screen.queryByLabelText("API Base")).not.toBeInTheDocument();
-  });
-
   it("uses built-in JEV without a license and preserves custom tiers and context through reload", () => {
     renderWithProviders(<Form />);
     expect(screen.getByLabelText("Judge model")).toBeInTheDocument();
     expect(screen.getByText("Reasoning Effort")).toBeInTheDocument();
     expect(screen.getByText("Classifier Prompt")).toBeInTheDocument();
     expect(screen.getByRole("switch", { name: "Use images for classification" })).toBeInTheDocument();
-    fireEvent.click(screen.getByRole("radio", { name: "Decision Model" }));
-    expect(screen.getByRole("radio", { name: "Decision Model" })).toBeChecked();
+    fireEvent.click(screen.getByRole("radio", { name: /Jev Classifier/ }));
+    expect(screen.getByRole("radio", { name: /^Jev Classifier/ })).toBeChecked();
     expect(screen.getByLabelText("Jev Model")).toHaveValue("jev-latest");
     expect(screen.getByLabelText("Jev Instructions")).toBeEnabled();
     expect(screen.queryByLabelText("Judge model")).not.toBeInTheDocument();
@@ -190,7 +117,7 @@ describe("JEV classifier editor", () => {
     fireEvent.click(screen.getByRole("switch", { name: "Classifier circuit breaker" }));
     fireEvent.click(screen.getByRole("button", { name: "Customize tiers" }));
     fireEvent.click(screen.getByRole("button", { name: "Save and reload" }));
-    expect(screen.getByRole("radio", { name: "Decision Model" })).toBeChecked();
+    expect(screen.getByRole("radio", { name: /Jev Classifier/ })).toBeChecked();
     expect(screen.getByLabelText("Jev Model")).toHaveValue("jev-test");
     expect(screen.getByLabelText("Jev Timeout (ms)")).toHaveValue(4200);
     expect(screen.getByLabelText("Context Window Size")).toHaveValue("6");
diff --git a/ui/litellm-dashboard/src/components/add_model/JevClassifierConfig.tsx b/ui/litellm-dashboard/src/components/add_model/JevClassifierConfig.tsx
index e0297a22821..97609bcd8c3 100644
--- a/ui/litellm-dashboard/src/components/add_model/JevClassifierConfig.tsx
+++ b/ui/litellm-dashboard/src/components/add_model/JevClassifierConfig.tsx
@@ -6,10 +6,7 @@ import { Label } from "@/components/ui/label";
 import { Textarea } from "@/components/ui/textarea";
 import ClassifierCircuitBreakerConfig from "./ClassifierCircuitBreakerConfig";
 import type { ComplexityRouterConfigValue } from "./ComplexityRouterConfig";
-import { defaultJevClassifierConfig, transitionDecisionModelProvider } from "./jev_classifier_config";
-import useAuthorized from "@/app/(dashboard)/hooks/useAuthorized";
-import { isProxyAdminRole } from "@/utils/roles";
-import { RadioGroup, RadioGroupItem } from "@/components/ui/radio-group";
+import { defaultJevClassifierConfig } from "./jev_classifier_config";
 
 export default function JevClassifierConfig({
   value,
@@ -19,45 +16,21 @@ export default function JevClassifierConfig({
   onChange: (value: ComplexityRouterConfigValue) => void;
 }) {
   const id = useId();
-  const { userRole, isViewOnly } = useAuthorized();
   const config = value.jev_classifier_config ?? defaultJevClassifierConfig();
-  const provider = config.provider ?? "typesafe";
-  const providerLabel = provider === "bespoke_nimble" ? "Nimble" : "Jev";
   const update = (patch: Partial<typeof config>) =>
     onChange({ ...value, jev_classifier_config: { ...config, ...patch } });
 
   return (
     <div className="mt-4 space-y-3">
-      <fieldset className="space-y-2">
-        <legend className="text-sm font-medium">Decision model provider</legend>
-        <RadioGroup
-          value={provider}
-          onValueChange={(next) => {
-            if (next === "typesafe" || next === "bespoke_nimble") {
-              onChange({ ...value, jev_classifier_config: transitionDecisionModelProvider(config, next) });
-            }
-          }}
-          className="flex flex-wrap gap-4"
-        >
-          <Label>
-            <RadioGroupItem value="typesafe" />
-            TypeSafe Jev
-          </Label>
-          <Label>
-            <RadioGroupItem value="bespoke_nimble" />
-            Nimble (open source)
-          </Label>
-        </RadioGroup>
-      </fieldset>
       <p className="text-sm text-muted-foreground">
-        {providerLabel} selects a tier for each request using your configured tier criteria
+        Uses TypeSafe System One Choice evaluation with your configured tiers
       </p>
       <div>
-        <Label htmlFor={`${id}-model`}>{providerLabel} Model</Label>
+        <Label htmlFor={`${id}-model`}>Jev Model</Label>
         <Input id={`${id}-model`} value={config.model} onChange={(event) => update({ model: event.target.value })} />
       </div>
       <div>
-        <Label htmlFor={`${id}-timeout`}>{providerLabel} Timeout (ms)</Label>
+        <Label htmlFor={`${id}-timeout`}>Jev Timeout (ms)</Label>
         <Input
           id={`${id}-timeout`}
           type="number"
@@ -67,58 +40,6 @@ export default function JevClassifierConfig({
           onChange={(event) => update({ timeout_ms: Number(event.target.value) })}
         />
       </div>
-      {isProxyAdminRole(userRole ?? "") && !isViewOnly && (
-        <details className="space-y-3 rounded-lg border p-3">
-          <summary className="cursor-pointer text-sm font-medium">Connection settings</summary>
-          <p className="text-xs text-muted-foreground">
-            Saved connection values are hidden. Untouched fields keep the saved connection. New routers use the gateway
-            connection when these fields are blank
-          </p>
-          <div>
-            <Label htmlFor={`${id}-api-base`}>API Base</Label>
-            <Input
-              id={`${id}-api-base`}
-              value={config.api_base ?? ""}
-              placeholder={provider === "bespoke_nimble" ? "https://nimble.example.com" : "https://api.typesafe.ai"}
-              onChange={(event) => update({ api_base: event.target.value })}
-            />
-          </div>
-          <div>
-            <Label htmlFor={`${id}-api-key`}>API Key</Label>
-            <Input
-              id={`${id}-api-key`}
-              type="password"
-              autoComplete="new-password"
-              value={config.api_key ?? ""}
-              placeholder={
-                provider === "bespoke_nimble" ? "Optional for a keyless Nimble server" : "Enter the endpoint's key"
-              }
-              onChange={(event) => update({ api_key: event.target.value || null })}
-            />
-          </div>
-          <div className="flex flex-wrap gap-2">
-            <Button variant="outline" type="button" onClick={() => update({ api_base: null, api_key: null })}>
-              Use gateway connection
-            </Button>
-            {provider === "bespoke_nimble" && (
-              <>
-                <Button variant="outline" type="button" onClick={() => update({ api_key: null })}>
-                  Clear saved API key
-                </Button>
-                <p className="w-full text-xs text-muted-foreground">
-                  Clearing the key keeps a saved custom endpoint and connects without authentication. A gateway
-                  connection still uses its configured key. Use gateway connection clears both router overrides
-                </p>
-              </>
-            )}
-          </div>
-          {config.api_base === null && config.api_key === null && (
-            <p role="status" className="text-xs text-muted-foreground">
-              Gateway connection selected for the next save
-            </p>
-          )}
-        </details>
-      )}
       <ClassifierCircuitBreakerConfig
         value={config}
         onChange={(next) =>
@@ -129,7 +50,7 @@ export default function JevClassifierConfig({
         }
       />
       <div>
-        <Label htmlFor={`${id}-instructions`}>{providerLabel} Instructions</Label>
+        <Label htmlFor={`${id}-instructions`}>Jev Instructions</Label>
         <AutoRouterAllowanceNote
           feature="tier_or_classifier_prompt"
           label="Custom instructions share the custom-tier allowance"
@@ -142,11 +63,11 @@ export default function JevClassifierConfig({
         />
         {config.instructions && (
           <Button variant="outline" type="button" onClick={() => update({ instructions: undefined })}>
-            Restore built-in {providerLabel} instructions
+            Restore built-in Jev instructions
           </Button>
         )}
         <p className="text-xs text-muted-foreground">
-          Built-in decision model classification is available without a license and uses the shipped tier criteria
+          Built-in Jev is available without a license and uses the shipped tier criteria
         </p>
       </div>
     </div>
diff --git a/ui/litellm-dashboard/src/components/add_model/JevConnectionTest.integration.test.tsx b/ui/litellm-dashboard/src/components/add_model/JevConnectionTest.integration.test.tsx
index 38a106bf650..ff147e20d1a 100644
--- a/ui/litellm-dashboard/src/components/add_model/JevConnectionTest.integration.test.tsx
+++ b/ui/litellm-dashboard/src/components/add_model/JevConnectionTest.integration.test.tsx
@@ -73,41 +73,6 @@ const response = (cause: string) => ({
 afterEach(() => vi.unstubAllGlobals());
 
 describe("JEV network probes", () => {
-  it.each(["jev_classifier", "classifier_fallback"])("labels Nimble probe results for %s", async (cause) => {
-    const fetchMock = vi.fn<typeof fetch>(async () => new Response(JSON.stringify(response(cause))));
-    vi.stubGlobal("fetch", fetchMock);
-    const nimbleRequest = buildSavedJevConnectionTestRequest(
-      {
-        ...config,
-        jev_classifier_config: {
-          provider: "bespoke_nimble",
-          model: "nimble-latest",
-          timeout_ms: 20000,
-          api_key: "masked-secret",
-          api_base: "https://nimble.example.com",
-        },
-      },
-      "nimble-router",
-    );
-    renderWithProviders(<AutoRouterConnectionTest accessToken="token" targets={[]} jevRequest={nimbleRequest} />);
-    expect(
-      await screen.findByText(
-        cause === "jev_classifier"
-          ? "Nimble classification succeeded"
-          : "Nimble was not reached successfully (routing cause: classifier_fallback)",
-      ),
-    ).toBeVisible();
-    expect(screen.getByRole("status", { name: "Nimble connection" })).toHaveTextContent("Nimble Classifier");
-    expect(JSON.parse(String(fetchMock.mock.calls[0][1]?.body))).toEqual({
-      prompt: JEV_CONNECTION_TEST_PROMPT,
-      saved_model_id: "nimble-router",
-      complexity_router_config: {
-        ...config,
-        jev_classifier_config: { provider: "bespoke_nimble", model: "nimble-latest", timeout_ms: 20000 },
-      },
-    });
-  });
-
   it.each(["jev_classifier", "classifier_fallback", "default_model_fallback", "keyword_match"])(
     "probes the routing endpoint independently of tier models and checks the cause %s",
     async (cause) => {
diff --git a/ui/litellm-dashboard/src/components/add_model/add_auto_router_tab.integration.test.tsx b/ui/litellm-dashboard/src/components/add_model/add_auto_router_tab.integration.test.tsx
index fe076ee853d..0337d35d698 100644
--- a/ui/litellm-dashboard/src/components/add_model/add_auto_router_tab.integration.test.tsx
+++ b/ui/litellm-dashboard/src/components/add_model/add_auto_router_tab.integration.test.tsx
@@ -274,7 +274,7 @@ describe("AddAutoRouterTab", () => {
     mockFetchAvailableModels.mockResolvedValue(ALL_FAMILY_MODELS);
     renderWithProviders(<Harness />);
     await user.click(await screen.findByRole("button", { name: "Choose models for me" }));
-    await user.click(screen.getByRole("radio", { name: "Decision Model" }));
+    await user.click(screen.getByRole("radio", { name: "Jev" }));
     await waitFor(() =>
       expect(apiClient.post).toHaveBeenLastCalledWith(
         "/auto_router/availability",
@@ -301,7 +301,7 @@ describe("AddAutoRouterTab", () => {
     expect(within(screen.getByRole("alert")).getByRole("link", { name: "Talk to our team" })).toBeVisible();
     await user.click(screen.getByRole("button", { name: "Restore defaults" }));
     await waitFor(() => expect(screen.queryByRole("alert")).not.toBeInTheDocument());
-    expect(screen.getByRole("radio", { name: "Decision Model" })).toBeChecked();
+    expect(screen.getByRole("radio", { name: "Jev" })).toBeChecked();
     await waitFor(() => expect(screen.getByRole("button", { name: "Add Auto Router" })).toBeEnabled());
     await user.click(screen.getByRole("button", { name: "Add Auto Router" }));
     await waitFor(() => expect(handleAddAutoRouterSubmit).toHaveBeenCalled());
@@ -317,7 +317,7 @@ describe("AddAutoRouterTab", () => {
     mockFetchAvailableModels.mockResolvedValue(ALL_FAMILY_MODELS);
     renderWithProviders(<Harness />);
     await user.click(await screen.findByRole("button", { name: "Choose models for me" }));
-    await user.click(screen.getByRole("radio", { name: "Decision Model" }));
+    await user.click(screen.getByRole("radio", { name: "Jev" }));
     fireEvent.change(screen.getByLabelText("Auto Router Name"), { target: { value: "checked-router" } });
     await waitFor(() => expect(screen.getByRole("button", { name: "Add Auto Router" })).toBeEnabled());
     let complete: ((result: unknown) => void) | undefined;
@@ -357,22 +357,17 @@ describe("AddAutoRouterTab", () => {
     expect(screen.getByRole("button", { name: "Routing approach" })).toHaveTextContent("Complexity");
   });
 
-  it.each(["LLM", "Decision Model"])(
-    "keeps %s and the frequency when choosing models automatically",
-    async (family) => {
-      mockFetchAvailableModels.mockResolvedValue(ALL_FAMILY_MODELS);
-      renderWithProviders(<Harness />);
-      const automatic = await screen.findByRole("button", { name: "Choose models for me" });
-      await userEvent.click(screen.getByRole("radio", { name: family }));
-      await selectAutoRouterOption("How often to classify", "Every new user message");
-      await userEvent.click(automatic);
-      expect(screen.getByRole("radio", { name: family })).toBeChecked();
-      expect(screen.getByRole("combobox", { name: "How often to classify" })).toHaveTextContent(
-        "Every new user message",
-      );
-      expect(screen.getByRole("button", { name: "Advanced settings" })).toHaveAttribute("aria-expanded", "false");
-    },
-  );
+  it.each(["LLM", "Jev"])("keeps %s and the frequency when choosing models automatically", async (family) => {
+    mockFetchAvailableModels.mockResolvedValue(ALL_FAMILY_MODELS);
+    renderWithProviders(<Harness />);
+    const automatic = await screen.findByRole("button", { name: "Choose models for me" });
+    await userEvent.click(screen.getByRole("radio", { name: family }));
+    await selectAutoRouterOption("How often to classify", "Every new user message");
+    await userEvent.click(automatic);
+    expect(screen.getByRole("radio", { name: family })).toBeChecked();
+    expect(screen.getByRole("combobox", { name: "How often to classify" })).toHaveTextContent("Every new user message");
+    expect(screen.getByRole("button", { name: "Advanced settings" })).toHaveAttribute("aria-expanded", "false");
+  });
 
   it.each(["Capability", "Fuse v2"])(
     "creates %s from its dedicated tab without complexity templates",
diff --git a/ui/litellm-dashboard/src/components/add_model/auto_router_connection_test.tsx b/ui/litellm-dashboard/src/components/add_model/auto_router_connection_test.tsx
index bcf77441137..aa2ce91766a 100644
--- a/ui/litellm-dashboard/src/components/add_model/auto_router_connection_test.tsx
+++ b/ui/litellm-dashboard/src/components/add_model/auto_router_connection_test.tsx
@@ -10,7 +10,6 @@ import {
 import { AutoRouterTestTarget } from "./build_auto_router_test_targets";
 import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
 import { Button } from "@/components/ui/button";
-import { jevClassifierConfigSchema } from "./jev_classifier_config";
 
 interface AutoRouterConnectionTestProps {
   accessToken: string;
@@ -32,9 +31,6 @@ const AutoRouterConnectionTest: React.FC<AutoRouterConnectionTestProps> = ({
   jevRequest,
   onTestComplete,
 }) => {
-  const provider = jevClassifierConfigSchema.safeParse(jevRequest?.complexity_router_config.jev_classifier_config).data
-    ?.provider;
-  const classifierLabel = provider === "bespoke_nimble" ? "Nimble" : "Jev";
   const [results, setResults] = React.useState<TargetResult[]>(() => targets.map(() => ({ status: "pending" })));
   const [jevResult, setJevResult] = React.useState<TargetResult>({ status: "pending" });
 
@@ -54,7 +50,7 @@ const AutoRouterConnectionTest: React.FC<AutoRouterConnectionTestProps> = ({
           ? { status: "success" }
           : {
               status: "error",
-              error: `${classifierLabel} was not reached successfully (routing cause: ${decision.cause ?? "unknown"})`,
+              error: `Jev was not reached successfully (routing cause: ${decision.cause ?? "unknown"})`,
             },
       );
     };
@@ -95,11 +91,11 @@ const AutoRouterConnectionTest: React.FC<AutoRouterConnectionTestProps> = ({
         classifier probe includes its reasoning effort override.
       </p>
       {jevRequest && (
-        <div role="status" aria-label={`${classifierLabel} connection`} className="rounded-lg border p-3 text-sm">
-          <strong>{classifierLabel} Classifier</strong>
+        <div role="status" aria-label="Jev connection" className="rounded-lg border p-3 text-sm">
+          <strong>Jev Classifier</strong>
           <p>
-            {jevResult.status === "pending" && `Testing ${classifierLabel} classification`}
-            {jevResult.status === "success" && `${classifierLabel} classification succeeded`}
+            {jevResult.status === "pending" && "Testing Jev classification"}
+            {jevResult.status === "success" && "Jev classification succeeded"}
             {jevResult.status === "error" && jevResult.error}
           </p>
         </div>
diff --git a/ui/litellm-dashboard/src/components/add_model/build_complexity_router_config.test.ts b/ui/litellm-dashboard/src/components/add_model/build_complexity_router_config.test.ts
index 999be42072e..6d458d61797 100644
--- a/ui/litellm-dashboard/src/components/add_model/build_complexity_router_config.test.ts
+++ b/ui/litellm-dashboard/src/components/add_model/build_complexity_router_config.test.ts
@@ -75,7 +75,7 @@ describe("buildComplexityRouterConfig", () => {
         classifier_type: "jev",
         jev_classifier_config: { model: "jev-latest", timeout_ms: 3000, ...patch },
       }),
-    ).toBe("Enter a decision model, a positive whole-number timeout and a positive cooldown");
+    ).toBe("Enter a JEV model, a positive whole-number timeout and a positive cooldown");
   });
 
   it.each([false, true])("serializes JEV with shared context and no LLM config, custom tiers: %s", (custom) => {
diff --git a/ui/litellm-dashboard/src/components/add_model/build_complexity_router_config.ts b/ui/litellm-dashboard/src/components/add_model/build_complexity_router_config.ts
index 3ea76cc391b..13df40464f0 100644
--- a/ui/litellm-dashboard/src/components/add_model/build_complexity_router_config.ts
+++ b/ui/litellm-dashboard/src/components/add_model/build_complexity_router_config.ts
@@ -8,7 +8,7 @@ import type { ModelGroup } from "../llm_calls/fetch_models";
 import { KeywordTierRule } from "./KeywordTierRules";
 import {
   type JevClassifierConfig,
-  jevClassifierFormConfigSchema,
+  jevClassifierConfigSchema,
   normalizeJevClassifierConfig,
 } from "./jev_classifier_config";
 import {
@@ -437,8 +437,8 @@ export const getClassifierModelError = (
   >,
 ): string | null => {
   if (effectiveClassifierType(config) === "jev") {
-    const parsed = jevClassifierFormConfigSchema.safeParse(config.jev_classifier_config ?? {});
-    return parsed.success ? null : "Enter a decision model, a positive whole-number timeout and a positive cooldown";
+    const parsed = jevClassifierConfigSchema.safeParse(config.jev_classifier_config ?? {});
+    return parsed.success ? null : "Enter a JEV model, a positive whole-number timeout and a positive cooldown";
   }
   if (!usesLlmClassifier(effectiveClassifierType(config)) || config.classifier_llm_config?.model) return null;
   return config.custom_tier_set
diff --git a/ui/litellm-dashboard/src/components/add_model/jev_classifier_config.test.ts b/ui/litellm-dashboard/src/components/add_model/jev_classifier_config.test.ts
deleted file mode 100644
index 1325852e00f..00000000000
--- a/ui/litellm-dashboard/src/components/add_model/jev_classifier_config.test.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  jevClassifierConfigSchema,
-  jevClassifierFormConfigSchema,
-  normalizeJevClassifierConfig,
-  transitionDecisionModelProvider,
-} from "./jev_classifier_config";
-
-const nimble = { provider: "bespoke_nimble" as const, model: "nimble-latest", timeout_ms: 3000 };
-
-describe("decision model connections", () => {
-  it("keeps new connection overrides but strips saved credentials on hydration", () => {
-    const supplied = { ...nimble, api_base: " https://nimble.example.com ", api_key: " new-key " };
-    expect(normalizeJevClassifierConfig(jevClassifierFormConfigSchema.parse(supplied))).toEqual({
-      ...nimble,
-      api_base: "https://nimble.example.com",
-      api_key: "new-key",
-    });
-    expect(jevClassifierConfigSchema.parse(supplied)).toEqual(nimble);
-  });
-
-  it.each([
-    [{ api_base: "", api_key: "  " }, {}],
-    [{ api_key: null }, { api_key: null }],
-    [
-      { api_base: null, api_key: null },
-      { api_base: null, api_key: null },
-    ],
-  ])("distinguishes untouched fields from explicit connection resets: %j", (input, expected) => {
-    expect(normalizeJevClassifierConfig({ ...nimble, ...input })).toEqual({ ...nimble, ...expected });
-  });
-
-  it("drops credentials when changing providers and keeps tuning settings", () => {
-    const jev = { model: "custom-jev", timeout_ms: 9000, api_base: "https://jev.example.com", api_key: "jev-key" };
-    const switched = transitionDecisionModelProvider(jev, "bespoke_nimble");
-    expect(switched).toEqual({ ...nimble, timeout_ms: 9000 });
-    expect(transitionDecisionModelProvider({ ...switched, api_key: "nimble-key" }, "typesafe")).toEqual({
-      provider: "typesafe",
-      model: "jev-latest",
-      timeout_ms: 9000,
-    });
-    expect(transitionDecisionModelProvider(jev, "typesafe")).toBe(jev);
-  });
-});
diff --git a/ui/litellm-dashboard/src/components/add_model/jev_classifier_config.ts b/ui/litellm-dashboard/src/components/add_model/jev_classifier_config.ts
index 101f6ba95d7..478c763351c 100644
--- a/ui/litellm-dashboard/src/components/add_model/jev_classifier_config.ts
+++ b/ui/litellm-dashboard/src/components/add_model/jev_classifier_config.ts
@@ -1,7 +1,6 @@
 import { z } from "zod";
 
 const jevClassifierConfigFields = {
-  provider: z.enum(["typesafe", "bespoke_nimble"]).optional(),
   model: z.string().trim().min(1).default("jev-latest"),
   timeout_ms: z.number().int().positive().default(3000),
   instructions: z
@@ -14,36 +13,15 @@ const jevClassifierConfigFields = {
 
 export const jevClassifierConfigSchema = z.object(jevClassifierConfigFields);
 
-export const jevClassifierFormConfigSchema = z.object({
-  ...jevClassifierConfigFields,
-  api_base: z.string().trim().nullish(),
-  api_key: z.string().trim().nullish(),
-});
-
-export type JevClassifierConfig = z.infer<typeof jevClassifierFormConfigSchema>;
-export type DecisionModelProvider = NonNullable<JevClassifierConfig["provider"]>;
+export type JevClassifierConfig = z.infer<typeof jevClassifierConfigSchema>;
 
 export const defaultJevClassifierConfig = (): JevClassifierConfig => jevClassifierConfigSchema.parse({});
 
-export const transitionDecisionModelProvider = (
-  config: JevClassifierConfig,
-  provider: DecisionModelProvider,
-): JevClassifierConfig => {
-  if ((config.provider ?? "typesafe") === provider) return config;
-  const { api_base, api_key, ...settings } = config;
-  return { ...settings, provider, model: provider === "bespoke_nimble" ? "nimble-latest" : "jev-latest" };
-};
-
 export const normalizeJevClassifierConfig = (
   config: JevClassifierConfig = defaultJevClassifierConfig(),
 ): JevClassifierConfig => ({
-  ...(config.provider !== undefined && { provider: config.provider }),
   model: config.model.trim(),
   timeout_ms: config.timeout_ms,
-  ...(config.api_base === null && { api_base: null }),
-  ...(config.api_base?.trim() && { api_base: config.api_base.trim() }),
-  ...(config.api_key === null && { api_key: null }),
-  ...(config.api_key?.trim() && { api_key: config.api_key.trim() }),
   ...(config.instructions?.trim() && { instructions: config.instructions.trim() }),
   ...(config.circuit_breaker_enabled !== undefined && { circuit_breaker_enabled: config.circuit_breaker_enabled }),
   ...(config.circuit_breaker_cooldown_seconds !== undefined && {
diff --git a/ui/litellm-dashboard/src/components/edit_auto_router/build_updated_complexity_router_config.test.ts b/ui/litellm-dashboard/src/components/edit_auto_router/build_updated_complexity_router_config.test.ts
index 5c034a5017c..4b8e298191d 100644
--- a/ui/litellm-dashboard/src/components/edit_auto_router/build_updated_complexity_router_config.test.ts
+++ b/ui/litellm-dashboard/src/components/edit_auto_router/build_updated_complexity_router_config.test.ts
@@ -48,35 +48,6 @@ const hydratedState: KeywordMatchingState = {
 };
 
 describe("buildUpdatedComplexityRouterConfig keyword matching", () => {
-  it("preserves Nimble through dashboard validation and saves without exposing transport credentials", () => {
-    const stored = {
-      classifier_type: "jev" as const,
-      tiers: FORM_VALUE.tiers,
-      jev_classifier_config: {
-        provider: "bespoke_nimble" as const,
-        model: "nimble-latest",
-        timeout_ms: 6100,
-        api_key: "masked-key",
-        api_base: "https://nimble.example.com",
-      },
-    };
-    const hydrated = hydrateComplexityRouterConfig(stored, undefined);
-    expect(hydrated.jev_classifier_config).toEqual({
-      provider: "bespoke_nimble",
-      model: "nimble-latest",
-      timeout_ms: 6100,
-    });
-    const edited = {
-      ...hydrated,
-      jev_classifier_config: { ...hydrated.jev_classifier_config!, timeout_ms: 900 },
-    };
-    expect(buildUpdatedComplexityRouterConfig(stored, edited).jev_classifier_config).toEqual({
-      provider: "bespoke_nimble",
-      model: "nimble-latest",
-      timeout_ms: 900,
-    });
-  });
-
   it.each([false, true])("omits masked JEV credentials from dashboard saves, edited: %s", (edited) => {
     const stored = {
       classifier_type: "jev" as const,
diff --git a/ui/litellm-dashboard/src/components/view_logs/LogDetailsDrawer/RoutingDecisionCard.test.tsx b/ui/litellm-dashboard/src/components/view_logs/LogDetailsDrawer/RoutingDecisionCard.test.tsx
index 0f16c1d2867..5492ceffefc 100644
--- a/ui/litellm-dashboard/src/components/view_logs/LogDetailsDrawer/RoutingDecisionCard.test.tsx
+++ b/ui/litellm-dashboard/src/components/view_logs/LogDetailsDrawer/RoutingDecisionCard.test.tsx
@@ -28,15 +28,6 @@ const forecast = {
 };
 
 describe("RoutingDecisionCard", () => {
-  it.each([
-    ["bespoke_nimble/nimble-latest", "Nimble classifier"],
-    ["typesafe/jev-latest", "JEV classifier"],
-  ])("labels a decision from %s", (classifier_model, label) => {
-    render(<RoutingDecisionCard decision={{ cause: "jev_classifier", classifier_model, tier: "SIMPLE" }} />);
-    expect(screen.getByText(label)).toBeInTheDocument();
-    expect(screen.getByText(classifier_model)).toBeInTheDocument();
-  });
-
   it("renders nothing when the request carried no routing decision", () => {
     const { container } = render(<RoutingDecisionCard decision={undefined} />);
     expect(container).toBeEmptyDOMElement();
diff --git a/ui/litellm-dashboard/src/components/view_logs/LogDetailsDrawer/RoutingDecisionCard.tsx b/ui/litellm-dashboard/src/components/view_logs/LogDetailsDrawer/RoutingDecisionCard.tsx
index ebd5aadf8d5..6a8cedd3746 100644
--- a/ui/litellm-dashboard/src/components/view_logs/LogDetailsDrawer/RoutingDecisionCard.tsx
+++ b/ui/litellm-dashboard/src/components/view_logs/LogDetailsDrawer/RoutingDecisionCard.tsx
@@ -143,7 +143,7 @@ function describeCause(decision: RoutingDecision): string {
     case "llm_classifier":
       return classifierModel ? `LLM classifier (${classifierModel})` : "LLM classifier";
     case "jev_classifier":
-      return classifierModel?.startsWith("bespoke_nimble/") ? "Nimble classifier" : "JEV classifier";
+      return "JEV classifier";
     case "literal_keyword_match":
     case "keyword":
       return matchedKeyword ? `Keyword match: "${matchedKeyword}"` : "Keyword match";