From 7bc7bf49d6e0635115ae6a2c671e9ffefb21be5d Mon Sep 17 00:00:00 2001
From: Debug Agent <debug@example.com>
Date: Fri, 29 May 2026 15:48:43 +0200
Subject: [PATCH 1/4] feat(chat): runtime-compatibility AgentProfile picker
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Reframe the in-conversation profile picker around AgentProfiles and their
runtime compatibility with the running conversation (agent-canvas#669):
incompatible profiles are shown but disabled with a reason, and a profile is
only ever switched live when the whole profile applies — never a silent
partial application.

- src/utils/agent-profiles/runtime-plan.ts: pure `deriveProfileRuntimePlan`
  implementing the issue's compatibility matrix (current | switch-live |
  disabled+reason) over a normalized AgentProfile / ConversationRuntimeContext,
  plus `normalizeLlmProfile`. Fully unit-tested incl. ACP/non-runtime reasons.
- src/utils/agent-profiles/reason-labels.ts: reason → i18n key (exhaustive).
- src/hooks/use-profile-runtime-plans.ts: pairs each saved profile with a plan
  for the current conversation/home context (cloud-gated; ACP-aware).
- switch-profile picker: renders plan-driven rows (current checked,
  switch-live actionable, disabled greyed + reason); switching is blocked
  unless the plan is switch-live.
- ACP/cloud model menu: shows incompatible saved profiles disabled with
  "Requires a new conversation" instead of hiding them.
- i18n: PROFILE_PICKER reason strings across all supported languages.

Backend persistence for ACP profiles lands separately in
software-agent-sdk#3433; until the typescript-client exposes the new profile
fields, ACP profiles still surface here as disabled.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../chat-input-model-profiles.test.tsx        | 110 ++++++++
 .../utils/agent-profiles/runtime-plan.test.ts | 266 ++++++++++++++++++
 .../chat/components/chat-input-model.tsx      |  67 ++++-
 .../features/chat/switch-profile-button.tsx   |  60 +---
 .../chat/switch-profile-context-menu.tsx      |  70 +++--
 src/hooks/use-profile-runtime-plans.ts        | 153 ++++++++++
 src/i18n/translation.json                     | 102 +++++++
 src/utils/agent-profiles/reason-labels.ts     |  36 +++
 src/utils/agent-profiles/runtime-plan.ts      | 252 +++++++++++++++++
 9 files changed, 1041 insertions(+), 75 deletions(-)
 create mode 100644 __tests__/components/features/chat/components/chat-input-model-profiles.test.tsx
 create mode 100644 __tests__/utils/agent-profiles/runtime-plan.test.ts
 create mode 100644 src/hooks/use-profile-runtime-plans.ts
 create mode 100644 src/utils/agent-profiles/reason-labels.ts
 create mode 100644 src/utils/agent-profiles/runtime-plan.ts

diff --git a/__tests__/components/features/chat/components/chat-input-model-profiles.test.tsx b/__tests__/components/features/chat/components/chat-input-model-profiles.test.tsx
new file mode 100644
index 000000000..0fa410895
--- /dev/null
+++ b/__tests__/components/features/chat/components/chat-input-model-profiles.test.tsx
@@ -0,0 +1,110 @@
+import { screen } from "@testing-library/react";
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderWithProviders } from "test-utils";
+import type { ChatInputModelState } from "#/hooks/use-chat-input-model-state";
+import type { ProfileWithPlan } from "#/hooks/use-profile-runtime-plans";
+
+const useProfileRuntimePlansMock = vi.fn();
+const switchAcpModelMutate = vi.fn();
+
+vi.mock("#/hooks/use-profile-runtime-plans", () => ({
+  useProfileRuntimePlans: () => useProfileRuntimePlansMock(),
+}));
+
+vi.mock("#/hooks/mutation/use-switch-acp-model", () => ({
+  useSwitchAcpModel: () => ({ mutate: switchAcpModelMutate }),
+}));
+
+import { ChatInputModelMenuContent } from "#/components/features/chat/components/chat-input-model";
+
+const acpModelState: ChatInputModelState = {
+  isAcpContext: true,
+  displayModel: "Claude Opus 4.7",
+  currentModelId: "claude-opus-4-7",
+  availableAcpModels: [{ id: "claude-opus-4-7", label: "Claude Opus 4.7" }],
+  showAcpPicker: true,
+  switchConversationId: "conv-1",
+  destinationPath: "/settings/agent",
+  destinationLabel: "Agent",
+};
+
+const disabledProfile: ProfileWithPlan = {
+  profile: {
+    name: "Cheap GPT daily driver",
+    model: "openai/gpt-4o",
+    base_url: null,
+    api_key_set: true,
+  },
+  plan: { action: "disabled", reason: "different-agent-kind" },
+};
+
+describe("ChatInputModelMenuContent disabled-profile section", () => {
+  beforeEach(() => {
+    useProfileRuntimePlansMock.mockReset();
+    switchAcpModelMutate.mockReset();
+  });
+
+  it("shows incompatible profiles visible-but-disabled with a reason in an ACP conversation", () => {
+    useProfileRuntimePlansMock.mockReturnValue({
+      profiles: [disabledProfile],
+      activeProfileName: null,
+      isAcpContext: true,
+    });
+
+    renderWithProviders(
+      <ChatInputModelMenuContent model={acpModelState} onClose={() => {}} />,
+    );
+
+    const row = screen.getByTestId(
+      "chat-input-profile-option-Cheap GPT daily driver",
+    );
+    expect(row).toBeDisabled();
+    expect(row).toHaveTextContent("Cheap GPT daily driver");
+    // The reason is surfaced inline (not silently swallowed).
+    expect(
+      screen.getByTestId(
+        "chat-input-profile-reason-Cheap GPT daily driver",
+      ),
+    ).toBeInTheDocument();
+  });
+
+  it("clicking a disabled profile never triggers a model switch", () => {
+    useProfileRuntimePlansMock.mockReturnValue({
+      profiles: [disabledProfile],
+      activeProfileName: null,
+      isAcpContext: true,
+    });
+
+    renderWithProviders(
+      <ChatInputModelMenuContent model={acpModelState} onClose={() => {}} />,
+    );
+
+    // disabled <button> swallows the click; assert no switch was attempted.
+    screen
+      .getByTestId("chat-input-profile-option-Cheap GPT daily driver")
+      .click();
+    expect(switchAcpModelMutate).not.toHaveBeenCalled();
+  });
+
+  it("omits the profiles section when there are no incompatible profiles", () => {
+    useProfileRuntimePlansMock.mockReturnValue({
+      profiles: [],
+      activeProfileName: null,
+      isAcpContext: true,
+    });
+
+    renderWithProviders(
+      <ChatInputModelMenuContent model={acpModelState} onClose={() => {}} />,
+    );
+
+    expect(
+      screen.queryByTestId(
+        "chat-input-profile-option-Cheap GPT daily driver",
+      ),
+    ).not.toBeInTheDocument();
+    // The ACP model picker is unaffected.
+    expect(
+      screen.getByTestId("chat-input-acp-model-option-claude-opus-4-7"),
+    ).toBeInTheDocument();
+  });
+});
diff --git a/__tests__/utils/agent-profiles/runtime-plan.test.ts b/__tests__/utils/agent-profiles/runtime-plan.test.ts
new file mode 100644
index 000000000..db78752a8
--- /dev/null
+++ b/__tests__/utils/agent-profiles/runtime-plan.test.ts
@@ -0,0 +1,266 @@
+import { describe, it, expect } from "vitest";
+import {
+  deriveProfileRuntimePlan,
+  normalizeLlmProfile,
+  type AgentProfile,
+  type ConversationRuntimeContext,
+} from "#/utils/agent-profiles/runtime-plan";
+
+const openHandsProfile = (
+  overrides: Partial<Extract<AgentProfile, { kind: "openhands" }>> = {},
+): AgentProfile => ({
+  kind: "openhands",
+  name: "profile",
+  llm: { model: "anthropic/claude-haiku", baseUrl: null },
+  ...overrides,
+});
+
+const acpProfile = (
+  overrides: Partial<Extract<AgentProfile, { kind: "acp" }>> = {},
+): AgentProfile => ({
+  kind: "acp",
+  name: "acp-profile",
+  acpServer: "claude-code",
+  acpModel: "claude-opus-4-7",
+  acpCommand: ["npx", "claude-code-acp"],
+  acpArgs: [],
+  acpEnv: {},
+  ...overrides,
+});
+
+const openHandsContext = (
+  overrides: Partial<Extract<ConversationRuntimeContext, { kind: "openhands" }>> = {},
+): ConversationRuntimeContext => ({
+  kind: "openhands",
+  llm: { model: "anthropic/claude-haiku", baseUrl: null },
+  ...overrides,
+});
+
+const acpContext = (
+  overrides: Partial<Extract<ConversationRuntimeContext, { kind: "acp" }>> = {},
+): ConversationRuntimeContext => ({
+  kind: "acp",
+  acpServer: "claude-code",
+  acpModel: "claude-opus-4-7",
+  acpCommand: ["npx", "claude-code-acp"],
+  acpArgs: [],
+  acpEnv: {},
+  providerSupportsRuntimeSwitch: true,
+  sessionInitialized: true,
+  ...overrides,
+});
+
+describe("deriveProfileRuntimePlan", () => {
+  it("returns current when the profile is the active one", () => {
+    const plan = deriveProfileRuntimePlan({
+      profile: openHandsProfile({ llm: { model: "other", baseUrl: null } }),
+      context: openHandsContext(),
+      isActive: true,
+    });
+    expect(plan).toEqual({ action: "current" });
+  });
+
+  it("disables an OpenHands profile against an ACP conversation (different kind)", () => {
+    const plan = deriveProfileRuntimePlan({
+      profile: openHandsProfile(),
+      context: acpContext(),
+    });
+    expect(plan).toEqual({
+      action: "disabled",
+      reason: "different-agent-kind",
+    });
+  });
+
+  it("disables an ACP profile against an OpenHands conversation (different kind)", () => {
+    const plan = deriveProfileRuntimePlan({
+      profile: acpProfile(),
+      context: openHandsContext(),
+    });
+    expect(plan).toEqual({
+      action: "disabled",
+      reason: "different-agent-kind",
+    });
+  });
+
+  describe("OpenHands -> OpenHands", () => {
+    it("switches live when only the model differs", () => {
+      const plan = deriveProfileRuntimePlan({
+        profile: openHandsProfile({ llm: { model: "openai/gpt-4o", baseUrl: null } }),
+        context: openHandsContext(),
+      });
+      expect(plan).toEqual({ action: "switch-live", mutableFields: ["llm"] });
+    });
+
+    it("switches live when only the base_url differs", () => {
+      const plan = deriveProfileRuntimePlan({
+        profile: openHandsProfile({
+          llm: { model: "anthropic/claude-haiku", baseUrl: "https://proxy" },
+        }),
+        context: openHandsContext(),
+      });
+      expect(plan).toEqual({ action: "switch-live", mutableFields: ["llm"] });
+    });
+
+    it("is current when model and base_url match and it is the active profile", () => {
+      const plan = deriveProfileRuntimePlan({
+        profile: openHandsProfile(),
+        context: openHandsContext(),
+        isActive: true,
+      });
+      expect(plan).toEqual({ action: "current" });
+    });
+
+    it("treats an identical non-active profile as current (a no-op switch)", () => {
+      const plan = deriveProfileRuntimePlan({
+        profile: openHandsProfile(),
+        context: openHandsContext(),
+      });
+      expect(plan).toEqual({ action: "current" });
+    });
+
+    it("disables when condenser settings differ", () => {
+      const plan = deriveProfileRuntimePlan({
+        profile: openHandsProfile({ nonRuntime: { condenser: "summary" } }),
+        context: openHandsContext(),
+      });
+      expect(plan).toEqual({
+        action: "disabled",
+        reason: "non-runtime-settings-differ",
+      });
+    });
+
+    it("disables with its own reason when verification differs", () => {
+      const plan = deriveProfileRuntimePlan({
+        profile: openHandsProfile({ nonRuntime: { verification: "strict" } }),
+        context: openHandsContext(),
+      });
+      expect(plan).toEqual({
+        action: "disabled",
+        reason: "verification-not-runtime-switchable",
+      });
+    });
+
+    it("prioritizes a non-runtime difference over a switchable model difference", () => {
+      const plan = deriveProfileRuntimePlan({
+        profile: openHandsProfile({
+          llm: { model: "openai/gpt-4o", baseUrl: null },
+          nonRuntime: { mcp: "github" },
+        }),
+        context: openHandsContext(),
+      });
+      expect(plan).toEqual({
+        action: "disabled",
+        reason: "non-runtime-settings-differ",
+      });
+    });
+  });
+
+  describe("ACP -> ACP", () => {
+    it("switches live when only acp_model differs", () => {
+      const plan = deriveProfileRuntimePlan({
+        profile: acpProfile({ acpModel: "claude-sonnet-4-6" }),
+        context: acpContext(),
+      });
+      expect(plan).toEqual({
+        action: "switch-live",
+        mutableFields: ["acp_model"],
+      });
+    });
+
+    it("is current when the model matches and it is the active profile", () => {
+      const plan = deriveProfileRuntimePlan({
+        profile: acpProfile(),
+        context: acpContext(),
+        isActive: true,
+      });
+      expect(plan).toEqual({ action: "current" });
+    });
+
+    it("disables when the ACP provider differs", () => {
+      const plan = deriveProfileRuntimePlan({
+        profile: acpProfile({ acpServer: "codex" }),
+        context: acpContext(),
+      });
+      expect(plan).toEqual({
+        action: "disabled",
+        reason: "different-acp-provider",
+      });
+    });
+
+    it("disables when the launch command differs", () => {
+      const plan = deriveProfileRuntimePlan({
+        profile: acpProfile({ acpCommand: ["npx", "other"] }),
+        context: acpContext(),
+      });
+      expect(plan).toEqual({
+        action: "disabled",
+        reason: "different-acp-command",
+      });
+    });
+
+    it("disables when env differs", () => {
+      const plan = deriveProfileRuntimePlan({
+        profile: acpProfile({ acpEnv: { API_KEY: "x" } }),
+        context: acpContext(),
+      });
+      expect(plan).toEqual({
+        action: "disabled",
+        reason: "different-acp-command",
+      });
+    });
+
+    it("disables when the provider has no runtime model switch", () => {
+      const plan = deriveProfileRuntimePlan({
+        profile: acpProfile({ acpModel: "claude-sonnet-4-6" }),
+        context: acpContext({ providerSupportsRuntimeSwitch: false }),
+      });
+      expect(plan).toEqual({
+        action: "disabled",
+        reason: "provider-does-not-support-runtime-switch",
+      });
+    });
+
+    it("disables when the session is not yet initialized", () => {
+      const plan = deriveProfileRuntimePlan({
+        profile: acpProfile({ acpModel: "claude-sonnet-4-6" }),
+        context: acpContext({ sessionInitialized: false }),
+      });
+      expect(plan).toEqual({
+        action: "disabled",
+        reason: "session-not-initialized",
+      });
+    });
+  });
+});
+
+describe("normalizeLlmProfile", () => {
+  it("maps an LLM-only ProfileInfo to an OpenHands AgentProfile", () => {
+    expect(
+      normalizeLlmProfile({
+        name: "gpt",
+        model: "openai/gpt-4o",
+        base_url: "https://proxy",
+        api_key_set: true,
+      }),
+    ).toEqual({
+      kind: "openhands",
+      name: "gpt",
+      llm: { model: "openai/gpt-4o", baseUrl: "https://proxy" },
+    });
+  });
+
+  it("defaults missing model and base_url to null", () => {
+    expect(
+      normalizeLlmProfile({
+        name: "blank",
+        model: null,
+        base_url: null,
+        api_key_set: false,
+      }),
+    ).toEqual({
+      kind: "openhands",
+      name: "blank",
+      llm: { model: null, baseUrl: null },
+    });
+  });
+});
diff --git a/src/components/features/chat/components/chat-input-model.tsx b/src/components/features/chat/components/chat-input-model.tsx
index 7774bcb3b..e5ecbe0f9 100644
--- a/src/components/features/chat/components/chat-input-model.tsx
+++ b/src/components/features/chat/components/chat-input-model.tsx
@@ -4,9 +4,12 @@ import {
   type ChatInputModelState,
 } from "#/hooks/use-chat-input-model-state";
 import { useSwitchAcpModel } from "#/hooks/mutation/use-switch-acp-model";
+import { useProfileRuntimePlans } from "#/hooks/use-profile-runtime-plans";
+import { reasonToI18nKey } from "#/utils/agent-profiles/reason-labels";
 import { ComboboxCaretInline } from "#/ui/combobox-caret";
 import SettingsGearIcon from "#/icons/settings-gear.svg?react";
 import CheckIcon from "#/icons/checkmark.svg?react";
+import CircuitIcon from "#/icons/u-circuit.svg?react";
 import { useClickOutsideElement } from "#/hooks/use-click-outside-element";
 import { NavigationLink } from "#/components/shared/navigation-link";
 import { ContextMenu } from "#/ui/context-menu";
@@ -50,7 +53,17 @@ export function ChatInputModelMenuContent({
 }: ChatInputModelMenuContentProps) {
   const { t } = useTranslation("openhands");
   const switchAcpModel = useSwitchAcpModel();
+  const { profiles } = useProfileRuntimePlans();
   const hasModelRows = model.showAcpPicker || Boolean(model.displayModel);
+  // Saved AgentProfiles that can't be switched into this conversation live
+  // (e.g. an OpenHands profile while an ACP agent is running). The issue
+  // requires these to be visible-but-disabled with a reason rather than
+  // hidden, so the user understands the profile exists but needs a new
+  // conversation. Cloud backends have no profiles, so this stays empty there.
+  const incompatibleProfiles = profiles.filter(
+    (entry) => entry.plan.action === "disabled",
+  );
+  const hasProfilesSection = incompatibleProfiles.length > 0;
 
   const handleSelectAcpModel = (modelId: string) => {
     if (modelId !== model.currentModelId) {
@@ -115,7 +128,59 @@ export function ChatInputModelMenuContent({
           </div>
         </li>
       ) : null}
-      {hasModelRows && <Divider inset={dividerInset} />}
+      {hasProfilesSection && (
+        <>
+          {hasModelRows && <Divider inset={dividerInset} />}
+          <li role="presentation" className="px-2 pt-1 pb-0.5">
+            <Typography.Text className="text-[11px] font-medium text-[var(--oh-text-dim)] uppercase tracking-wide leading-4">
+              {t(I18nKey.SETTINGS$AVAILABLE_PROFILES)}
+            </Typography.Text>
+          </li>
+          {incompatibleProfiles.map(({ profile, plan }) => {
+            // `plan.action` is "disabled" by construction of
+            // `incompatibleProfiles`; narrow it for `reason` access.
+            const reasonLabel =
+              plan.action === "disabled"
+                ? t(reasonToI18nKey(plan.reason))
+                : null;
+            return (
+              <ContextMenuListItem
+                key={profile.name}
+                testId={`chat-input-profile-option-${profile.name}`}
+                isDisabled
+                // Disabled rows never act; the empty handler keeps the shared
+                // button API satisfied without applying anything.
+                onClick={() => {}}
+                className="flex flex-col gap-0.5 h-auto"
+              >
+                <span
+                  className="flex items-center gap-2 min-w-0"
+                  title={reasonLabel ?? undefined}
+                >
+                  <CircuitIcon
+                    width={16}
+                    height={16}
+                    className="shrink-0"
+                    aria-hidden
+                  />
+                  <span className="flex-1 truncate text-sm leading-5">
+                    {profile.name}
+                  </span>
+                </span>
+                {reasonLabel && (
+                  <span
+                    className="block truncate text-xs leading-4 text-[var(--oh-text-dim)] pl-6"
+                    data-testid={`chat-input-profile-reason-${profile.name}`}
+                  >
+                    {reasonLabel}
+                  </span>
+                )}
+              </ContextMenuListItem>
+            );
+          })}
+        </>
+      )}
+      {(hasModelRows || hasProfilesSection) && <Divider inset={dividerInset} />}
       <li className="text-sm">
         <NavigationLink
           to={model.destinationPath}
diff --git a/src/components/features/chat/switch-profile-button.tsx b/src/components/features/chat/switch-profile-button.tsx
index 4d23c6823..afa64fd54 100644
--- a/src/components/features/chat/switch-profile-button.tsx
+++ b/src/components/features/chat/switch-profile-button.tsx
@@ -2,12 +2,9 @@ import React from "react";
 import { useTranslation } from "react-i18next";
 import { I18nKey } from "#/i18n/declaration";
 import { ComboboxCaretInline } from "#/ui/combobox-caret";
-import { useLlmProfiles } from "#/hooks/query/use-llm-profiles";
 import { useSwitchLlmProfileAndLog } from "#/hooks/mutation/use-switch-llm-profile-and-log";
-import { useActiveConversation } from "#/hooks/query/use-active-conversation";
-import { useSettings } from "#/hooks/query/use-settings";
 import { useOptionalConversationId } from "#/hooks/use-conversation-id";
-import { useModelStore } from "#/stores/model-store";
+import { useProfileRuntimePlans } from "#/hooks/use-profile-runtime-plans";
 import { cn } from "#/utils/utils";
 import { SwitchProfileContextMenu } from "./switch-profile-context-menu";
 
@@ -17,51 +14,19 @@ export function SwitchProfileButton() {
   // Null on the home page; `useSwitchLlmProfileAndLog` is fine with that
   // because /api/profiles/<name>/activate is a global endpoint.
   const { conversationId } = useOptionalConversationId();
-  const { data } = useLlmProfiles();
-  const { data: conversation } = useActiveConversation();
-  const { data: settings } = useSettings();
+  const { profiles, activeProfileName, isAcpContext } =
+    useProfileRuntimePlans();
   const { switchAndLog, isPending } = useSwitchLlmProfileAndLog();
-  // Optimistic value written by recordSwitch on a successful switch — gives
-  // instant in-conversation feedback before the conversation refetch lands
-  // with the new `llm_model`.
-  const optimisticActiveProfile = useModelStore((s) =>
-    conversationId ? s.activeProfileByConversation[conversationId] : undefined,
-  );
-
-  const profiles = data?.profiles ?? [];
-  const conversationModel = conversation?.llm_model ?? null;
-  // ACPAgent conversations route prompts to a CLI subprocess whose model is
-  // controlled by ``acp_model`` (set in Settings → Agent), not by the LLM
-  // profile picker. Surfacing the switcher here would let the user "change
-  // the model" while the running subprocess silently keeps its own — a
-  // confusing no-op. Hide the button even when ``llm_model`` carries an ACP
-  // display model for chips/headers.
-  //
-  // On the home screen ``conversation`` is undefined; fall back to
-  // ``settings.agent_settings.agent_kind`` so the picker also hides when
-  // ACP is the *default* the next-created conversation would inherit.
-  // Otherwise an ACP user lands on a home page with an LLM-switch
-  // control that contradicts the ACP nav gating everywhere else.
-  const isAcpActive =
-    conversation?.agent_kind === "acp" ||
-    (!conversation && settings?.agent_settings?.agent_kind === "acp");
 
-  // Resolution priority for the active profile name:
-  //   1. Optimistic (just-clicked) — instant feedback before the refetch.
-  //   2. Profile whose model matches the running llm_model — cold loads.
-  //   3. User-level active_profile — home page / before the conversation has
-  //      sent any messages.
-  const activeProfileName =
-    optimisticActiveProfile ??
-    (conversationModel
-      ? (profiles.find((p) => p.model === conversationModel)?.name ?? null)
-      : (data?.active_profile ?? null));
   const activeProfileModel =
-    profiles.find((p) => p.name === activeProfileName)?.model ??
-    conversationModel ??
+    profiles.find((p) => p.profile.name === activeProfileName)?.profile.model ??
     null;
 
-  if (profiles.length === 0 || isAcpActive) {
+  // This control is the OpenHands surface. ACP conversations route the model
+  // through the ACP picker (`ChatInputModel`), which surfaces these same saved
+  // profiles disabled with "Requires a new conversation" — so there is no
+  // silent partial application even though this button is hidden there.
+  if (profiles.length === 0 || isAcpContext) {
     return null;
   }
 
@@ -71,8 +36,12 @@ export function SwitchProfileButton() {
     setContextMenuOpen((open) => !open);
   };
 
+  // Only `switch-live` plans act. `current` is a no-op and `disabled` rows are
+  // non-interactive in the menu — the partial-application guard lives both
+  // here and in the menu.
   const handleSelect = (profileName: string) => {
-    if (profileName === activeProfileName) return;
+    const target = profiles.find((p) => p.profile.name === profileName);
+    if (target?.plan.action !== "switch-live") return;
     switchAndLog(conversationId, profileName);
   };
 
@@ -100,7 +69,6 @@ export function SwitchProfileButton() {
       {contextMenuOpen && (
         <SwitchProfileContextMenu
           profiles={profiles}
-          activeProfileName={activeProfileName}
           onSelect={handleSelect}
           onClose={() => setContextMenuOpen(false)}
         />
diff --git a/src/components/features/chat/switch-profile-context-menu.tsx b/src/components/features/chat/switch-profile-context-menu.tsx
index 0b67c8455..e92b71846 100644
--- a/src/components/features/chat/switch-profile-context-menu.tsx
+++ b/src/components/features/chat/switch-profile-context-menu.tsx
@@ -11,28 +11,23 @@ import CircuitIcon from "#/icons/u-circuit.svg?react";
 import SettingsIcon from "#/icons/settings.svg?react";
 import CheckIcon from "#/icons/checkmark.svg?react";
 import { cn } from "#/utils/utils";
-import type { ProfileInfo } from "#/api/profiles-service/profiles-service.api";
+import type { ProfileWithPlan } from "#/hooks/use-profile-runtime-plans";
+import { reasonToI18nKey } from "#/utils/agent-profiles/reason-labels";
 
-const rowBaseClassName = cn(
-  "w-full flex flex-col gap-0.5 p-2 rounded",
-  "text-start hover:bg-[var(--oh-interactive-hover)] cursor-pointer text-nowrap",
-);
-const profileRowClassName = cn(rowBaseClassName, "h-auto");
+const profileRowClassName = cn("w-full flex flex-col gap-0.5 p-2 h-auto");
 const linkRowClassName = cn(
   "w-full flex items-center gap-2 p-2 rounded",
   "text-start hover:bg-[var(--oh-interactive-hover)] cursor-pointer text-nowrap",
 );
 
 interface SwitchProfileContextMenuProps {
-  profiles: ProfileInfo[];
-  activeProfileName: string | null;
+  profiles: ProfileWithPlan[];
   onSelect: (profileName: string) => void;
   onClose: () => void;
 }
 
 export function SwitchProfileContextMenu({
   profiles,
-  activeProfileName,
   onSelect,
   onClose,
 }: SwitchProfileContextMenuProps) {
@@ -47,16 +42,6 @@ export function SwitchProfileContextMenu({
     return () => document.removeEventListener("keydown", onKey);
   }, [onClose]);
 
-  const handleSelect = (
-    event: React.MouseEvent<HTMLButtonElement>,
-    name: string,
-  ) => {
-    event.preventDefault();
-    event.stopPropagation();
-    onSelect(name);
-    onClose();
-  };
-
   return (
     <ContextMenu
       ref={ref}
@@ -70,21 +55,41 @@ export function SwitchProfileContextMenu({
           {t(I18nKey.SETTINGS$AVAILABLE_PROFILES)}
         </Typography.Text>
       </div>
-      {profiles.map((profile) => {
-        const isActive = profile.name === activeProfileName;
+      {profiles.map(({ profile, plan }) => {
+        const isCurrent = plan.action === "current";
+        const isDisabled = plan.action === "disabled";
+        const reasonLabel =
+          plan.action === "disabled" ? t(reasonToI18nKey(plan.reason)) : null;
+
+        // Block partial application: a disabled row never fires (the button is
+        // disabled), a `current` row is a no-op close, and only `switch-live`
+        // reaches `onSelect`.
+        const handleClick = (event: React.MouseEvent<HTMLButtonElement>) => {
+          event.preventDefault();
+          event.stopPropagation();
+          if (isCurrent) {
+            onClose();
+            return;
+          }
+          onSelect(profile.name);
+          onClose();
+        };
+
         return (
           <ContextMenuListItem
             key={profile.name}
             testId={`switch-profile-option-${profile.name}`}
-            onClick={(event) => handleSelect(event, profile.name)}
+            isDisabled={isDisabled}
+            onClick={handleClick}
             className={cn(
               profileRowClassName,
-              isActive && "bg-[var(--oh-interactive-hover)]",
+              isCurrent && "bg-[var(--oh-interactive-hover)]",
             )}
           >
             <span
               className="flex items-center gap-2 min-w-0"
-              title={profile.model ?? undefined}
+              // The reason is shown inline; mirror it on the title for a tooltip.
+              title={reasonLabel ?? profile.model ?? undefined}
             >
               <CircuitIcon
                 width={16}
@@ -95,7 +100,7 @@ export function SwitchProfileContextMenu({
               <span className="flex-1 truncate text-sm leading-5">
                 {profile.name}
               </span>
-              {isActive && (
+              {isCurrent && (
                 <CheckIcon
                   width={14}
                   height={14}
@@ -104,10 +109,19 @@ export function SwitchProfileContextMenu({
                 />
               )}
             </span>
-            {profile.model && (
-              <span className="block truncate text-xs leading-4 text-[var(--oh-muted)] pl-6">
-                {profile.model}
+            {reasonLabel ? (
+              <span
+                className="block truncate text-xs leading-4 text-[var(--oh-text-dim)] pl-6"
+                data-testid={`switch-profile-reason-${profile.name}`}
+              >
+                {reasonLabel}
               </span>
+            ) : (
+              profile.model && (
+                <span className="block truncate text-xs leading-4 text-[var(--oh-muted)] pl-6">
+                  {profile.model}
+                </span>
+              )
             )}
           </ContextMenuListItem>
         );
diff --git a/src/hooks/use-profile-runtime-plans.ts b/src/hooks/use-profile-runtime-plans.ts
new file mode 100644
index 000000000..6980b0328
--- /dev/null
+++ b/src/hooks/use-profile-runtime-plans.ts
@@ -0,0 +1,153 @@
+import { useMemo } from "react";
+import { useActiveBackend } from "#/contexts/active-backend-context";
+import { useActiveConversation } from "#/hooks/query/use-active-conversation";
+import { useLlmProfiles } from "#/hooks/query/use-llm-profiles";
+import { useSettings } from "#/hooks/query/use-settings";
+import { useOptionalConversationId } from "#/hooks/use-conversation-id";
+import { useModelStore } from "#/stores/model-store";
+import { getAcpProvider } from "#/constants/acp-providers";
+import type { ProfileInfo } from "#/api/profiles-service/profiles-service.api";
+import {
+  deriveProfileRuntimePlan,
+  normalizeLlmProfile,
+  type ConversationRuntimeContext,
+  type ProfileRuntimePlan,
+} from "#/utils/agent-profiles/runtime-plan";
+
+export interface ProfileWithPlan {
+  profile: ProfileInfo;
+  plan: ProfileRuntimePlan;
+}
+
+export interface ProfileRuntimePlans {
+  /** Saved AgentProfiles paired with their runtime-compatibility verdict. */
+  profiles: ProfileWithPlan[];
+  /** Name of the profile currently driving the conversation, if known. */
+  activeProfileName: string | null;
+  /** True when the conversation/home context runs an ACP agent. */
+  isAcpContext: boolean;
+}
+
+/**
+ * Resolve the active profile name the same way the chip label does:
+ *   1. Optimistic (just-clicked) value — instant feedback before the refetch.
+ *   2. Profile whose model matches the running ``llm_model`` — cold loads.
+ *   3. The user-level ``active_profile`` — home page / before any messages.
+ */
+function resolveActiveProfileName(
+  profiles: ProfileInfo[],
+  conversationModel: string | null,
+  userActiveProfile: string | null,
+  optimistic: string | undefined,
+): string | null {
+  if (optimistic) return optimistic;
+  if (conversationModel) {
+    return profiles.find((p) => p.model === conversationModel)?.name ?? null;
+  }
+  return userActiveProfile;
+}
+
+/**
+ * Pairs each saved AgentProfile with a {@link ProfileRuntimePlan} for the
+ * conversation as it is actually running (agent-canvas#669). Surfaces consume
+ * this so the in-conversation picker can switch compatible profiles live and
+ * show incompatible ones disabled with a reason — never applying a profile
+ * partially.
+ *
+ * Today profiles persist as LLM-only OpenHands profiles, so the practical
+ * verdicts are: in an OpenHands conversation every profile is ``current`` or a
+ * live ``switch-live`` LLM swap; in an ACP conversation they are ``disabled``
+ * (``different-agent-kind`` → "Requires a new conversation"). The ACP→ACP
+ * branch of the matrix activates once the backend persists ACP profiles.
+ */
+export function useProfileRuntimePlans(): ProfileRuntimePlans {
+  const { backend } = useActiveBackend();
+  // Profiles are a local-backend concept; don't fire /api/profiles on cloud.
+  const { data: profilesData } = useLlmProfiles({
+    enabled: backend.kind !== "cloud",
+  });
+  const { data: conversation } = useActiveConversation();
+  const { data: settings } = useSettings();
+  const { conversationId } = useOptionalConversationId();
+  const optimisticActiveProfile = useModelStore((s) =>
+    conversationId ? s.activeProfileByConversation[conversationId] : undefined,
+  );
+
+  const profiles = useMemo(
+    () => profilesData?.profiles ?? [],
+    [profilesData?.profiles],
+  );
+  const conversationModel = conversation?.llm_model ?? null;
+
+  const isAcpContext =
+    conversation?.agent_kind === "acp" ||
+    (!conversation && settings?.agent_settings?.agent_kind === "acp");
+
+  const activeProfileName = resolveActiveProfileName(
+    profiles,
+    conversationModel,
+    profilesData?.active_profile ?? null,
+    optimisticActiveProfile,
+  );
+
+  const context = useMemo<ConversationRuntimeContext>(() => {
+    if (isAcpContext) {
+      const acpServer = conversation?.acp_server
+        ? conversation.acp_server
+        : typeof settings?.agent_settings?.acp_server === "string"
+          ? settings.agent_settings.acp_server
+          : null;
+      const provider = getAcpProvider(acpServer);
+      return {
+        kind: "acp",
+        acpServer,
+        acpModel: conversationModel,
+        // Built-in providers expose a model picker → a runtime model switch.
+        providerSupportsRuntimeSwitch:
+          backend.kind !== "cloud" &&
+          (provider?.available_models?.length ?? 0) > 0,
+        // The ACP wrapper rejects a runtime switch before the first message
+        // (no session yet); treat an active conversation as initialized.
+        sessionInitialized: Boolean(conversationId),
+      };
+    }
+    return {
+      kind: "openhands",
+      // baseUrl is left null: AppConversation doesn't surface the running
+      // conversation's base_url, and the active profile is identified by name
+      // (isActive) rather than by base_url equality, so this never produces a
+      // spurious disable.
+      llm: {
+        model: conversationModel ?? settings?.llm_model ?? null,
+        baseUrl: null,
+      },
+    };
+  }, [
+    isAcpContext,
+    conversation?.acp_server,
+    conversationModel,
+    settings?.agent_settings?.acp_server,
+    settings?.llm_model,
+    backend.kind,
+    conversationId,
+  ]);
+
+  const withPlans = useMemo<ProfileWithPlan[]>(
+    () =>
+      profiles.map((profile) => ({
+        profile,
+        plan: deriveProfileRuntimePlan({
+          profile: normalizeLlmProfile(profile),
+          context,
+          // Saved profiles are OpenHands (LLM) profiles. In an ACP context the
+          // running agent is *not* any of them — `active_profile` is just the
+          // default LLM profile, not what this ACP conversation runs — so none
+          // is "current"; they must all show disabled with a reason.
+          isActive: !isAcpContext && profile.name === activeProfileName,
+        }),
+      })),
+    [profiles, context, activeProfileName, isAcpContext],
+  );
+
+  return { profiles: withPlans, activeProfileName, isAcpContext };
+}
diff --git a/src/i18n/translation.json b/src/i18n/translation.json
index 53ad6c2ac..16e3f91ff 100644
--- a/src/i18n/translation.json
+++ b/src/i18n/translation.json
@@ -27930,6 +27930,108 @@
     "uk": "Доступні профілі",
     "ca": "Perfils disponibles"
   },
+  "PROFILE_PICKER$REASON_REQUIRES_NEW_CONVERSATION": {
+    "en": "Requires a new conversation",
+    "ja": "新しい会話が必要です",
+    "zh-CN": "需要新建对话",
+    "zh-TW": "需要新的對話",
+    "ko-KR": "새 대화가 필요합니다",
+    "no": "Krever en ny samtale",
+    "it": "Richiede una nuova conversazione",
+    "pt": "Requer uma nova conversa",
+    "es": "Requiere una nueva conversación",
+    "ar": "يتطلب محادثة جديدة",
+    "fr": "Nécessite une nouvelle conversation",
+    "tr": "Yeni bir sohbet gerektirir",
+    "de": "Erfordert eine neue Unterhaltung",
+    "uk": "Потрібна нова розмова",
+    "ca": "Requereix una nova conversa"
+  },
+  "PROFILE_PICKER$REASON_DIFFERENT_ACP_PROVIDER": {
+    "en": "Different agent provider",
+    "ja": "エージェントプロバイダーが異なります",
+    "zh-CN": "代理提供方不同",
+    "zh-TW": "代理提供者不同",
+    "ko-KR": "다른 에이전트 공급자",
+    "no": "Annen agentleverandør",
+    "it": "Provider dell'agente diverso",
+    "pt": "Provedor de agente diferente",
+    "es": "Proveedor de agente diferente",
+    "ar": "مزود وكيل مختلف",
+    "fr": "Fournisseur d'agent différent",
+    "tr": "Farklı aracı sağlayıcısı",
+    "de": "Anderer Agent-Anbieter",
+    "uk": "Інший постачальник агента",
+    "ca": "Proveïdor d'agent diferent"
+  },
+  "PROFILE_PICKER$REASON_DIFFERENT_ACP_COMMAND": {
+    "en": "Different agent command",
+    "ja": "エージェントコマンドが異なります",
+    "zh-CN": "代理命令不同",
+    "zh-TW": "代理指令不同",
+    "ko-KR": "다른 에이전트 명령",
+    "no": "Annen agentkommando",
+    "it": "Comando dell'agente diverso",
+    "pt": "Comando de agente diferente",
+    "es": "Comando de agente diferente",
+    "ar": "أمر وكيل مختلف",
+    "fr": "Commande d'agent différente",
+    "tr": "Farklı aracı komutu",
+    "de": "Anderer Agent-Befehl",
+    "uk": "Інша команда агента",
+    "ca": "Ordre d'agent diferent"
+  },
+  "PROFILE_PICKER$REASON_PROVIDER_NO_RUNTIME_SWITCH": {
+    "en": "Can't switch model live",
+    "ja": "モデルをライブで切り替えられません",
+    "zh-CN": "无法实时切换模型",
+    "zh-TW": "無法即時切換模型",
+    "ko-KR": "모델을 실시간으로 전환할 수 없습니다",
+    "no": "Kan ikke bytte modell live",
+    "it": "Impossibile cambiare modello in tempo reale",
+    "pt": "Não é possível trocar o modelo ao vivo",
+    "es": "No se puede cambiar el modelo en vivo",
+    "ar": "لا يمكن تبديل النموذج مباشرة",
+    "fr": "Impossible de changer de modèle en direct",
+    "tr": "Model canlı olarak değiştirilemez",
+    "de": "Modell kann nicht live gewechselt werden",
+    "uk": "Неможливо змінити модель наживо",
+    "ca": "No es pot canviar el model en directe"
+  },
+  "PROFILE_PICKER$REASON_SESSION_NOT_INITIALIZED": {
+    "en": "Send a message first",
+    "ja": "最初にメッセージを送信してください",
+    "zh-CN": "请先发送一条消息",
+    "zh-TW": "請先傳送一則訊息",
+    "ko-KR": "먼저 메시지를 보내세요",
+    "no": "Send en melding først",
+    "it": "Invia prima un messaggio",
+    "pt": "Envie uma mensagem primeiro",
+    "es": "Envía un mensaje primero",
+    "ar": "أرسل رسالة أولاً",
+    "fr": "Envoyez d'abord un message",
+    "tr": "Önce bir mesaj gönderin",
+    "de": "Senden Sie zuerst eine Nachricht",
+    "uk": "Спочатку надішліть повідомлення",
+    "ca": "Envia un missatge primer"
+  },
+  "PROFILE_PICKER$REASON_VERIFICATION_DIFFERS": {
+    "en": "Verification settings differ",
+    "ja": "検証設定が異なります",
+    "zh-CN": "验证设置不同",
+    "zh-TW": "驗證設定不同",
+    "ko-KR": "검증 설정이 다릅니다",
+    "no": "Verifiseringsinnstillingene er forskjellige",
+    "it": "Le impostazioni di verifica sono diverse",
+    "pt": "As configurações de verificação são diferentes",
+    "es": "La configuración de verificación es diferente",
+    "ar": "إعدادات التحقق مختلفة",
+    "fr": "Les paramètres de vérification diffèrent",
+    "tr": "Doğrulama ayarları farklı",
+    "de": "Verifizierungseinstellungen unterscheiden sich",
+    "uk": "Налаштування перевірки відрізняються",
+    "ca": "La configuració de verificació és diferent"
+  },
   "SETTINGS$EDIT_LLM_PROFILE": {
     "en": "Edit LLM Profile",
     "ja": "LLMプロファイルを編集",
diff --git a/src/utils/agent-profiles/reason-labels.ts b/src/utils/agent-profiles/reason-labels.ts
new file mode 100644
index 000000000..7a6de7a19
--- /dev/null
+++ b/src/utils/agent-profiles/reason-labels.ts
@@ -0,0 +1,36 @@
+import { I18nKey } from "#/i18n/declaration";
+import type { RuntimeIncompatibilityReason } from "./runtime-plan";
+
+/**
+ * Map a {@link RuntimeIncompatibilityReason} to the i18n key for the short
+ * label shown on a disabled profile row. Kept out of {@link runtime-plan.ts}
+ * so the core compatibility logic stays free of UI/i18n coupling and remains
+ * trivially unit-testable.
+ *
+ * "different-agent-kind" and "non-runtime-settings-differ" both collapse to
+ * the same user-facing message — from the picker's point of view the only
+ * remedy is the same ("start a new conversation"), and that phrasing matches
+ * the example reasons in the issue.
+ */
+export function reasonToI18nKey(reason: RuntimeIncompatibilityReason): I18nKey {
+  switch (reason) {
+    case "different-agent-kind":
+    case "non-runtime-settings-differ":
+      return I18nKey.PROFILE_PICKER$REASON_REQUIRES_NEW_CONVERSATION;
+    case "different-acp-provider":
+      return I18nKey.PROFILE_PICKER$REASON_DIFFERENT_ACP_PROVIDER;
+    case "different-acp-command":
+      return I18nKey.PROFILE_PICKER$REASON_DIFFERENT_ACP_COMMAND;
+    case "provider-does-not-support-runtime-switch":
+      return I18nKey.PROFILE_PICKER$REASON_PROVIDER_NO_RUNTIME_SWITCH;
+    case "session-not-initialized":
+      return I18nKey.PROFILE_PICKER$REASON_SESSION_NOT_INITIALIZED;
+    case "verification-not-runtime-switchable":
+      return I18nKey.PROFILE_PICKER$REASON_VERIFICATION_DIFFERS;
+    default: {
+      // Exhaustiveness guard: a new reason must add a label above.
+      const _exhaustive: never = reason;
+      return _exhaustive;
+    }
+  }
+}
diff --git a/src/utils/agent-profiles/runtime-plan.ts b/src/utils/agent-profiles/runtime-plan.ts
new file mode 100644
index 000000000..0060d2635
--- /dev/null
+++ b/src/utils/agent-profiles/runtime-plan.ts
@@ -0,0 +1,252 @@
+/**
+ * Runtime compatibility planning for AgentProfiles (agent-canvas#669).
+ *
+ * The in-conversation picker shows the user's saved AgentProfiles, but only
+ * profiles that are *runtime-compatible* with the conversation as it is
+ * actually running can be switched live. Everything else must be visible but
+ * disabled, with a concrete reason — never a silent partial application where
+ * we'd apply only the model and ignore condenser / tools / verification /
+ * provider / command differences.
+ *
+ * This module is the single source of truth for that decision. It is pure
+ * (no React, no network) so it can be unit-tested exhaustively and reused by
+ * any surface that needs the compatibility verdict.
+ *
+ * NB on scope: today profiles persist on the agent-server as LLM-only records
+ * ({@link normalizeLlmProfile} maps them to ``kind: "openhands"``), so the ACP
+ * and non-runtime-settings branches below only fire once the backend grows
+ * full AgentProfile persistence. They are implemented (and tested) now so that
+ * work plugs straight in without re-deriving the matrix. See the issue's
+ * "Runtime compatibility rules" section for the contract these encode.
+ */
+import type { ProfileInfo } from "#/api/profiles-service/profiles-service.api";
+
+export type RuntimeIncompatibilityReason =
+  | "different-agent-kind"
+  | "different-acp-provider"
+  | "different-acp-command"
+  | "provider-does-not-support-runtime-switch"
+  | "session-not-initialized"
+  | "non-runtime-settings-differ"
+  | "verification-not-runtime-switchable";
+
+export type ProfileRuntimePlan =
+  | { action: "current" }
+  | { action: "switch-live"; mutableFields: string[] }
+  | { action: "disabled"; reason: RuntimeIncompatibilityReason };
+
+/**
+ * Normalized, comparable view of an OpenHands profile's non-LLM settings.
+ * These are *launch-only*: they cannot be applied to a running conversation,
+ * so any difference greys out the profile. Values are opaque fingerprints —
+ * the caller decides how to derive them; equality is all this module needs.
+ */
+export interface OpenHandsNonRuntimeSettings {
+  /** Condenser configuration fingerprint (e.g. JSON string), or null/undefined when unset. */
+  condenser?: string | null;
+  /** MCP/tools configuration fingerprint. */
+  mcp?: string | null;
+  /** Tools configuration fingerprint. */
+  tools?: string | null;
+  /** Verification configuration fingerprint — special-cased to its own reason. */
+  verification?: string | null;
+  /** Confirmation mode toggle. */
+  confirmationMode?: boolean | null;
+  /** Security analyzer selection. */
+  securityAnalyzer?: string | null;
+  /** Launch-only iteration cap. */
+  maxIterations?: number | null;
+}
+
+export type AgentProfile =
+  | {
+      kind: "openhands";
+      name: string;
+      llm: { model: string | null; baseUrl: string | null };
+      nonRuntime?: OpenHandsNonRuntimeSettings;
+    }
+  | {
+      kind: "acp";
+      name: string;
+      acpServer: string;
+      acpModel?: string | null;
+      acpCommand?: string[];
+      acpArgs?: string[];
+      acpEnv?: Record<string, string>;
+    };
+
+/**
+ * The effective config a conversation is actually running with. Compatibility
+ * is compared against this, not against a profile name — profiles can be
+ * edited after a conversation starts (see the issue's
+ * ``ConversationProfileSnapshot``).
+ */
+export type ConversationRuntimeContext =
+  | {
+      kind: "openhands";
+      llm: { model: string | null; baseUrl: string | null };
+      nonRuntime?: OpenHandsNonRuntimeSettings;
+    }
+  | {
+      kind: "acp";
+      acpServer: string | null;
+      acpModel: string | null;
+      acpCommand?: string[];
+      acpArgs?: string[];
+      acpEnv?: Record<string, string>;
+      /** Provider exposes a runtime model switch (e.g. ACP ``session/set_model``). */
+      providerSupportsRuntimeSwitch: boolean;
+      /** The ACP session has been initialized and can accept a runtime switch. */
+      sessionInitialized: boolean;
+    };
+
+export interface DeriveProfileRuntimePlanInput {
+  profile: AgentProfile;
+  context: ConversationRuntimeContext;
+  /**
+   * The profile already driving the conversation. When true the plan is
+   * ``current`` regardless of field comparison — identity wins over a
+   * config-equality guess (two profiles can share a config).
+   */
+  isActive?: boolean;
+}
+
+function nullish<T>(value: T | null | undefined): T | null {
+  return value === undefined ? null : value;
+}
+
+function arraysEqual(
+  a: string[] | undefined,
+  b: string[] | undefined,
+): boolean {
+  const left = a ?? [];
+  const right = b ?? [];
+  if (left.length !== right.length) return false;
+  return left.every((value, index) => value === right[index]);
+}
+
+function envEqual(
+  a: Record<string, string> | undefined,
+  b: Record<string, string> | undefined,
+): boolean {
+  const left = a ?? {};
+  const right = b ?? {};
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  if (leftKeys.length !== rightKeys.length) return false;
+  return leftKeys.every((key) => left[key] === right[key]);
+}
+
+/**
+ * Compare the launch-only OpenHands settings. Returns the disabling reason
+ * when they differ (verification has its own reason so the UI can explain it
+ * precisely), or ``null`` when they match and a live LLM swap is allowed.
+ */
+function nonRuntimeIncompatibility(
+  profile: OpenHandsNonRuntimeSettings | undefined,
+  context: OpenHandsNonRuntimeSettings | undefined,
+): RuntimeIncompatibilityReason | null {
+  const a = profile ?? {};
+  const b = context ?? {};
+  if (nullish(a.verification) !== nullish(b.verification)) {
+    return "verification-not-runtime-switchable";
+  }
+  if (
+    nullish(a.condenser) !== nullish(b.condenser) ||
+    nullish(a.mcp) !== nullish(b.mcp) ||
+    nullish(a.tools) !== nullish(b.tools) ||
+    nullish(a.confirmationMode) !== nullish(b.confirmationMode) ||
+    nullish(a.securityAnalyzer) !== nullish(b.securityAnalyzer) ||
+    nullish(a.maxIterations) !== nullish(b.maxIterations)
+  ) {
+    return "non-runtime-settings-differ";
+  }
+  return null;
+}
+
+/**
+ * Derive whether a profile can be switched into the running conversation
+ * live, is already current, or must be disabled (with a reason).
+ *
+ * Rules (from agent-canvas#669):
+ * - Different agent kind (OpenHands vs ACP) is never a live switch.
+ * - OpenHands → OpenHands switches live only when the target differs solely
+ *   in live-switchable LLM config; any non-runtime difference disables it.
+ * - ACP → ACP switches live only when the provider, command/args/env and
+ *   credential/launch identity all match, the provider supports a runtime
+ *   model switch, the session is initialized, and only ``acp_model`` differs.
+ */
+export function deriveProfileRuntimePlan({
+  profile,
+  context,
+  isActive = false,
+}: DeriveProfileRuntimePlanInput): ProfileRuntimePlan {
+  if (isActive) {
+    return { action: "current" };
+  }
+
+  if (profile.kind !== context.kind) {
+    return { action: "disabled", reason: "different-agent-kind" };
+  }
+
+  if (profile.kind === "openhands" && context.kind === "openhands") {
+    const nonRuntimeReason = nonRuntimeIncompatibility(
+      profile.nonRuntime,
+      context.nonRuntime,
+    );
+    if (nonRuntimeReason) {
+      return { action: "disabled", reason: nonRuntimeReason };
+    }
+    const modelMatches = profile.llm.model === context.llm.model;
+    const baseUrlMatches =
+      nullish(profile.llm.baseUrl) === nullish(context.llm.baseUrl);
+    if (modelMatches && baseUrlMatches) {
+      return { action: "current" };
+    }
+    return { action: "switch-live", mutableFields: ["llm"] };
+  }
+
+  if (profile.kind === "acp" && context.kind === "acp") {
+    if (profile.acpServer !== context.acpServer) {
+      return { action: "disabled", reason: "different-acp-provider" };
+    }
+    if (
+      !arraysEqual(profile.acpCommand, context.acpCommand) ||
+      !arraysEqual(profile.acpArgs, context.acpArgs) ||
+      !envEqual(profile.acpEnv, context.acpEnv)
+    ) {
+      return { action: "disabled", reason: "different-acp-command" };
+    }
+    if (!context.providerSupportsRuntimeSwitch) {
+      return {
+        action: "disabled",
+        reason: "provider-does-not-support-runtime-switch",
+      };
+    }
+    if (!context.sessionInitialized) {
+      return { action: "disabled", reason: "session-not-initialized" };
+    }
+    if (nullish(profile.acpModel) === nullish(context.acpModel)) {
+      return { action: "current" };
+    }
+    return { action: "switch-live", mutableFields: ["acp_model"] };
+  }
+
+  // Unreachable given the kind guard above, but keeps the union exhaustive
+  // for the type checker without an unsafe cast.
+  return { action: "disabled", reason: "different-agent-kind" };
+}
+
+/**
+ * Map the agent-server's LLM-only ``ProfileInfo`` to the normalized
+ * AgentProfile this module compares. Existing saved profiles are OpenHands
+ * profiles by definition (the backend has no ACP profile concept yet), so
+ * they default to ``kind: "openhands"`` per the issue's migration direction.
+ */
+export function normalizeLlmProfile(profile: ProfileInfo): AgentProfile {
+  return {
+    kind: "openhands",
+    name: profile.name,
+    llm: { model: profile.model ?? null, baseUrl: profile.base_url ?? null },
+  };
+}

From 0103fa455e273b7f31580aae01a004743a8879b4 Mon Sep 17 00:00:00 2001
From: Debug Agent <debug@example.com>
Date: Fri, 29 May 2026 17:26:08 +0200
Subject: [PATCH 2/4] =?UTF-8?q?feat(chat):=20consume=20AgentProfile=20kind?=
 =?UTF-8?q?/acp=20fields=20=E2=80=94=20first-class=20ACP=20profiles?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Pin @openhands/typescript-client to the typescript-client#195 commit (git SHA)
so CI builds against the client that exposes the new profile fields, and wire
the picker to actually use them:

- normalizeLlmProfile maps `kind: "acp"` ProfileInfo → an ACP AgentProfile
  (provider + model from the list summary; command/args/env derive from the
  provider for built-ins, so the runtime-plan reduces to provider+model).
- useProfileRuntimePlans: kind-aware `isActive` (an OpenHands profile can no
  longer be mislabeled "current" in an ACP conversation, and an ACP profile
  matching the running provider+model now reads as current); the ACP context
  is always switchable (useSwitchAcpModel handles both the home-page default
  and the in-conversation live swap), so home-page ACP profiles aren't wrongly
  greyed "session not initialized".
- The ACP/cloud model menu now renders ALL profiles plan-driven: a
  same-provider model-only-diff ACP profile is switch-live (clickable → live
  acp_model swap), current is checked, incompatible ones stay disabled with
  the precise reason (different provider vs requires-new-conversation).

Validated end-to-end against a local agent-server built from
software-agent-sdk#3433: current / switch-live / "Different agent provider" /
"Requires a new conversation" all render from real profile data.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../chat-input-model-profiles.test.tsx        | 34 ++++++++++
 .../utils/agent-profiles/runtime-plan.test.ts | 19 ++++++
 package-lock.json                             |  8 +--
 package.json                                  |  2 +-
 .../chat/components/chat-input-model.tsx      | 62 +++++++++++++------
 src/hooks/use-profile-runtime-plans.ts        | 45 +++++++++-----
 src/utils/agent-profiles/runtime-plan.ts      | 14 +++++
 7 files changed, 144 insertions(+), 40 deletions(-)

diff --git a/__tests__/components/features/chat/components/chat-input-model-profiles.test.tsx b/__tests__/components/features/chat/components/chat-input-model-profiles.test.tsx
index 0fa410895..9e2f1b338 100644
--- a/__tests__/components/features/chat/components/chat-input-model-profiles.test.tsx
+++ b/__tests__/components/features/chat/components/chat-input-model-profiles.test.tsx
@@ -107,4 +107,38 @@ describe("ChatInputModelMenuContent disabled-profile section", () => {
       screen.getByTestId("chat-input-acp-model-option-claude-opus-4-7"),
     ).toBeInTheDocument();
   });
+
+  it("switches the ACP model live when a switch-live ACP profile is clicked", () => {
+    const switchLiveAcpProfile: ProfileWithPlan = {
+      profile: {
+        name: "Claude Sonnet daily",
+        kind: "acp",
+        model: "claude-sonnet-4-6",
+        base_url: null,
+        acp_server: "claude-code",
+        acp_model: "claude-sonnet-4-6",
+        api_key_set: true,
+      },
+      plan: { action: "switch-live", mutableFields: ["acp_model"] },
+    };
+    useProfileRuntimePlansMock.mockReturnValue({
+      profiles: [switchLiveAcpProfile],
+      activeProfileName: null,
+      isAcpContext: true,
+    });
+
+    renderWithProviders(
+      <ChatInputModelMenuContent model={acpModelState} onClose={() => {}} />,
+    );
+
+    const row = screen.getByTestId(
+      "chat-input-profile-option-Claude Sonnet daily",
+    );
+    expect(row).not.toBeDisabled();
+    row.click();
+    expect(switchAcpModelMutate).toHaveBeenCalledWith({
+      conversationId: "conv-1",
+      model: "claude-sonnet-4-6",
+    });
+  });
 });
diff --git a/__tests__/utils/agent-profiles/runtime-plan.test.ts b/__tests__/utils/agent-profiles/runtime-plan.test.ts
index db78752a8..5ce593b0b 100644
--- a/__tests__/utils/agent-profiles/runtime-plan.test.ts
+++ b/__tests__/utils/agent-profiles/runtime-plan.test.ts
@@ -263,4 +263,23 @@ describe("normalizeLlmProfile", () => {
       llm: { model: null, baseUrl: null },
     });
   });
+
+  it("maps a kind=acp ProfileInfo to an ACP AgentProfile (provider + model)", () => {
+    expect(
+      normalizeLlmProfile({
+        name: "Local Codex",
+        kind: "acp",
+        model: "gpt-5-codex",
+        base_url: null,
+        acp_server: "codex",
+        acp_model: "gpt-5-codex",
+        api_key_set: true,
+      }),
+    ).toEqual({
+      kind: "acp",
+      name: "Local Codex",
+      acpServer: "codex",
+      acpModel: "gpt-5-codex",
+    });
+  });
 });
diff --git a/package-lock.json b/package-lock.json
index cb89c9a88..b959f2181 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -13,7 +13,7 @@
         "@microlink/react-json-view": "1.31.20",
         "@monaco-editor/react": "4.7.0",
         "@openhands/extensions": "git+https://github.com/OpenHands/extensions.git#39711065f53166c52608462f60a4c8507253ce56",
-        "@openhands/typescript-client": "1.24.3",
+        "@openhands/typescript-client": "git+https://github.com/OpenHands/typescript-client.git#c86ce065e9d4016a49f5a54a0856de35656cece3",
         "@react-router/node": "7.14.2",
         "@react-router/serve": "7.14.2",
         "@tailwindcss/vite": "4.2.4",
@@ -3454,9 +3454,9 @@
       }
     },
     "node_modules/@openhands/typescript-client": {
-      "version": "1.24.3",
-      "resolved": "https://registry.npmjs.org/@openhands/typescript-client/-/typescript-client-1.24.3.tgz",
-      "integrity": "sha512-4w5rGbgXSnRKm6DZGedGRMWa4nIyl8/1+lEzinBIjZbdE0MD6+89EAItkk6FTvKU0jdVpoCAtmLWBP3Y/r8ORA==",
+      "version": "1.24.2",
+      "resolved": "git+ssh://git@github.com/OpenHands/typescript-client.git#c86ce065e9d4016a49f5a54a0856de35656cece3",
+      "integrity": "sha512-OIbepDSmuwqG/ak7Pm6mlcA4GDOhY2p6CN3fuyIxD3WirketlFdVqP+9KBfAQd4jD/OsA0PRCO9BbwGLJXk7jw==",
       "license": "MIT",
       "dependencies": {
         "@openrouter/sdk": "^0.12.35",
diff --git a/package.json b/package.json
index 5a97f1e39..c2a621bab 100644
--- a/package.json
+++ b/package.json
@@ -24,7 +24,7 @@
     "@microlink/react-json-view": "1.31.20",
     "@monaco-editor/react": "4.7.0",
     "@openhands/extensions": "git+https://github.com/OpenHands/extensions.git#39711065f53166c52608462f60a4c8507253ce56",
-    "@openhands/typescript-client": "1.24.3",
+    "@openhands/typescript-client": "git+https://github.com/OpenHands/typescript-client.git#c86ce065e9d4016a49f5a54a0856de35656cece3",
     "@react-router/node": "7.14.2",
     "@react-router/serve": "7.14.2",
     "@tailwindcss/vite": "4.2.4",
diff --git a/src/components/features/chat/components/chat-input-model.tsx b/src/components/features/chat/components/chat-input-model.tsx
index e5ecbe0f9..33cf88eed 100644
--- a/src/components/features/chat/components/chat-input-model.tsx
+++ b/src/components/features/chat/components/chat-input-model.tsx
@@ -55,15 +55,25 @@ export function ChatInputModelMenuContent({
   const switchAcpModel = useSwitchAcpModel();
   const { profiles } = useProfileRuntimePlans();
   const hasModelRows = model.showAcpPicker || Boolean(model.displayModel);
-  // Saved AgentProfiles that can't be switched into this conversation live
-  // (e.g. an OpenHands profile while an ACP agent is running). The issue
-  // requires these to be visible-but-disabled with a reason rather than
-  // hidden, so the user understands the profile exists but needs a new
-  // conversation. Cloud backends have no profiles, so this stays empty there.
-  const incompatibleProfiles = profiles.filter(
-    (entry) => entry.plan.action === "disabled",
-  );
-  const hasProfilesSection = incompatibleProfiles.length > 0;
+  // Saved AgentProfiles, shown plan-driven: a same-provider ACP profile whose
+  // only difference is the model is switchable live; current is checked;
+  // incompatible ones (different provider, or an OpenHands profile while ACP
+  // runs) stay visible-but-disabled with a reason. Cloud backends have no
+  // profiles, so this section stays empty there.
+  const hasProfilesSection = profiles.length > 0;
+
+  // Switching to a switch-live ACP profile is a live acp_model swap (same
+  // endpoint as picking a raw model). Only `switch-live` acts; `current` is a
+  // no-op and `disabled` rows are non-interactive.
+  const handleSelectProfile = (entry: (typeof profiles)[number]) => {
+    if (entry.plan.action === "switch-live" && entry.profile.acp_model) {
+      switchAcpModel.mutate({
+        conversationId: model.switchConversationId,
+        model: entry.profile.acp_model,
+      });
+    }
+    onClose();
+  };
 
   const handleSelectAcpModel = (modelId: string) => {
     if (modelId !== model.currentModelId) {
@@ -136,9 +146,10 @@ export function ChatInputModelMenuContent({
               {t(I18nKey.SETTINGS$AVAILABLE_PROFILES)}
             </Typography.Text>
           </li>
-          {incompatibleProfiles.map(({ profile, plan }) => {
-            // `plan.action` is "disabled" by construction of
-            // `incompatibleProfiles`; narrow it for `reason` access.
+          {profiles.map((entry) => {
+            const { profile, plan } = entry;
+            const isCurrent = plan.action === "current";
+            const isDisabled = plan.action === "disabled";
             const reasonLabel =
               plan.action === "disabled"
                 ? t(reasonToI18nKey(plan.reason))
@@ -147,15 +158,22 @@ export function ChatInputModelMenuContent({
               <ContextMenuListItem
                 key={profile.name}
                 testId={`chat-input-profile-option-${profile.name}`}
-                isDisabled
-                // Disabled rows never act; the empty handler keeps the shared
-                // button API satisfied without applying anything.
-                onClick={() => {}}
-                className="flex flex-col gap-0.5 h-auto"
+                isDisabled={isDisabled}
+                onClick={(event) => {
+                  event.preventDefault();
+                  event.stopPropagation();
+                  // Disabled rows are already non-interactive via isDisabled;
+                  // current is a no-op close; only switch-live acts.
+                  handleSelectProfile(entry);
+                }}
+                className={cn(
+                  "flex flex-col gap-0.5 h-auto",
+                  isCurrent && "bg-[var(--oh-interactive-hover)]",
+                )}
               >
                 <span
                   className="flex items-center gap-2 min-w-0"
-                  title={reasonLabel ?? undefined}
+                  title={reasonLabel ?? profile.model ?? undefined}
                 >
                   <CircuitIcon
                     width={16}
@@ -166,6 +184,14 @@ export function ChatInputModelMenuContent({
                   <span className="flex-1 truncate text-sm leading-5">
                     {profile.name}
                   </span>
+                  {isCurrent && (
+                    <CheckIcon
+                      width={14}
+                      height={14}
+                      className="shrink-0"
+                      aria-hidden
+                    />
+                  )}
                 </span>
                 {reasonLabel && (
                   <span
diff --git a/src/hooks/use-profile-runtime-plans.ts b/src/hooks/use-profile-runtime-plans.ts
index 6980b0328..6cbb00023 100644
--- a/src/hooks/use-profile-runtime-plans.ts
+++ b/src/hooks/use-profile-runtime-plans.ts
@@ -106,9 +106,14 @@ export function useProfileRuntimePlans(): ProfileRuntimePlans {
         providerSupportsRuntimeSwitch:
           backend.kind !== "cloud" &&
           (provider?.available_models?.length ?? 0) > 0,
-        // The ACP wrapper rejects a runtime switch before the first message
-        // (no session yet); treat an active conversation as initialized.
-        sessionInitialized: Boolean(conversationId),
+        // `useSwitchAcpModel` handles both selection paths: on the home page it
+        // persists the choice as the agent-settings default (always valid), and
+        // inside a conversation it does a live `session/set_model` (surfacing
+        // the pre-first-message 409 as a toast). Neither path needs us to
+        // pre-disable here, so the picker treats the context as switchable; the
+        // `session-not-initialized` reason stays reserved for when the backend
+        // exposes that state explicitly.
+        sessionInitialized: true,
       };
     }
     return {
@@ -129,24 +134,30 @@ export function useProfileRuntimePlans(): ProfileRuntimePlans {
     settings?.agent_settings?.acp_server,
     settings?.llm_model,
     backend.kind,
-    conversationId,
   ]);
 
   const withPlans = useMemo<ProfileWithPlan[]>(
     () =>
-      profiles.map((profile) => ({
-        profile,
-        plan: deriveProfileRuntimePlan({
-          profile: normalizeLlmProfile(profile),
-          context,
-          // Saved profiles are OpenHands (LLM) profiles. In an ACP context the
-          // running agent is *not* any of them — `active_profile` is just the
-          // default LLM profile, not what this ACP conversation runs — so none
-          // is "current"; they must all show disabled with a reason.
-          isActive: !isAcpContext && profile.name === activeProfileName,
-        }),
-      })),
-    [profiles, context, activeProfileName, isAcpContext],
+      profiles.map((profile) => {
+        const normalized = normalizeLlmProfile(profile);
+        return {
+          profile,
+          plan: deriveProfileRuntimePlan({
+            profile: normalized,
+            context,
+            // Mark "current" only when the profile's kind matches the running
+            // context AND it's the active profile. The kind guard prevents a
+            // same-named cross-kind profile (e.g. an OpenHands profile in an
+            // ACP conversation) from being mislabeled current; within-kind
+            // config equality in deriveProfileRuntimePlan also resolves
+            // "current" on cold loads where active_profile isn't known.
+            isActive:
+              normalized.kind === context.kind &&
+              profile.name === activeProfileName,
+          }),
+        };
+      }),
+    [profiles, context, activeProfileName],
   );
 
   return { profiles: withPlans, activeProfileName, isAcpContext };
diff --git a/src/utils/agent-profiles/runtime-plan.ts b/src/utils/agent-profiles/runtime-plan.ts
index 0060d2635..350266f4c 100644
--- a/src/utils/agent-profiles/runtime-plan.ts
+++ b/src/utils/agent-profiles/runtime-plan.ts
@@ -244,6 +244,20 @@ export function deriveProfileRuntimePlan({
  * they default to ``kind: "openhands"`` per the issue's migration direction.
  */
 export function normalizeLlmProfile(profile: ProfileInfo): AgentProfile {
+  if (profile.kind === "acp") {
+    // The list summary only carries the launch *identity* we can compare
+    // against a running ACP conversation: provider + model. command/args/env
+    // aren't in the summary (they live in the full profile config), and for
+    // built-in providers they're derived from acp_server anyway — so leaving
+    // them undefined makes the runtime-plan comparison reduce to
+    // provider + model, which is the correct switch-live test for ACP.
+    return {
+      kind: "acp",
+      name: profile.name,
+      acpServer: profile.acp_server ?? "",
+      acpModel: profile.acp_model ?? null,
+    };
+  }
   return {
     kind: "openhands",
     name: profile.name,

From 33b8bf6154e3402cdada289c7bd4decd09e0491d Mon Sep 17 00:00:00 2001
From: Debug Agent <debug@example.com>
Date: Fri, 29 May 2026 18:20:38 +0200
Subject: [PATCH 3/4] fix(chat): new-conversation profile picker must not grey
 out by runtime compat
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

On /conversations (the new-conversation / home surface) there is no running
agent to be incompatible with, yet the picker applied the in-conversation
live-switch compatibility matrix — so ACP profiles showed disabled with
"Requires a new conversation" and couldn't be chosen to launch a conversation.

- useProfileRuntimePlans: expose `inConversation`; when it's false, every
  profile is selectable (active one is `current`) and the grey-out matrix is
  skipped. Compat gating now applies only inside an existing conversation.
- chat-input-model picker: selecting a profile on the home surface (no
  switchConversationId) activates the whole profile kind-aware (/activate) so
  picking an OpenHands profile flips the default away from ACP — rather than
  only swapping acp_model. In-conversation ACP selection still does the live
  session/set_model swap.

Tests: home selection activates (not model-swap); existing in-conversation
switch-live / disabled behavior unchanged. Allowlist the temporary
typescript-client git pin in the package-library guard.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../chat-input-model-profiles.test.tsx        | 42 +++++++++++++++
 __tests__/package-library.test.ts             |  9 +++-
 .../chat/components/chat-input-model.tsx      | 27 +++++++---
 src/hooks/use-profile-runtime-plans.ts        | 51 +++++++++++++++----
 4 files changed, 110 insertions(+), 19 deletions(-)

diff --git a/__tests__/components/features/chat/components/chat-input-model-profiles.test.tsx b/__tests__/components/features/chat/components/chat-input-model-profiles.test.tsx
index 9e2f1b338..aa473d2fd 100644
--- a/__tests__/components/features/chat/components/chat-input-model-profiles.test.tsx
+++ b/__tests__/components/features/chat/components/chat-input-model-profiles.test.tsx
@@ -6,6 +6,7 @@ import type { ProfileWithPlan } from "#/hooks/use-profile-runtime-plans";
 
 const useProfileRuntimePlansMock = vi.fn();
 const switchAcpModelMutate = vi.fn();
+const switchAndLog = vi.fn();
 
 vi.mock("#/hooks/use-profile-runtime-plans", () => ({
   useProfileRuntimePlans: () => useProfileRuntimePlansMock(),
@@ -15,6 +16,10 @@ vi.mock("#/hooks/mutation/use-switch-acp-model", () => ({
   useSwitchAcpModel: () => ({ mutate: switchAcpModelMutate }),
 }));
 
+vi.mock("#/hooks/mutation/use-switch-llm-profile-and-log", () => ({
+  useSwitchLlmProfileAndLog: () => ({ switchAndLog, isPending: false }),
+}));
+
 import { ChatInputModelMenuContent } from "#/components/features/chat/components/chat-input-model";
 
 const acpModelState: ChatInputModelState = {
@@ -42,6 +47,7 @@ describe("ChatInputModelMenuContent disabled-profile section", () => {
   beforeEach(() => {
     useProfileRuntimePlansMock.mockReset();
     switchAcpModelMutate.mockReset();
+    switchAndLog.mockReset();
   });
 
   it("shows incompatible profiles visible-but-disabled with a reason in an ACP conversation", () => {
@@ -141,4 +147,40 @@ describe("ChatInputModelMenuContent disabled-profile section", () => {
       model: "claude-sonnet-4-6",
     });
   });
+
+  it("activates the whole profile (not a model swap) when selected on the home surface", () => {
+    // Home / new-conversation: no active ACP conversation, so the model state
+    // carries no switchConversationId. Selecting a profile must activate it
+    // (kind-aware) rather than only swapping acp_model.
+    const homeModelState: ChatInputModelState = {
+      ...acpModelState,
+      switchConversationId: null,
+    };
+    const selectableProfile: ProfileWithPlan = {
+      profile: {
+        name: "Local Codex",
+        kind: "acp",
+        model: "gpt-5-codex",
+        base_url: null,
+        acp_server: "codex",
+        acp_model: "gpt-5-codex",
+        api_key_set: true,
+      },
+      plan: { action: "switch-live", mutableFields: [] },
+    };
+    useProfileRuntimePlansMock.mockReturnValue({
+      profiles: [selectableProfile],
+      activeProfileName: null,
+      isAcpContext: true,
+      inConversation: false,
+    });
+
+    renderWithProviders(
+      <ChatInputModelMenuContent model={homeModelState} onClose={() => {}} />,
+    );
+
+    screen.getByTestId("chat-input-profile-option-Local Codex").click();
+    expect(switchAndLog).toHaveBeenCalledWith(null, "Local Codex");
+    expect(switchAcpModelMutate).not.toHaveBeenCalled();
+  });
 });
diff --git a/__tests__/package-library.test.ts b/__tests__/package-library.test.ts
index c006aa145..17db7ec33 100644
--- a/__tests__/package-library.test.ts
+++ b/__tests__/package-library.test.ts
@@ -55,9 +55,16 @@ describe("package library metadata", () => {
   // runs the prepare script without devDependencies. All packages should be
   // referenced from a registry; only @openhands/extensions is allowed as a git
   // dep until it is published to npm.
+  //
+  // @openhands/typescript-client is a TEMPORARY git pin to the AgentProfile
+  // client commit (typescript-client#195) so CI builds against the new profile
+  // types before that PR publishes. Revert to a semver range once #195 ships.
   it("does not use git dependencies (except @openhands/extensions)", () => {
     const GIT_DEP_PATTERN = /^(git[+:]|github:|bitbucket:|gitlab:|[a-zA-Z0-9_-]+\/)/;
-    const ALLOWED_GIT_DEPS = new Set(["@openhands/extensions"]);
+    const ALLOWED_GIT_DEPS = new Set([
+      "@openhands/extensions",
+      "@openhands/typescript-client",
+    ]);
 
     const allDeps = {
       ...packageJson.dependencies,
diff --git a/src/components/features/chat/components/chat-input-model.tsx b/src/components/features/chat/components/chat-input-model.tsx
index 33cf88eed..54310812c 100644
--- a/src/components/features/chat/components/chat-input-model.tsx
+++ b/src/components/features/chat/components/chat-input-model.tsx
@@ -4,6 +4,7 @@ import {
   type ChatInputModelState,
 } from "#/hooks/use-chat-input-model-state";
 import { useSwitchAcpModel } from "#/hooks/mutation/use-switch-acp-model";
+import { useSwitchLlmProfileAndLog } from "#/hooks/mutation/use-switch-llm-profile-and-log";
 import { useProfileRuntimePlans } from "#/hooks/use-profile-runtime-plans";
 import { reasonToI18nKey } from "#/utils/agent-profiles/reason-labels";
 import { ComboboxCaretInline } from "#/ui/combobox-caret";
@@ -53,6 +54,7 @@ export function ChatInputModelMenuContent({
 }: ChatInputModelMenuContentProps) {
   const { t } = useTranslation("openhands");
   const switchAcpModel = useSwitchAcpModel();
+  const { switchAndLog } = useSwitchLlmProfileAndLog();
   const { profiles } = useProfileRuntimePlans();
   const hasModelRows = model.showAcpPicker || Boolean(model.displayModel);
   // Saved AgentProfiles, shown plan-driven: a same-provider ACP profile whose
@@ -62,15 +64,24 @@ export function ChatInputModelMenuContent({
   // profiles, so this section stays empty there.
   const hasProfilesSection = profiles.length > 0;
 
-  // Switching to a switch-live ACP profile is a live acp_model swap (same
-  // endpoint as picking a raw model). Only `switch-live` acts; `current` is a
-  // no-op and `disabled` rows are non-interactive.
+  // Selecting a profile: only `switch-live` acts (`current` is a no-op,
+  // `disabled` rows are non-interactive). Inside an ACP conversation
+  // (`switchConversationId` set) it's a live `acp_model` swap; on the
+  // new-conversation / home surface it activates the whole profile
+  // (kind-aware /activate) so picking, say, an OpenHands profile here flips
+  // the default away from ACP rather than just changing a model string.
   const handleSelectProfile = (entry: (typeof profiles)[number]) => {
-    if (entry.plan.action === "switch-live" && entry.profile.acp_model) {
-      switchAcpModel.mutate({
-        conversationId: model.switchConversationId,
-        model: entry.profile.acp_model,
-      });
+    if (entry.plan.action === "switch-live") {
+      if (model.switchConversationId) {
+        if (entry.profile.acp_model) {
+          switchAcpModel.mutate({
+            conversationId: model.switchConversationId,
+            model: entry.profile.acp_model,
+          });
+        }
+      } else {
+        switchAndLog(null, entry.profile.name);
+      }
     }
     onClose();
   };
diff --git a/src/hooks/use-profile-runtime-plans.ts b/src/hooks/use-profile-runtime-plans.ts
index 6cbb00023..aa5e0b9a4 100644
--- a/src/hooks/use-profile-runtime-plans.ts
+++ b/src/hooks/use-profile-runtime-plans.ts
@@ -26,6 +26,13 @@ export interface ProfileRuntimePlans {
   activeProfileName: string | null;
   /** True when the conversation/home context runs an ACP agent. */
   isAcpContext: boolean;
+  /**
+   * True only inside an existing conversation. On the new-conversation / home
+   * surface this is false — there's no running agent to be incompatible with,
+   * so selecting a profile *launches/activates* it (any kind) rather than
+   * live-switching, and the runtime-compatibility grey-out does not apply.
+   */
+  inConversation: boolean;
 }
 
 /**
@@ -54,11 +61,14 @@ function resolveActiveProfileName(
  * show incompatible ones disabled with a reason — never applying a profile
  * partially.
  *
- * Today profiles persist as LLM-only OpenHands profiles, so the practical
- * verdicts are: in an OpenHands conversation every profile is ``current`` or a
- * live ``switch-live`` LLM swap; in an ACP conversation they are ``disabled``
- * (``different-agent-kind`` → "Requires a new conversation"). The ACP→ACP
- * branch of the matrix activates once the backend persists ACP profiles.
+ * On the new-conversation / home surface ({@link ProfileRuntimePlans.inConversation}
+ * is false) there is no running agent to be incompatible with, so every profile
+ * is selectable (the active one is ``current``) and selecting it activates the
+ * whole profile, kind-aware. Inside a conversation the full compatibility matrix
+ * applies: an incompatible profile is ``disabled`` with a reason (e.g. an
+ * OpenHands profile in an ACP conversation → "Requires a new conversation",
+ * a different ACP provider → "Different agent provider"), and only a
+ * same-identity model-only difference is a live ``switch-live``.
  */
 export function useProfileRuntimePlans(): ProfileRuntimePlans {
   const { backend } = useActiveBackend();
@@ -136,10 +146,28 @@ export function useProfileRuntimePlans(): ProfileRuntimePlans {
     backend.kind,
   ]);
 
+  const inConversation = Boolean(conversationId);
+
   const withPlans = useMemo<ProfileWithPlan[]>(
     () =>
       profiles.map((profile) => {
         const normalized = normalizeLlmProfile(profile);
+        const isActive =
+          normalized.kind === context.kind &&
+          profile.name === activeProfileName;
+        // New-conversation / home surface: no running agent to be incompatible
+        // with. Selecting a profile activates it (kind-aware), so every profile
+        // is selectable; only the active/default one is marked current. The
+        // runtime-compatibility grey-out is reserved for live in-conversation
+        // switches below.
+        if (!inConversation) {
+          return {
+            profile,
+            plan: isActive
+              ? { action: "current" }
+              : { action: "switch-live", mutableFields: [] },
+          };
+        }
         return {
           profile,
           plan: deriveProfileRuntimePlan({
@@ -151,14 +179,17 @@ export function useProfileRuntimePlans(): ProfileRuntimePlans {
             // ACP conversation) from being mislabeled current; within-kind
             // config equality in deriveProfileRuntimePlan also resolves
             // "current" on cold loads where active_profile isn't known.
-            isActive:
-              normalized.kind === context.kind &&
-              profile.name === activeProfileName,
+            isActive,
           }),
         };
       }),
-    [profiles, context, activeProfileName],
+    [profiles, context, activeProfileName, inConversation],
   );
 
-  return { profiles: withPlans, activeProfileName, isAcpContext };
+  return {
+    profiles: withPlans,
+    activeProfileName,
+    isAcpContext,
+    inConversation,
+  };
 }

From 0922c82b0ae861caaaeb69871b0c1baf628518eb Mon Sep 17 00:00:00 2001
From: Debug Agent <debug@example.com>
Date: Fri, 29 May 2026 19:01:32 +0200
Subject: [PATCH 4/4] =?UTF-8?q?feat(settings):=20unify=20Settings=20?=
 =?UTF-8?q?=E2=86=92=20Agent=20as=20the=20AgentProfile=20editor=20(#669)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Settings → Agent is now the single surface for building an AgentProfile, and
the standalone LLM page is folded into it.

- The Agent page lists profiles and creates/edits them with a kind toggle:
  OpenHands shows the LLM config form; ACP shows a new AcpProfileForm
  (provider / command / model / env). Save persists the profile kind-aware
  via /api/profiles (llm for OpenHands, agent_settings for ACP) and activates
  it — "build a profile and save" is all that's needed.
- New AcpProfileForm: controlled provider/command/model/env editor (ports the
  ACP fields from the old agent page; env is one KEY=value per line, stored
  encrypted at rest).
- /settings/llm now redirects to /settings/agent and the standalone LLM nav
  item is removed (the named LlmSettingsScreen export stays for the OpenHands
  form / onboarding / cloud). Condenser and Verification remain separate, as
  the backend doesn't persist them inside a profile yet.
- Adds SETTINGS$AGENT_ENV / _HINT strings (all locales); updates settings nav,
  route and editor tests for the merged IA.

Validated end-to-end against a local agent-server built from
software-agent-sdk#3433: create an ACP profile in the UI → it persists as
agent_kind=acp and activates; activating an OpenHands profile flips the kind
back.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../settings/settings-navigation.test.tsx     |  26 +-
 .../hooks/use-settings-nav-items.test.tsx     |  30 +-
 __tests__/routes/agent-settings.test.tsx      | 702 ++----------------
 __tests__/routes/llm-settings.test.tsx        |  32 +-
 __tests__/routes/settings.test.tsx            |   4 +-
 .../agent-profiles/acp-profile-form.tsx       | 195 +++++
 .../llm-profiles/llm-settings-local-view.tsx  | 293 ++++----
 src/constants/settings-nav.tsx                |   8 -
 src/i18n/translation.json                     |  34 +
 src/routes/agent-settings.tsx                 | 510 +------------
 src/routes/llm-settings.tsx                   |  28 +-
 11 files changed, 493 insertions(+), 1369 deletions(-)
 create mode 100644 src/components/features/settings/agent-profiles/acp-profile-form.tsx

diff --git a/__tests__/components/features/settings/settings-navigation.test.tsx b/__tests__/components/features/settings/settings-navigation.test.tsx
index 4ce3b4a70..5539ad28d 100644
--- a/__tests__/components/features/settings/settings-navigation.test.tsx
+++ b/__tests__/components/features/settings/settings-navigation.test.tsx
@@ -29,14 +29,14 @@ vi.mock("#/components/shared/buttons/styled-tooltip", () => ({
   ),
 }));
 
-const llmItem = OSS_NAV_ITEMS.find((item) => item.to === "/settings/llm")!;
+const verificationItem = OSS_NAV_ITEMS.find((item) => item.to === "/settings/verification")!;
 const condenserItem = OSS_NAV_ITEMS.find(
   (item) => item.to === "/settings/condenser",
 )!;
 
 const baseItems: SettingsNavRenderedItem[] = [
   { type: "header", text: "SETTINGS$TITLE" as never },
-  { type: "item", item: llmItem },
+  { type: "item", item: verificationItem },
   { type: "divider" },
   { type: "item", item: condenserItem },
 ];
@@ -67,7 +67,7 @@ describe("SettingsNavigation", () => {
 
     expect(screen.getByTestId("settings-navbar")).toBeInTheDocument();
     expect(screen.getAllByText("SETTINGS$TITLE").length).toBeGreaterThan(0);
-    expect(screen.getAllByText("SETTINGS$NAV_LLM").length).toBeGreaterThan(0);
+    expect(screen.getAllByText("SETTINGS$NAV_VERIFICATION").length).toBeGreaterThan(0);
     expect(
       screen.getAllByText("SETTINGS$NAV_CONDENSER").length,
     ).toBeGreaterThan(0);
@@ -101,13 +101,13 @@ describe("SettingsNavigation", () => {
     );
 
     const mobileNav = screen.getByTestId("settings-navbar");
-    await userEvent.click(within(mobileNav).getByText("SETTINGS$NAV_LLM"));
+    await userEvent.click(within(mobileNav).getByText("SETTINGS$NAV_VERIFICATION"));
 
     expect(onCloseMobileMenu).toHaveBeenCalledTimes(1);
   });
 
   it("renders disabled-by-ACP items as disabled in the desktop sidebar", () => {
-    // Regression guard: when ACP is active, the LLM and Condenser items
+    // Regression guard: when ACP is active, the Verification and Condenser items
     // come through with ``disabled: true`` from ``useSettingsNavItems``;
     // both the mobile drawer (via SettingsNavLink) and the desktop
     // sidebar (via SidebarNavLink) must propagate that. Earlier the
@@ -119,7 +119,7 @@ describe("SettingsNavigation", () => {
         navigationItems={[
           {
             type: "item",
-            item: llmItem,
+            item: verificationItem,
             disabled: true,
             disabledAgentName: "Claude Code",
           },
@@ -137,13 +137,13 @@ describe("SettingsNavigation", () => {
 
     // SidebarNavLink renders disabled items as a non-link span with
     // ``aria-disabled="true"`` and ``opacity-50`` styling.
-    const llmLink = within(desktopNav).getByTestId(
-      "sidebar-settings-/settings/llm",
+    const verificationLink = within(desktopNav).getByTestId(
+      "sidebar-settings-/settings/verification",
     );
     const condenserLink = within(desktopNav).getByTestId(
       "sidebar-settings-/settings/condenser",
     );
-    expect(llmLink).toHaveAttribute("aria-disabled", "true");
+    expect(verificationLink).toHaveAttribute("aria-disabled", "true");
     expect(condenserLink).toHaveAttribute("aria-disabled", "true");
   });
 
@@ -152,14 +152,14 @@ describe("SettingsNavigation", () => {
       <SettingsNavigation
         isMobileMenuOpen={false}
         onCloseMobileMenu={vi.fn()}
-        navigationItems={[{ type: "item", item: llmItem }]}
+        navigationItems={[{ type: "item", item: verificationItem }]}
       />,
     );
     const desktopNav = screen.getByTestId("settings-navbar-desktop");
-    const llmLink = within(desktopNav).getByTestId(
-      "sidebar-settings-/settings/llm",
+    const verificationLink = within(desktopNav).getByTestId(
+      "sidebar-settings-/settings/verification",
     );
-    expect(llmLink).not.toHaveAttribute("aria-disabled", "true");
+    expect(verificationLink).not.toHaveAttribute("aria-disabled", "true");
   });
 
   it("wraps disabled-by-ACP desktop items in the explanatory tooltip", () => {
diff --git a/__tests__/hooks/use-settings-nav-items.test.tsx b/__tests__/hooks/use-settings-nav-items.test.tsx
index 0b4ce2139..6d04c6767 100644
--- a/__tests__/hooks/use-settings-nav-items.test.tsx
+++ b/__tests__/hooks/use-settings-nav-items.test.tsx
@@ -60,20 +60,20 @@ describe("useSettingsNavItems", () => {
     });
   });
 
-  it("returns the LLM settings item unchanged on local backends", () => {
+  it("returns a non-special settings item unchanged on local backends", () => {
     useConfigMock.mockReturnValue({ data: createConfig() });
 
     const { result } = renderHook(() => useSettingsNavItems());
-    const llmItem = result.current.find(
-      (item) => item.type === "item" && item.item.to === "/settings/llm",
+    const condenserItem = result.current.find(
+      (item) => item.type === "item" && item.item.to === "/settings/condenser",
     );
 
-    const baseLlm = OSS_NAV_ITEMS.find(
-      (item) => item.to === "/settings/llm",
+    const baseCondenser = OSS_NAV_ITEMS.find(
+      (item) => item.to === "/settings/condenser",
     )!;
-    expect(llmItem).toEqual({
+    expect(condenserItem).toEqual({
       type: "item",
-      item: baseLlm,
+      item: baseCondenser,
     });
   });
 
@@ -120,7 +120,7 @@ describe("useSettingsNavItems", () => {
     expect(paths).not.toContain("/settings/mcp");
   });
 
-  it("disables LLM + Condenser when the active agent_kind is acp", () => {
+  it("disables Condenser + Verification when the active agent_kind is acp", () => {
     useConfigMock.mockReturnValue({ data: createConfig() });
     useSettingsMock.mockReturnValue({ data: acpClaudeCodeSettings });
 
@@ -134,17 +134,17 @@ describe("useSettingsNavItems", () => {
         ),
     );
 
-    const llm = byPath.get("/settings/llm");
-    expect(llm?.type).toBe("item");
-    if (llm?.type === "item") {
-      expect(llm.disabled).toBe(true);
-      expect(llm.disabledAgentName).toBe("Claude Code");
-    }
-
     const condenser = byPath.get("/settings/condenser");
     expect(condenser?.type).toBe("item");
     if (condenser?.type === "item") {
       expect(condenser.disabled).toBe(true);
+      expect(condenser.disabledAgentName).toBe("Claude Code");
+    }
+
+    const verification = byPath.get("/settings/verification");
+    expect(verification?.type).toBe("item");
+    if (verification?.type === "item") {
+      expect(verification.disabled).toBe(true);
     }
 
     // Items without `disabledByAcp` stay enabled.
diff --git a/__tests__/routes/agent-settings.test.tsx b/__tests__/routes/agent-settings.test.tsx
index 51652498c..915c9776b 100644
--- a/__tests__/routes/agent-settings.test.tsx
+++ b/__tests__/routes/agent-settings.test.tsx
@@ -1,24 +1,31 @@
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { render, screen, waitFor } from "@testing-library/react";
-import userEvent from "@testing-library/user-event";
+import { render, screen } from "@testing-library/react";
 import { MemoryRouter } from "react-router";
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import AgentSettingsScreen from "#/routes/agent-settings";
-import SettingsService from "#/api/settings-service/settings-service.api";
-import { MOCK_DEFAULT_USER_SETTINGS } from "#/mocks/handlers";
-import { Settings } from "#/types/settings";
-
-function buildSettings(overrides: Partial<Settings> = {}): Settings {
-  return {
-    ...MOCK_DEFAULT_USER_SETTINGS,
-    ...overrides,
-    agent_settings:
-      overrides.agent_settings ?? MOCK_DEFAULT_USER_SETTINGS.agent_settings,
-  };
-}
-
-function renderAgentSettingsScreen() {
-  return render(<AgentSettingsScreen />, {
+import AgentSettingsRoute from "#/routes/agent-settings";
+import * as activeBackendContext from "#/contexts/active-backend-context";
+import * as useLlmProfilesHook from "#/hooks/query/use-llm-profiles";
+import type { Backend } from "#/api/backend-registry/types";
+
+vi.mock("#/hooks/query/use-llm-profiles");
+
+const localBackend: Backend = {
+  id: "local-1",
+  name: "Local Backend",
+  host: "http://localhost:18000",
+  apiKey: "",
+  kind: "local",
+};
+const cloudBackend: Backend = {
+  id: "cloud-1",
+  name: "Cloud Backend",
+  host: "https://app.all-hands.dev",
+  apiKey: "k",
+  kind: "cloud",
+};
+
+function renderRoute() {
+  return render(<AgentSettingsRoute />, {
     wrapper: ({ children }) => (
       <MemoryRouter>
         <QueryClientProvider
@@ -33,655 +40,30 @@ function renderAgentSettingsScreen() {
   });
 }
 
-describe("AgentSettingsScreen", () => {
+describe("AgentSettingsRoute (unified AgentProfile editor)", () => {
   beforeEach(() => {
     vi.restoreAllMocks();
-    vi.spyOn(SettingsService, "saveSettings").mockResolvedValue(true);
-  });
-
-  it("renders the agent type selector defaulting to OpenHands with sub-agents toggle", async () => {
-    vi.spyOn(SettingsService, "getSettings").mockResolvedValue(
-      buildSettings({
-        agent_settings: {
-          ...MOCK_DEFAULT_USER_SETTINGS.agent_settings,
-          agent_kind: "openhands",
-        },
-      }),
-    );
-
-    renderAgentSettingsScreen();
-    await screen.findByTestId("agent-settings-screen");
-    expect(screen.getByTestId("agent-type-selector")).toBeInTheDocument();
-    // Sub-agents toggle visible on the OpenHands branch.
-    expect(
-      screen.getByTestId("agent-settings-enable-sub-agents"),
-    ).toBeInTheDocument();
-    // ACP-only fields stay hidden on the OpenHands branch.
-    expect(screen.queryByTestId("agent-command-input")).not.toBeInTheDocument();
-  });
-
-  it("labels the save button 'Save Changes' for consistency with other settings pages", async () => {
-    // Arrange — render with any valid settings; the label is independent
-    // of the form's state.
-    vi.spyOn(SettingsService, "getSettings").mockResolvedValue(
-      buildSettings({
-        agent_settings: {
-          ...MOCK_DEFAULT_USER_SETTINGS.agent_settings,
-          agent_kind: "openhands",
-        },
-      }),
-    );
-
-    // Act
-    renderAgentSettingsScreen();
-    await screen.findByTestId("agent-settings-screen");
-
-    // Assert — t() is stubbed to return the key, so the rendered text is
-    // the translation key. SETTINGS$SAVE_CHANGES = "Save Changes" in
-    // public/locales/en/openhands.json; BUTTON$SAVE = "Save" (the bug).
-    expect(screen.getByTestId("agent-save-button")).toHaveTextContent(
-      "SETTINGS$SAVE_CHANGES",
-    );
-  });
-
-  it("saves enable_sub_agents when toggling on the OpenHands path", async () => {
-    const user = userEvent.setup();
-    vi.spyOn(SettingsService, "getSettings").mockResolvedValue(
-      buildSettings({
-        agent_settings: {
-          ...MOCK_DEFAULT_USER_SETTINGS.agent_settings,
-          agent_kind: "openhands",
-          enable_sub_agents: false,
-        },
-      }),
-    );
-    const save = vi.spyOn(SettingsService, "saveSettings");
-
-    renderAgentSettingsScreen();
-    await screen.findByTestId("agent-settings-screen");
-
-    // Toggle sub-agents on via the enclosing label
-    const toggle = screen.getByTestId("agent-settings-enable-sub-agents");
-    const label = toggle.closest("label")!;
-    await user.click(label);
-
-    await user.click(screen.getByTestId("agent-save-button"));
-
-    await waitFor(() => {
-      expect(save).toHaveBeenCalledTimes(1);
-    });
-    const call = save.mock.calls[0]?.[0] as {
-      agent_settings_diff?: Record<string, unknown>;
-    };
-    expect(call.agent_settings_diff).toEqual({
-      agent_kind: "openhands",
-      enable_sub_agents: true,
-    });
-  });
-
-  it("hides sub-agents toggle when ACP is selected", async () => {
-    const user = userEvent.setup();
-    vi.spyOn(SettingsService, "getSettings").mockResolvedValue(
-      buildSettings({
-        agent_settings: {
-          ...MOCK_DEFAULT_USER_SETTINGS.agent_settings,
-          agent_kind: "openhands",
-        },
-      }),
-    );
-
-    renderAgentSettingsScreen();
-    await screen.findByTestId("agent-settings-screen");
-
-    // Sub-agents toggle should be visible initially
-    expect(
-      screen.getByTestId("agent-settings-enable-sub-agents"),
-    ).toBeInTheDocument();
-
-    // Switch to ACP
-    await user.click(screen.getByTestId("agent-type-selector"));
-    await user.click(
-      await screen.findByRole("option", { name: "SETTINGS$AGENT_TYPE_ACP" }),
-    );
-
-    // Sub-agents toggle should be hidden, ACP fields should appear
-    expect(
-      screen.queryByTestId("agent-settings-enable-sub-agents"),
-    ).not.toBeInTheDocument();
-    expect(screen.getByTestId("agent-command-input")).toBeInTheDocument();
-  });
-
-  it("shows the ACP form when the active agent_kind is acp", async () => {
-    // Use a model ID that isn't in CLAUDE_MODELS so the form falls through to
-    // the custom-input branch — that's the path this test is asserting (saved
-    // value round-trips into the visible input). Known IDs go through the
-    // dropdown instead and are covered separately.
-    vi.spyOn(SettingsService, "getSettings").mockResolvedValue(
-      buildSettings({
-        agent_settings: {
-          schema_version: 1,
-          agent_kind: "acp",
-          acp_server: "claude-code",
-          acp_command: ["npx", "-y", "@agentclientprotocol/claude-agent-acp"],
-          acp_model: "my-pinned-fork-model",
-        },
-      }),
-    );
-
-    renderAgentSettingsScreen();
-    const commandInput = (await screen.findByTestId(
-      "agent-command-input",
-    )) as HTMLTextAreaElement;
-    expect(commandInput.value).toBe(
-      "npx -y @agentclientprotocol/claude-agent-acp",
-    );
-    const modelInput = screen.getByTestId(
-      "agent-model-input",
-    ) as HTMLInputElement;
-    expect(modelInput.value).toBe("my-pinned-fork-model");
-  });
-
-  it("defaults built-in ACP providers to a suggested model when none is saved", async () => {
-    vi.spyOn(SettingsService, "getSettings").mockResolvedValue(
-      buildSettings({
-        agent_settings: {
-          schema_version: 1,
-          agent_kind: "acp",
-          acp_server: "claude-code",
-          acp_command: [],
-          acp_model: null,
-        },
-      }),
-    );
-
-    renderAgentSettingsScreen();
-
-    await screen.findByTestId("agent-command-input");
-    expect(screen.getByLabelText("SETTINGS$AGENT_MODEL")).toHaveValue(
-      "Claude Opus 4.7",
-    );
-  });
-
-  it("saves the selected built-in ACP model", async () => {
-    const user = userEvent.setup();
-    vi.spyOn(SettingsService, "getSettings").mockResolvedValue(
-      buildSettings({
-        agent_settings: {
-          schema_version: 1,
-          agent_kind: "acp",
-          acp_server: "claude-code",
-          acp_command: [],
-          acp_model: null,
-        },
-      }),
-    );
-    const save = vi.spyOn(SettingsService, "saveSettings");
-
-    renderAgentSettingsScreen();
-    await screen.findByTestId("agent-command-input");
-    await user.click(screen.getByLabelText("SETTINGS$AGENT_MODEL"));
-    await user.click(await screen.findByText("Claude Haiku 4.5"));
-    await user.click(screen.getByTestId("agent-save-button"));
-
-    await waitFor(() => {
-      expect(save).toHaveBeenCalledTimes(1);
-    });
-    const call = save.mock.calls[0]?.[0] as {
-      agent_settings_diff?: Record<string, unknown>;
-    };
-    expect(call.agent_settings_diff?.acp_model).toBe("claude-haiku-4-5");
-  });
-
-  it("clears the model when switching from a built-in provider to Custom", async () => {
-    // F3 from review: built-ins seed ``acp_model`` to their registered
-    // ``default_model`` on load. Picking Custom must not leak that built-in
-    // default into custom settings — otherwise a user choosing Custom from
-    // Claude Code would silently save ``acp_model: "claude-opus-4-7"`` on an
-    // unrelated wrapper.
-    const user = userEvent.setup();
-    vi.spyOn(SettingsService, "getSettings").mockResolvedValue(
-      buildSettings({
-        agent_settings: {
-          schema_version: 1,
-          agent_kind: "acp",
-          acp_server: "claude-code",
-          acp_command: [],
-          acp_model: null,
-        },
-      }),
-    );
-    const save = vi.spyOn(SettingsService, "saveSettings");
-
-    renderAgentSettingsScreen();
-    await screen.findByTestId("agent-command-input");
-    // Form loads with the Claude Code default visible.
-    expect(screen.getByLabelText("SETTINGS$AGENT_MODEL")).toHaveValue(
-      "Claude Opus 4.7",
-    );
-
-    // Switch to the Custom preset, then enter a different command — the
-    // form's ``selectedPreset`` re-derives from the command text, so the
-    // save path only treats it as Custom once the command no longer matches
-    // a built-in provider's default.
-    await user.click(screen.getByTestId("agent-preset-selector"));
-    await user.click(
-      await screen.findByRole("option", { name: "SETTINGS$AGENT_PRESET_CUSTOM" }),
-    );
-    const commandInput = screen.getByTestId(
-      "agent-command-input",
-    ) as HTMLTextAreaElement;
-    await user.clear(commandInput);
-    await user.type(commandInput, "my-custom-acp --flag");
-
-    await user.click(screen.getByTestId("agent-save-button"));
-    await waitFor(() => {
-      expect(save).toHaveBeenCalledTimes(1);
-    });
-
-    const call = save.mock.calls[0]?.[0] as {
-      agent_settings_diff?: Record<string, unknown>;
-    };
-    // Custom preset has no registered default — saved acp_model must be null,
-    // not the inherited Claude Opus default.
-    expect(call.agent_settings_diff?.acp_server).toBe("custom");
-    expect(call.agent_settings_diff?.acp_model).toBeNull();
-  });
-
-  it("reconciles the model when the command is retyped to a different provider", async () => {
-    // Editing the command textarea (rather than the preset dropdown) into a
-    // different built-in provider must not leave the previous provider's model
-    // selected — otherwise Save would persist e.g. ``claude-opus-4-7`` against
-    // a Codex wrapper. The detected preset changes, so the model reconciles to
-    // the new provider's default.
-    const user = userEvent.setup();
-    vi.spyOn(SettingsService, "getSettings").mockResolvedValue(
-      buildSettings({
-        agent_settings: {
-          schema_version: 1,
-          agent_kind: "acp",
-          acp_server: "claude-code",
-          acp_command: [],
-          acp_model: null,
-        },
-      }),
-    );
-    const save = vi.spyOn(SettingsService, "saveSettings");
-
-    renderAgentSettingsScreen();
-    await screen.findByTestId("agent-command-input");
-    expect(screen.getByLabelText("SETTINGS$AGENT_MODEL")).toHaveValue(
-      "Claude Opus 4.7",
-    );
-
-    const commandInput = screen.getByTestId(
-      "agent-command-input",
-    ) as HTMLTextAreaElement;
-    await user.clear(commandInput);
-    await user.type(commandInput, "npx -y @zed-industries/codex-acp");
-
-    // The model field now reflects the Codex default, not the stale Claude one.
-    expect(screen.getByLabelText("SETTINGS$AGENT_MODEL")).toHaveValue(
-      "GPT-5.5 (medium)",
-    );
-
-    await user.click(screen.getByTestId("agent-save-button"));
-    await waitFor(() => {
-      expect(save).toHaveBeenCalledTimes(1);
-    });
-
-    const call = save.mock.calls[0]?.[0] as {
-      agent_settings_diff?: Record<string, unknown>;
-    };
-    expect(call.agent_settings_diff?.acp_server).toBe("codex");
-    expect(call.agent_settings_diff?.acp_model).toBe("gpt-5.5/medium");
-  });
-
-  it("saves an ACP diff when switching to ACP + Claude Code", async () => {
-    const user = userEvent.setup();
-    vi.spyOn(SettingsService, "getSettings").mockResolvedValue(
-      buildSettings({
-        agent_settings: {
-          ...MOCK_DEFAULT_USER_SETTINGS.agent_settings,
-          agent_kind: "openhands",
-        },
-      }),
-    );
-    const save = vi.spyOn(SettingsService, "saveSettings");
-
-    renderAgentSettingsScreen();
-    await screen.findByTestId("agent-settings-screen");
-
-    // Switching to ACP prefills the command from the first registered provider
-    // (Claude Code).
-    await user.click(screen.getByTestId("agent-type-selector"));
-    await user.click(
-      await screen.findByRole("option", { name: "SETTINGS$AGENT_TYPE_ACP" }),
-    );
-
-    const commandInput = (await screen.findByTestId(
-      "agent-command-input",
-    )) as HTMLTextAreaElement;
-    expect(commandInput.value).toBe(
-      "npx -y @agentclientprotocol/claude-agent-acp",
-    );
-    expect(screen.getByLabelText("SETTINGS$AGENT_MODEL")).toHaveValue(
-      "Claude Opus 4.7",
-    );
-
-    await user.click(screen.getByTestId("agent-save-button"));
-
-    await waitFor(() => {
-      expect(save).toHaveBeenCalledTimes(1);
-    });
-    const call = save.mock.calls[0]?.[0] as {
-      agent_settings_diff?: Record<string, unknown>;
-    };
-    expect(call.agent_settings_diff).toEqual({
-      agent_kind: "acp",
-      acp_server: "claude-code",
-      // The default-command path stores acp_command: [] and lets the registry
-      // resolve it on the agent-server side. Round-tripping verbatim would
-      // pin a stale command if the registry default changes upstream.
-      acp_command: [],
-      // ``acp_args: []`` is reset on every save so an API-set
-      // ``acp_args`` can't survive and concatenate onto the spawn
-      // command at conversation-create time.
-      acp_args: [],
-      acp_model: "claude-opus-4-7",
-    });
-  });
-
-  it("clears ACP fields when switching back to OpenHands", async () => {
-    const user = userEvent.setup();
-    vi.spyOn(SettingsService, "getSettings").mockResolvedValue(
-      buildSettings({
-        agent_settings: {
-          schema_version: 1,
-          agent_kind: "acp",
-          acp_server: "claude-code",
-          acp_command: ["npx", "-y", "@agentclientprotocol/claude-agent-acp"],
-        },
-      }),
-    );
-    const save = vi.spyOn(SettingsService, "saveSettings");
-
-    renderAgentSettingsScreen();
-    await screen.findByTestId("agent-settings-screen");
-
-    await user.click(screen.getByTestId("agent-type-selector"));
-    await user.click(
-      await screen.findByRole("option", {
-        name: "SETTINGS$AGENT_TYPE_OPENHANDS",
-      }),
-    );
-    await user.click(screen.getByTestId("agent-save-button"));
-
-    await waitFor(() => {
-      expect(save).toHaveBeenCalledTimes(1);
-    });
-    const call = save.mock.calls[0]?.[0] as {
-      agent_settings_diff?: Record<string, unknown>;
-    };
-    expect(call.agent_settings_diff).toEqual({
-      agent_kind: "openhands",
-      enable_sub_agents: false,
-    });
-  });
-
-  it("disables Save when the user has cleared the command on the ACP path", async () => {
-    const user = userEvent.setup();
-    vi.spyOn(SettingsService, "getSettings").mockResolvedValue(
-      buildSettings({
-        agent_settings: {
-          schema_version: 1,
-          agent_kind: "acp",
-          acp_server: "claude-code",
-          acp_command: ["npx", "-y", "@agentclientprotocol/claude-agent-acp"],
-        },
-      }),
-    );
-
-    renderAgentSettingsScreen();
-    const cmd = (await screen.findByTestId(
-      "agent-command-input",
-    )) as HTMLTextAreaElement;
-    const save = screen.getByTestId("agent-save-button") as HTMLButtonElement;
-
-    // Clear the field. Save should be disabled (the agent-server would
-    // crash on an empty acp_command and the adapter has no way to
-    // recover — better to block the save than silently submit garbage).
-    await user.clear(cmd);
-    expect(save).toBeDisabled();
-  });
-
-  it("treats whitespace-only as empty and keeps Save disabled", async () => {
-    const user = userEvent.setup();
-    vi.spyOn(SettingsService, "getSettings").mockResolvedValue(
-      buildSettings({
-        agent_settings: {
-          schema_version: 1,
-          agent_kind: "acp",
-          acp_server: "claude-code",
-          acp_command: ["npx", "-y", "@agentclientprotocol/claude-agent-acp"],
-        },
-      }),
-    );
-
-    renderAgentSettingsScreen();
-    const cmd = (await screen.findByTestId(
-      "agent-command-input",
-    )) as HTMLTextAreaElement;
-    const save = screen.getByTestId("agent-save-button") as HTMLButtonElement;
-    await user.clear(cmd);
-    await user.type(cmd, "   \t   ");
-    expect(save).toBeDisabled();
+    vi.mocked(useLlmProfilesHook.useLlmProfiles).mockReturnValue({
+      data: { profiles: [], active_profile: null },
+    } as unknown as ReturnType<typeof useLlmProfilesHook.useLlmProfiles>);
   });
 
-  it("preserves a Custom command with quoted args end-to-end", async () => {
-    // Regression guard for the .split-vs-shell-quote bug: a Custom
-    // command like ``bash -c "echo hi"`` used to get tokenised as
-    // ``["bash","-c","\"echo","hi\""]`` and silently fail at spawn.
-    const user = userEvent.setup();
-    vi.spyOn(SettingsService, "getSettings").mockResolvedValue(
-      buildSettings({
-        agent_settings: {
-          ...MOCK_DEFAULT_USER_SETTINGS.agent_settings,
-          agent_kind: "openhands",
-        },
-      }),
-    );
-    const save = vi.spyOn(SettingsService, "saveSettings");
-
-    renderAgentSettingsScreen();
-    await screen.findByTestId("agent-settings-screen");
-
-    await user.click(screen.getByTestId("agent-type-selector"));
-    await user.click(
-      await screen.findByRole("option", { name: "SETTINGS$AGENT_TYPE_ACP" }),
-    );
-    const cmd = (await screen.findByTestId(
-      "agent-command-input",
-    )) as HTMLTextAreaElement;
-    await user.clear(cmd);
-    await user.type(cmd, 'bash -c "echo hi"');
-    await user.click(screen.getByTestId("agent-save-button"));
-
-    await waitFor(() => {
-      expect(save).toHaveBeenCalledTimes(1);
+  it("renders the AgentProfile manager (Add Profile) for local backends", async () => {
+    vi.spyOn(activeBackendContext, "useActiveBackend").mockReturnValue({
+      backend: localBackend,
+      orgId: null,
     });
-    const call = save.mock.calls[0]?.[0] as {
-      agent_settings_diff?: Record<string, unknown>;
-    };
-    expect(call.agent_settings_diff?.acp_command).toEqual([
-      "bash",
-      "-c",
-      "echo hi",
-    ]);
-    // Anything that diverges from a built-in default-command snaps to
-    // the Custom preset.
-    expect(call.agent_settings_diff?.acp_server).toBe("custom");
+    renderRoute();
+    expect(await screen.findByTestId("add-llm-profile")).toBeInTheDocument();
   });
 
-  it("preserves the registry default when acp_command:[] + non-empty acp_args is loaded", async () => {
-    // Regression guard for the data-corruption bug:
-    //
-    //   stored: acp_server: 'claude-code', acp_command: [], acp_args:
-    //           ['--extra-arg']
-    //   actual spawn: ['npx', '-y', '@agentclientprotocol/claude-agent-acp',
-    //                  '--extra-arg']
-    //
-    // The form used to merge acp_command + acp_args literally and would
-    // show only ``--extra-arg`` in the textarea. Saving then sent
-    // ``acp_command: ['--extra-arg']`` and flipped the preset to
-    // ``custom``, silently dropping the registry-default prefix.
-    // The load path must expand the default *before* merging with args.
-    const user = userEvent.setup();
-    vi.spyOn(SettingsService, "getSettings").mockResolvedValue(
-      buildSettings({
-        agent_settings: {
-          schema_version: 1,
-          agent_kind: "acp",
-          acp_server: "claude-code",
-          acp_command: [],
-          acp_args: ["--extra-arg"],
-        },
-      }),
-    );
-    const save = vi.spyOn(SettingsService, "saveSettings");
-
-    renderAgentSettingsScreen();
-    const cmd = (await screen.findByTestId(
-      "agent-command-input",
-    )) as HTMLTextAreaElement;
-    expect(cmd.value).toBe(
-      "npx -y @agentclientprotocol/claude-agent-acp --extra-arg",
-    );
-
-    // Touch the form to mark it dirty (Save is disabled until isDirty),
-    // then submit. The data the form sends has to carry the registry-
-    // default prefix the user can now SEE in the textarea, not the bare
-    // ``--extra-arg`` that was stored.
-    await user.click(cmd);
-    await user.keyboard("{End} ");
-    await user.keyboard("{Backspace}");
-
-    await user.click(screen.getByTestId("agent-save-button"));
-    await waitFor(() => {
-      expect(save).toHaveBeenCalledTimes(1);
-    });
-    const call = save.mock.calls[0]?.[0] as {
-      agent_settings_diff?: Record<string, unknown>;
-    };
-    expect(call.agent_settings_diff?.acp_server).toBe("custom");
-    expect(call.agent_settings_diff?.acp_command).toEqual([
-      "npx",
-      "-y",
-      "@agentclientprotocol/claude-agent-acp",
-      "--extra-arg",
-    ]);
-    // ``acp_args: []`` resets the API-set args so they don't double up
-    // at spawn time.
-    expect(call.agent_settings_diff?.acp_args).toEqual([]);
-  });
-
-  it("preserves an unknown loaded acp_server when the user saves without editing", async () => {
-    // Data-corruption regression: a user with an ``acp_server`` value
-    // canvas's registry doesn't know about (e.g. set via the API for a
-    // future provider that hasn't been mirrored into ``ACP_PROVIDERS``
-    // yet) opens Settings → Agent and clicks Save. Without preservation
-    // the save flow demotes ``acp_server: "amp"`` → ``acp_server:
-    // "custom"`` because ``detectPreset`` returns ``custom`` for any
-    // unknown server. The original key name is silently lost.
-    //
-    // The fix is narrow: when the user hasn't touched the command since
-    // load AND the loaded server is non-empty, non-``"custom"``, and
-    // absent from ``ACP_PROVIDERS``, write the loaded key back verbatim
-    // via the ``allowUnknownServer`` pass-through.
-    const user = userEvent.setup();
-    vi.spyOn(SettingsService, "getSettings").mockResolvedValue(
-      buildSettings({
-        agent_settings: {
-          schema_version: 1,
-          agent_kind: "acp",
-          acp_server: "amp",
-          acp_command: ["npx", "-y", "@some-future/amp-acp"],
-          acp_args: [],
-        },
-      }),
-    );
-    const save = vi.spyOn(SettingsService, "saveSettings");
-
-    renderAgentSettingsScreen();
-    const cmd = (await screen.findByTestId(
-      "agent-command-input",
-    )) as HTMLTextAreaElement;
-    expect(cmd.value).toBe("npx -y @some-future/amp-acp");
-
-    // Touch + revert the textarea to flip isDirty without changing
-    // the persisted command text — matches "user opens settings and
-    // hits Save without intending to change anything."
-    await user.click(cmd);
-    await user.keyboard("{End} ");
-    await user.keyboard("{Backspace}");
-
-    await user.click(screen.getByTestId("agent-save-button"));
-    await waitFor(() => {
-      expect(save).toHaveBeenCalledTimes(1);
-    });
-    const call = save.mock.calls[0]?.[0] as {
-      agent_settings_diff?: Record<string, unknown>;
-    };
-    expect(call.agent_settings_diff?.acp_server).toBe("amp");
-    expect(call.agent_settings_diff?.acp_command).toEqual([
-      "npx",
-      "-y",
-      "@some-future/amp-acp",
-    ]);
-  });
-
-  it("demotes an unknown loaded acp_server to 'custom' when the user edits the command", async () => {
-    // Counterpart to the preserve test: editing the command is a
-    // material change of configuration, so it's correct to drop the
-    // unknown ``amp`` key and fall back to ``"custom"``. The user is
-    // configuring a new command, not preserving the prior one — so
-    // the preset name follows the command.
-    const user = userEvent.setup();
-    vi.spyOn(SettingsService, "getSettings").mockResolvedValue(
-      buildSettings({
-        agent_settings: {
-          schema_version: 1,
-          agent_kind: "acp",
-          acp_server: "amp",
-          acp_command: ["npx", "-y", "@some-future/amp-acp"],
-          acp_args: [],
-        },
-      }),
-    );
-    const save = vi.spyOn(SettingsService, "saveSettings");
-
-    renderAgentSettingsScreen();
-    const cmd = (await screen.findByTestId(
-      "agent-command-input",
-    )) as HTMLTextAreaElement;
-
-    // Actually change the command — append a flag so the textarea
-    // differs from the loaded value.
-    await user.click(cmd);
-    await user.keyboard("{End} --new-flag");
-
-    await user.click(screen.getByTestId("agent-save-button"));
-    await waitFor(() => {
-      expect(save).toHaveBeenCalledTimes(1);
+  it("renders the standard LLM form (no profiles) for cloud backends", async () => {
+    vi.spyOn(activeBackendContext, "useActiveBackend").mockReturnValue({
+      backend: cloudBackend,
+      orgId: "org-1",
     });
-    const call = save.mock.calls[0]?.[0] as {
-      agent_settings_diff?: Record<string, unknown>;
-    };
-    expect(call.agent_settings_diff?.acp_server).toBe("custom");
-    expect(call.agent_settings_diff?.acp_command).toEqual([
-      "npx",
-      "-y",
-      "@some-future/amp-acp",
-      "--new-flag",
-    ]);
+    renderRoute();
+    expect(await screen.findByTestId("llm-settings-screen")).toBeInTheDocument();
+    expect(screen.queryByTestId("add-llm-profile")).not.toBeInTheDocument();
   });
 });
diff --git a/__tests__/routes/llm-settings.test.tsx b/__tests__/routes/llm-settings.test.tsx
index 58b0ab315..8afe5c44c 100644
--- a/__tests__/routes/llm-settings.test.tsx
+++ b/__tests__/routes/llm-settings.test.tsx
@@ -180,7 +180,10 @@ describe("LlmSettingsRoute - backend mode rendering", () => {
     );
   });
 
-  it("renders LlmSettingsLocalView (profile manager) for local backends", async () => {
+  // The standalone LLM page is folded into Settings → Agent (#669); the route
+  // now redirects there, so it renders neither the local profile manager nor
+  // the cloud LLM form itself.
+  it("redirects local backends away from the standalone LLM page", () => {
     vi.spyOn(activeBackendContext, "useActiveBackend").mockReturnValue({
       backend: mockLocalBackend,
       orgId: null,
@@ -188,39 +191,18 @@ describe("LlmSettingsRoute - backend mode rendering", () => {
 
     renderLlmSettingsRoute();
 
-    // Local mode shows the "Add LLM Profile" button from LlmProfilesManager
-    await screen.findByTestId("add-llm-profile");
-    expect(screen.getByTestId("add-llm-profile")).toBeInTheDocument();
+    expect(screen.queryByTestId("add-llm-profile")).not.toBeInTheDocument();
   });
 
-  it("renders standard LlmSettingsScreen (no profiles) for cloud backends", async () => {
+  it("redirects cloud backends away from the standalone LLM page", () => {
     vi.spyOn(activeBackendContext, "useActiveBackend").mockReturnValue({
       backend: mockCloudBackend,
       orgId: "org-123",
     });
 
-    vi.spyOn(SettingsService, "getSettings").mockResolvedValue(
-      buildSettings({
-        llm_model: "openai/gpt-4o",
-        llm_api_key_set: true,
-        agent_settings: {
-          ...MOCK_DEFAULT_USER_SETTINGS.agent_settings,
-          llm: {
-            model: "openai/gpt-4o",
-            api_key: null,
-            base_url: "",
-          },
-        },
-      }),
-    );
-
     renderLlmSettingsRoute();
 
-    // Cloud mode shows the standard LLM settings form (not profile manager)
-    await screen.findByTestId("llm-settings-screen");
-    expect(screen.getByTestId("llm-settings-screen")).toBeInTheDocument();
-
-    // Should NOT show the "Add LLM Profile" button
+    expect(screen.queryByTestId("llm-settings-screen")).not.toBeInTheDocument();
     expect(screen.queryByTestId("add-llm-profile")).not.toBeInTheDocument();
   });
 });
diff --git a/__tests__/routes/settings.test.tsx b/__tests__/routes/settings.test.tsx
index 3463ba233..d4d9f028d 100644
--- a/__tests__/routes/settings.test.tsx
+++ b/__tests__/routes/settings.test.tsx
@@ -74,6 +74,8 @@ describe("settings route", () => {
     });
 
     const response = (await clientLoader({
+      // /settings/llm no longer exists (folded into Agent), so it is an
+      // unavailable path the loader redirects to the first available route.
       request: new Request("http://localhost/settings/llm"),
       params: {},
       context: {},
@@ -159,7 +161,7 @@ describe("settings route", () => {
     });
 
     const response = (await clientLoader({
-      request: new Request("http://localhost/settings/llm"),
+      request: new Request("http://localhost/settings/condenser"),
       params: {},
       context: {},
     } as never)) as Response;
diff --git a/src/components/features/settings/agent-profiles/acp-profile-form.tsx b/src/components/features/settings/agent-profiles/acp-profile-form.tsx
new file mode 100644
index 000000000..d66fd7ecd
--- /dev/null
+++ b/src/components/features/settings/agent-profiles/acp-profile-form.tsx
@@ -0,0 +1,195 @@
+import React from "react";
+import { useTranslation } from "react-i18next";
+import { SettingsDropdownInput } from "#/components/features/settings/settings-dropdown-input";
+import { SettingsInput } from "#/components/features/settings/settings-input";
+import { Typography } from "#/ui/typography";
+import { I18nKey } from "#/i18n/declaration";
+import {
+  ACP_PROVIDERS,
+  ACP_CUSTOM_PRESET_KEY,
+  getAcpProvider,
+} from "#/constants/acp-providers";
+import { parseCommand, formatCommand } from "#/utils/acp-command";
+
+const ACP_CUSTOM_MODEL_KEY = "__custom_model__";
+
+/** The ACP launch fields an ACP AgentProfile persists. */
+export interface AcpProfileFormValue {
+  /** Provider registry key, or {@link ACP_CUSTOM_PRESET_KEY} for a raw command. */
+  acpServer: string;
+  /** Resolved launch command tokens (``acp_command``). */
+  command: string[];
+  /** Selected ``acp_model`` (empty = provider default). */
+  acpModel: string;
+  /** Extra environment for the ACP subprocess (``acp_env``); carries creds. */
+  env: Record<string, string>;
+}
+
+interface AcpProfileFormProps {
+  value: AcpProfileFormValue;
+  onChange: (value: AcpProfileFormValue) => void;
+}
+
+function parseEnvText(text: string): Record<string, string> {
+  const env: Record<string, string> = {};
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq <= 0) continue;
+    env[trimmed.slice(0, eq).trim()] = trimmed.slice(eq + 1).trim();
+  }
+  return env;
+}
+
+function formatEnvText(env: Record<string, string>): string {
+  return Object.entries(env)
+    .map(([k, v]) => `${k}=${v}`)
+    .join("\n");
+}
+
+/**
+ * Controlled editor for the ACP half of an AgentProfile: provider, launch
+ * command, model and environment. The parent owns the value and turns it into
+ * the ``agent_settings`` payload on save.
+ */
+export function AcpProfileForm({ value, onChange }: AcpProfileFormProps) {
+  const { t } = useTranslation("openhands");
+  const provider = getAcpProvider(value.acpServer);
+  const models = provider?.available_models ?? [];
+  const hasModelSuggestions = models.length > 0;
+  // Editing an env textarea drops focus on every keystroke if we re-derive it
+  // from the parsed map, so keep the raw text locally and only push the parsed
+  // map up.
+  const [envText, setEnvText] = React.useState(() => formatEnvText(value.env));
+  React.useEffect(() => {
+    // Re-sync only when the profile being edited changes underneath us
+    // (parent swaps `value` wholesale), not on our own keystrokes.
+    setEnvText(formatEnvText(value.env));
+  }, [value.acpServer]);
+
+  const modelIsKnown = models.some((m) => m.id === value.acpModel);
+  const usingCustomModel = !hasModelSuggestions || !modelIsKnown;
+  const selectedModelKey = usingCustomModel
+    ? ACP_CUSTOM_MODEL_KEY
+    : value.acpModel;
+
+  const selectProvider = (key: string) => {
+    const next = getAcpProvider(key);
+    if (next) {
+      onChange({
+        acpServer: key,
+        command: [...next.default_command],
+        acpModel: next.default_model ?? "",
+        env: value.env,
+      });
+    } else {
+      // custom
+      onChange({
+        acpServer: ACP_CUSTOM_PRESET_KEY,
+        command: [],
+        acpModel: "",
+        env: value.env,
+      });
+    }
+  };
+
+  return (
+    <div className="flex flex-col gap-4">
+      <SettingsDropdownInput
+        testId="acp-provider-selector"
+        name="acp-provider"
+        label={t(I18nKey.SETTINGS$AGENT_PRESET)}
+        items={[
+          ...ACP_PROVIDERS.map((p) => ({ key: p.key, label: p.display_name })),
+          {
+            key: ACP_CUSTOM_PRESET_KEY,
+            label: t(I18nKey.SETTINGS$AGENT_PRESET_CUSTOM),
+          },
+        ]}
+        selectedKey={value.acpServer || ACP_PROVIDERS[0]?.key}
+        onSelectionChange={(key) => key && selectProvider(String(key))}
+      />
+
+      <div className="flex flex-col gap-2.5">
+        <Typography.Text className="text-sm">
+          {t(I18nKey.SETTINGS$AGENT_COMMAND)}
+        </Typography.Text>
+        <textarea
+          data-testid="acp-command-input"
+          className="bg-tertiary border border-[#717888] rounded-sm p-2 text-sm font-mono text-white placeholder:text-[#717888] min-h-[60px] resize-y focus:outline-none focus:border-white"
+          value={formatCommand(value.command)}
+          onChange={(e) =>
+            onChange({ ...value, command: parseCommand(e.target.value) })
+          }
+        />
+        <Typography.Text className="text-xs text-[#717888]">
+          {t(I18nKey.SETTINGS$AGENT_COMMAND_HINT)}
+        </Typography.Text>
+      </div>
+
+      <div className="flex flex-col gap-1.5">
+        {hasModelSuggestions && (
+          <SettingsDropdownInput
+            testId="acp-model-selector"
+            name="acp-model"
+            label={t(I18nKey.SETTINGS$AGENT_MODEL)}
+            items={[
+              ...models.map((m) => ({ key: m.id, label: m.label })),
+              {
+                key: ACP_CUSTOM_MODEL_KEY,
+                label: t(I18nKey.SETTINGS$AGENT_PRESET_CUSTOM),
+              },
+            ]}
+            selectedKey={selectedModelKey}
+            onSelectionChange={(key) => {
+              if (!key) return;
+              const k = String(key);
+              onChange({
+                ...value,
+                acpModel: k === ACP_CUSTOM_MODEL_KEY ? "" : k,
+              });
+            }}
+          />
+        )}
+        {usingCustomModel && (
+          <SettingsInput
+            testId="acp-model-input"
+            label={
+              hasModelSuggestions
+                ? t(I18nKey.SETTINGS$AGENT_CUSTOM_MODEL)
+                : t(I18nKey.SETTINGS$AGENT_MODEL)
+            }
+            type="text"
+            className="w-full"
+            value={value.acpModel}
+            showOptionalTag
+            onChange={(v) => onChange({ ...value, acpModel: v })}
+          />
+        )}
+        <Typography.Text className="text-xs text-[#717888]">
+          {t(I18nKey.SETTINGS$AGENT_MODEL_HINT)}
+        </Typography.Text>
+      </div>
+
+      <div className="flex flex-col gap-2.5">
+        <Typography.Text className="text-sm">
+          {t(I18nKey.SETTINGS$AGENT_ENV)}
+        </Typography.Text>
+        <textarea
+          data-testid="acp-env-input"
+          className="bg-tertiary border border-[#717888] rounded-sm p-2 text-sm font-mono text-white placeholder:text-[#717888] min-h-[60px] resize-y focus:outline-none focus:border-white"
+          placeholder={"ANTHROPIC_API_KEY=sk-...\nKEY=value"}
+          value={envText}
+          onChange={(e) => {
+            setEnvText(e.target.value);
+            onChange({ ...value, env: parseEnvText(e.target.value) });
+          }}
+        />
+        <Typography.Text className="text-xs text-[#717888]">
+          {t(I18nKey.SETTINGS$AGENT_ENV_HINT)}
+        </Typography.Text>
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/features/settings/llm-profiles/llm-settings-local-view.tsx b/src/components/features/settings/llm-profiles/llm-settings-local-view.tsx
index d83a23757..5dbbc3c67 100644
--- a/src/components/features/settings/llm-profiles/llm-settings-local-view.tsx
+++ b/src/components/features/settings/llm-profiles/llm-settings-local-view.tsx
@@ -3,12 +3,21 @@ import { useTranslation } from "react-i18next";
 import { LlmProfilesManager } from "./llm-profiles-manager";
 import { ProfileNameInput } from "./profile-name-input";
 import { BrandButton } from "#/components/features/settings/brand-button";
+import { SettingsDropdownInput } from "#/components/features/settings/settings-dropdown-input";
 import { LlmSettingsScreen } from "#/routes/llm-settings";
+import {
+  AcpProfileForm,
+  type AcpProfileFormValue,
+} from "#/components/features/settings/agent-profiles/acp-profile-form";
 import { useSaveLlmProfile } from "#/hooks/mutation/use-save-llm-profile";
 import { useLlmProfiles } from "#/hooks/query/use-llm-profiles";
 import ProfilesService, {
   ProfileInfo,
 } from "#/api/profiles-service/profiles-service.api";
+import {
+  ACP_PROVIDERS,
+  ACP_CUSTOM_PRESET_KEY,
+} from "#/constants/acp-providers";
 import {
   displayErrorToast,
   displaySuccessToast,
@@ -25,22 +34,34 @@ import { Typography } from "#/ui/typography";
 import { useSettingsSectionHeader } from "#/contexts/settings-section-header-context";
 
 type ViewMode = "list" | "create" | "edit";
+type ProfileKind = "openhands" | "acp";
 
 interface EditingProfile {
   profile: ProfileInfo;
   initialValues: SettingsFormValues;
 }
 
+function defaultAcpValue(): AcpProfileFormValue {
+  const first = ACP_PROVIDERS[0];
+  return {
+    acpServer: first?.key ?? ACP_CUSTOM_PRESET_KEY,
+    command: first ? [...first.default_command] : [],
+    acpModel: first?.default_model ?? "",
+    env: {},
+  };
+}
+
+function asString(v: unknown): string {
+  return typeof v === "string" ? v : "";
+}
+
 /**
- * LlmSettingsLocalView provides an integrated view for managing LLM profiles
- * in local agent-server mode. It supports listing, creating, and editing profiles.
- *
- * Note: This component manages multiple responsibilities (view state, validation,
- * form coordination, save logic). A future refactoring could extract these into
- * separate hooks (e.g., useProfileForm, useProfileSave) for better testability.
- * See PR review feedback for details.
+ * Unified AgentProfile editor for local agent-server mode (Settings → Agent).
+ * Lists profiles and creates/edits them; a kind toggle switches the form
+ * between an OpenHands profile (LLM config) and an ACP profile
+ * (provider / command / model / env). Saving persists the profile via
+ * /api/profiles (kind-aware) and activates it, so "save" is all the user needs.
  */
-
 export function LlmSettingsLocalView() {
   const { t } = useTranslation("openhands");
   const { setHideSectionHeader } = useSettingsSectionHeader();
@@ -49,6 +70,9 @@ export function LlmSettingsLocalView() {
 
   const [viewMode, setViewMode] = useState<ViewMode>("list");
   const [profileName, setProfileName] = useState("");
+  const [kind, setKind] = useState<ProfileKind>("openhands");
+  const [acpValue, setAcpValue] =
+    useState<AcpProfileFormValue>(defaultAcpValue);
   const [editingProfile, setEditingProfile] = useState<EditingProfile | null>(
     null,
   );
@@ -62,19 +86,14 @@ export function LlmSettingsLocalView() {
     return () => setHideSectionHeader(false);
   }, [viewMode, setHideSectionHeader]);
 
-  // Get existing profile names for validation
   const existingNames = useMemo(
     () => new Set(profilesData?.profiles.map((p) => p.name) ?? []),
     [profilesData],
   );
 
-  // Validate profile name. The shared validator rejects any whitespace, so
-  // duplicate checks below compare the raw value directly.
   const isNameValid = useMemo(() => {
     if (!isProfileNameValid(profileName, { isRequired: true })) return false;
-    // In create mode, check for duplicates
     if (viewMode === "create" && existingNames.has(profileName)) return false;
-    // In edit mode, name can match current profile name
     if (
       viewMode === "edit" &&
       profileName !== editingProfile?.profile.name &&
@@ -87,6 +106,8 @@ export function LlmSettingsLocalView() {
 
   const handleAddProfile = useCallback(() => {
     setProfileName("");
+    setKind("openhands");
+    setAcpValue(defaultAcpValue());
     setEditingProfile(null);
     setViewMode("create");
   }, []);
@@ -94,24 +115,37 @@ export function LlmSettingsLocalView() {
   const handleEditProfile = useCallback(
     async (profile: ProfileInfo) => {
       try {
-        // Fetch profile details with encrypted secrets to preserve API key
         const detail = await ProfilesService.getProfile(
           profile.name,
           "encrypted",
         );
-
-        // Profile config contains llm settings directly at the top level
-        // The structure is: { model, api_key, base_url, ... }
-        // (NOT nested under a "llm" key)
         const config = (detail.config ?? {}) as Record<string, unknown>;
 
-        const initialValues: SettingsFormValues = {
-          "llm.model": (config.model as string) ?? "",
-          "llm.api_key": (config.api_key as string) ?? "",
-          "llm.base_url": (config.base_url as string) ?? "",
-        };
-
-        setEditingProfile({ profile, initialValues });
+        if (config.agent_kind === "acp" || profile.kind === "acp") {
+          setKind("acp");
+          setAcpValue({
+            acpServer: asString(config.acp_server) || ACP_CUSTOM_PRESET_KEY,
+            command: Array.isArray(config.acp_command)
+              ? (config.acp_command as unknown[]).map((c) => String(c))
+              : [],
+            acpModel: asString(config.acp_model),
+            env:
+              config.acp_env && typeof config.acp_env === "object"
+                ? (config.acp_env as Record<string, string>)
+                : {},
+          });
+          setEditingProfile({ profile, initialValues: {} });
+        } else {
+          setKind("openhands");
+          setEditingProfile({
+            profile,
+            initialValues: {
+              "llm.model": asString(config.model),
+              "llm.api_key": asString(config.api_key),
+              "llm.base_url": asString(config.base_url),
+            },
+          });
+        }
         setProfileName(profile.name);
         setViewMode("edit");
       } catch (error) {
@@ -132,99 +166,74 @@ export function LlmSettingsLocalView() {
   const handleSaveControlChange = useCallback(
     (control: SdkSectionSaveControl) => {
       setSaveControl(control);
-
-      // Auto-derive profile name from model in create mode.
-      // Note: The uniqueness check uses existingNames from state, which is derived
-      // from profilesData at component render time. If another client creates a
-      // profile with the same derived name while this form is open, the client-side
-      // check would pass but the server save would fail with a conflict error.
-      // This is acceptable for the current use case; the server error is handled
-      // gracefully in handleSave.
-      if (viewMode === "create" && !profileName) {
+      if (viewMode === "create" && kind === "openhands" && !profileName) {
         const modelValue = control.values["llm.model"];
         if (typeof modelValue === "string" && modelValue) {
           const derived = deriveProfileNameFromModel(modelValue);
-          if (!existingNames.has(derived)) {
-            setProfileName(derived);
-          }
+          if (!existingNames.has(derived)) setProfileName(derived);
         }
       }
     },
-    [viewMode, profileName, existingNames],
+    [viewMode, kind, profileName, existingNames],
   );
 
   const handleSave = useCallback(async () => {
-    if (!saveControl || !isNameValid) return;
-
-    const values = saveControl.values;
-    const model =
-      typeof values["llm.model"] === "string" ? values["llm.model"] : "";
-    const apiKey =
-      typeof values["llm.api_key"] === "string" ? values["llm.api_key"] : "";
-    const baseUrl =
-      typeof values["llm.base_url"] === "string" ? values["llm.base_url"] : "";
-
-    if (!model) {
-      displayErrorToast(t(I18nKey.SETTINGS$MODEL_REQUIRED));
-      return;
-    }
-
+    if (!isNameValid) return;
     const trimmedName = profileName.trim();
     const originalName = editingProfile?.profile.name;
     const isRename =
       viewMode === "edit" && originalName && originalName !== trimmedName;
-    const wasActive = profilesData?.active_profile === originalName;
 
-    setIsSaving(true);
-    try {
-      // If editing and name changed, rename the profile first
-      if (isRename) {
-        await ProfilesService.renameProfile(originalName, trimmedName);
+    // Build the kind-aware save request.
+    let request: Parameters<typeof saveProfile.mutateAsync>[0]["request"];
+    if (kind === "acp") {
+      if (!acpValue.acpServer || acpValue.command.length === 0) {
+        displayErrorToast(t(I18nKey.SETTINGS$AGENT_COMMAND));
+        return;
       }
-
-      // Build the LLM config object
-      const llmConfig: Record<string, unknown> = { model };
-
-      // API key handling:
-      // - If user entered a new key, use it
-      // - In edit mode with no new key, preserve the existing encrypted key
-      //   (fetched with exposeSecrets='encrypted' and passed back to server)
-      // - In create mode with no key, omit api_key entirely
-      //
-      // Note: The current UX doesn't support explicitly clearing an API key.
-      // If needed, a future enhancement could add a "Clear API Key" option.
-      // The encrypted key format is stable and can be round-tripped to the server.
-      if (apiKey) {
-        llmConfig.api_key = apiKey;
-      } else if (
+      request = {
+        agent_settings: {
+          agent_kind: "acp",
+          acp_server: acpValue.acpServer,
+          acp_command: acpValue.command,
+          acp_args: [],
+          acp_model: acpValue.acpModel.trim() || null,
+          acp_env: acpValue.env,
+        },
+        include_secrets: true,
+      };
+    } else {
+      if (!saveControl) return;
+      const values = saveControl.values;
+      const model = asString(values["llm.model"]);
+      if (!model) {
+        displayErrorToast(t(I18nKey.SETTINGS$MODEL_REQUIRED));
+        return;
+      }
+      const apiKey = asString(values["llm.api_key"]);
+      const baseUrl = asString(values["llm.base_url"]);
+      const llm: Record<string, unknown> = { model };
+      if (apiKey) llm.api_key = apiKey;
+      else if (
         viewMode === "edit" &&
         editingProfile?.initialValues["llm.api_key"]
-      ) {
-        llmConfig.api_key = editingProfile.initialValues["llm.api_key"];
-      }
-
-      // Only include base_url if set
-      if (baseUrl) {
-        llmConfig.base_url = baseUrl;
-      }
-
-      await saveProfile.mutateAsync({
-        name: trimmedName,
-        request: {
-          llm: llmConfig as {
-            model: string;
-            api_key?: string;
-            base_url?: string;
-          },
-          include_secrets: true,
-        },
-      });
+      )
+        llm.api_key = editingProfile.initialValues["llm.api_key"];
+      if (baseUrl) llm.base_url = baseUrl;
+      request = {
+        llm: llm as { model: string; api_key?: string; base_url?: string },
+        include_secrets: true,
+      };
+    }
 
-      // If the renamed profile was the active profile, re-activate it
-      // (the rename operation doesn't automatically update active_profile)
-      if (isRename && wasActive) {
-        await ProfilesService.activateProfile(trimmedName);
+    setIsSaving(true);
+    try {
+      if (isRename) {
+        await ProfilesService.renameProfile(originalName, trimmedName);
       }
+      await saveProfile.mutateAsync({ name: trimmedName, request });
+      // "Save and that's it": the saved profile becomes the active one.
+      await ProfilesService.activateProfile(trimmedName);
 
       displaySuccessToast(
         viewMode === "create"
@@ -239,18 +248,18 @@ export function LlmSettingsLocalView() {
       setIsSaving(false);
     }
   }, [
-    saveControl,
     isNameValid,
     profileName,
+    kind,
+    acpValue,
+    saveControl,
     viewMode,
     editingProfile,
-    profilesData?.active_profile,
     saveProfile,
     t,
     handleBackToList,
   ]);
 
-  // List view: show profiles manager
   if (viewMode === "list") {
     return (
       <LlmProfilesManager
@@ -260,21 +269,15 @@ export function LlmSettingsLocalView() {
     );
   }
 
-  const profileEditorTitle =
-    viewMode === "edit"
-      ? t(I18nKey.SETTINGS$EDIT_LLM_PROFILE)
-      : t(I18nKey.SETTINGS$ADD_LLM_PROFILE);
-  const profileEditorDescription =
-    viewMode === "edit" && editingProfile
-      ? t(I18nKey.SETTINGS$PROFILE_LOADED, {
-          name: editingProfile.profile.name,
-        })
-      : t(I18nKey.SETTINGS$PROFILE_SAVE_HINT);
+  const saveDisabled =
+    !isNameValid ||
+    isSaving ||
+    (kind === "openhands"
+      ? !saveControl
+      : !acpValue.acpServer || acpValue.command.length === 0);
 
-  // Create/Edit view: show form with profile name input
   return (
     <div className="flex flex-col gap-6">
-      {/* Header with back button */}
       <div className="flex flex-col gap-2">
         <button
           type="button"
@@ -286,17 +289,22 @@ export function LlmSettingsLocalView() {
           <span className="text-sm leading-5">{t(I18nKey.BUTTON$BACK)}</span>
         </button>
         <Typography.H2 testId="profile-editor-title">
-          {profileEditorTitle}
+          {viewMode === "edit"
+            ? t(I18nKey.SETTINGS$EDIT_LLM_PROFILE)
+            : t(I18nKey.SETTINGS$ADD_LLM_PROFILE)}
         </Typography.H2>
         <p
           data-testid="profile-editor-description"
           className="text-sm leading-5 text-tertiary-light"
         >
-          {profileEditorDescription}
+          {viewMode === "edit" && editingProfile
+            ? t(I18nKey.SETTINGS$PROFILE_LOADED, {
+                name: editingProfile.profile.name,
+              })
+            : t(I18nKey.SETTINGS$PROFILE_SAVE_HINT)}
         </p>
       </div>
 
-      {/* Profile name input */}
       <ProfileNameInput
         testId="profile-name-input"
         value={profileName}
@@ -304,26 +312,39 @@ export function LlmSettingsLocalView() {
         isRequired
       />
 
-      {/* Profile form - key ensures form remounts when switching profiles */}
-      <LlmSettingsScreen
-        key={
-          viewMode === "edit"
-            ? `edit-${editingProfile?.profile.name}`
-            : "new-profile"
-        }
-        embedded
-        hideSaveButton
-        initialValueOverrides={
-          viewMode === "edit" && editingProfile?.initialValues
-            ? // Edit mode: use the existing profile values
-              editingProfile.initialValues
-            : // Create mode: start with empty fields for a fresh profile
-              { "llm.model": "", "llm.api_key": "", "llm.base_url": "" }
-        }
-        onSaveControlChange={handleSaveControlChange}
+      {/* Agent kind toggle: OpenHands profile (LLM) vs ACP profile. */}
+      <SettingsDropdownInput
+        testId="profile-kind-selector"
+        name="profile-kind"
+        label={t(I18nKey.SETTINGS$NAV_AGENT)}
+        items={[
+          { key: "openhands", label: t(I18nKey.SETTINGS$AGENT_TYPE_OPENHANDS) },
+          { key: "acp", label: t(I18nKey.SETTINGS$AGENT_TYPE_ACP) },
+        ]}
+        selectedKey={kind}
+        onSelectionChange={(key) => key && setKind(key as ProfileKind)}
       />
 
-      {/* Action buttons */}
+      {kind === "openhands" ? (
+        <LlmSettingsScreen
+          key={
+            viewMode === "edit"
+              ? `edit-${editingProfile?.profile.name}`
+              : "new-profile"
+          }
+          embedded
+          hideSaveButton
+          initialValueOverrides={
+            viewMode === "edit" && editingProfile?.initialValues
+              ? editingProfile.initialValues
+              : { "llm.model": "", "llm.api_key": "", "llm.base_url": "" }
+          }
+          onSaveControlChange={handleSaveControlChange}
+        />
+      ) : (
+        <AcpProfileForm value={acpValue} onChange={setAcpValue} />
+      )}
+
       <div className="flex justify-start gap-3 pt-4 border-t border-[var(--oh-border)]">
         <BrandButton
           testId="cancel-profile-btn"
@@ -338,7 +359,7 @@ export function LlmSettingsLocalView() {
           type="button"
           variant="primary"
           onClick={handleSave}
-          isDisabled={!isNameValid || isSaving || !saveControl}
+          isDisabled={saveDisabled}
           aria-busy={isSaving}
         >
           {isSaving ? t(I18nKey.STATUS$SAVING) : t(I18nKey.BUTTON$SAVE)}
diff --git a/src/constants/settings-nav.tsx b/src/constants/settings-nav.tsx
index 84ae8a1b6..7dbece463 100644
--- a/src/constants/settings-nav.tsx
+++ b/src/constants/settings-nav.tsx
@@ -1,7 +1,6 @@
 import { AppWindow, Shield } from "lucide-react";
 import KeyIcon from "#/icons/key.svg?react";
 import MemoryIcon from "#/icons/memory_icon.svg?react";
-import CircuitIcon from "#/icons/u-circuit.svg?react";
 import RobotIcon from "#/icons/u-robot.svg?react";
 
 export interface SettingsNavItem {
@@ -26,13 +25,6 @@ export const OSS_NAV_ITEMS: SettingsNavItem[] = [
     text: "SETTINGS$NAV_AGENT",
     subtitle: "SETTINGS$PAGE_AGENT_SUBLINE",
   },
-  {
-    icon: <CircuitIcon width={16} height={16} />,
-    to: "/settings/llm",
-    text: "SETTINGS$NAV_LLM",
-    subtitle: "SETTINGS$PAGE_LLM_SUBLINE",
-    disabledByAcp: true,
-  },
   {
     icon: <MemoryIcon width={16} height={16} />,
     to: "/settings/condenser",
diff --git a/src/i18n/translation.json b/src/i18n/translation.json
index 16e3f91ff..a7f7c9584 100644
--- a/src/i18n/translation.json
+++ b/src/i18n/translation.json
@@ -5201,6 +5201,40 @@
     "uk": "Виберіть рекомендовану модель ACP або введіть користувацьке перевизначення моделі. Вбудовані постачальники зберігають конкретну модель замість того, щоб залишати поле порожнім.",
     "ca": "Tria un model ACP suggerit o introdueix una substitució de model personalitzada. Els proveïdors integrats desen un model concret en lloc de deixar-lo en blanc."
   },
+  "SETTINGS$AGENT_ENV": {
+    "en": "Environment variables",
+    "ja": "環境変数",
+    "zh-CN": "环境变量",
+    "zh-TW": "環境變數",
+    "ko-KR": "환경 변수",
+    "no": "Miljøvariabler",
+    "it": "Variabili d'ambiente",
+    "pt": "Variáveis de ambiente",
+    "es": "Variables de entorno",
+    "ar": "متغيرات البيئة",
+    "fr": "Variables d'environnement",
+    "tr": "Ortam değişkenleri",
+    "de": "Umgebungsvariablen",
+    "uk": "Змінні середовища",
+    "ca": "Variables d'entorn"
+  },
+  "SETTINGS$AGENT_ENV_HINT": {
+    "en": "One KEY=value per line. Passed to the ACP subprocess (e.g. provider credentials). Stored encrypted at rest.",
+    "ja": "1行に KEY=value を1つ。ACP サブプロセスに渡されます（プロバイダーの認証情報など）。保存時は暗号化されます。",
+    "zh-CN": "每行一个 KEY=value。传递给 ACP 子进程（例如提供商凭据）。静态存储时加密。",
+    "zh-TW": "每行一個 KEY=value。傳遞給 ACP 子程序（例如供應商憑證）。靜態儲存時加密。",
+    "ko-KR": "한 줄에 KEY=value 하나씩. ACP 하위 프로세스에 전달됩니다(예: 공급자 자격 증명). 저장 시 암호화됩니다.",
+    "no": "Én KEY=verdi per linje. Sendes til ACP-underprosessen (f.eks. leverandørlegitimasjon). Lagres kryptert.",
+    "it": "Una KEY=valore per riga. Passata al sottoprocesso ACP (es. credenziali del provider). Memorizzata cifrata.",
+    "pt": "Um KEY=valor por linha. Passado para o subprocesso ACP (ex.: credenciais do provedor). Armazenado criptografado.",
+    "es": "Un KEY=valor por línea. Se pasa al subproceso ACP (p. ej., credenciales del proveedor). Se almacena cifrado.",
+    "ar": "زوج KEY=value واحد لكل سطر. يُمرَّر إلى العملية الفرعية ACP (مثل بيانات اعتماد المزود). يُخزَّن مشفرًا.",
+    "fr": "Un KEY=valeur par ligne. Transmis au sous-processus ACP (par ex. identifiants du fournisseur). Stocké chiffré.",
+    "tr": "Her satıra bir KEY=değer. ACP alt sürecine iletilir (ör. sağlayıcı kimlik bilgileri). Şifreli olarak saklanır.",
+    "de": "Ein KEY=Wert pro Zeile. Wird an den ACP-Subprozess übergeben (z. B. Anbieter-Anmeldedaten). Verschlüsselt gespeichert.",
+    "uk": "Один KEY=значення на рядок. Передається підпроцесу ACP (напр., облікові дані постачальника). Зберігається зашифрованим.",
+    "ca": "Un KEY=valor per línia. Es passa al subprocés ACP (p. ex. credencials del proveïdor). S'emmagatzema xifrat."
+  },
   "SETTINGS$AGENT_DISABLED_TOOLTIP": {
     "en": "Disabled while {{agentName}} is the active agent",
     "ja": "Disabled while {{agentName}} is the active agent",
diff --git a/src/routes/agent-settings.tsx b/src/routes/agent-settings.tsx
index f2668be7a..4d2f87815 100644
--- a/src/routes/agent-settings.tsx
+++ b/src/routes/agent-settings.tsx
@@ -1,493 +1,23 @@
-import React, { useEffect, useRef, useState } from "react";
-import { useTranslation } from "react-i18next";
-import { AxiosError } from "axios";
-import { useSettings } from "#/hooks/query/use-settings";
-import { useSaveSettings } from "#/hooks/mutation/use-save-settings";
-import { useAgentSettingsSchema } from "#/hooks/query/use-agent-settings-schema";
-import { SettingsDropdownInput } from "#/components/features/settings/settings-dropdown-input";
-import { SettingsInput } from "#/components/features/settings/settings-input";
-import { SettingsSwitch } from "#/components/features/settings/settings-switch";
-import { BrandButton } from "#/components/features/settings/brand-button";
-import { Typography } from "#/ui/typography";
-import { I18nKey } from "#/i18n/declaration";
-import { formControlSwitchDescriptionClassName } from "#/utils/form-control-classes";
-import { cn } from "#/utils/utils";
-import { SettingsFieldSchema } from "#/types/settings";
-import {
-  displayErrorToast,
-  displaySuccessToast,
-} from "#/utils/custom-toast-handlers";
-import { retrieveAxiosErrorMessage } from "#/utils/retrieve-axios-error-message";
-import {
-  resolveSchemaFieldDescription,
-  resolveSchemaFieldLabel,
-} from "#/utils/sdk-settings-field-metadata";
-import {
-  ACP_PROVIDERS,
-  ACP_CUSTOM_PRESET_KEY,
-  buildAcpAgentSettingsDiff,
-  getAcpProvider,
-  type ACPProviderConfig,
-} from "#/constants/acp-providers";
-import { parseCommand, formatCommand } from "#/utils/acp-command";
-
-export const handle = { hideTitle: true };
-
-type AgentType = "openhands" | "acp";
-
-const ENABLE_SUB_AGENTS_FIELD_KEY = "enable_sub_agents";
-const COMMAND_PLACEHOLDER_FALLBACK = "npx -y <package-name>";
-const ACP_CUSTOM_MODEL_KEY = "__custom_model__";
-
-function toStringArray(value: unknown): string[] {
-  return Array.isArray(value)
-    ? value.filter((v): v is string => typeof v === "string")
-    : [];
-}
-
-function detectPreset(
-  commandText: string,
-  providers: ACPProviderConfig[],
-): string {
-  const normalized = parseCommand(commandText).join(" ");
-  for (const provider of providers) {
-    if (normalized === provider.default_command.join(" ")) {
-      return provider.key;
-    }
+import { useActiveBackend } from "#/contexts/active-backend-context";
+import { LlmSettingsScreen } from "#/routes/llm-settings";
+import { LlmSettingsLocalView } from "#/components/features/settings/llm-profiles/llm-settings-local-view";
+
+/**
+ * Settings → Agent is the single surface for building an AgentProfile (#669).
+ *
+ * - Local backends: the unified AgentProfile editor — list profiles and
+ *   create/edit them with a kind toggle (OpenHands = LLM config, ACP =
+ *   provider / command / model / env). Save persists + activates the profile.
+ *   The former standalone "LLM" page is folded in here for the OpenHands kind.
+ * - Cloud backends: the standard LLM settings form (named profiles aren't
+ *   supported on cloud).
+ */
+export default function AgentSettingsRoute() {
+  const { backend } = useActiveBackend();
+
+  if (backend.kind === "cloud") {
+    return <LlmSettingsScreen />;
   }
-  return ACP_CUSTOM_PRESET_KEY;
-}
 
-function findEnableSubAgentsField(
-  fields: SettingsFieldSchema[] | undefined,
-): SettingsFieldSchema | undefined {
-  return fields?.find((field) => field.key === ENABLE_SUB_AGENTS_FIELD_KEY);
+  return <LlmSettingsLocalView />;
 }
-
-function getEnableSubAgentsValue(
-  settingsValue: unknown,
-  field: SettingsFieldSchema | undefined,
-) {
-  if (typeof settingsValue === "boolean") return settingsValue;
-  return field?.default === true;
-}
-
-function isKnownAcpModel(
-  provider: ACPProviderConfig | undefined,
-  model: string,
-): boolean {
-  return (
-    provider?.available_models?.some(({ id }) => id === model.trim()) ?? false
-  );
-}
-
-function AgentSettingsScreen() {
-  const { t } = useTranslation("openhands");
-  const { data: settings, isLoading } = useSettings();
-  const { mutate: saveSettings, isPending: isSaving } = useSaveSettings();
-  const { data: schema } = useAgentSettingsSchema(
-    settings?.agent_settings_schema,
-  );
-
-  // --- Sub-agents (OpenHands path) ---
-  const fields = React.useMemo(
-    () => schema?.sections.flatMap((section) => section.fields),
-    [schema],
-  );
-  const subAgentsField = findEnableSubAgentsField(fields);
-  const initialSubAgentsEnabled = React.useMemo(
-    () =>
-      getEnableSubAgentsValue(
-        settings?.agent_settings?.[ENABLE_SUB_AGENTS_FIELD_KEY],
-        subAgentsField,
-      ),
-    [subAgentsField, settings?.agent_settings],
-  );
-  const [subAgentsEnabled, setSubAgentsEnabled] = useState(
-    initialSubAgentsEnabled,
-  );
-
-  // --- ACP path ---
-  const [agentType, setAgentType] = useState<AgentType>("openhands");
-  const [commandText, setCommandText] = useState("");
-  const [acpModel, setAcpModel] = useState("");
-  const [isCustomAcpModel, setIsCustomAcpModel] = useState(false);
-  const [isDirty, setIsDirty] = useState(false);
-
-  const lastInitializedSettingsRef = useRef<unknown>(null);
-  const loadedAcpServerRef = useRef<string | null>(null);
-  const loadedCommandTextRef = useRef<string>("");
-
-  useEffect(() => {
-    if (!settings) return;
-    if (lastInitializedSettingsRef.current === settings) return;
-
-    lastInitializedSettingsRef.current = settings;
-    const kind = settings.agent_settings?.agent_kind;
-
-    if (kind === "acp") {
-      setAgentType("acp");
-
-      const rawAcpServer = settings.agent_settings?.acp_server;
-      const acpServer =
-        typeof rawAcpServer === "string" ? rawAcpServer : undefined;
-      const provider = getAcpProvider(acpServer);
-      const storedCommand = toStringArray(settings.agent_settings?.acp_command);
-      const effectiveBaseCommand =
-        storedCommand.length > 0
-          ? storedCommand
-          : (provider?.default_command ?? []);
-      const tokens = [
-        ...effectiveBaseCommand,
-        ...toStringArray(settings.agent_settings?.acp_args),
-      ];
-      const renderedCommandText =
-        tokens.length > 0 ? formatCommand(tokens) : "";
-      setCommandText(renderedCommandText);
-      loadedAcpServerRef.current = acpServer ?? null;
-      loadedCommandTextRef.current = renderedCommandText;
-
-      const savedModel = settings.agent_settings?.acp_model;
-      const normalizedSavedModel =
-        typeof savedModel === "string" ? savedModel.trim() : "";
-      setAcpModel(normalizedSavedModel || provider?.default_model || "");
-      setIsCustomAcpModel(
-        !!normalizedSavedModel &&
-          (!provider || !isKnownAcpModel(provider, normalizedSavedModel)),
-      );
-    } else {
-      setAgentType("openhands");
-      setCommandText("");
-      setAcpModel("");
-      loadedAcpServerRef.current = null;
-      loadedCommandTextRef.current = "";
-      setIsCustomAcpModel(false);
-    }
-    setIsDirty(false);
-  }, [settings]);
-
-  // Sync the sub-agents toggle when settings reload
-  useEffect(() => {
-    setSubAgentsEnabled(initialSubAgentsEnabled);
-  }, [initialSubAgentsEnabled]);
-
-  if (isLoading) return null;
-
-  const isAcp = agentType === "acp";
-  const commandTokens = parseCommand(commandText);
-  const isAcpInvalid = isAcp && commandTokens.length === 0;
-  const selectedPreset = detectPreset(commandText, ACP_PROVIDERS);
-  const selectedProvider = getAcpProvider(selectedPreset);
-  const modelSuggestions = selectedProvider?.available_models ?? [];
-  const hasModelSuggestions = modelSuggestions.length > 0;
-  const selectedModelIsSuggestion = isKnownAcpModel(selectedProvider, acpModel);
-  const selectedModelKey =
-    isCustomAcpModel || !selectedModelIsSuggestion
-      ? ACP_CUSTOM_MODEL_KEY
-      : acpModel;
-  const isDefaultProviderCommand =
-    !!selectedProvider &&
-    commandTokens.join(" ") === selectedProvider.default_command.join(" ");
-  const commandPlaceholder =
-    formatCommand(ACP_PROVIDERS[0]?.default_command ?? []) ||
-    COMMAND_PLACEHOLDER_FALLBACK;
-
-  // Dirty tracking: for OpenHands path, also check sub-agents toggle
-  const isOpenHandsDirty =
-    !isAcp && subAgentsEnabled !== initialSubAgentsEnabled;
-  const effectiveIsDirty = isDirty || isOpenHandsDirty;
-
-  const handleSave = () => {
-    if (isAcp) {
-      const useDefault = !!(selectedProvider && isDefaultProviderCommand);
-      const loadedServer = loadedAcpServerRef.current;
-      const commandUnchanged = commandText === loadedCommandTextRef.current;
-      const loadedServerIsUnknown =
-        !!loadedServer &&
-        loadedServer !== ACP_CUSTOM_PRESET_KEY &&
-        !ACP_PROVIDERS.some((p) => p.key === loadedServer);
-      const preserveUnknownServer =
-        isAcp && commandUnchanged && loadedServerIsUnknown;
-      const providerKey = preserveUnknownServer
-        ? (loadedServer as string)
-        : selectedProvider && isDefaultProviderCommand
-          ? selectedProvider.key
-          : ACP_CUSTOM_PRESET_KEY;
-      // ``model: undefined`` lets buildAcpAgentSettingsDiff seed the provider's
-      // ``default_model`` for built-in keys; for the custom preset it falls
-      // through to ``null`` since custom has no default.
-      const agentSettingsDiff = buildAcpAgentSettingsDiff(providerKey, {
-        command: useDefault ? [] : commandTokens,
-        model: acpModel.trim() || undefined,
-        allowUnknownServer: preserveUnknownServer,
-      });
-
-      if (!agentSettingsDiff) return;
-
-      saveSettings(
-        { agent_settings_diff: agentSettingsDiff },
-        {
-          onError: (error) => {
-            const message = retrieveAxiosErrorMessage(error as AxiosError);
-            displayErrorToast(message || t(I18nKey.ERROR$GENERIC));
-          },
-          onSuccess: () => {
-            displaySuccessToast(t(I18nKey.SETTINGS$SAVED));
-            setIsDirty(false);
-          },
-        },
-      );
-    } else {
-      // OpenHands path: save agent_kind + sub-agents toggle
-      saveSettings(
-        {
-          agent_settings_diff: {
-            agent_kind: "openhands",
-            enable_sub_agents: subAgentsEnabled,
-          },
-        },
-        {
-          onError: (error) => {
-            const message = retrieveAxiosErrorMessage(error as AxiosError);
-            displayErrorToast(message || t(I18nKey.ERROR$GENERIC));
-          },
-          onSuccess: () => {
-            displaySuccessToast(t(I18nKey.SETTINGS$SAVED));
-            setIsDirty(false);
-          },
-        },
-      );
-    }
-  };
-
-  // Sub-agents field metadata for OpenHands section
-  const subAgentsLabel = subAgentsField
-    ? resolveSchemaFieldLabel(t, subAgentsField.key, subAgentsField.label)
-    : t(I18nKey.SCHEMA$ENABLE_SUB_AGENTS$LABEL);
-  const subAgentsDescription = subAgentsField
-    ? resolveSchemaFieldDescription(
-        t,
-        subAgentsField.key,
-        subAgentsField.description,
-      )
-    : t(I18nKey.SCHEMA$ENABLE_SUB_AGENTS$DESCRIPTION);
-
-  return (
-    <div
-      data-testid="agent-settings-screen"
-      className="flex flex-col gap-6 pb-8 max-w-2xl"
-    >
-      <div>
-        <Typography.H2 className="mb-2">
-          {t(I18nKey.SETTINGS$NAV_AGENT)}
-        </Typography.H2>
-        <Typography.Paragraph className="text-sm text-[#A3A3A3]">
-          {t(I18nKey.SETTINGS$AGENT_PAGE_DESCRIPTION)}
-        </Typography.Paragraph>
-      </div>
-
-      <SettingsDropdownInput
-        testId="agent-type-selector"
-        name="agent-type"
-        label={t(I18nKey.SETTINGS$NAV_AGENT)}
-        items={[
-          {
-            key: "openhands",
-            label: t(I18nKey.SETTINGS$AGENT_TYPE_OPENHANDS),
-          },
-          { key: "acp", label: t(I18nKey.SETTINGS$AGENT_TYPE_ACP) },
-        ]}
-        selectedKey={agentType}
-        onSelectionChange={(key) => {
-          if (!key) return;
-          const newType = key as AgentType;
-          setAgentType(newType);
-          if (newType === "acp" && !commandText) {
-            const preferred = ACP_PROVIDERS[0];
-            if (preferred) {
-              setCommandText(formatCommand(preferred.default_command));
-              setAcpModel(preferred.default_model ?? "");
-              setIsCustomAcpModel(false);
-            }
-          } else if (newType === "openhands") {
-            setIsCustomAcpModel(false);
-          }
-          setIsDirty(true);
-        }}
-      />
-
-      {!isAcp && (
-        <div className="flex flex-col gap-1.5">
-          <SettingsSwitch
-            testId="agent-settings-enable-sub-agents"
-            isToggled={subAgentsEnabled}
-            onToggle={(val) => {
-              setSubAgentsEnabled(val);
-            }}
-          >
-            {subAgentsLabel}
-          </SettingsSwitch>
-          {subAgentsDescription ? (
-            <Typography.Paragraph
-              className={cn(
-                formControlSwitchDescriptionClassName,
-                "text-tertiary-alt text-xs leading-5",
-              )}
-            >
-              {subAgentsDescription}
-            </Typography.Paragraph>
-          ) : null}
-        </div>
-      )}
-
-      {isAcp && (
-        <>
-          <SettingsDropdownInput
-            testId="agent-preset-selector"
-            name="agent-preset"
-            label={t(I18nKey.SETTINGS$AGENT_PRESET)}
-            items={[
-              ...ACP_PROVIDERS.map((provider) => ({
-                key: provider.key,
-                label: provider.display_name,
-              })),
-              {
-                key: ACP_CUSTOM_PRESET_KEY,
-                label: t(I18nKey.SETTINGS$AGENT_PRESET_CUSTOM),
-              },
-            ]}
-            selectedKey={selectedPreset}
-            onSelectionChange={(key) => {
-              if (!key) return;
-              const preset = String(key);
-              const provider = getAcpProvider(preset);
-              if (provider) {
-                setCommandText(formatCommand(provider.default_command));
-                setAcpModel(provider.default_model ?? "");
-                setIsCustomAcpModel(false);
-              } else if (preset === ACP_CUSTOM_PRESET_KEY) {
-                // Clear command + model: the previous provider's default
-                // command would otherwise make detectPreset(commandText)
-                // re-match it on the next render and snap the dropdown back
-                // off "Custom". Clearing model also prevents leaking e.g.
-                // ``claude-opus-4-7`` into ``acp_model`` for an unrelated
-                // wrapper.
-                setCommandText("");
-                setAcpModel("");
-                setIsCustomAcpModel(true);
-              }
-              setIsDirty(true);
-            }}
-          />
-
-          <div className="flex flex-col gap-2.5">
-            <Typography.Text className="text-sm">
-              {t(I18nKey.SETTINGS$AGENT_COMMAND)}
-            </Typography.Text>
-            <textarea
-              data-testid="agent-command-input"
-              className="bg-tertiary border border-[#717888] rounded-sm p-2 text-sm font-mono text-white placeholder:text-[#717888] min-h-[60px] resize-y focus:outline-none focus:border-white"
-              value={commandText}
-              placeholder={commandPlaceholder}
-              onChange={(e) => {
-                const nextCommandText = e.target.value;
-                // Keep the model selector in sync with the command being
-                // typed. Editing the command into a *different* provider — or
-                // into a custom command — must drop the previous provider's
-                // model, or Save would silently persist e.g.
-                // ``claude-opus-4-7`` against a Codex / custom wrapper. The
-                // preset dropdown already does this; the textarea is the other
-                // way a user changes provider, so it needs the same
-                // reconciliation. Gated on the *detected preset* actually
-                // changing, so it never clobbers a model the user is editing
-                // within the same provider.
-                const prevPreset = detectPreset(commandText, ACP_PROVIDERS);
-                const nextPreset = detectPreset(nextCommandText, ACP_PROVIDERS);
-                if (nextPreset !== prevPreset) {
-                  const nextProvider = getAcpProvider(nextPreset);
-                  setAcpModel(nextProvider?.default_model ?? "");
-                  setIsCustomAcpModel(false);
-                }
-                setCommandText(nextCommandText);
-                setIsDirty(true);
-              }}
-            />
-            <Typography.Text className="text-xs text-[#717888]">
-              {t(I18nKey.SETTINGS$AGENT_COMMAND_HINT)}
-            </Typography.Text>
-          </div>
-
-          <div className="flex flex-col gap-1.5">
-            {hasModelSuggestions && (
-              <SettingsDropdownInput
-                testId="agent-model-selector"
-                name="agent-model"
-                label={t(I18nKey.SETTINGS$AGENT_MODEL)}
-                items={[
-                  ...modelSuggestions.map((model) => ({
-                    key: model.id,
-                    label: model.label,
-                  })),
-                  {
-                    key: ACP_CUSTOM_MODEL_KEY,
-                    label: t(I18nKey.SETTINGS$AGENT_PRESET_CUSTOM),
-                  },
-                ]}
-                selectedKey={selectedModelKey}
-                onSelectionChange={(key) => {
-                  if (!key) return;
-                  const modelKey = String(key);
-                  if (modelKey === ACP_CUSTOM_MODEL_KEY) {
-                    setIsCustomAcpModel(true);
-                    setAcpModel("");
-                  } else {
-                    setIsCustomAcpModel(false);
-                    setAcpModel(modelKey);
-                  }
-                  setIsDirty(true);
-                }}
-              />
-            )}
-            {selectedModelKey === ACP_CUSTOM_MODEL_KEY && (
-              <SettingsInput
-                testId="agent-model-input"
-                label={
-                  hasModelSuggestions
-                    ? t(I18nKey.SETTINGS$AGENT_CUSTOM_MODEL)
-                    : t(I18nKey.SETTINGS$AGENT_MODEL)
-                }
-                type="text"
-                className="w-full"
-                value={acpModel}
-                showOptionalTag
-                onChange={(value) => {
-                  setAcpModel(value);
-                  setIsDirty(true);
-                }}
-              />
-            )}
-            <Typography.Text className="text-xs text-[#717888]">
-              {t(I18nKey.SETTINGS$AGENT_MODEL_HINT)}
-            </Typography.Text>
-          </div>
-        </>
-      )}
-
-      <div>
-        <BrandButton
-          testId="agent-save-button"
-          type="button"
-          variant="primary"
-          isDisabled={isSaving || !effectiveIsDirty || isAcpInvalid}
-          onClick={handleSave}
-        >
-          {isSaving
-            ? t(I18nKey.SETTINGS$SAVING)
-            : t(I18nKey.SETTINGS$SAVE_CHANGES)}
-        </BrandButton>
-      </div>
-    </div>
-  );
-}
-
-export default AgentSettingsScreen;
diff --git a/src/routes/llm-settings.tsx b/src/routes/llm-settings.tsx
index e0df4dd2a..5690a139d 100644
--- a/src/routes/llm-settings.tsx
+++ b/src/routes/llm-settings.tsx
@@ -1,4 +1,5 @@
 import React from "react";
+import { Navigate } from "react-router";
 import { useTranslation } from "react-i18next";
 import { ModelSelector } from "#/components/shared/modals/settings/model-selector";
 import { useAgentSettingsSchema } from "#/hooks/query/use-agent-settings-schema";
@@ -11,11 +12,9 @@ import {
   SdkSectionPage,
   SdkSectionSaveControl,
 } from "#/components/features/settings/sdk-settings/sdk-section-page";
-import { LlmSettingsLocalView } from "#/components/features/settings/llm-profiles";
 import { I18nKey } from "#/i18n/declaration";
 import { Settings, SettingsSchema, SettingsScope } from "#/types/settings";
 import { extractModelAndProvider } from "#/utils/extract-model-and-provider";
-import { useActiveBackend } from "#/contexts/active-backend-context";
 import {
   inferInitialView,
   type SettingsFormValues,
@@ -308,26 +307,13 @@ export function LlmSettingsScreen({
 }
 
 /**
- * Default export for the route renders different views based on backend type:
- * - Local backends: LlmSettingsLocalView with profile management
- * - Cloud backends: Standard LlmSettingsScreen (profiles are not supported)
+ * The standalone LLM settings page has been folded into Settings → Agent
+ * (#669): for OpenHands the Agent page now owns the LLM config, and profiles
+ * are managed there. Redirect any remaining /settings/llm links accordingly.
  *
- * The LlmSettingsScreen component is also exported for embedded use cases
- * (e.g., onboarding, profile editing forms).
- *
- * Note: This is a route file, only the router should import the default export.
- * Other consumers should use the named export `LlmSettingsScreen` for embedded
- * use cases.
+ * The named {@link LlmSettingsScreen} export remains for embedded use
+ * (onboarding, the Agent page's OpenHands profile form, cloud).
  */
 export default function LlmSettingsRoute() {
-  const { backend } = useActiveBackend();
-  const isCloud = backend.kind === "cloud";
-
-  // Cloud backends use the standard LLM settings form (no profiles support)
-  if (isCloud) {
-    return <LlmSettingsScreen />;
-  }
-
-  // Local backends use the profile management view
-  return <LlmSettingsLocalView />;
+  return <Navigate to="/settings/agent" replace />;
 }