diff --git a/console/index.html b/console/index.html
index ce892e2..1deea95 100644
--- a/console/index.html
+++ b/console/index.html
@@ -46,6 +46,35 @@
           </div>
         </form>
       </section>
+      <section id="agents" class="agents-wrap">
+        <div class="agents-head">
+          <span class="agents-label">agent consoles</span>
+          <span class="agents-sub">select an agent to open its console — chat + read-only config</span>
+        </div>
+        <div id="agent-list" class="agent-list"></div>
+        <div id="agent-console" class="agent-console" hidden>
+          <div class="ac-head">
+            <span class="ac-title">agent console</span>
+            <span class="ac-spacer"></span>
+            <button class="ac-close" type="button" data-action="close-console">Close</button>
+          </div>
+          <div id="ac-config" class="ac-config"></div>
+          <div class="ac-chat chat-wrap">
+            <div class="chat-head">
+              <span class="chat-title">Chat</span>
+              <span class="chat-conn" id="ac-chat-conn">disconnected</span>
+            </div>
+            <div id="ac-chat-log" class="chat-log"></div>
+            <form id="ac-chat-form" class="chat-input">
+              <textarea id="ac-chat-text" class="chat-text" rows="2" placeholder="Message this agent…  (Enter to send · Shift+Enter for a newline)"></textarea>
+              <div class="chat-actions">
+                <button type="button" id="ac-chat-stop" class="chat-btn chat-stop" hidden>Stop</button>
+                <button type="submit" id="ac-chat-send" class="chat-btn chat-send">Send</button>
+              </div>
+            </form>
+          </div>
+        </div>
+      </section>
       <section class="logs">
         <nav class="tabs" id="tabs">
           <button class="tab is-active" data-target="log">Activity</button>
diff --git a/console/src/agentConsole.ts b/console/src/agentConsole.ts
new file mode 100644
index 0000000..2502798
--- /dev/null
+++ b/console/src/agentConsole.ts
@@ -0,0 +1,185 @@
+// The agent-console shell (ADR agent-consoles, Part C): an endpoint selector +
+// a per-agent console that dials the endpoint, shows its read-only config, and
+// mounts the reusable chat primitive bound to that agent. The operator opens one
+// console at a time (ADR §7 bounded fan-out), so this owns a single open console
+// and a clean open→dial / close→teardown lifecycle.
+//
+// It stays out of the transcript/turn machinery — that is `chatPanel.ts`. Its
+// job is selection, the dial/teardown, the read-only config header, and
+// registering the mounted panel in the shared event-router map so `main.ts` can
+// route this agent's `agent-update` / `remote-status` events to it. The remote
+// file editor (view/edit/apply) is a later slice; config is read-only here.
+
+import type { Source } from "./source";
+import type { AgentEndpointView } from "./types";
+import { createChatPanel, type ChatPanel } from "./chatPanel";
+import { renderAgentList, agentConsoleHeaderHtml } from "./render";
+
+export interface AgentConsoleConfig {
+  source: Source;
+  // Browser build (no live agent) → the mounted panel drives a canned reply.
+  mock: boolean;
+  note: (level: "info" | "error", msg: string) => void;
+  // The shared event-router map (keyed by endpoint name) `main.ts` dispatches
+  // backend events through. The open console registers/unregisters its panel here.
+  panels: Map<string, ChatPanel>;
+  // The management endpoint's name (resolved async in `main.ts`) — read lazily so
+  // the console never tries to re-key a name the management console owns.
+  managementName: () => string | null;
+}
+
+export interface AgentConsole {
+  // Re-fetch the registry and re-render the selector.
+  refresh(): Promise<void>;
+  // Reflect a live `remote-status` on the open console's badge (no-op otherwise).
+  onStatus(agent: string, status: string): void;
+  dispose(): void;
+}
+
+export function initAgentConsole(cfg: AgentConsoleConfig): AgentConsole {
+  const listEl = document.getElementById("agent-list");
+  const consoleEl = document.getElementById("agent-console");
+  const configEl = document.getElementById("ac-config");
+  const log = document.getElementById("ac-chat-log");
+  const form = document.getElementById("ac-chat-form") as HTMLFormElement | null;
+  const text = document.getElementById("ac-chat-text") as HTMLTextAreaElement | null;
+  const send = document.getElementById("ac-chat-send") as HTMLButtonElement | null;
+  const stop = document.getElementById("ac-chat-stop") as HTMLButtonElement | null;
+  const conn = document.getElementById("ac-chat-conn");
+
+  const noop: AgentConsole = {
+    refresh: async () => {},
+    onStatus: () => {},
+    dispose: () => {},
+  };
+  if (!listEl || !consoleEl) return noop;
+
+  let agents: AgentEndpointView[] = [];
+  let openName: string | null = null;
+  let panel: ChatPanel | null = null;
+  const ac = new AbortController();
+  const { signal } = ac;
+
+  function errText(e: unknown): string {
+    return e instanceof Error ? e.message : String(e);
+  }
+
+  function find(name: string): AgentEndpointView | undefined {
+    return agents.find((a) => a.name === name);
+  }
+
+  function renderList(): void {
+    if (listEl) renderAgentList(listEl, agents, openName);
+  }
+
+  function renderHeader(status: string): void {
+    const a = openName ? find(openName) : undefined;
+    if (!configEl || !a) return;
+    configEl.innerHTML = agentConsoleHeaderHtml(a, status);
+  }
+
+  async function refresh(): Promise<void> {
+    try {
+      agents = await cfg.source.remoteAgents();
+    } catch (e) {
+      agents = [];
+      cfg.note("error", `agents: registry load failed — ${errText(e)}`);
+    }
+    renderList();
+    // Keep an open console's header status in sync with the refreshed registry.
+    if (openName) renderHeader(find(openName)?.status ?? "disconnected");
+  }
+
+  // Tear down the open console: dispose its panel, drop it from the router, hide
+  // the section, and disconnect the endpoint. Safe to call with nothing open.
+  function close(): void {
+    if (!openName) return;
+    const name = openName;
+    openName = null;
+    panel?.dispose();
+    panel = null;
+    cfg.panels.delete(name);
+    if (consoleEl) consoleEl.hidden = true;
+    // Fire-and-forget teardown; a failed disconnect is logged, not fatal.
+    void cfg.source.remoteDisconnect(name).catch((e) => {
+      cfg.note("error", `agents: disconnect ${name} failed — ${errText(e)}`);
+    });
+    cfg.note("info", `agents: closed console for "${name}"`);
+    renderList();
+  }
+
+  // Open a console for a named endpoint: teardown any current one, mount a chat
+  // panel bound to this agent, render its read-only config, and dial the
+  // endpoint. The management endpoint is never opened here (it has its own
+  // console); unconfigured endpoints are not dialable.
+  async function open(name: string): Promise<void> {
+    if (name === openName) return;
+    if (name === cfg.managementName()) return; // has its own top-level console
+    const a = find(name);
+    if (!a || !a.configured) return;
+    close();
+    openName = name;
+    if (consoleEl) consoleEl.hidden = false;
+    // Optimistic "connecting" until the first `remote-status` (or ready in mock).
+    renderHeader(cfg.mock ? "connected" : "connecting");
+    renderList();
+    if (log && form && text && send && stop && conn) {
+      panel = createChatPanel(
+        { log, form, text, send, stop, conn },
+        {
+          agent: name,
+          source: cfg.source,
+          mock: cfg.mock,
+          note: cfg.note,
+          notReadyLabel: "connecting to the agent…",
+        },
+      );
+      cfg.panels.set(name, panel);
+    }
+    try {
+      await cfg.source.remoteConnect(name);
+      cfg.note("info", `agents: opened console for "${name}" — dialing ${a.url}`);
+    } catch (e) {
+      cfg.note("error", `agents: connect ${name} failed — ${errText(e)}`);
+      renderHeader(`error: ${errText(e)}`);
+    }
+  }
+
+  function onStatus(agent: string, status: string): void {
+    // Update the cached entry so the selector badge reflects it too.
+    const a = find(agent);
+    if (a) a.status = status;
+    renderList();
+    if (agent === openName) renderHeader(status);
+  }
+
+  // Delegated: a selector row opens its endpoint; the console's Close tears down.
+  listEl.addEventListener(
+    "click",
+    (ev) => {
+      const btn = (ev.target as HTMLElement).closest<HTMLElement>("[data-agent]");
+      if (btn?.dataset.agent) void open(btn.dataset.agent);
+    },
+    { signal },
+  );
+  consoleEl.addEventListener(
+    "click",
+    (ev) => {
+      if ((ev.target as HTMLElement).closest('[data-action="close-console"]')) {
+        close();
+      }
+    },
+    { signal },
+  );
+
+  void refresh();
+
+  return {
+    refresh,
+    onStatus,
+    dispose: () => {
+      close();
+      ac.abort();
+    },
+  };
+}
diff --git a/console/src/chatPanel.ts b/console/src/chatPanel.ts
new file mode 100644
index 0000000..3511b9f
--- /dev/null
+++ b/console/src/chatPanel.ts
@@ -0,0 +1,269 @@
+// The chat panel as a **reusable primitive** (ADR agent-consoles Part A: "the
+// chat panel is one component, instantiated against a chosen endpoint"). Both
+// the management console and each per-agent console mount one of these; the only
+// difference is the endpoint the turns are sent to (`opts.agent`) and the DOM it
+// binds. All the turn machinery — the transcript, the one-turn-at-a-time queue,
+// the streaming spinner, stop/retry, copy — lives here so it is written once.
+//
+// The pure transcript reducers and HTML stay in `chat.ts` (unit-tested without a
+// DOM); this module owns the imperative shell: DOM writes, the `<form>`/keydown
+// listeners, and the queue. It does **not** subscribe to backend events itself —
+// the caller (`main.ts`) owns the single `agent-update` / `remote-status`
+// subscription and routes each event to the matching panel by endpoint name via
+// `onChunk` / `onTurnEnd` / `setConnected`. That keeps one listener for N panels
+// and makes routing explicit.
+
+import DOMPurify from "dompurify";
+import {
+  transcriptHtml,
+  mdToHtml,
+  appendUser,
+  appendChunk,
+  endTurn,
+  type ChatTurn,
+} from "./chat";
+import type { Source } from "./source";
+
+// The DOM a panel drives. The management console and each agent console pass
+// their own set of these (same roles, different nodes).
+export interface ChatPanelElements {
+  log: HTMLElement;
+  form: HTMLFormElement;
+  text: HTMLTextAreaElement;
+  send: HTMLButtonElement;
+  stop: HTMLButtonElement;
+  conn: HTMLElement;
+}
+
+export interface ChatPanelOptions {
+  // The registry endpoint name turns are sent to (`agentPrompt`/`agentCancel`
+  // pass it through). Omitted ⇒ the management endpoint (legacy single-console
+  // commands). Event routing keys off this same name in `main.ts`.
+  agent?: string;
+  source: Source;
+  // True in the browser build (no live agent): drive a canned reply locally so
+  // the panel stays demonstrable without a gateway.
+  mock: boolean;
+  note: (level: "info" | "error", msg: string) => void;
+  // Shown on the connection pill when chat isn't usable yet. Defaults to the
+  // management console's wording; an agent console overrides it (it auto-dials).
+  notReadyLabel?: string;
+}
+
+// The imperative handle the caller drives. `onChunk`/`onTurnEnd` feed streamed
+// backend events in; `setConnected` reflects the live transport state; `dispose`
+// tears down the DOM listeners (an agent console re-binds a panel per selection).
+export interface ChatPanel {
+  readonly agent?: string;
+  onChunk(text: string): void;
+  onTurnEnd(stopReason: string): void;
+  setConnected(connected: boolean): void;
+  isConnected(): boolean;
+  render(): void;
+  dispose(): void;
+}
+
+// Untrusted agent markdown → HTML: markdown-it escapes raw HTML and blocks
+// dangerous link protocols; DOMPurify is the second layer (ADR: markdown-it +
+// DOMPurify). Only the agent-markdown body takes this — user text and the
+// panel's own chrome are escaped/trusted in `chat.ts`.
+function renderAgentBody(text: string): string {
+  return DOMPurify.sanitize(mdToHtml(text));
+}
+
+export function createChatPanel(
+  els: ChatPanelElements,
+  opts: ChatPanelOptions,
+): ChatPanel {
+  const notReady = opts.notReadyLabel ?? "activate the remote connection to chat";
+  // Per-panel transcript state (was module-global in main.ts's single console).
+  let turns: ChatTurn[] = [];
+  let turnActive = false;
+  const queue: string[] = [];
+  let seq = 0;
+  let connected = false;
+  // DOM listeners are scoped to this controller so `dispose()` removes them all
+  // at once — an agent console mounts a fresh panel each time it opens.
+  const ac = new AbortController();
+  const { signal } = ac;
+
+  function errText(e: unknown): string {
+    return e instanceof Error ? e.message : String(e);
+  }
+
+  // Chat is usable once the connection is live (or always, in the mock).
+  function ready(): boolean {
+    return opts.mock || connected;
+  }
+
+  function render(): void {
+    els.log.innerHTML = transcriptHtml(turns, renderAgentBody);
+    els.log.scrollTop = els.log.scrollHeight; // keep the latest turn in view
+  }
+
+  function updateControls(): void {
+    const r = ready();
+    els.send.disabled = !r;
+    els.text.disabled = !r;
+    els.stop.hidden = !turnActive;
+    const label = !r ? notReady : turnActive ? "agent is responding…" : "connected";
+    els.conn.textContent = label;
+    els.conn.classList.toggle("is-connected", r && !turnActive);
+    els.conn.classList.toggle("is-error", false);
+  }
+
+  // Enqueue a prompt and try to release it. `flush` is the single choke point
+  // that enforces one-turn-at-a-time; typing mid-turn just grows the queue.
+  function submit(text: string): void {
+    const trimmed = text.trim();
+    if (!trimmed) return;
+    queue.push(trimmed);
+    void flush();
+  }
+
+  async function flush(): Promise<void> {
+    if (turnActive) return; // a turn is in flight — wait for its `turn_end`
+    const next = queue.shift();
+    if (next === undefined) return;
+    turnActive = true;
+    seq += 1;
+    turns = appendUser(turns, seq, next);
+    render();
+    updateControls();
+    try {
+      await opts.source.agentPrompt(next, opts.agent);
+      if (opts.mock) mockReply(next); // browser preview: synthesize the reply
+    } catch (e) {
+      // Send failed (not connected / socket just closed): close the turn with an
+      // error, surface it, release the queue so a later prompt can still go.
+      turnActive = false;
+      opts.note("error", `chat: ${errText(e)}`);
+      seq += 1;
+      turns = endTurn(turns, seq, "error");
+      render();
+      updateControls();
+      void flush();
+    }
+  }
+
+  // A streamed `chunk`: open the agent turn on the first one (stable id for its
+  // copy button), append thereafter.
+  function onChunk(text: string): void {
+    const last = turns[turns.length - 1];
+    const open = last?.role === "agent" && last.streaming;
+    const id = open ? (last as ChatTurn).id : (seq += 1);
+    turns = appendChunk(turns, id, text);
+    render();
+  }
+
+  // `turn_end`: finalize the open agent turn (markdown render), free the gate,
+  // and release any queued prompt.
+  function onTurnEnd(stopReason: string): void {
+    seq += 1;
+    turns = endTurn(turns, seq, stopReason);
+    turnActive = false;
+    render();
+    updateControls();
+    void flush();
+  }
+
+  async function stopTurn(): Promise<void> {
+    if (!turnActive) return;
+    try {
+      await opts.source.agentCancel(opts.agent);
+      opts.note("info", "chat: cancel sent");
+    } catch (e) {
+      opts.note("error", `chat: cancel failed — ${errText(e)}`);
+    }
+    // The backend still emits a `turn_end` (stopReason `cancelled`), which clears
+    // `turnActive` and flushes the queue — no local state change needed here.
+  }
+
+  // Browser preview only: stream a short canned markdown reply so the chunk →
+  // turn_end → markdown path is visible without a live gateway.
+  function mockReply(prompt: string): void {
+    const parts = [
+      `You said: **${prompt}**.\n\n`,
+      "Here's what the panel renders:\n\n",
+      "- streamed *chunks*\n- then final `markdown`\n\n",
+      "```\ncode stays monospaced\n```",
+    ];
+    let i = 0;
+    const step = (): void => {
+      if (i < parts.length) {
+        onChunk(parts[i]);
+        i += 1;
+        window.setTimeout(step, 130);
+      } else {
+        onTurnEnd("end_turn");
+      }
+    };
+    window.setTimeout(step, 150);
+  }
+
+  function setConnected(next: boolean): void {
+    connected = next;
+    // If the socket drops mid-turn, no `turn_end` will arrive — close the open
+    // turn so the panel doesn't hang on a spinner.
+    if (!connected && turnActive) onTurnEnd("disconnected");
+    updateControls();
+  }
+
+  // ---- wiring ---------------------------------------------------------------
+  els.form.addEventListener(
+    "submit",
+    (ev) => {
+      ev.preventDefault();
+      submit(els.text.value);
+      els.text.value = "";
+    },
+    { signal },
+  );
+  // Enter sends; Shift+Enter inserts a newline.
+  els.text.addEventListener(
+    "keydown",
+    (ev) => {
+      if (ev.key === "Enter" && !ev.shiftKey) {
+        ev.preventDefault();
+        els.form.requestSubmit();
+      }
+    },
+    { signal },
+  );
+  els.stop.addEventListener("click", () => void stopTurn(), { signal });
+  // Delegated copy: copy the raw turn text (not the rendered HTML).
+  els.log.addEventListener(
+    "click",
+    (ev) => {
+      const btn = (ev.target as HTMLElement).closest<HTMLButtonElement>(
+        "button.chat-copy",
+      );
+      if (!btn) return;
+      const turn = turns.find((t) => t.id === Number(btn.dataset.copy));
+      if (!turn) return;
+      void navigator.clipboard?.writeText(turn.text).then(
+        () => {
+          btn.textContent = "Copied";
+          window.setTimeout(() => {
+            if (btn.isConnected) btn.textContent = "Copy";
+          }, 1500);
+        },
+        () => opts.note("error", "chat: copy failed"),
+      );
+    },
+    { signal },
+  );
+
+  render();
+  updateControls();
+
+  return {
+    agent: opts.agent,
+    onChunk,
+    onTurnEnd,
+    setConnected,
+    isConnected: () => connected,
+    render,
+    dispose: () => ac.abort(),
+  };
+}
diff --git a/console/src/fixtures.ts b/console/src/fixtures.ts
index f7c4500..673f031 100644
--- a/console/src/fixtures.ts
+++ b/console/src/fixtures.ts
@@ -1,10 +1,42 @@
 import type {
+  AgentEndpointView,
   Deployment,
   FleetConfig,
   RemoteConfig,
   RuntimeContext,
 } from "./types";
 
+// Stand-in endpoint registry so the browser build renders the agent-console
+// selector without a core. Mirrors src-tauri's `remote_agents`: one management
+// entry (backs the top-level console + reverse-MCP grant) plus ordinary agent
+// consoles. Tokens are never present — only whether each entry is configured.
+export const FIXTURE_AGENTS: AgentEndpointView[] = [
+  {
+    name: "orca",
+    url: "wss://orca-acp.example/acp",
+    cwd: "/home/node",
+    management: true,
+    configured: true,
+    status: "disconnected",
+  },
+  {
+    name: "mira",
+    url: "wss://mira-acp.example/acp",
+    cwd: "/home/node",
+    management: false,
+    configured: true,
+    status: "disconnected",
+  },
+  {
+    name: "falcon",
+    url: "",
+    cwd: "/home/node",
+    management: false,
+    configured: false,
+    status: "disconnected",
+  },
+];
+
 // Stand-in remote-connection view so the browser build renders the remote panel
 // without a core. A configured-but-disconnected example — the shape the panel
 // shows before the operator hits "Activate".
diff --git a/console/src/main.ts b/console/src/main.ts
index 8847741..2ef0b4c 100644
--- a/console/src/main.ts
+++ b/console/src/main.ts
@@ -10,15 +10,8 @@ import {
   deploymentKey,
 } from "./render";
 import type { Deployment, FleetConfig, RemoteConfig } from "./types";
-import {
-  transcriptHtml,
-  mdToHtml,
-  appendUser,
-  appendChunk,
-  endTurn,
-  type ChatTurn,
-} from "./chat";
-import DOMPurify from "dompurify";
+import { createChatPanel, type ChatPanel } from "./chatPanel";
+import { initAgentConsole, type AgentConsole } from "./agentConsole";
 import { createPane, bindBackend, type Level } from "./log";
 import { EditorView, basicSetup } from "codemirror";
 import { EditorState } from "@codemirror/state";
@@ -39,6 +32,7 @@ let activeCluster = DEFAULT_CLUSTER;
 let activeMembers: string[] = [];
 let fleetConfig: FleetConfig | null = null;
 let remoteConfig: RemoteConfig | null = null;
+let agentConsole: AgentConsole | null = null;
 
 const roster = document.getElementById("roster");
 const identityEl = document.getElementById("identity");
@@ -362,187 +356,83 @@ if (remoteEl) {
   });
 }
 
-// ---- chat panel (Part C) -----------------------------------------------------
-// The backend serves ONE turn at a time over the live `/acp` session (Part B):
-// `agent_prompt` sends a turn, and the reply streams back as `agent-update`
-// events (`chunk` → `turn_end`). `turnActive` gates sends; a prompt typed
-// mid-turn is queued and `flushQueue` releases the next only once the current
-// turn ends (the katashiro turn model). This UI-level gate means two turns never
-// overlap — so the backend's in-flight guard is a safety net, not the norm.
-let chatTurns: ChatTurn[] = [];
-let turnActive = false;
-const promptQueue: string[] = [];
-let chatSeq = 0;
-let remoteConnected = false;
-
-// True in the browser build (no Tauri shell): there is no live agent, so we drive
-// a canned reply locally to keep the panel demonstrable.
+// ---- chat panels (Part C, reusable primitive) --------------------------------
+// The chat panel is one component (`chatPanel.ts`) instantiated per endpoint. The
+// management console mounts one against the management binding; each agent
+// console mounts one against its agent (`agentConsole.ts`). This module owns the
+// single `agent-update` / `remote-status` subscription and routes each event to
+// the matching panel by endpoint name — the backend tags every event with the
+// agent it belongs to, so N panels share one listener.
+const chatPanels = new Map<string, ChatPanel>();
+
+// True in the browser build (no Tauri shell): there is no live agent, so panels
+// drive a canned reply locally to stay demonstrable.
 function isMock(): boolean {
   return tauriInvoke() === undefined;
 }
 
-// Chat is usable once the remote connection is live (or always, in the mock).
-function chatReady(): boolean {
-  return isMock() || remoteConnected;
-}
-
-// Untrusted agent markdown → HTML: markdown-it escapes raw HTML and blocks
-// dangerous link protocols; DOMPurify is the second layer (ADR: markdown-it +
-// DOMPurify). Only the agent-markdown body takes this — user text and the
-// panel's own chrome are escaped/trusted in `chat.ts`.
-function renderAgentBody(text: string): string {
-  return DOMPurify.sanitize(mdToHtml(text));
-}
-
-function renderChat(): void {
-  if (!chatLogEl) return;
-  chatLogEl.innerHTML = transcriptHtml(chatTurns, renderAgentBody);
-  chatLogEl.scrollTop = chatLogEl.scrollHeight; // keep the latest turn in view
-}
-
-function updateChatControls(): void {
-  const ready = chatReady();
-  if (chatSendEl) chatSendEl.disabled = !ready;
-  if (chatTextEl) chatTextEl.disabled = !ready;
-  if (chatStopEl) chatStopEl.hidden = !turnActive;
-  if (chatConnEl) {
-    const label = !ready
-      ? "activate the remote connection to chat"
-      : turnActive
-        ? "agent is responding…"
-        : "connected";
-    chatConnEl.textContent = label;
-    chatConnEl.classList.toggle("is-connected", ready && !turnActive);
-    chatConnEl.classList.toggle("is-error", false);
-  }
+// The management console's chat panel + the endpoint name its events carry. The
+// panel is built at boot; its name is learned from the registry (the
+// `management: true` entry) so events tagged with that name route here. `agent:
+// undefined` ⇒ the legacy single-console commands (no `agent` arg).
+let managementPanel: ChatPanel | null = null;
+let managementName: string | null = null;
+
+function buildManagementPanel(): void {
+  if (
+    !chatLogEl ||
+    !chatFormEl ||
+    !chatTextEl ||
+    !chatSendEl ||
+    !chatStopEl ||
+    !chatConnEl
+  )
+    return;
+  managementPanel = createChatPanel(
+    {
+      log: chatLogEl,
+      form: chatFormEl,
+      text: chatTextEl,
+      send: chatSendEl,
+      stop: chatStopEl,
+      conn: chatConnEl,
+    },
+    { source, mock: isMock(), note },
+  );
 }
 
-// Enqueue a prompt and try to release it. `flushQueue` is the single choke point
-// that enforces one-turn-at-a-time; typing mid-turn just grows the queue.
-function submitPrompt(text: string): void {
-  const trimmed = text.trim();
-  if (!trimmed) return;
-  promptQueue.push(trimmed);
-  void flushQueue();
-}
-
-async function flushQueue(): Promise<void> {
-  if (turnActive) return; // a turn is in flight — wait for its `turn_end`
-  const next = promptQueue.shift();
-  if (next === undefined) return;
-  turnActive = true;
-  chatSeq += 1;
-  chatTurns = appendUser(chatTurns, chatSeq, next);
-  renderChat();
-  updateChatControls();
+// Key the management panel under its endpoint name (from the registry) so its
+// `agent-update` / `remote-status` events route to it. The legacy `remote.toml`
+// setup is adopted as a `management` entry named "management".
+async function registerManagementPanel(): Promise<void> {
+  if (!managementPanel) return;
   try {
-    await source.agentPrompt(next);
-    if (isMock()) mockReply(next); // browser preview: synthesize the reply
-  } catch (e) {
-    // Send failed (not connected / socket just closed): don't leave the panel
-    // hanging on a spinner — close the turn with an error, surface it, release
-    // the queue so a later (connected) prompt can still go.
-    turnActive = false;
-    note("error", `chat: ${errText(e)}`);
-    chatSeq += 1;
-    chatTurns = endTurn(chatTurns, chatSeq, "error");
-    renderChat();
-    updateChatControls();
-    void flushQueue();
+    const agents = await source.remoteAgents();
+    managementName = agents.find((a) => a.management)?.name ?? "management";
+  } catch {
+    managementName = "management";
   }
+  chatPanels.set(managementName, managementPanel);
 }
 
-// A streamed `chunk`: open the agent turn on the first one (stable id for its
-// copy button), append thereafter.
-function onAgentChunk(text: string): void {
-  const last = chatTurns[chatTurns.length - 1];
-  const open = last?.role === "agent" && last.streaming;
-  const id = open ? (last as ChatTurn).id : (chatSeq += 1);
-  chatTurns = appendChunk(chatTurns, id, text);
-  renderChat();
+// Route a backend event to the panel that owns the endpoint. Unknown names (a
+// console that was closed, or an agent with no open panel) are dropped.
+function routeChunk(agent: string, text: string): void {
+  chatPanels.get(agent)?.onChunk(text);
 }
-
-// `turn_end`: finalize the open agent turn (markdown render), free the gate, and
-// release any queued prompt.
-function onAgentTurnEnd(stopReason: string): void {
-  chatSeq += 1;
-  chatTurns = endTurn(chatTurns, chatSeq, stopReason);
-  turnActive = false;
-  renderChat();
-  updateChatControls();
-  void flushQueue();
+function routeTurnEnd(agent: string, stopReason: string): void {
+  chatPanels.get(agent)?.onTurnEnd(stopReason);
+}
+function routeStatus(agent: string, status: string): void {
+  chatPanels.get(agent)?.setConnected(status === "connected");
+  // Also reflect it on the agent console's read-only status badge (no-op when
+  // the event isn't for the currently open console).
+  agentConsole?.onStatus(agent, status);
 }
 
-async function stopTurn(): Promise<void> {
-  if (!turnActive) return;
-  try {
-    await source.agentCancel();
-    note("info", "chat: cancel sent");
-  } catch (e) {
-    note("error", `chat: cancel failed — ${errText(e)}`);
-  }
-  // The backend still emits a `turn_end` (stopReason `cancelled`), which clears
-  // `turnActive` and flushes the queue — no local state change needed here.
-}
-
-// Browser preview only: stream a short canned markdown reply so the chunk →
-// turn_end → markdown path is visible without a live gateway.
-function mockReply(prompt: string): void {
-  const parts = [
-    `You said: **${prompt}**.\n\n`,
-    "Here's what the panel renders:\n\n",
-    "- streamed *chunks*\n- then final `markdown`\n\n",
-    "```\ncode stays monospaced\n```",
-  ];
-  let i = 0;
-  const step = (): void => {
-    if (i < parts.length) {
-      onAgentChunk(parts[i]);
-      i += 1;
-      window.setTimeout(step, 130);
-    } else {
-      onAgentTurnEnd("end_turn");
-    }
-  };
-  window.setTimeout(step, 150);
-}
-
-chatFormEl?.addEventListener("submit", (ev) => {
-  ev.preventDefault();
-  if (!chatTextEl) return;
-  submitPrompt(chatTextEl.value);
-  chatTextEl.value = "";
-});
-// Enter sends; Shift+Enter inserts a newline.
-chatTextEl?.addEventListener("keydown", (ev) => {
-  if (ev.key === "Enter" && !ev.shiftKey) {
-    ev.preventDefault();
-    chatFormEl?.requestSubmit();
-  }
-});
-chatStopEl?.addEventListener("click", () => void stopTurn());
-// Delegated copy: copy the raw turn text (not the rendered HTML).
-chatLogEl?.addEventListener("click", (ev) => {
-  const btn = (ev.target as HTMLElement).closest<HTMLButtonElement>(
-    "button.chat-copy",
-  );
-  if (!btn) return;
-  const turn = chatTurns.find((t) => t.id === Number(btn.dataset.copy));
-  if (!turn) return;
-  void navigator.clipboard?.writeText(turn.text).then(
-    () => {
-      btn.textContent = "Copied";
-      window.setTimeout(() => {
-        if (btn.isConnected) btn.textContent = "Copy";
-      }, 1500);
-    },
-    () => note("error", "chat: copy failed"),
-  );
-});
-
-// Subscribe to the backend's streamed chat updates (desktop only). `chunk` and
-// `turn_end` drive the transcript; the browser build has no bridge and uses the
-// mock reply path instead.
+// Subscribe to the backend's streamed chat updates (desktop only). Each event is
+// tagged with the `agent` endpoint it belongs to; route it to that panel. The
+// browser build has no bridge and drives the mock reply path per panel instead.
 async function bindAgentUpdates(): Promise<void> {
   const listen = (
     globalThis as {
@@ -557,14 +447,17 @@ async function bindAgentUpdates(): Promise<void> {
     }
   ).__TAURI__?.event?.listen;
   if (!listen) return;
-  await listen<{ kind?: string; text?: string; stopReason?: string }>(
-    "agent-update",
-    (e) => {
-      const p = e.payload;
-      if (p.kind === "chunk") onAgentChunk(p.text ?? "");
-      else if (p.kind === "turn_end") onAgentTurnEnd(p.stopReason ?? "end_turn");
-    },
-  );
+  await listen<{
+    agent?: string;
+    kind?: string;
+    text?: string;
+    stopReason?: string;
+  }>("agent-update", (e) => {
+    const p = e.payload;
+    const agent = p.agent ?? managementName ?? "management";
+    if (p.kind === "chunk") routeChunk(agent, p.text ?? "");
+    else if (p.kind === "turn_end") routeTurnEnd(agent, p.stopReason ?? "end_turn");
+  });
 }
 
 // ---- start / stop (ADR-2 write model: stop = scale→0, start = scale→1) -------
@@ -725,17 +618,18 @@ async function bindRemoteStatus(): Promise<void> {
   const listen = (globalThis as { __TAURI__?: EventGlobal }).__TAURI__?.event
     ?.listen;
   if (!listen) return;
-  await listen<{ status: string }>("remote-status", (e) => {
+  await listen<{ agent?: string; status: string }>("remote-status", (e) => {
     const status = e.payload?.status ?? "disconnected";
-    if (remoteConfig) {
+    const agent = e.payload?.agent ?? managementName ?? "management";
+    // The legacy remote panel shows only the management connection's status.
+    if (agent === managementName && remoteConfig) {
       remoteConfig = { ...remoteConfig, status };
       if (remoteEl) renderRemote(remoteEl, remoteConfig);
     }
-    remoteConnected = status === "connected";
-    // If the socket drops mid-turn, no `turn_end` will arrive — close the open
-    // turn so the panel doesn't hang on a spinner.
-    if (!remoteConnected && turnActive) onAgentTurnEnd(status);
-    updateChatControls();
+    // Route the live state to the owning chat panel — it re-enables its input on
+    // `connected` and, on a mid-turn drop, closes the open turn so it doesn't
+    // hang on a spinner (handled inside the panel's `setConnected`).
+    routeStatus(agent, status);
   });
 }
 
@@ -744,10 +638,21 @@ async function bindRemoteStatus(): Promise<void> {
 async function boot(): Promise<void> {
   note("info", `OAB Studio ${BUILD} (built ${__BUILD_TIME__})`);
   if (activity && mcp) await bindBackend(activity, mcp);
+  // Mount the management chat panel and learn its endpoint name before binding
+  // the event listeners, so status/chat events route to it from the first tick.
+  buildManagementPanel();
+  await registerManagementPanel();
   await bindRemoteStatus();
   await bindAgentUpdates();
-  renderChat();
-  updateChatControls();
+  // The agent-console shell: the endpoint selector + a per-agent console (dial +
+  // read-only config + chat) sharing the same event router (`chatPanels`).
+  agentConsole = initAgentConsole({
+    source,
+    mock: isMock(),
+    note,
+    panels: chatPanels,
+    managementName: () => managementName,
+  });
   if (clusterLabel) clusterLabel.textContent = activeCluster;
   note("info", `app: polling cluster "${activeCluster}" every ${POLL_MS / 1000}s`);
   setupUpdater();
diff --git a/console/src/render.test.ts b/console/src/render.test.ts
index e2fa253..84257d4 100644
--- a/console/src/render.test.ts
+++ b/console/src/render.test.ts
@@ -4,17 +4,25 @@ import {
   identityHtml,
   fleetConfigHtml,
   remoteHtml,
+  agentListHtml,
+  agentConsoleHeaderHtml,
   filterByMembers,
   serviceName,
   deploymentKey,
 } from "./render";
 import {
+  FIXTURE_AGENTS,
   FIXTURE_DEPLOYMENTS,
   FIXTURE_FLEET_CONFIG,
   FIXTURE_REMOTE_CONFIG,
   FIXTURE_RUNTIME_CONTEXT,
 } from "./fixtures";
-import { AGENT_STATES, type Deployment, type RuntimeContext } from "./types";
+import {
+  AGENT_STATES,
+  type AgentEndpointView,
+  type Deployment,
+  type RuntimeContext,
+} from "./types";
 
 function ctx(partial: Partial<RuntimeContext>): RuntimeContext {
   return { ...structuredClone(FIXTURE_RUNTIME_CONTEXT), ...partial };
@@ -365,3 +373,86 @@ describe("filterByMembers", () => {
     expect(serviceName({ ...FIXTURE_DEPLOYMENTS[0] })).toBe("oab-prod-orca");
   });
 });
+
+describe("agentListHtml", () => {
+  function ep(partial: Partial<AgentEndpointView>): AgentEndpointView {
+    return {
+      name: "x",
+      url: "wss://x.example/acp",
+      cwd: "/home/node",
+      management: false,
+      configured: true,
+      status: "disconnected",
+      ...partial,
+    };
+  }
+
+  it("renders an empty-state pointing at agents.toml when the registry is empty", () => {
+    const html = agentListHtml([], null);
+    expect(html).toContain("ag-empty");
+    expect(html).toContain("agents.toml");
+  });
+
+  it("makes an ordinary configured endpoint an openable button", () => {
+    const html = agentListHtml([ep({ name: "mira" })], null);
+    expect(html).toContain('data-agent="mira"');
+    expect(html).toContain("<button");
+    expect(html).not.toContain("disabled");
+  });
+
+  it("disables an unconfigured endpoint (no url+token to dial)", () => {
+    const html = agentListHtml([ep({ name: "falcon", configured: false, url: "" })], null);
+    expect(html).toContain('data-agent="falcon"');
+    expect(html).toContain("disabled");
+    expect(html).toContain("not configured");
+  });
+
+  it("shows the management endpoint but does not make it openable", () => {
+    const html = agentListHtml([ep({ name: "orca", management: true })], null);
+    // no data-agent hook → the delegated open handler can't fire for it
+    expect(html).not.toContain('data-agent="orca"');
+    expect(html).toContain("management");
+    expect(html).toContain("console above");
+  });
+
+  it("marks the currently open console as pressed", () => {
+    const html = agentListHtml([ep({ name: "mira" })], "mira");
+    expect(html).toContain('aria-pressed="true"');
+    expect(html).toContain("is-open");
+  });
+
+  it("renders every fixture endpoint", () => {
+    const html = agentListHtml(FIXTURE_AGENTS, null);
+    for (const a of FIXTURE_AGENTS) expect(html).toContain(a.name);
+  });
+
+  it("escapes endpoint names and urls", () => {
+    const html = agentListHtml(
+      [ep({ name: "a<b", url: "wss://x/?q=<script>" })],
+      null,
+    );
+    expect(html).not.toContain("<script>");
+    expect(html).toContain("a&lt;b");
+  });
+});
+
+describe("agentConsoleHeaderHtml", () => {
+  const orca = FIXTURE_AGENTS[0];
+
+  it("shows the endpoint's identity, dial target, and the passed live status", () => {
+    const html = agentConsoleHeaderHtml(orca, "connected");
+    expect(html).toContain(orca.name);
+    expect(html).toContain(orca.url);
+    expect(html).toContain(orca.cwd);
+    expect(html).toContain("rm-connected");
+  });
+
+  it("never leaks a token field (secrets don't cross the bridge)", () => {
+    const html = agentConsoleHeaderHtml(orca, "connected");
+    expect(html.toLowerCase()).not.toContain("token");
+  });
+
+  it("notes the read-only editor limitation until the fs/* wire lands", () => {
+    expect(agentConsoleHeaderHtml(orca, "disconnected")).toContain("Read-only");
+  });
+});
diff --git a/console/src/render.ts b/console/src/render.ts
index 2515e1c..1702dd9 100644
--- a/console/src/render.ts
+++ b/console/src/render.ts
@@ -1,4 +1,5 @@
 import type {
+  AgentEndpointView,
   AgentState,
   Deployment,
   FleetConfig,
@@ -304,3 +305,91 @@ export function remoteHtml(view: RemoteConfig | null): string {
 export function renderRemote(el: HTMLElement, view: RemoteConfig | null): void {
   el.innerHTML = remoteHtml(view);
 }
+
+// ---- Agent consoles (ADR agent-consoles, Parts B/C) --------------------------
+// The per-agent endpoint registry: a selector of every reachable agent + the
+// open console's read-only config header. The chat region is the reusable
+// `chatPanel` primitive (mounted imperatively in `agentConsole.ts`); the file
+// editor is a later slice, so config is read-only here.
+
+// A connection-status pill, reusing the remote panel's status classes so the two
+// surfaces read the same. `error: …` collapses to the error class.
+function endpointStatusBadge(status: string): string {
+  const s = status || "disconnected";
+  const key = s.startsWith("error") ? "error" : s;
+  const cls = REMOTE_STATUS_CLASS[key] ?? "rm-disconnected";
+  return `<span class="rm-status ${cls}">${escapeHtml(s)}</span>`;
+}
+
+// One selector row per endpoint. The management endpoint is shown but not
+// openable as an agent console — it has its own top-level console (with chat +
+// fleet control); a duplicate per-agent console for it is redundant. Ordinary
+// endpoints open on click (`data-agent`); an unconfigured one (no url+token) is
+// disabled. `openName` marks the currently open console.
+function agentRow(a: AgentEndpointView, openName: string | null): string {
+  const name = escapeHtml(a.name);
+  const url = a.url
+    ? `<code class="ag-url">${escapeHtml(a.url)}</code>`
+    : `<span class="muted">not configured</span>`;
+  const tags = a.management
+    ? `<span class="ag-tag ag-mgmt">management</span>`
+    : "";
+  if (a.management) {
+    return `<div class="ag-row ag-row-mgmt" aria-disabled="true">
+        <span class="ag-name">${name}</span>${tags}
+        ${url}
+        ${endpointStatusBadge(a.status)}
+        <span class="ag-hint muted">console above</span>
+      </div>`;
+  }
+  const open = a.name === openName;
+  const cls = open ? "ag-row is-open" : "ag-row";
+  const disabled = a.configured ? "" : " disabled";
+  return `<button class="${cls}" type="button" data-agent="${name}" aria-pressed="${open}"${disabled}>
+      <span class="ag-name">${name}</span>${tags}
+      ${url}
+      ${endpointStatusBadge(a.status)}
+    </button>`;
+}
+
+// Pure: the endpoint registry -> the selector HTML. An empty registry renders a
+// hint pointing at the config file (there is no in-app registry editor yet — a
+// later slice). `openName` is the console currently open (or `null`).
+export function agentListHtml(
+  agents: AgentEndpointView[],
+  openName: string | null,
+): string {
+  if (agents.length === 0) {
+    return `<p class="ag-empty">No agent endpoints configured — add <code>[[agent]]</code> entries to <code>agents.toml</code> to reach more agents.</p>`;
+  }
+  return `<div class="ag-list">${agents
+    .map((a) => agentRow(a, openName))
+    .join("")}</div>`;
+}
+
+export function renderAgentList(
+  el: HTMLElement,
+  agents: AgentEndpointView[],
+  openName: string | null,
+): void {
+  el.innerHTML = agentListHtml(agents, openName);
+}
+
+// Pure: the open console's read-only config header — identity + dial target +
+// live status. The bearer token is never here (secrets don't cross the bridge).
+// `status` is passed separately so a live `remote-status` update can refresh just
+// the badge without re-fetching the whole registry.
+export function agentConsoleHeaderHtml(
+  a: AgentEndpointView,
+  status: string,
+): string {
+  return `<div class="ac-id">
+      <span class="ac-name">${escapeHtml(a.name)}</span>
+      ${endpointStatusBadge(status)}
+    </div>
+    <div class="ac-fields">
+      ${field("url", a.url || "—")}
+      ${field("cwd", a.cwd || "—")}
+    </div>
+    <p class="ac-note muted">Read-only — the remote file editor (view / edit / apply the agent's files) arrives once the <code>fs/*</code> wire lands.</p>`;
+}
diff --git a/console/src/source.ts b/console/src/source.ts
index cc4cf08..6cd9037 100644
--- a/console/src/source.ts
+++ b/console/src/source.ts
@@ -1,10 +1,12 @@
 import type {
+  AgentEndpointView,
   Deployment,
   FleetConfig,
   RemoteConfig,
   RuntimeContext,
 } from "./types";
 import {
+  FIXTURE_AGENTS,
   FIXTURE_DEPLOYMENTS,
   FIXTURE_FLEET_CONFIG,
   FIXTURE_REMOTE_CONFIG,
@@ -34,13 +36,21 @@ export interface Source {
   // `remote.toml` for the editor, and the explicit activate/deactivate actions.
   remoteConfig(): Promise<RemoteConfig>;
   writeRemoteConfig(text: string): Promise<RemoteConfig>;
-  remoteConnect(): Promise<void>;
-  remoteDisconnect(): Promise<void>;
+  // Dial / tear down a connection. `agent` names a registry endpoint (an agent
+  // console); omitted ⇒ the management endpoint (legacy single-console path).
+  remoteConnect(agent?: string): Promise<void>;
+  remoteDisconnect(agent?: string): Promise<void>;
+  // The per-agent endpoint registry with each entry's live status — what an
+  // agent-console selector renders (ADR agent-consoles Parts B/C). Tokens are
+  // never included.
+  remoteAgents(): Promise<AgentEndpointView[]>;
   // Chat over the live connection (Part C): send one turn (`session/prompt`) or
-  // cancel the in-flight turn (`session/cancel`). The reply streams back as
-  // `agent-update` events, not through this call, so both resolve immediately.
-  agentPrompt(text: string): Promise<void>;
-  agentCancel(): Promise<void>;
+  // cancel the in-flight turn (`session/cancel`) for a given endpoint. `agent`
+  // names the registry endpoint; omitted ⇒ the management endpoint. The reply
+  // streams back as `agent-update` events, not through this call, so both
+  // resolve immediately.
+  agentPrompt(text: string, agent?: string): Promise<void>;
+  agentCancel(agent?: string): Promise<void>;
 }
 
 // Fixture-backed source for the standalone / browser build — no core required.
@@ -71,6 +81,9 @@ export class MockSource implements Source {
   // Browser preview: no core to dial, so activate/deactivate are no-ops.
   async remoteConnect(): Promise<void> {}
   async remoteDisconnect(): Promise<void> {}
+  async remoteAgents(): Promise<AgentEndpointView[]> {
+    return structuredClone(FIXTURE_AGENTS);
+  }
   // Browser preview: no live agent. `main.ts` detects the mock (no Tauri shell)
   // and drives a canned reply locally so the panel is still demonstrable.
   async agentPrompt(): Promise<void> {}
@@ -127,17 +140,23 @@ export class TauriSource implements Source {
   async writeRemoteConfig(text: string): Promise<RemoteConfig> {
     return this.invoke()<RemoteConfig>("remote_config_write", { text });
   }
-  async remoteConnect(): Promise<void> {
-    await this.invoke()<unknown>("remote_connect");
+  async remoteConnect(agent?: string): Promise<void> {
+    await this.invoke()<unknown>("remote_connect", { agent });
+  }
+  async remoteDisconnect(agent?: string): Promise<void> {
+    await this.invoke()<unknown>("remote_disconnect", { agent });
   }
-  async remoteDisconnect(): Promise<void> {
-    await this.invoke()<unknown>("remote_disconnect");
+  async remoteAgents(): Promise<AgentEndpointView[]> {
+    const res = await this.invoke()<{ agents: AgentEndpointView[] }>(
+      "remote_agents",
+    );
+    return res.agents;
   }
-  async agentPrompt(text: string): Promise<void> {
-    await this.invoke()<unknown>("agent_prompt", { text });
+  async agentPrompt(text: string, agent?: string): Promise<void> {
+    await this.invoke()<unknown>("agent_prompt", { text, agent });
   }
-  async agentCancel(): Promise<void> {
-    await this.invoke()<unknown>("agent_cancel");
+  async agentCancel(agent?: string): Promise<void> {
+    await this.invoke()<unknown>("agent_cancel", { agent });
   }
 }
 
diff --git a/console/src/styles.css b/console/src/styles.css
index ee28bc3..ee8924f 100644
--- a/console/src/styles.css
+++ b/console/src/styles.css
@@ -1033,3 +1033,153 @@ button.act:disabled {
   color: var(--text);
   font: inherit;
 }
+
+/* ---- Agent consoles (ADR agent-consoles Parts B/C) ------------------------ */
+.agents-wrap {
+  margin: 0 0 12px;
+}
+.agents-head {
+  display: flex;
+  align-items: baseline;
+  gap: 10px;
+  margin-bottom: 8px;
+}
+.agents-label {
+  font-weight: 600;
+  font-size: 13px;
+}
+.agents-sub {
+  font-size: 12px;
+  color: var(--muted);
+}
+.ag-list {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+.ag-empty {
+  color: var(--muted);
+  font-size: 13px;
+  margin: 4px 0;
+}
+.ag-row {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  width: 100%;
+  text-align: left;
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  background: var(--panel);
+  color: var(--text);
+  font: inherit;
+  font-size: 13px;
+  padding: 8px 10px;
+  cursor: pointer;
+}
+button.ag-row:hover {
+  border-color: var(--s-starting);
+}
+.ag-row.is-open {
+  border-color: var(--s-starting);
+  box-shadow: inset 0 0 0 1px var(--s-starting);
+}
+.ag-row:disabled {
+  opacity: 0.55;
+  cursor: default;
+}
+.ag-row-mgmt {
+  cursor: default;
+  border-style: dashed;
+}
+.ag-name {
+  font-weight: 600;
+  white-space: nowrap;
+}
+.ag-url {
+  font-size: 12px;
+  color: var(--muted);
+  overflow-wrap: anywhere;
+  flex: 1 1 auto;
+  min-width: 0;
+}
+.ag-tag {
+  font-size: 10px;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  border-radius: 999px;
+  padding: 1px 7px;
+  white-space: nowrap;
+}
+.ag-mgmt {
+  background: var(--s-starting);
+  color: #fff;
+}
+.ag-hint {
+  font-size: 11px;
+  white-space: nowrap;
+}
+.agent-console {
+  margin-top: 10px;
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  background: var(--panel);
+  padding: 10px 12px;
+}
+.ac-head {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin-bottom: 8px;
+}
+.ac-title {
+  font-weight: 600;
+  font-size: 13px;
+}
+.ac-spacer {
+  flex: 1 1 auto;
+}
+.ac-close {
+  cursor: pointer;
+  border: 1px solid var(--border);
+  border-radius: 5px;
+  background: var(--bg);
+  color: var(--text);
+  font: inherit;
+  font-size: 12px;
+  padding: 4px 12px;
+}
+.ac-close:hover {
+  border-color: var(--s-unhealthy);
+  color: var(--s-unhealthy);
+}
+.ac-config {
+  margin-bottom: 10px;
+}
+.ac-id {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin-bottom: 6px;
+}
+.ac-id .ac-name {
+  font-weight: 600;
+  font-size: 14px;
+}
+.ac-fields {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px 18px;
+}
+.ac-fields .id-field {
+  font-size: 12px;
+}
+.ac-note {
+  font-size: 12px;
+  margin: 8px 0 0;
+}
+/* the agent console's chat region reuses .chat-wrap/.chat-* wholesale */
+.agent-console .chat-wrap {
+  margin: 0;
+}
diff --git a/console/src/types.ts b/console/src/types.ts
index 82cd942..33bb2b2 100644
--- a/console/src/types.ts
+++ b/console/src/types.ts
@@ -84,6 +84,22 @@ export interface RemoteConfig {
   status: string;
 }
 
+// One entry of the per-agent endpoint registry — mirrors src-tauri's
+// `remote_agents` command (ADR agent-consoles, Parts B/C). It is the view an
+// agent-console selector renders: an identity (`name`), the dial target
+// (`url`/`cwd`), whether this entry backs the management console (`management`),
+// whether it has a usable url+token (`configured`), and the live per-endpoint
+// connection `status` (`disconnected` | `connecting` | `connected` | `error: …`).
+// The bearer `token` is deliberately absent — secrets never cross this bridge.
+export interface AgentEndpointView {
+  name: string;
+  url: string;
+  cwd: string;
+  management: boolean;
+  configured: boolean;
+  status: string;
+}
+
 // The effective runtime identity/context the control plane resolved for a
 // cluster — mirrors oab-mcp's `runtime_context` tool (ADR #19). `identity_matches`
 // is `null` when the binding declares no `expected_principal`.
diff --git a/crates/acp-tunnel/src/config.rs b/crates/acp-tunnel/src/config.rs
index 620e8d1..22c5965 100644
--- a/crates/acp-tunnel/src/config.rs
+++ b/crates/acp-tunnel/src/config.rs
@@ -83,6 +83,163 @@ impl RemoteConfig {
     }
 }
 
+/// One agent endpoint in the registry (`[[agent]]` in `agents.toml`): a named
+/// `/acp` connection plus a `management` policy flag. The connection fields are
+/// the same shape as [`RemoteConfig`] (a legacy `remote.toml` maps to a single
+/// `management = true` entry), so the dial path and validation are shared.
+///
+/// Fields are spelled out rather than `#[serde(flatten)]`-ing a `RemoteConfig`
+/// because `toml` serialization of a flattened struct is order-fragile; the
+/// [`AgentEndpoint::conn`] accessor rebuilds the `RemoteConfig` the transport
+/// dials with, keeping one source of truth for connection validation.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct AgentEndpoint {
+    /// Stable identity — the map key in `RemoteState` and the label in the
+    /// selector. Required (a nameless entry can't be addressed).
+    #[serde(default)]
+    pub name: String,
+    /// The `/acp` WSS endpoint.
+    #[serde(default)]
+    pub url: String,
+    /// The `/acp` bearer token (secret; never logged).
+    #[serde(default)]
+    pub token: String,
+    /// The session `cwd` sent on `session/new` (defaults to `/`).
+    #[serde(default = "default_cwd")]
+    pub cwd: String,
+    /// This entry backs the **management console**: Studio publishes its
+    /// reverse-MCP `oab` fleet-control tools to this agent (the whole point of
+    /// the management binding). **Off by default** — an ordinary agent console
+    /// chats with and configures an agent *without* granting it fleet control
+    /// (least privilege, ADR agent-consoles Part A).
+    #[serde(default)]
+    pub management: bool,
+}
+
+impl Default for AgentEndpoint {
+    fn default() -> Self {
+        AgentEndpoint {
+            name: String::new(),
+            url: String::new(),
+            token: String::new(),
+            cwd: default_cwd(),
+            management: false,
+        }
+    }
+}
+
+impl AgentEndpoint {
+    /// The connection view the transport dials with — one source of truth for
+    /// the `/acp` handshake fields and their validation.
+    pub fn conn(&self) -> RemoteConfig {
+        RemoteConfig {
+            url: self.url.clone(),
+            token: self.token.clone(),
+            cwd: self.cwd.clone(),
+        }
+    }
+
+    /// Enough is set to attempt a connection (a name **and** a configured conn).
+    pub fn is_configured(&self) -> bool {
+        !self.name.trim().is_empty() && self.conn().is_configured()
+    }
+
+    /// Validate before dialing: a name is required (it addresses the endpoint),
+    /// then the connection fields validate as a [`RemoteConfig`].
+    pub fn validate(&self) -> Result<(), String> {
+        if self.name.trim().is_empty() {
+            return Err("agent name is required (it addresses the endpoint)".to_string());
+        }
+        self.conn().validate()
+    }
+}
+
+/// The per-agent endpoint registry (`~/.config/oab-studio/agents.toml`): a list
+/// of `[[agent]]` entries. Generalizes the single `remote.toml` so Studio can
+/// reach N agents — one carries `management = true` (the management console + its
+/// reverse-MCP grant); all are selectable as agent consoles. A legacy
+/// `remote.toml` is adopted via [`AgentRegistry::from_legacy`] as one management
+/// entry, so existing setups keep working (ADR agent-consoles Part B).
+#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub struct AgentRegistry {
+    /// The endpoints, one per `[[agent]]` table. Empty ⇒ "not configured".
+    #[serde(default, rename = "agent")]
+    pub agents: Vec<AgentEndpoint>,
+}
+
+impl AgentRegistry {
+    /// Parse `agents.toml`. An empty file yields an empty registry (not an error),
+    /// so a fresh install is "not configured" rather than broken.
+    pub fn parse(text: &str) -> Result<Self, toml::de::Error> {
+        toml::from_str(text)
+    }
+
+    /// Serialize back to `agents.toml` text (used when the app writes structured
+    /// changes; the editor otherwise round-trips the operator's raw text).
+    pub fn to_toml(&self) -> String {
+        toml::to_string_pretty(self).unwrap_or_default()
+    }
+
+    /// Adopt a legacy single `remote.toml` as one `management = true` entry, so a
+    /// pre-registry setup keeps working while the registry is rolled out. The
+    /// entry is named `name` (the app passes a stable default like `"management"`).
+    pub fn from_legacy(cfg: RemoteConfig, name: &str) -> Self {
+        AgentRegistry {
+            agents: vec![AgentEndpoint {
+                name: name.to_string(),
+                url: cfg.url,
+                token: cfg.token,
+                cwd: cfg.cwd,
+                management: true,
+            }],
+        }
+    }
+
+    /// Look an endpoint up by name (the `RemoteState` key).
+    pub fn get(&self, name: &str) -> Option<&AgentEndpoint> {
+        self.agents.iter().find(|a| a.name == name)
+    }
+
+    /// The management endpoint (the one carrying `management = true`), if any.
+    /// Backs the top-level console and its reverse-MCP `oab` grant; also the
+    /// default target for the legacy single-endpoint commands.
+    pub fn management(&self) -> Option<&AgentEndpoint> {
+        self.agents.iter().find(|a| a.management)
+    }
+
+    /// No endpoints configured.
+    pub fn is_empty(&self) -> bool {
+        self.agents.is_empty()
+    }
+
+    /// Structural validation for a file save (mirrors how the fleets.toml editor
+    /// rejects a bad file without writing): every entry is named, names are
+    /// unique (they key connections), and **at most one** entry is `management`
+    /// (exactly one binding carries the reverse-MCP grant). Per-endpoint
+    /// connection completeness is checked at dial time, not here — so a
+    /// half-filled entry can still be saved, like an empty `remote.toml`.
+    pub fn validate(&self) -> Result<(), String> {
+        let mut seen = std::collections::HashSet::new();
+        let mut management = 0usize;
+        for a in &self.agents {
+            let name = a.name.trim();
+            if name.is_empty() {
+                return Err("every [[agent]] needs a name".to_string());
+            }
+            if !seen.insert(name) {
+                return Err(format!("duplicate agent name {name:?} — names must be unique"));
+            }
+            if a.management {
+                management += 1;
+            }
+        }
+        if management > 1 {
+            return Err("at most one agent may be management = true".to_string());
+        }
+        Ok(())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -152,4 +309,131 @@ token = "t""#)
         };
         assert_eq!(RemoteConfig::parse(&cfg.to_toml()).unwrap(), cfg);
     }
+
+    // ---- AgentRegistry (per-agent endpoint registry) --------------------------
+
+    #[test]
+    fn registry_parses_multiple_agents() {
+        let reg = AgentRegistry::parse(
+            r#"
+[[agent]]
+name = "orca"
+url = "wss://orca/acp"
+token = "s1"
+cwd = "/home/node"
+management = true
+
+[[agent]]
+name = "mira"
+url = "wss://mira/acp"
+token = "s2"
+"#,
+        )
+        .expect("parse");
+        assert_eq!(reg.agents.len(), 2);
+        let orca = reg.get("orca").expect("orca present");
+        assert_eq!(orca.cwd, "/home/node");
+        assert!(orca.management);
+        assert!(orca.is_configured());
+        // cwd defaults to "/" when omitted, mirroring RemoteConfig.
+        let mira = reg.get("mira").expect("mira present");
+        assert_eq!(mira.cwd, "/");
+        assert!(!mira.management); // management defaults off (least privilege)
+        // management() returns the one flagged entry.
+        assert_eq!(reg.management().map(|a| a.name.as_str()), Some("orca"));
+    }
+
+    #[test]
+    fn empty_registry_is_not_configured() {
+        let reg = AgentRegistry::parse("").expect("empty parses");
+        assert!(reg.is_empty());
+        assert!(reg.management().is_none());
+        assert_eq!(reg, AgentRegistry::default());
+        assert!(reg.validate().is_ok());
+    }
+
+    #[test]
+    fn from_legacy_remote_becomes_one_management_entry() {
+        let cfg = RemoteConfig {
+            url: "wss://gw/acp".into(),
+            token: "sek".into(),
+            cwd: "/work".into(),
+        };
+        let reg = AgentRegistry::from_legacy(cfg, "management");
+        assert_eq!(reg.agents.len(), 1);
+        let e = reg.management().expect("has management");
+        assert_eq!(e.name, "management");
+        assert_eq!(e.cwd, "/work");
+        assert!(e.management);
+        // The adopted entry dials with the same conn the legacy file did.
+        assert!(e.conn().validate().is_ok());
+    }
+
+    #[test]
+    fn validate_rejects_dup_names_missing_names_and_two_managements() {
+        assert!(AgentRegistry {
+            agents: vec![AgentEndpoint { name: "a".into(), ..Default::default() },
+                         AgentEndpoint { name: "a".into(), ..Default::default() }],
+        }
+        .validate()
+        .unwrap_err()
+        .contains("unique"));
+
+        assert!(AgentRegistry {
+            agents: vec![AgentEndpoint { name: "  ".into(), ..Default::default() }],
+        }
+        .validate()
+        .is_err());
+
+        assert!(AgentRegistry {
+            agents: vec![
+                AgentEndpoint { name: "a".into(), management: true, ..Default::default() },
+                AgentEndpoint { name: "b".into(), management: true, ..Default::default() },
+            ],
+        }
+        .validate()
+        .unwrap_err()
+        .contains("management"));
+    }
+
+    #[test]
+    fn endpoint_validate_requires_name_and_conn() {
+        // Missing name → error even with a good conn.
+        assert!(AgentEndpoint {
+            name: "".into(),
+            url: "wss://x/acp".into(),
+            token: "t".into(),
+            ..Default::default()
+        }
+        .validate()
+        .unwrap_err()
+        .contains("name"));
+        // Named but unconfigured conn → the RemoteConfig validation fires.
+        assert!(AgentEndpoint { name: "x".into(), ..Default::default() }
+            .validate()
+            .is_err());
+    }
+
+    #[test]
+    fn registry_to_toml_round_trips() {
+        let reg = AgentRegistry {
+            agents: vec![
+                AgentEndpoint {
+                    name: "orca".into(),
+                    url: "wss://orca/acp".into(),
+                    token: "s1".into(),
+                    cwd: "/home/node".into(),
+                    management: true,
+                },
+                AgentEndpoint {
+                    name: "mira".into(),
+                    url: "wss://mira/acp".into(),
+                    token: "s2".into(),
+                    cwd: "/".into(),
+                    management: false,
+                },
+            ],
+        };
+        assert_eq!(AgentRegistry::parse(&reg.to_toml()).unwrap(), reg);
+    }
 }
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 3db42f9..6ab2b31 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -338,7 +338,20 @@ async fn remote_view(remote: &remote::Remote) -> Result<Value, String> {
     let path = remote::config_path()
         .map(|p| p.display().to_string())
         .unwrap_or_default();
-    let status = remote.0.lock().await.status.clone();
+    // Status of the management connection — the one this legacy panel controls.
+    // `RemoteState` is now keyed per agent, so look it up under the management
+    // endpoint's name (the legacy `remote.toml` adopts the name "management").
+    let mgmt_name = remote::load_registry()
+        .ok()
+        .and_then(|r| r.management().map(|e| e.name.clone()))
+        .unwrap_or_else(|| remote::LEGACY_MANAGEMENT_NAME.to_string());
+    let status = remote
+        .0
+        .lock()
+        .await
+        .get(&mgmt_name)
+        .map(|st| st.status.clone())
+        .unwrap_or_default();
     Ok(json!({
         "path": path,
         "text": text,
@@ -354,6 +367,37 @@ async fn remote_config(remote: tauri::State<'_, remote::Remote>) -> Result<Value
     remote_view(&remote).await
 }
 
+/// The per-agent endpoint registry with each entry's live status — the data an
+/// agent-console selector renders (ADR agent-consoles Parts B/C). Reads
+/// `agents.toml` (or the adopted legacy `remote.toml`) and overlays each entry's
+/// current connection status. Tokens are **not** included (secrets never cross
+/// this bridge); only whether the entry is configured.
+#[tauri::command]
+async fn remote_agents(remote: tauri::State<'_, remote::Remote>) -> Result<Value, String> {
+    let reg = remote::load_registry()?;
+    let guard = remote.0.lock().await;
+    let agents: Vec<Value> = reg
+        .agents
+        .iter()
+        .map(|a| {
+            let status = guard
+                .get(&a.name)
+                .map(|st| st.status.clone())
+                .filter(|s| !s.is_empty())
+                .unwrap_or_else(|| "disconnected".to_string());
+            json!({
+                "name": a.name,
+                "url": a.url,
+                "cwd": a.cwd,
+                "management": a.management,
+                "configured": a.is_configured(),
+                "status": status,
+            })
+        })
+        .collect();
+    Ok(json!({ "agents": agents }))
+}
+
 /// Persist the edited `remote.toml` (validates it parses before writing) and
 /// return the refreshed view.
 #[tauri::command]
@@ -373,6 +417,7 @@ async fn remote_connect(
     app: tauri::AppHandle,
     core: tauri::State<'_, Core>,
     remote: tauri::State<'_, remote::Remote>,
+    agent: Option<String>,
 ) -> Result<(), String> {
     let client = {
         let guard = core.0.lock().await;
@@ -381,34 +426,47 @@ async fn remote_connect(
             .cloned()
             .ok_or_else(|| "core not started yet — start the core before connecting".to_string())?
     };
-    remote::connect(app, &remote, client).await
+    // `None` ⇒ the management endpoint (legacy single-console behaviour); `Some`
+    // ⇒ a specific agent console from the registry.
+    let endpoint = remote::resolve_endpoint(agent.as_deref())?;
+    remote::connect(app, &remote, client, endpoint).await
 }
 
-/// Deactivate the remote connection.
+/// Deactivate a connection. `None` targets the management endpoint.
 #[tauri::command]
 async fn remote_disconnect(
     app: tauri::AppHandle,
     remote: tauri::State<'_, remote::Remote>,
+    agent: Option<String>,
 ) -> Result<(), String> {
-    remote::disconnect(&app, &remote).await;
+    let name = remote::resolve_name(agent.as_deref())?;
+    remote::disconnect(&app, &remote, &name).await;
     Ok(())
 }
 
-/// Send a chat turn to the connected agent (ADR *agent-chat-panel*): pushes a
-/// `session/prompt` onto the live `/acp` session. The reply streams back as
-/// `agent-update` events. Errors if no session is active.
+/// Send a chat turn to an agent (ADR *agent-chat-panel*): pushes a `session/prompt`
+/// onto that agent's live `/acp` session. The reply streams back as `agent-update`
+/// events tagged with the agent name. `None` targets the management endpoint.
+/// Errors if that agent's session is not active.
 #[tauri::command]
 async fn agent_prompt(
     remote: tauri::State<'_, remote::Remote>,
+    agent: Option<String>,
     text: String,
 ) -> Result<(), String> {
-    remote.send_prompt(text).await
+    let name = remote::resolve_name(agent.as_deref())?;
+    remote.send_prompt(&name, text).await
 }
 
-/// Abandon the in-flight chat turn (`session/cancel`). Best-effort.
+/// Abandon an agent's in-flight chat turn (`session/cancel`). Best-effort.
+/// `None` targets the management endpoint.
 #[tauri::command]
-async fn agent_cancel(remote: tauri::State<'_, remote::Remote>) -> Result<(), String> {
-    remote.send_cancel().await
+async fn agent_cancel(
+    remote: tauri::State<'_, remote::Remote>,
+    agent: Option<String>,
+) -> Result<(), String> {
+    let name = remote::resolve_name(agent.as_deref())?;
+    remote.send_cancel(&name).await
 }
 
 /// What the frontend needs to render the "update available" state: the version
@@ -490,6 +548,7 @@ pub fn run() {
             fleet_config_write,
             deploy_scale,
             remote_config,
+            remote_agents,
             remote_config_write,
             remote_connect,
             remote_disconnect,
@@ -507,7 +566,7 @@ pub fn run() {
             // Disconnect button already does this; this covers Cmd-Q / window close.
             if let tauri::RunEvent::ExitRequested { .. } = event {
                 let remote = app_handle.state::<remote::Remote>();
-                tauri::async_runtime::block_on(remote::disconnect(app_handle, &remote));
+                tauri::async_runtime::block_on(remote::disconnect_all(app_handle, &remote));
             }
         });
 }
diff --git a/src-tauri/src/remote.rs b/src-tauri/src/remote.rs
index 9db6868..e5b081c 100644
--- a/src-tauri/src/remote.rs
+++ b/src-tauri/src/remote.rs
@@ -10,13 +10,14 @@
 //! are validated against the live gateway once the §5 endpoint exists; this
 //! module is structurally complete and compiles under `desktop.yml`.
 
+use std::collections::HashMap;
 use std::path::PathBuf;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 
 use acp_tunnel as acp;
-use acp_tunnel::config::RemoteConfig;
+use acp_tunnel::config::{AgentEndpoint, AgentRegistry, RemoteConfig};
 use acp_tunnel::{DisconnectReason, Inbound, Session};
 use futures_util::{Sink, SinkExt, StreamExt};
 use serde_json::{json, Value};
@@ -42,10 +43,14 @@ const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(20);
 /// katashiro's `ACP_PROMPT_TIMEOUT_MS`.
 const PROMPT_TIMEOUT: Duration = Duration::from_secs(600);
 
-/// Managed state: the running connection task (abort to disconnect) plus the last
-/// status string the UI renders.
+/// Managed state: a map of **per-agent** connections keyed by the endpoint name
+/// (ADR agent-consoles Part B — `RemoteState` is no longer a singleton). Each
+/// agent console dials its own endpoint; the management console is just the entry
+/// keyed by the `management` endpoint's name. The map grows on connect and each
+/// entry carries its own task/status/reconnect, so opening one console never
+/// disturbs another.
 #[derive(Default)]
-pub struct Remote(pub AsyncMutex<RemoteState>);
+pub struct Remote(pub AsyncMutex<HashMap<String, RemoteState>>);
 
 #[derive(Default)]
 pub struct RemoteState {
@@ -76,21 +81,22 @@ pub enum OutMsg {
 }
 
 impl Remote {
-    /// Send a chat turn to the connected agent. Errors if no session is live.
-    pub async fn send_prompt(&self, text: String) -> Result<(), String> {
-        self.push(OutMsg::Prompt(text)).await
+    /// Send a chat turn to the named agent. Errors if that agent's session is not
+    /// live (each agent console has its own connection, so the target is explicit).
+    pub async fn send_prompt(&self, agent: &str, text: String) -> Result<(), String> {
+        self.push(agent, OutMsg::Prompt(text)).await
     }
 
-    /// Cancel the in-flight turn (best-effort).
-    pub async fn send_cancel(&self) -> Result<(), String> {
-        self.push(OutMsg::Cancel).await
+    /// Cancel the named agent's in-flight turn (best-effort).
+    pub async fn send_cancel(&self, agent: &str) -> Result<(), String> {
+        self.push(agent, OutMsg::Cancel).await
     }
 
-    async fn push(&self, msg: OutMsg) -> Result<(), String> {
+    async fn push(&self, agent: &str, msg: OutMsg) -> Result<(), String> {
         let guard = self.0.lock().await;
         let tx = guard
-            .prompt_tx
-            .as_ref()
+            .get(agent)
+            .and_then(|st| st.prompt_tx.as_ref())
             .ok_or_else(|| "not connected — activate the remote connection first".to_string())?;
         // A live `prompt_tx` whose receiver has gone means the connection is
         // tearing down (the socket closed and `run_reconnecting` is about to
@@ -103,13 +109,81 @@ impl Remote {
     }
 }
 
-/// `~/.config/oab-studio/remote.toml` — beside `fleets.toml`.
+/// Legacy single-endpoint config `~/.config/oab-studio/remote.toml` — beside
+/// `fleets.toml`. Still the file the current management-console editor writes; the
+/// registry adopts it as one `management = true` entry when `agents.toml` is
+/// absent (ADR agent-consoles Part B back-compat).
 pub fn config_path() -> Result<PathBuf, String> {
     dirs::config_dir()
         .map(|d| d.join("oab-studio").join("remote.toml"))
         .ok_or_else(|| "no config directory resolved".to_string())
 }
 
+/// The per-agent endpoint registry `~/.config/oab-studio/agents.toml`. When
+/// present it is the source of truth; the legacy `remote.toml` is the fallback.
+pub fn registry_path() -> Result<PathBuf, String> {
+    dirs::config_dir()
+        .map(|d| d.join("oab-studio").join("agents.toml"))
+        .ok_or_else(|| "no config directory resolved".to_string())
+}
+
+/// The stable name given to a legacy `remote.toml` when it is adopted into the
+/// registry as the single management entry.
+pub const LEGACY_MANAGEMENT_NAME: &str = "management";
+
+/// Load the endpoint registry: prefer `agents.toml`; if it is missing or empty,
+/// adopt the legacy `remote.toml` as one `management = true` entry so existing
+/// single-endpoint setups keep working untouched.
+pub fn load_registry() -> Result<AgentRegistry, String> {
+    let rp = registry_path()?;
+    match std::fs::read_to_string(&rp) {
+        Ok(s) if !s.trim().is_empty() => {
+            return AgentRegistry::parse(&s).map_err(|e| format!("invalid agents.toml: {e}"))
+        }
+        Ok(_) => {} // present but empty → fall through to legacy
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
+        Err(e) => return Err(format!("read {}: {e}", rp.display())),
+    }
+    let legacy = load_config()?;
+    if legacy.is_configured() {
+        Ok(AgentRegistry::from_legacy(legacy, LEGACY_MANAGEMENT_NAME))
+    } else {
+        // Nothing configured anywhere → empty registry (the app shows
+        // "not configured" rather than erroring).
+        Ok(AgentRegistry::default())
+    }
+}
+
+/// Resolve a command's optional `agent` argument to just the connection **key**
+/// (the map name). `Some` is already the key; `None` resolves to the management
+/// endpoint's name. Cheaper than [`resolve_endpoint`] when only the key is needed
+/// (disconnect / prompt / cancel target an already-open connection).
+pub fn resolve_name(agent: Option<&str>) -> Result<String, String> {
+    match agent {
+        Some(n) => Ok(n.to_string()),
+        None => load_registry()?
+            .management()
+            .map(|e| e.name.clone())
+            .ok_or_else(|| "no management agent configured".to_string()),
+    }
+}
+
+/// Resolve a command's optional `agent` argument to a concrete endpoint. `None`
+/// means the legacy single-endpoint commands — resolve to the management entry.
+pub fn resolve_endpoint(agent: Option<&str>) -> Result<AgentEndpoint, String> {
+    let reg = load_registry()?;
+    match agent {
+        Some(name) => reg
+            .get(name)
+            .cloned()
+            .ok_or_else(|| format!("no agent named {name:?} in the registry")),
+        None => reg
+            .management()
+            .cloned()
+            .ok_or_else(|| "no management agent configured".to_string()),
+    }
+}
+
 /// Raw file text for the editor; a missing file is empty ("not configured").
 pub fn read_config_text() -> Result<String, String> {
     let p = config_path()?;
@@ -135,34 +209,46 @@ fn load_config() -> Result<RemoteConfig, String> {
     RemoteConfig::parse(&read_config_text()?).map_err(|e| format!("invalid remote.toml: {e}"))
 }
 
-fn emit_status<R: Runtime>(app: &AppHandle<R>, status: &str) {
-    let _ = app.emit("remote-status", json!({ "status": status }));
+/// Emit a connection-status change for a specific agent. The `agent` field lets
+/// the UI route the update to the matching console (the management console keys
+/// off the management endpoint's name); a single-agent UI can ignore it.
+fn emit_status<R: Runtime>(app: &AppHandle<R>, agent: &str, status: &str) {
+    let _ = app.emit("remote-status", json!({ "agent": agent, "status": status }));
 }
 
-/// Activate the remote connection: validate config, spawn the connection task.
-/// Idempotent — a no-op if already connected.
+/// Activate a named agent's connection: validate the endpoint, spawn its
+/// connection task keyed under the endpoint name. Idempotent — a no-op if that
+/// agent is already connecting/connected. Reverse-MCP `oab` fleet-control tools
+/// are published **only** when the endpoint is `management` (least privilege): an
+/// ordinary agent console dials, chats, and (later) edits files without granting
+/// the agent fleet control.
 pub async fn connect<R: Runtime>(
     app: AppHandle<R>,
     remote: &Remote,
     client: McpClient,
+    endpoint: AgentEndpoint,
 ) -> Result<(), String> {
-    let cfg = load_config()?;
-    cfg.validate()?;
+    endpoint.validate()?;
+    let agent = endpoint.name.clone();
+    let cfg = endpoint.conn();
+    let management = endpoint.management;
 
     let mut guard = remote.0.lock().await;
-    if guard.task.is_some() {
+    let st = guard.entry(agent.clone()).or_default();
+    if st.task.is_some() {
         return Ok(());
     }
     let app_task = app.clone();
+    let agent_task = agent.clone();
     let stop = Arc::new(AtomicBool::new(false));
     let stop_task = stop.clone();
     let task = tauri::async_runtime::spawn(async move {
-        run_reconnecting(app_task, cfg, client, stop_task).await;
+        run_reconnecting(app_task, agent_task, cfg, management, client, stop_task).await;
     });
-    guard.task = Some(task);
-    guard.stop = Some(stop);
-    guard.status = "connecting".to_string();
-    emit_status(&app, "connecting");
+    st.task = Some(task);
+    st.stop = Some(stop);
+    st.status = "connecting".to_string();
+    emit_status(&app, &agent, "connecting");
     Ok(())
 }
 
@@ -171,15 +257,18 @@ pub async fn connect<R: Runtime>(
 /// frame) so the gateway releases the session slot immediately rather than holding
 /// it for a resume that will never come (until its TTL / liveness reaper fires).
 /// Safe to call on app teardown and from the Disconnect button; a no-op if idle.
-pub async fn disconnect<R: Runtime>(app: &AppHandle<R>, remote: &Remote) {
+pub async fn disconnect<R: Runtime>(app: &AppHandle<R>, remote: &Remote, agent: &str) {
     // Flag the reconnect loop to stop, and grab the pieces we need to tear down
     // outside the lock (so the loop can take the lock to retract `prompt_tx`).
     let (task, tx) = {
         let mut guard = remote.0.lock().await;
-        if let Some(stop) = guard.stop.take() {
+        let Some(st) = guard.get_mut(agent) else {
+            return; // never connected — nothing to tear down
+        };
+        if let Some(stop) = st.stop.take() {
             stop.store(true, Ordering::SeqCst);
         }
-        (guard.task.take(), guard.prompt_tx.take())
+        (st.task.take(), st.prompt_tx.take())
     };
     // Ask the running connection to flush a graceful close.
     if let Some(tx) = tx {
@@ -192,16 +281,38 @@ pub async fn disconnect<R: Runtime>(app: &AppHandle<R>, remote: &Remote) {
         tokio::time::sleep(Duration::from_millis(400)).await;
         t.abort();
     }
-    let mut guard = remote.0.lock().await;
-    guard.status = "disconnected".to_string();
-    guard.prompt_tx = None;
-    emit_status(app, "disconnected");
+    if let Some(st) = remote.0.lock().await.get_mut(agent) {
+        st.status = "disconnected".to_string();
+        st.prompt_tx = None;
+    }
+    emit_status(app, agent, "disconnected");
     let _ = app.emit(
         "app-log",
-        json!({ "level": "info", "msg": "remote: disconnected by user" }),
+        json!({ "level": "info", "msg": format!("remote: {agent} disconnected by user") }),
     );
 }
 
+/// Disconnect **every** live agent connection (app teardown): close each socket
+/// cleanly so the gateway frees all held session slots at once.
+pub async fn disconnect_all<R: Runtime>(app: &AppHandle<R>, remote: &Remote) {
+    let agents: Vec<String> = remote.0.lock().await.keys().cloned().collect();
+    for agent in agents {
+        disconnect(app, remote, &agent).await;
+    }
+}
+
+/// The reverse-MCP `oab` server declaration for a connection, **only** when this
+/// endpoint is the management binding. A non-management agent console declares no
+/// servers, so the gateway never tunnels Studio's fleet-control tools to it
+/// (least privilege, ADR agent-consoles Part A).
+fn servers_for(management: bool, conn_id: &str) -> Vec<acp::ServerDecl> {
+    if management {
+        vec![acp::oab_server(conn_id)]
+    } else {
+        vec![]
+    }
+}
+
 /// Reconnect loop: one attempt, then back off and retry until the task is
 /// aborted (by [`disconnect`]).
 ///
@@ -213,11 +324,16 @@ pub async fn disconnect<R: Runtime>(app: &AppHandle<R>, remote: &Remote) {
 /// a full `initialize` handshake.
 async fn run_reconnecting<R: Runtime>(
     app: AppHandle<R>,
+    agent: String,
     cfg: RemoteConfig,
+    management: bool,
     client: McpClient,
     stop: Arc<AtomicBool>,
 ) {
-    let mut session = Session::new(vec![acp::oab_server(&uuid::Uuid::new_v4().to_string())]);
+    let mut session = Session::new(servers_for(
+        management,
+        &uuid::Uuid::new_v4().to_string(),
+    ));
     // Consecutive-failure counter driving the reconnect backoff. Reset to 0 once an
     // attempt has held a live connection for a while (see below), so a long-running
     // session that blips reconnects promptly instead of at the capped delay.
@@ -228,20 +344,24 @@ async fn run_reconnecting<R: Runtime>(
         }
         let conn_id = uuid::Uuid::new_v4().to_string();
         // Fresh per-connection server id + phase reset; keeps `session_id` so
-        // `run_once` picks the resume path when one exists.
-        session.redeclare(vec![acp::oab_server(&conn_id)]);
+        // `run_once` picks the resume path when one exists. `servers_for` gates the
+        // `oab` declaration on `management`, so a non-management console re-attaches
+        // without ever republishing fleet-control tools.
+        session.redeclare(servers_for(management, &conn_id));
         if session.session_id().is_some() {
             let _ = app.emit(
                 "app-log",
-                json!({ "level": "info", "msg": "remote: reconnecting — will resume the existing session" }),
+                json!({ "level": "info", "msg": format!("remote: {agent} reconnecting — will resume the existing session") }),
             );
         }
 
         let started = Instant::now();
-        let result = run_once(&app, &cfg, &client, &mut session, &conn_id).await;
-        // The socket is gone — retract the outbound-chat channel so a prompt
-        // between attempts fails fast rather than dropping into a dead sink.
-        app.state::<Remote>().0.lock().await.prompt_tx = None;
+        let result = run_once(&app, &agent, &cfg, management, &client, &mut session, &conn_id).await;
+        // The socket is gone — retract this agent's outbound-chat channel so a
+        // prompt between attempts fails fast rather than dropping into a dead sink.
+        if let Some(st) = app.state::<Remote>().0.lock().await.get_mut(&agent) {
+            st.prompt_tx = None;
+        }
         // User-initiated disconnect: stop here instead of reconnecting (and skip
         // the misleading "reconnecting…" log).
         if stop.load(Ordering::SeqCst) {
@@ -257,10 +377,10 @@ async fn run_reconnecting<R: Runtime>(
             // Classify so the status line says *why* (network / auth rejected /
             // server at capacity / protocol) instead of a raw error blob.
             let reason = DisconnectReason::classify(&e);
-            emit_status(&app, &format!("error: {}", reason.label()));
+            emit_status(&app, &agent, &format!("error: {}", reason.label()));
             let _ = app.emit(
                 "app-log",
-                json!({ "level": "error", "msg": format!("remote: {} — {e}", reason.label()) }),
+                json!({ "level": "error", "msg": format!("remote: {agent} {} — {e}", reason.label()) }),
             );
         }
         // Exponential backoff (capped 30s) + per-connection jitter, so a flapping
@@ -269,10 +389,10 @@ async fn run_reconnecting<R: Runtime>(
         let salt = conn_id.as_bytes().first().copied().unwrap_or(0);
         let delay = acp::backoff_delay(attempt, salt);
         attempt = attempt.saturating_add(1);
-        emit_status(&app, "connecting");
+        emit_status(&app, &agent, "connecting");
         let _ = app.emit(
             "app-log",
-            json!({ "level": "info", "msg": format!("remote: reconnecting in {}s…", delay.as_secs()) }),
+            json!({ "level": "info", "msg": format!("remote: {agent} reconnecting in {}s…", delay.as_secs()) }),
         );
         tokio::time::sleep(delay).await;
     }
@@ -284,7 +404,9 @@ async fn run_reconnecting<R: Runtime>(
 /// is dead and returns `Err` so [`run_reconnecting`] reconnects.
 async fn run_once<R: Runtime>(
     app: &AppHandle<R>,
+    agent: &str,
     cfg: &RemoteConfig,
+    management: bool,
     client: &McpClient,
     session: &mut Session,
     conn_id: &str,
@@ -318,7 +440,7 @@ async fn run_once<R: Runtime>(
     // otherwise invisible in Activity until it succeeds or errors.
     let _ = app.emit(
         "app-log",
-        json!({ "level": "info", "msg": format!("remote: dialing {}…", cfg.url) }),
+        json!({ "level": "info", "msg": format!("remote: {agent} dialing {}…", cfg.url) }),
     );
     let (ws, _resp) = tokio_tungstenite::connect_async(req)
         .await
@@ -578,7 +700,7 @@ async fn run_once<R: Runtime>(
                                     let _ = app.emit(
                                         "app-log",
                                         json!({ "level": "warn", "msg": format!(
-                                            "remote: session/resume rejected ({emsg}) — opening a fresh session"
+                                            "remote: {agent} session/resume rejected ({emsg}) — opening a fresh session"
                                         ) }),
                                     );
                                     session.forget_session();
@@ -600,15 +722,30 @@ async fn run_once<R: Runtime>(
                                     .unwrap_or_default()
                                     .to_string();
                                 session.on_session_created(sid);
-                                // Now a turn can be sent — publish the outbound channel.
-                                app.state::<Remote>().0.lock().await.prompt_tx = Some(out_tx.clone());
-                                emit_status(app, "connected");
-                                let msg = if resume_attempted {
-                                    "remote: session resumed — oab tools republished"
+                                // Now a turn can be sent — publish this agent's outbound channel.
+                                if let Some(st) =
+                                    app.state::<Remote>().0.lock().await.get_mut(agent)
+                                {
+                                    st.prompt_tx = Some(out_tx.clone());
+                                    st.status = "connected".to_string();
+                                }
+                                emit_status(app, agent, "connected");
+                                // Only the management binding publishes `oab` tools; an
+                                // agent console runs chat-only (least privilege).
+                                let tools = if management {
+                                    if resume_attempted {
+                                        " — oab tools republished"
+                                    } else {
+                                        " — oab tools published"
+                                    }
                                 } else {
-                                    "remote: session active — oab tools published"
+                                    ""
                                 };
-                                let _ = app.emit("app-log", json!({ "level": "info", "msg": msg }));
+                                let verb = if resume_attempted { "resumed" } else { "active" };
+                                let _ = app.emit(
+                                    "app-log",
+                                    json!({ "level": "info", "msg": format!("remote: {agent} session {verb}{tools}") }),
+                                );
                             }
                         }
                         acp::Phase::SessionActive => {
@@ -625,7 +762,7 @@ async fn run_once<R: Runtime>(
                                     .to_string();
                                 let _ = app.emit(
                                     "agent-update",
-                                    json!({ "kind": "turn_end", "stopReason": stop }),
+                                    json!({ "agent": agent, "kind": "turn_end", "stopReason": stop }),
                                 );
                             }
                             // Any other method-less frame (e.g. a heartbeat probe's
@@ -669,7 +806,7 @@ async fn run_once<R: Runtime>(
                     }
                     // A piece of the agent's chat reply → forward to the panel.
                     Inbound::AgentChunk { text } => {
-                        let _ = app.emit("agent-update", json!({ "kind": "chunk", "text": text }));
+                        let _ = app.emit("agent-update", json!({ "agent": agent, "kind": "chunk", "text": text }));
                     }
                     Inbound::Cancel { .. } | Inbound::Other => {}
                 }
@@ -685,7 +822,7 @@ async fn run_once<R: Runtime>(
     if pending_prompt.is_some() {
         let _ = app.emit(
             "app-log",
-            json!({ "level": "warn", "msg": "remote: connection dropped with a turn in flight — turn abandoned" }),
+            json!({ "level": "warn", "msg": format!("remote: {agent} connection dropped with a turn in flight — turn abandoned") }),
         );
     }
     outcome