diff --git a/src/adapters/agents/kilo/index.ts b/src/adapters/agents/kilo/index.ts
index 44c4960..8cdf2b7 100644
--- a/src/adapters/agents/kilo/index.ts
+++ b/src/adapters/agents/kilo/index.ts
@@ -19,6 +19,7 @@ import {
   ambientUnset,
   anthropicOptions,
   collapsedTierWarning,
+  compatIgnoredWarning,
   sessionUnavailableWarning,
   extendedContextWarning,
   modelRef,
@@ -57,7 +58,7 @@ export const kilo = {
   },
   binary,
   translate(input: TranslateInput): Translation {
-    const { intent, passthrough } = input
+    const { intent, passthrough, profile } = input
     const primary = intent.models.opus
 
     const config: Record<string, unknown> = {
@@ -82,6 +83,8 @@ export const kilo = {
     if (collapse) warnings.push(collapse)
     const ext = extendedContextWarning(intent, primary, 'Kilo')
     if (ext) warnings.push(ext)
+    const compat = compatIgnoredWarning(profile.compat, 'Kilo')
+    if (compat) warnings.push(compat)
 
     return { plan: { set, unset: ambientUnset(intent) }, args: [...passthrough], warnings }
   },
diff --git a/src/adapters/agents/opencode/index.ts b/src/adapters/agents/opencode/index.ts
index 17336f0..0b9976b 100644
--- a/src/adapters/agents/opencode/index.ts
+++ b/src/adapters/agents/opencode/index.ts
@@ -16,6 +16,7 @@ import {
   ambientUnset,
   anthropicOptions,
   collapsedTierWarning,
+  compatIgnoredWarning,
   sessionUnavailableWarning,
   extendedContextWarning,
   modelRef,
@@ -56,7 +57,7 @@ export const opencode = {
   },
   binary,
   translate(input: TranslateInput): Translation {
-    const { intent, passthrough } = input
+    const { intent, passthrough, profile } = input
     const primary = intent.models.opus
     const small = intent.models.haiku
 
@@ -87,6 +88,8 @@ export const opencode = {
     if (collapse) warnings.push(collapse)
     const ext = extendedContextWarning(intent, primary, 'OpenCode')
     if (ext) warnings.push(ext)
+    const compat = compatIgnoredWarning(profile.compat, 'OpenCode')
+    if (compat) warnings.push(compat)
 
     return { plan: { set, unset: ambientUnset(intent) }, args, warnings }
   },
diff --git a/src/adapters/agents/shared.ts b/src/adapters/agents/shared.ts
index a41da85..593dffb 100644
--- a/src/adapters/agents/shared.ts
+++ b/src/adapters/agents/shared.ts
@@ -103,6 +103,35 @@ export function collapsedTierWarning(
   }
 }
 
+/**
+ * Warn when a profile carries gateway compatibility flags that this agent does
+ * not consume.
+ *
+ * The compat mechanism is Claude-Code-only (capabilities.compatFlags). A flag
+ * toggled on for a Kilo or OpenCode setup changes nothing and, until this
+ * existed, said so NOWHERE — not at edit, not at launch, not in the doctor.
+ * That is the one capability mismatch with no net, and the
+ * capability-gap-never-silently-dropped rule the tier and session warnings
+ * already follow says it should have one. The flags are kept, not stripped, so
+ * the setup still works when it runs Claude Code again.
+ */
+export function compatIgnoredWarning(
+  compat: Record<string, boolean | undefined> | undefined,
+  agentLabel: string,
+): EnvWarning | null {
+  const active = Object.entries(compat ?? {})
+    .filter(([, on]) => on)
+    .map(([id]) => id)
+  if (active.length === 0) return null
+  return {
+    severity: 'medium',
+    code: 'compat-ignored',
+    message:
+      `${agentLabel} does not use gateway compatibility flags; these are set but ignored: ` +
+      `${active.join(', ')}.`,
+  }
+}
+
 /**
  * Warn when a 1M-capable provider is reached without Claude Code's `[1m]`
  * signal, which only Claude Code sends. The model still runs; its window is
diff --git a/test/adapters/agents/kilo.test.ts b/test/adapters/agents/kilo.test.ts
index 1ddba9a..5e9eb9f 100644
--- a/test/adapters/agents/kilo.test.ts
+++ b/test/adapters/agents/kilo.test.ts
@@ -68,3 +68,35 @@ test('capabilities describe a single model slot', () => {
   assert.equal(kilo.binary.name, 'kilo')
   assert.equal(kilo.binary.overrideEnv, 'SWISSCODE_KILO_BIN')
 })
+
+test('a gateway compat flag on a Kilo profile is flagged as ignored — the safety net', () => {
+  // The UI now hides the compat section for Kilo, but a hand-edited or
+  // agent-switched config can still carry a flag. Compat is Claude-Code-only,
+  // so Kilo warns rather than silently doing nothing — the one mismatch that
+  // previously had no net at edit, launch, or doctor.
+  const input: TranslateInput = {
+    intent: intent(),
+    profile: makeProfile({ provider: 'zai', compat: { disableAdaptiveThinking: true } }),
+    provider: null,
+    passthrough: [],
+    ambient: {},
+  }
+  const w = kilo.translate(input).warnings.find((x) => x.code === 'compat-ignored')
+  assert.ok(w, 'Kilo should warn that a compat flag is ignored')
+  assert.match(w.message, /disableAdaptiveThinking/)
+  assert.match(w.message, /Kilo/)
+})
+
+test('a Kilo profile with no compat flags emits no compat-ignored warning', () => {
+  const input: TranslateInput = {
+    intent: intent(),
+    profile: makeProfile({ provider: 'zai' }),
+    provider: null,
+    passthrough: [],
+    ambient: {},
+  }
+  assert.equal(
+    kilo.translate(input).warnings.find((x) => x.code === 'compat-ignored'),
+    undefined,
+  )
+})
diff --git a/web/src/routes/Accounts.tsx b/web/src/routes/Accounts.tsx
index 1c2b39d..791de27 100644
--- a/web/src/routes/Accounts.tsx
+++ b/web/src/routes/Accounts.tsx
@@ -223,7 +223,12 @@ export function Accounts({ data, reload }: { data: Bootstrap; reload: () => Prom
     const isNew = !data.state.providerAccounts?.[editing]
     const provider = data.providers.find((p) => p.id === draft.provider)
     const stored = data.state.providerAccounts?.[editing]
-    const mode: 'key' | 'session' = draft.configDir ? 'session' : 'key'
+    // Session mode belongs to the first-party Anthropic endpoint: a provider
+    // with no baseUrl of its own that is not the custom "ask me" one. A gateway
+    // (baseUrl set) or a custom endpoint cannot read a ~/.claude login.
+    const sessionCapable = Boolean(provider && provider.baseUrl === null && !provider.askBaseUrl)
+    const mode: 'key' | 'session' =
+      draft.configDir && sessionCapable ? 'session' : 'key'
     return (
       <>
         <PageHeader
@@ -250,7 +255,20 @@ export function Accounts({ data, reload }: { data: Bootstrap; reload: () => Prom
             <select
               className={selectStyle}
               value={String(draft.provider ?? '')}
-              onChange={(e) => put('provider', e.target.value)}
+              onChange={(e) => {
+                const nextId = e.target.value
+                const next = data.providers.find((p) => p.id === nextId)
+                const nextSessionCapable = Boolean(next && next.baseUrl === null && !next.askBaseUrl)
+                setDraft((d) => ({
+                  ...d,
+                  provider: nextId,
+                  // A session login belongs to the first-party Anthropic
+                  // endpoint; switching to a gateway must not leave a stale
+                  // configDir that would send the ~/.claude token to a foreign
+                  // host. Drop it, reverting the account to key mode.
+                  ...(nextSessionCapable ? {} : { configDir: '' }),
+                }))
+              }}
             >
               {data.providers.map((p) => (
                 <option key={p.id} value={p.id}>
@@ -292,16 +310,27 @@ export function Accounts({ data, reload }: { data: Bootstrap; reload: () => Prom
                 naming nothing.
               */}
               <SectionLabel id={MODE_LABEL_ID}>How this account authenticates</SectionLabel>
-              <SegmentedControl
-                labelledBy={MODE_LABEL_ID}
-                options={CREDENTIAL_MODES}
-                value={mode}
-                onChange={(id) => put('configDir', id === 'session' ? '~/.claude' : '')}
-              />
-              <Note>
-                A key, or a login the agent already performed. Never both — the server refuses that
-                rather than picking one.
-              </Note>
+              {sessionCapable ? (
+                <>
+                  <SegmentedControl
+                    labelledBy={MODE_LABEL_ID}
+                    options={CREDENTIAL_MODES}
+                    value={mode}
+                    onChange={(id) => put('configDir', id === 'session' ? '~/.claude' : '')}
+                  />
+                  <Note>
+                    A key, or a login the agent already performed. Never both — the server refuses
+                    that rather than picking one.
+                  </Note>
+                </>
+              ) : (
+                // Session mode is a subscription login held in ~/.claude, which
+                // only the first-party Anthropic endpoint reads. A gateway or a
+                // custom endpoint authenticates with a key, so the choice is not
+                // offered — it could only build an account that ships the wrong
+                // token to the wrong host.
+                <Note>{provider?.label ?? 'This provider'} authenticates with an API key.</Note>
+              )}
             </Stack>
 
             {/*
diff --git a/web/src/routes/AgentProfiles.tsx b/web/src/routes/AgentProfiles.tsx
index 4a2ec98..9d668e7 100644
--- a/web/src/routes/AgentProfiles.tsx
+++ b/web/src/routes/AgentProfiles.tsx
@@ -82,11 +82,18 @@ export function AgentProfiles({ data, reload }: { data: Bootstrap; reload: () =>
   const [error, setError] = useState<string | null>(null)
   const [warnings, setWarnings] = useState<string[]>([])
   const [picking, setPicking] = useState<string | null>(null)
+  // The provider whose catalog the Browse buttons search. `null` means "derive a
+  // sensible default" — see the editor. It is a LENS, never stored: a model id
+  // pinned here is a bare, provider-agnostic string, so which catalog you
+  // browsed it from is not part of the saved setup.
+  const [browseProviderId, setBrowseProviderId] = useState<string | null>(null)
 
   const open = (name: string | null) => {
     setError(null)
     setWarnings([])
     setEditing(name ?? '')
+    // Re-derive the browse default for whichever profile just opened.
+    setBrowseProviderId(null)
     setDraft(name ? { ...data.state.agentProfiles[name] } : { models: {}, compat: {} })
   }
 
@@ -130,13 +137,54 @@ export function AgentProfiles({ data, reload }: { data: Bootstrap; reload: () =>
   if (editing !== null) {
     const isNew = !data.state.agentProfiles?.[editing]
     const users = usersOf(editing)
-    // Borrow a provider from a profile that uses this setup, purely so the
-    // picker has a catalog to browse.
-    const viaProfile = users.map((n) => data.state.profiles[n]).find(Boolean)
-    const viaAccount = viaProfile?.accounts?.[0]
-      ? data.state.providerAccounts?.[viaProfile.accounts[0]]
-      : undefined
-    const provider = data.providers.find((p) => p.id === viaAccount?.provider)
+
+    // The agent decides how many model slots exist and which behaviour applies —
+    // `data.tiers` is Claude Code's four, but Kilo runs one model and OpenCode a
+    // primary + a small. Reading capabilities here is what stops the editor
+    // offering inputs and flags the selected agent silently ignores.
+    const agentId = (draft.agent as string) || 'claude-code'
+    const agentInfo = data.agents.find((a) => a.id === agentId)
+    const modelShape = agentInfo?.capabilities.models ?? 'tiers'
+    const supportsCompat = agentInfo?.capabilities.compatFlags ?? true
+    const usesExtendedContext = agentInfo?.capabilities.extendedContextSuffix ?? true
+    // The slots to show, mapped onto the tier keys the adapters actually read:
+    // Kilo reads `opus`; OpenCode reads `opus` (primary) + `haiku` (small);
+    // Claude Code reads all four. Hidden tiers keep their stored value.
+    const visibleSlots: { tier: string; label: string }[] =
+      modelShape === 'single'
+        ? [{ tier: 'opus', label: 'model' }]
+        : modelShape === 'primary+small'
+          ? [
+              { tier: 'opus', label: 'primary' },
+              { tier: 'haiku', label: 'small' },
+            ]
+          : data.tiers.map((t) => ({ tier: t, label: t }))
+
+    // The catalog LENS: browse against a chosen provider rather than an implicit
+    // borrow. Default to the provider a downstream profile pairs this setup with,
+    // then the default profile's provider, then any browsable one — but let the
+    // user change it, and never store the choice.
+    const borrowedProviderId = (() => {
+      const viaProfile = users.map((n) => data.state.profiles[n]).find(Boolean)
+      const acc = viaProfile?.accounts?.[0]
+        ? data.state.providerAccounts?.[viaProfile.accounts[0]]
+        : undefined
+      return acc?.provider
+    })()
+    const defaultProfileProviderId = (() => {
+      const dp = data.state.defaultProfile ? data.state.profiles?.[data.state.defaultProfile] : null
+      const acc = dp?.accounts?.[0] ? data.state.providerAccounts?.[dp.accounts[0]] : undefined
+      return acc?.provider
+    })()
+    const firstBrowsableId = data.providers.find((p) => p.catalogId)?.id
+    const activeBrowseId =
+      browseProviderId ??
+      borrowedProviderId ??
+      defaultProfileProviderId ??
+      firstBrowsableId ??
+      data.providers[0]?.id ??
+      null
+    const provider = data.providers.find((p) => p.id === activeBrowseId) ?? null
     const browsable = Boolean(provider?.catalogId)
 
     return (
@@ -192,20 +240,48 @@ export function AgentProfiles({ data, reload }: { data: Bootstrap; reload: () =>
         <Panel
           title="Models"
           description={
-            'All four tiers, from one table. Claude Code reads the extended-context marker per ' +
-            'variable, so a tier left out is the bug where three run wide and the fourth silently ' +
-            'does not. Blank inherits the provider default.'
+            (modelShape === 'single'
+              ? `${agentInfo?.label ?? 'This agent'} runs a single model. `
+              : modelShape === 'primary+small'
+                ? `${agentInfo?.label ?? 'This agent'} runs a primary model and a small one for background work. `
+                : 'Claude Code runs a model per tier. ') +
+            (usesExtendedContext
+              ? 'It reads the extended-context marker per variable, so a tier left blank is the bug where the others run wide and it silently does not. '
+              : 'Each runs at the endpoint’s own context window. ') +
+            'Blank inherits the provider default.'
           }
         >
           <Stack gap="4">
+            {/* The catalog lens. Browsing needs a provider and this setup names
+                none of its own, so choose which one to browse against — it only
+                drives the Browse buttons and the default-model placeholders, and
+                is never saved onto the agent profile. */}
+            <Field
+              label="Browse models against"
+              hint="Which provider’s catalog the Browse buttons search. A model id is stored bare, so this choice is not part of the setup."
+            >
+              <select
+                className={selectStyle}
+                value={activeBrowseId ?? ''}
+                onChange={(e) => setBrowseProviderId(e.target.value)}
+              >
+                {data.providers.map((p) => (
+                  <option key={p.id} value={p.id}>
+                    {p.label}
+                    {p.catalogId ? '' : '  — no catalog'}
+                  </option>
+                ))}
+              </select>
+            </Field>
+
             {/* The label is not wrapped around its input the way `Field` wraps
                 one, because the two live in different grid columns — hence the
                 explicit htmlFor, which buys back the click target. */}
             <div className={modelGrid({ browsable })}>
-              {data.tiers.map((tier) => (
+              {visibleSlots.map(({ tier, label }) => (
                 <Fragment key={tier}>
                   <label className={tierLabel} htmlFor={`model-${tier}`}>
-                    {tier}
+                    {label}
                   </label>
                   <input
                     id={`model-${tier}`}
@@ -218,11 +294,8 @@ export function AgentProfiles({ data, reload }: { data: Bootstrap; reload: () =>
                 </Fragment>
               ))}
             </div>
-            {!provider ? (
-              <Note>
-                No profile uses this setup yet, so there is no provider to browse a catalog from.
-                Type ids by hand, or attach it to a profile first.
-              </Note>
+            {provider && !browsable ? (
+              <Note>{provider.label} publishes no browsable catalog — type ids by hand.</Note>
             ) : null}
           </Stack>
         </Panel>
@@ -258,29 +331,49 @@ export function AgentProfiles({ data, reload }: { data: Bootstrap; reload: () =>
             <Checkbox
               checked={Boolean(draft.skipPermissions)}
               onChange={(v) => put('skipPermissions', v)}
+              // Neutral wording: every agent supports skipping prompts, but each
+              // lowers it differently (Claude Code's --dangerously-skip-permissions,
+              // OpenCode's --auto, Kilo's config permission block), so the concrete
+              // flag is shown only for the agent that actually receives it.
               label={
-                <>
-                  Skip permission prompts <Code>--dangerously-skip-permissions</Code>
-                </>
+                agentId === 'claude-code' ? (
+                  <>
+                    Skip permission prompts <Code>--dangerously-skip-permissions</Code>
+                  </>
+                ) : (
+                  <>Skip permission prompts</>
+                )
               }
             />
 
-            <Stack gap="2">
-              <SectionLabel>Gateway compatibility</SectionLabel>
-              {/* A flag that trades something away says what it costs, here as
-                  well as on stderr — as the checkbox's note, so the price reads
-                  as belonging to that flag rather than competing with its name. */}
-              {data.compatFlags.map((flag) => (
-                <Checkbox
-                  key={flag.id}
-                  checked={Boolean(compat[flag.id])}
-                  onChange={(v) => put('compat', { ...compat, [flag.id]: v })}
-                  label={<Mono>{flag.id}</Mono>}
-                  note={flag.consequence ? `costs: ${flag.consequence}` : undefined}
-                  noteTone="warn"
-                />
-              ))}
-            </Stack>
+            {/* Gateway compat is a Claude-Code-only mechanism (capabilities.compatFlags).
+                For an agent that does not consume it, a checked box would be a
+                pure silent no-op — nothing catches it at launch or in the doctor —
+                so the section is hidden, and a note explains any flags a previous
+                Claude Code setup left behind rather than dropping them. */}
+            {supportsCompat ? (
+              <Stack gap="2">
+                <SectionLabel>Gateway compatibility</SectionLabel>
+                {/* A flag that trades something away says what it costs, here as
+                    well as on stderr — as the checkbox's note, so the price reads
+                    as belonging to that flag rather than competing with its name. */}
+                {data.compatFlags.map((flag) => (
+                  <Checkbox
+                    key={flag.id}
+                    checked={Boolean(compat[flag.id])}
+                    onChange={(v) => put('compat', { ...compat, [flag.id]: v })}
+                    label={<Mono>{flag.id}</Mono>}
+                    note={flag.consequence ? `costs: ${flag.consequence}` : undefined}
+                    noteTone="warn"
+                  />
+                ))}
+              </Stack>
+            ) : Object.values(compat).some(Boolean) ? (
+              <Note tone="warn">
+                {agentInfo?.label ?? 'This agent'} does not use gateway compatibility flags; the ones
+                set here are kept but ignored until this setup runs Claude Code again.
+              </Note>
+            ) : null}
           </Stack>
         </Panel>
 
@@ -320,7 +413,21 @@ export function AgentProfiles({ data, reload }: { data: Bootstrap; reload: () =>
           <DataList>
             {agentProfiles.map(([name, ap]) => {
               const users = usersOf(name)
-              const pinned = data.tiers.filter((t) => ap.models?.[t]).length
+              // Count only the slots this agent actually reads — a Kilo setup
+              // with an opus id is "1 model", not "1 of 4 tiers".
+              const shape = data.agents.find((a) => a.id === (ap.agent ?? 'claude-code'))?.capabilities
+                .models
+              const slots =
+                shape === 'single' ? ['opus'] : shape === 'primary+small' ? ['opus', 'haiku'] : data.tiers
+              const pinned = slots.filter((t) => ap.models?.[t]).length
+              const modelsLabel =
+                shape === 'single'
+                  ? pinned > 0
+                    ? '1 model'
+                    : 'provider default'
+                  : pinned > 0
+                    ? `${pinned} of ${slots.length} ${shape === 'primary+small' ? 'models' : 'tiers'} pinned`
+                    : 'provider defaults'
               return (
                 <DataRow
                   key={name}
@@ -345,11 +452,7 @@ export function AgentProfiles({ data, reload }: { data: Bootstrap; reload: () =>
                       <KeyValue label="Agent" mono>
                         {ap.agent ?? 'claude-code'}
                       </KeyValue>
-                      <KeyValue label="Models">
-                        {pinned > 0
-                          ? `${pinned} of ${data.tiers.length} tiers pinned`
-                          : 'provider defaults'}
-                      </KeyValue>
+                      <KeyValue label="Models">{modelsLabel}</KeyValue>
                       <KeyValue label="Used by" tone={users.length > 0 ? 'default' : 'neutral'}>
                         {users.length > 0 ? users.join(', ') : 'nothing yet'}
                       </KeyValue>
diff --git a/web/src/routes/Profiles.tsx b/web/src/routes/Profiles.tsx
index 5f27a8a..bc4f697 100644
--- a/web/src/routes/Profiles.tsx
+++ b/web/src/routes/Profiles.tsx
@@ -26,6 +26,7 @@ import {
   selectStyle,
 } from '../ui'
 import { EmptyState } from '../Brand'
+import { credentialSource } from '../../../src/core/account'
 
 /**
  * Profiles — the pairing, and the only screen that expresses MULTIPLE accounts.
@@ -229,7 +230,16 @@ export function Profiles({ data, reload }: { data: Bootstrap; reload: () => Prom
                         <span className={refResolved}>
                           <Mono>{a.provider}</Mono>
                         </span>
-                        {a.hasKey || a.apiKeyFromEnv ? null : <Badge tone="warn">no key</Badge>}
+                        {/* A session account is authenticated by its login, not a
+                            key, so "no key" is only a warning for an account that
+                            carries no credential of any kind. `credentialSource`
+                            reads the redacted `hasKey`, so the browser and the
+                            server agree on what counts. */}
+                        {credentialSource(a) === 'none' ? (
+                          <Badge tone="warn">no credential</Badge>
+                        ) : credentialSource(a) === 'conflict' ? (
+                          <Badge tone="danger">key + login</Badge>
+                        ) : null}
                       </span>
                     }
                   />