diff --git a/docs/profiles.md b/docs/profiles.md
index dfb828311..15f878e30 100644
--- a/docs/profiles.md
+++ b/docs/profiles.md
@@ -2,8 +2,9 @@
 
 The bundled `buzz.profiles` plugin supplies a profile panel for any
 public identity, human or agent. It uses the current session's shared profile
-directory. Agents retains agent-specific configuration/operations; this slice
-adds no ownership/running badge, editor, agent-library read or execution API.
+directory. Agents retains agent-specific configuration and its page-local editor. Profiles
+can dispatch existing local Start/Stop/Restart commands for an exact managed
+identity in the active community; profile metadata and library hints grant no authority.
 When Agent Activity is enabled and the host supplies conversation context, **View
 activity** opens its raw panel for this exact identity and originating channel.
 The Info tab's “Latest activity” card shows up to three recently updated assistant
@@ -159,3 +160,44 @@ Before publisher entry, navigation or loss of eligibility stops the write. Once
 publication begins, leaving the tab cannot undo the request; the session outbox
 retains its outcome and an unconfirmed result requires checking membership
 before attempting again. Neither list is a cross-community/global directory.
+
+## Owned local agent actions
+
+`ProfileAgentActions` observes the app-owned `AgentControl` injected into Profiles.
+It mounts only in Info, alongside the linked-instance child; changing tabs releases
+the actions view without cancelling an admitted app-owned command. Returning to
+Info observes current host evidence without restoring focus from the retired view.
+In this composition, actions own controller errors and Retry status; linked instances
+suppress their duplicate error surface only when actions can present recovery
+(unknown inventory or one exact match). Known unmatched/ambiguous identities keep
+a single linked-instance status warning and Retry agents. Standalone
+linked-instance views retain their own recovery. Initial-read Retry remains available
+when native ownership is unknown.
+It matches the exact public key and canonical active-community scope to one native
+ID; namesakes, other-community identities, ambiguous matches and browser-only
+profiles get no runtime actions. It adds no controller, relay scan or agent editor.
+Profiles and Agents share `useAgentControl` for observation. While mounted it
+refreshes host evidence every five seconds when visible/ready; errors stop polling and expose explicit Retry status. Unmount
+releases observation, never native execution.
+
+Start/Restart require ready host evidence, an available runtime and no pending
+operation or process transition. Stop uses the controller's existing recovery
+policy, including stale evidence and pending launch/credential waits; it is the
+intentional exception to disabling pending actions. A pending Stop cannot repeat.
+Host failures remain visible with snapshot uncertainty for the matched agent.
+Known unmatched profiles suppress unrelated controller errors; an initial read
+failure still offers Retry while ownership is unknown. Start stays focusable but
+inactive while pending, and moves focus to Stop if success removes the focused
+Start button. It does not steal focus moved elsewhere during the wait. Stop and
+Restart retain focus when disabled or pending without allowing activation.
+`agentLaunchBlock` centralizes the launch gates used by Profiles and Agents.
+Retired relay
+presentations cannot dispatch commands. The separate runtime child owns badges
+and runtime detail; actions do not infer relay readiness.
+
+Edit ingress is deferred: Agents currently registers no specific editor route;
+its editor selection is page-local state. No invented route or second editor is
+added. Mounted React regression tests exercise exact dispatch, pending/failure/
+recovery and profile/community lifecycle through the real controller projection
+with a synthetic native host. Live process/credential handover and rendered native
+acceptance remain attended checks, not established by these tests.
diff --git a/src/bundled/agents/AgentControlPanel.tsx b/src/bundled/agents/AgentControlPanel.tsx
index d66f369a0..34cb3886e 100644
--- a/src/bundled/agents/AgentControlPanel.tsx
+++ b/src/bundled/agents/AgentControlPanel.tsx
@@ -1,10 +1,6 @@
 import type { useIdentityNames } from "../../features/identity-names/react";
-import {
-  useEffect,
-  useState,
-  useSyncExternalStore,
-  type ReactNode,
-} from "react";
+import { useAgentControl } from "../../features/agents/control-react";
+import { useEffect, useState, type ReactNode } from "react";
 import type {
   AgentControl,
   AgentControlState,
@@ -50,22 +46,7 @@ export function AgentControlPanel({
   } | null>(null);
   const edit = (agent: AgentView, avatar?: string) =>
     setSelected({ id: agent.id, ...(avatar ? { avatar } : {}) });
-  const state = useSyncExternalStore(
-    control.subscribe,
-    control.snapshot,
-    control.snapshot,
-  );
-  useEffect(() => {
-    void control.refresh();
-    const timer = setInterval(() => {
-      if (
-        document.visibilityState !== "hidden" &&
-        control.snapshot().status === "ready"
-      )
-        void control.refresh();
-    }, 5000);
-    return () => clearInterval(timer);
-  }, [control]);
+  const state = useAgentControl(control);
   useEffect(() => {
     if (
       state.data?.agents.some(
diff --git a/src/bundled/agents/AgentEditor.tsx b/src/bundled/agents/AgentEditor.tsx
index f49b066bc..d609ba737 100644
--- a/src/bundled/agents/AgentEditor.tsx
+++ b/src/bundled/agents/AgentEditor.tsx
@@ -6,6 +6,7 @@ import { Accordion } from "../../shared/design-system/ui/Accordion";
 import { Avatar } from "../../shared/design-system/ui/Avatar";
 import {
   canStopAgent,
+  agentLaunchBlock,
   type AgentControl,
   type AgentControlState,
   type AgentView,
@@ -43,8 +44,7 @@ export function AgentEditor({
   const blocked = state.busy || state.status !== "ready";
   const canClose =
     !state.busy || !!(state.pendingLaunch || state.pendingCredentialWrite);
-  const transitioning =
-    agent.status === "starting" || agent.status === "stopping";
+  const launchBlocked = !!agentLaunchBlock(state, agent) || dirty;
   const unapplied =
     agent.runningRevision !== null && agent.runningRevision !== agent.revision;
   const change = (patch: Partial<AgentDraft>) => {
@@ -160,12 +160,7 @@ export function AgentEditor({
                           <div className="flex flex-wrap gap-2">
                             {agent.status !== "running" && (
                               <Button
-                                disabled={
-                                  blocked ||
-                                  transitioning ||
-                                  dirty ||
-                                  !state.data?.runtimeAvailable
-                                }
+                                disabled={launchBlocked}
                                 onClick={() => act("start")}
                               >
                                 Start
@@ -178,12 +173,7 @@ export function AgentEditor({
                               Stop
                             </Button>
                             <Button
-                              disabled={
-                                blocked ||
-                                transitioning ||
-                                dirty ||
-                                !state.data?.runtimeAvailable
-                              }
+                              disabled={launchBlocked}
                               onClick={() => act("restart")}
                             >
                               {unapplied ? "Restart to apply" : "Restart"}
diff --git a/src/bundled/agents/ManagedAgentActions.tsx b/src/bundled/agents/ManagedAgentActions.tsx
index 054891bcb..95af623f1 100644
--- a/src/bundled/agents/ManagedAgentActions.tsx
+++ b/src/bundled/agents/ManagedAgentActions.tsx
@@ -1,6 +1,7 @@
 import { useEffect, useRef } from "react";
 import {
   canStopAgent,
+  agentLaunchBlock,
   type AgentControl,
   type AgentControlState,
   type AgentView,
@@ -26,19 +27,7 @@ export function ManagedAgentActions({
       details.current?.focus();
     }
   }, [imported]);
-  const transitioning =
-    agent.status === "starting" || agent.status === "stopping";
-  const startBlock =
-    state.status !== "ready"
-      ? "Refresh status before starting."
-      : state.busy
-        ? "Waiting for the current operation."
-        : !state.data?.runtimeAvailable
-          ? state.data?.runtimeMessage ||
-            "The bundled agent runtime is unavailable."
-          : transitioning
-            ? "Waiting for the process transition."
-            : null;
+  const startBlock = agentLaunchBlock(state, agent);
   const act = (action: "start" | "stop") => {
     void control.action(agent.id, action).catch(() => {});
   };
diff --git a/src/bundled/profiles/ProfileAgentActions.test.tsx b/src/bundled/profiles/ProfileAgentActions.test.tsx
new file mode 100644
index 000000000..1fadd4c6c
--- /dev/null
+++ b/src/bundled/profiles/ProfileAgentActions.test.tsx
@@ -0,0 +1,424 @@
+// @vitest-environment jsdom
+import "@testing-library/jest-dom/vitest";
+import {
+  act,
+  cleanup,
+  render,
+  screen,
+  waitFor,
+  within,
+} from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { StrictMode } from "react";
+import { afterEach, expect, it, vi } from "vitest";
+import {
+  createAgentControl,
+  type ControlSnapshot,
+} from "../../features/agents/control";
+import { controlFixture } from "../../features/agents/control-testing";
+import { profileTarget } from "../../features/profiles/target";
+import type { RelayData, RelaySnapshot } from "../../features/relay/service";
+import { createRelaySession } from "../../features/relay/session";
+import { ProfilePanel } from "./ProfilePanel";
+
+const disposers: (() => void)[] = [];
+afterEach(() => {
+  cleanup();
+  for (const dispose of disposers.splice(0)) dispose();
+  vi.useRealTimers();
+});
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (reason: unknown) => void;
+  const promise = new Promise<T>((yes, no) => {
+    resolve = yes;
+    reject = no;
+  });
+  return { promise, resolve, reject };
+}
+function setup(native = true) {
+  const fixture = controlFixture();
+  const control = createAgentControl(native ? fixture.host : null);
+  const owner = createRelaySession(null);
+  disposers.push(control.dispose, owner.dispose);
+  const listeners = new Set<() => void>();
+  let snapshot: RelaySnapshot = {
+    status: "ready",
+    generation: 1,
+    session: owner.session,
+    viewer: "cd".repeat(32),
+    scope: `https://relay.example.test:${"cd".repeat(32)}`,
+  };
+  const relay: RelayData = {
+    snapshot: () => snapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    retry() {},
+    disconnect() {},
+    async clearCache() {},
+  };
+  const panel = (pubkey = fixture.agent.pubkey) => (
+    <StrictMode>
+      <ProfilePanel
+        relay={relay}
+        control={control}
+        target={profileTarget(pubkey) ?? ""}
+        close={() => {}}
+      />
+    </StrictMode>
+  );
+  const switchScope = (patch: Partial<RelaySnapshot>, notify = true) => {
+    snapshot = { ...snapshot, ...patch };
+    if (notify) for (const listener of listeners) listener();
+  };
+  return { ...fixture, control, relay, panel, switchScope };
+}
+
+it("dispatches Stop, Start and Restart to the exact local native ID, never a namesake or another relay", async () => {
+  const h = setup();
+  h.data.agents.unshift(
+    { ...h.agent, id: "other-relay", relayUrl: "wss://other.test" },
+    { ...h.agent, id: "namesake", pubkey: "ef".repeat(32) },
+  );
+  const user = userEvent.setup();
+  render(h.panel());
+  await user.click(await screen.findByRole("button", { name: "Stop" }));
+  await user.click(await screen.findByRole("button", { name: "Start" }));
+  await user.click(screen.getByRole("button", { name: "Restart" }));
+  expect(h.calls.filter((call) => call.action !== "snapshot")).toEqual([
+    { action: "stop", payload: { id: h.agent.id } },
+    { action: "start", payload: { id: h.agent.id } },
+    { action: "restart", payload: { id: h.agent.id } },
+  ]);
+});
+
+it.each([
+  "public identity",
+  "other relay",
+  "duplicate identity",
+  "browser",
+  "missing scope",
+])("does not expose controls for %s", async (mode) => {
+  const h = setup(mode !== "browser");
+  if (mode === "other relay") h.agent.relayUrl = "wss://other.test";
+  if (mode === "duplicate identity")
+    h.data.agents.push({ ...h.agent, id: "duplicate" });
+  if (mode === "missing scope") h.switchScope({ scope: "" });
+  const view = render(
+    h.panel(mode === "public identity" ? "ef".repeat(32) : undefined),
+  );
+  await act(() => h.control.refresh());
+  expect(
+    screen.queryByRole("region", { name: "Local agent actions" }),
+  ).not.toBeInTheDocument();
+  expect(
+    screen.queryByRole("button", { name: /^(Start|Stop|Restart|Edit)$/ }),
+  ).not.toBeInTheDocument();
+  expect(h.calls.every((call) => call.action === "snapshot")).toBe(true);
+  view.unmount();
+});
+
+it("blocks runtime-unavailable and transitioning launches but preserves recovery Stop", async () => {
+  const h = setup();
+  h.data.runtimeAvailable = false;
+  h.data.runtimeMessage = "Runtime resources are missing.";
+  render(h.panel());
+  expect(
+    await screen.findByText("Runtime resources are missing."),
+  ).toBeInTheDocument();
+  expect(screen.getByRole("button", { name: "Restart" })).toHaveAttribute(
+    "aria-disabled",
+    "true",
+  );
+  expect(screen.getByRole("button", { name: "Stop" })).not.toHaveAttribute(
+    "aria-disabled",
+    "true",
+  );
+  h.data.runtimeAvailable = true;
+  h.agent.status = "starting";
+  await act(() => h.control.refresh());
+  expect(screen.getByRole("button", { name: "Start" })).toHaveAttribute(
+    "aria-disabled",
+    "true",
+  );
+  expect(screen.getByRole("button", { name: "Restart" })).toHaveAttribute(
+    "aria-disabled",
+    "true",
+  );
+  expect(
+    screen.getByText("Waiting for the process transition."),
+  ).toBeInTheDocument();
+});
+
+it("disables duplicate pending commands, reports failure, and requires explicit status recovery", async () => {
+  const h = setup();
+  const pending = deferred<ControlSnapshot>();
+  const action = vi
+    .spyOn(h.host, "action")
+    .mockImplementationOnce(() => pending.promise);
+  const user = userEvent.setup();
+  render(h.panel());
+  await user.click(await screen.findByRole("button", { name: "Stop" }));
+  try {
+    expect(screen.getByRole("button", { name: "Stop" })).toHaveAttribute(
+      "aria-disabled",
+      "true",
+    );
+    expect(screen.getByRole("button", { name: "Restart" })).toHaveAttribute(
+      "aria-disabled",
+      "true",
+    );
+    expect(
+      screen.getByText("Waiting for the host to confirm…"),
+    ).toBeInTheDocument();
+    await user.click(screen.getByRole("button", { name: "Stop" }));
+    expect(action).toHaveBeenCalledTimes(1);
+  } finally {
+    await act(async () =>
+      pending.reject("The host could not stop the process."),
+    );
+  }
+  expect(
+    screen.getByText(/The host could not stop the process/),
+  ).toBeInTheDocument();
+  expect(
+    screen.getByText(/Showing the last host snapshot/),
+  ).toBeInTheDocument();
+  expect(screen.getByRole("button", { name: "Stop" })).not.toHaveAttribute(
+    "aria-disabled",
+    "true",
+  );
+  expect(screen.getByRole("button", { name: "Restart" })).toHaveAttribute(
+    "aria-disabled",
+    "true",
+  );
+  await user.click(screen.getByRole("button", { name: "Retry status" }));
+  await waitFor(() =>
+    expect(screen.getByRole("button", { name: "Restart" })).not.toHaveAttribute(
+      "aria-disabled",
+      "true",
+    ),
+  );
+  await user.click(screen.getByRole("button", { name: "Restart" }));
+  expect(action).toHaveBeenLastCalledWith(h.agent.id, "restart");
+  expect(
+    within(
+      screen.getByRole("region", { name: "Local agent actions" }),
+    ).queryByRole("alert"),
+  ).not.toBeInTheDocument();
+});
+
+it("allows recovery Stop during a pending Start and ignores its late failure", async () => {
+  const h = setup();
+  h.agent.enabled = false;
+  h.agent.status = "stopped";
+  const pending = deferred<ControlSnapshot>();
+  const action = vi
+    .spyOn(h.host, "action")
+    .mockImplementationOnce(() => pending.promise);
+  const user = userEvent.setup();
+  render(h.panel());
+  await user.click(await screen.findByRole("button", { name: "Start" }));
+  try {
+    expect(screen.getByRole("button", { name: "Start" })).toHaveAttribute(
+      "aria-disabled",
+      "true",
+    );
+    expect(screen.getByRole("button", { name: "Restart" })).toHaveAttribute(
+      "aria-disabled",
+      "true",
+    );
+    expect(screen.getByRole("button", { name: "Stop" })).not.toHaveAttribute(
+      "aria-disabled",
+      "true",
+    );
+    await user.click(screen.getByRole("button", { name: "Stop" }));
+    expect(action).toHaveBeenLastCalledWith(h.agent.id, "stop");
+    expect(screen.getByRole("button", { name: "Restart" })).toHaveAttribute(
+      "aria-disabled",
+      "true",
+    );
+  } finally {
+    await act(async () => pending.reject("Retired launch failed."));
+  }
+  expect(
+    within(
+      screen.getByRole("region", { name: "Local agent actions" }),
+    ).queryByRole("alert"),
+  ).not.toBeInTheDocument();
+  expect(screen.getByRole("button", { name: "Start" })).not.toHaveAttribute(
+    "aria-disabled",
+    "true",
+  );
+});
+
+it("recovers an initial read failure without inferring ownership and stops polling errors", async () => {
+  const h = setup();
+  const read = vi
+    .spyOn(h.host, "snapshot")
+    .mockRejectedValueOnce("No host status");
+  const user = userEvent.setup();
+  render(h.panel());
+  await screen.findByRole("button", { name: "Retry status" });
+  expect(
+    screen.queryByRole("button", { name: "Stop" }),
+  ).not.toBeInTheDocument();
+  vi.useFakeTimers();
+  await act(() => vi.advanceTimersByTimeAsync(15000));
+  expect(read).toHaveBeenCalledTimes(1);
+  vi.useRealTimers();
+  await user.click(screen.getByRole("button", { name: "Retry status" }));
+  expect(
+    await screen.findByRole("button", { name: "Stop" }),
+  ).not.toHaveAttribute("aria-disabled", "true");
+});
+
+it("fences retired relay clicks and tracks profile, community, reconnect and disconnect changes", async () => {
+  const h = setup();
+  const user = userEvent.setup();
+  const view = render(h.panel());
+  const stop = await screen.findByRole("button", { name: "Stop" });
+  // Retire synchronously before React hears the subscription notification.
+  h.switchScope({ scope: `https://other.test:${"cd".repeat(32)}` }, false);
+  await user.click(stop);
+  expect(h.calls.filter((call) => call.action !== "snapshot")).toEqual([]);
+  act(() => h.switchScope({}));
+  expect(
+    screen.queryByRole("button", { name: "Stop" }),
+  ).not.toBeInTheDocument();
+  act(() =>
+    h.switchScope({
+      scope: `https://relay.example.test:${"cd".repeat(32)}`,
+      generation: 2,
+    }),
+  );
+  expect(
+    await screen.findByRole("button", { name: "Stop" }),
+  ).not.toHaveAttribute("aria-disabled", "true");
+  view.rerender(h.panel("ef".repeat(32)));
+  expect(
+    screen.queryByRole("button", { name: "Stop" }),
+  ).not.toBeInTheDocument();
+  view.rerender(h.panel());
+  expect(
+    await screen.findByRole("button", { name: "Stop" }),
+  ).not.toHaveAttribute("aria-disabled", "true");
+  act(() => h.switchScope({ status: "disconnected" }));
+  expect(
+    screen.queryByRole("button", { name: "Stop" }),
+  ).not.toBeInTheDocument();
+  expect(
+    screen.getByText("Connect to a community to view this profile."),
+  ).toBeInTheDocument();
+});
+
+it("does not leak late completion into a replacement identity or dispose native execution on unmount", async () => {
+  const h = setup();
+  const pending = deferred<ControlSnapshot>();
+  vi.spyOn(h.host, "action").mockImplementationOnce(() => pending.promise);
+  const read = vi.spyOn(h.host, "snapshot");
+  const dispose = vi.spyOn(h.control, "dispose");
+  const user = userEvent.setup();
+  const view = render(h.panel());
+  await user.click(await screen.findByRole("button", { name: "Restart" }));
+  try {
+    view.rerender(h.panel("ef".repeat(32)));
+    expect(
+      screen.queryByRole("button", { name: "Stop" }),
+    ).not.toBeInTheDocument();
+  } finally {
+    await act(async () => pending.resolve(structuredClone(h.data)));
+  }
+  expect(
+    screen.queryByRole("region", { name: "Local agent actions" }),
+  ).not.toBeInTheDocument();
+  view.unmount();
+  const reads = read.mock.calls.length;
+  vi.useFakeTimers();
+  await act(() => vi.advanceTimersByTimeAsync(15000));
+  expect(read).toHaveBeenCalledTimes(reads);
+  expect(dispose).not.toHaveBeenCalled();
+  expect(h.control.snapshot().status).toBe("ready");
+});
+
+it("polls only while visible and ready, and releases the timer on unmount", async () => {
+  vi.useFakeTimers();
+  const h = setup();
+  const read = vi.spyOn(h.host, "snapshot");
+  const visibility = vi.spyOn(document, "visibilityState", "get");
+  try {
+    const view = render(h.panel());
+    await act(() => h.control.refresh());
+    expect(read).toHaveBeenCalledTimes(1);
+    await act(() => vi.advanceTimersByTimeAsync(5000));
+    expect(read).toHaveBeenCalledTimes(2);
+    visibility.mockReturnValue("hidden");
+    await act(() => vi.advanceTimersByTimeAsync(5000));
+    expect(read).toHaveBeenCalledTimes(2);
+    visibility.mockReturnValue("visible");
+    view.unmount();
+    await act(() => vi.advanceTimersByTimeAsync(10000));
+    expect(read).toHaveBeenCalledTimes(2);
+  } finally {
+    visibility.mockRestore();
+  }
+});
+
+it("keeps unrelated command failures off a known non-owned profile", async () => {
+  const h = setup();
+  const view = render(h.panel("ef".repeat(32)));
+  await act(() => h.control.refresh());
+  vi.spyOn(h.host, "action").mockRejectedValueOnce("Unrelated launch failed.");
+  await act(async () => {
+    await h.control.action(h.agent.id, "start").catch(() => {});
+  });
+  expect(h.control.snapshot().status).toBe("error");
+  expect(
+    screen.queryByRole("region", { name: "Local agent actions" }),
+  ).not.toBeInTheDocument();
+  view.rerender(h.panel());
+  expect(screen.getByText(/Unrelated launch failed/)).toBeInTheDocument();
+  expect(
+    screen.getByRole("button", { name: "Retry status" }),
+  ).not.toHaveAttribute("aria-disabled", "true");
+});
+
+it.each([false, true])(
+  "preserves Start focus on success without stealing moved focus (moved=%s)",
+  async (moveFocus) => {
+    const h = setup();
+    h.agent.status = "stopped";
+    h.agent.enabled = false;
+    const pending = deferred<ControlSnapshot>();
+    vi.spyOn(h.host, "action").mockImplementationOnce(() => pending.promise);
+    const user = userEvent.setup();
+    render(h.panel());
+    const start = await screen.findByRole("button", { name: "Start" });
+    start.focus();
+    await user.keyboard("{Enter}");
+    try {
+      expect(h.control.snapshot().busy).toBe(true);
+      expect(start).toHaveFocus();
+      await user.keyboard("{Enter}");
+      expect(h.host.action).toHaveBeenCalledTimes(1);
+      if (moveFocus) screen.getByRole("button", { name: "Copy npub" }).focus();
+    } finally {
+      await act(async () =>
+        pending.resolve({
+          ...h.data,
+          agents: [{ ...h.agent, status: "running", enabled: true }],
+        }),
+      );
+    }
+    expect(
+      screen.queryByRole("button", { name: "Start" }),
+    ).not.toBeInTheDocument();
+    expect(
+      screen.getByRole("button", { name: moveFocus ? "Copy npub" : "Stop" }),
+    ).toHaveFocus();
+  },
+);
diff --git a/src/bundled/profiles/ProfileAgentActions.tsx b/src/bundled/profiles/ProfileAgentActions.tsx
new file mode 100644
index 000000000..467dcfe07
--- /dev/null
+++ b/src/bundled/profiles/ProfileAgentActions.tsx
@@ -0,0 +1,118 @@
+import { useCallback, useLayoutEffect, useRef } from "react";
+import { useAgentControl } from "../../features/agents/control-react";
+import {
+  canStopAgent,
+  agentLaunchBlock,
+  type AgentAction,
+  type AgentControl,
+} from "../../features/agents/control";
+import { sameCommunityAgents } from "../../features/agents/choices";
+import { useRelayConnection } from "../../features/relay/react";
+import type { RelayData } from "../../features/relay/service";
+import { Button } from "../../shared/design-system/ui/Button";
+
+/** Observe the app-owned controller; profile metadata never grants control. */
+export function ProfileAgentActions({
+  control,
+  relay,
+  pubkey,
+}: {
+  control: AgentControl;
+  relay: RelayData;
+  pubkey: string;
+}) {
+  const connection = useRelayConnection(relay);
+  const state = useAgentControl(control);
+  const stopButton = useRef<HTMLButtonElement>(null);
+  const restoreStartFocus = useRef(false);
+  const startRef = useCallback((node: HTMLButtonElement | null) => {
+    if (!node) return;
+    // Capture focus before React removes Start, not after it falls back to body.
+    return () => {
+      restoreStartFocus.current = document.activeElement === node;
+    };
+  }, []);
+  useLayoutEffect(() => {
+    if (restoreStartFocus.current && document.activeElement === document.body)
+      stopButton.current?.focus();
+    restoreStartFocus.current = false;
+  });
+  if (connection.status !== "ready" || !connection.scope) return null;
+  const matches = sameCommunityAgents(
+    state.data?.agents ?? [],
+    connection.scope,
+  ).filter((agent) => agent.pubkey === pubkey);
+  // A native ID is actionable only when the identity/destination is unambiguous.
+  const agent = matches.length === 1 ? matches[0] : undefined;
+  if (!agent && (state.status !== "error" || state.data)) return null;
+  const startBlock = agent ? agentLaunchBlock(state, agent) : null;
+  const act = (action: AgentAction) => {
+    // A retired presentation cannot dispatch into a newly selected community.
+    if (!agent || relay.snapshot() !== connection) return;
+    const current = control.snapshot();
+    if (action === "stop" ? !canStopAgent(current, agent.id) : !!startBlock)
+      return;
+    void control.action(agent.id, action).catch(() => {});
+  };
+  return (
+    <section aria-label="Local agent actions" className="flex flex-col gap-2">
+      {agent && (
+        <>
+          <div className="flex flex-wrap gap-2">
+            {agent.status !== "running" && (
+              <Button
+                size="compact"
+                ref={startRef}
+                focusableWhenDisabled
+                disabled={!!startBlock}
+                onClick={() => act("start")}
+              >
+                Start
+              </Button>
+            )}
+            <Button
+              ref={stopButton}
+              size="compact"
+              focusableWhenDisabled
+              disabled={!canStopAgent(state, agent.id)}
+              onClick={() => act("stop")}
+            >
+              Stop
+            </Button>
+            <Button
+              size="compact"
+              focusableWhenDisabled
+              disabled={!!startBlock}
+              onClick={() => act("restart")}
+            >
+              Restart
+            </Button>
+          </div>
+          {startBlock && (
+            <p className="text-body-sm text-secondary">{startBlock}</p>
+          )}
+          {agent.error && <p role="alert">{agent.error}</p>}
+        </>
+      )}
+      {state.error && <p role="alert">{state.error}</p>}
+      {state.status === "error" && (
+        <>
+          {agent && (
+            <p className="text-body-sm text-secondary">
+              Showing the last host snapshot. Current process state and durable
+              enabled intent are unconfirmed.
+            </p>
+          )}
+          <Button
+            size="compact"
+            disabled={state.busy}
+            onClick={() => void control.refresh()}
+          >
+            Retry status
+          </Button>
+        </>
+      )}
+      {state.busy && <p role="status">Waiting for the host to confirm…</p>}
+    </section>
+  );
+}
diff --git a/src/bundled/profiles/ProfileInstances.tsx b/src/bundled/profiles/ProfileInstances.tsx
index e478e3328..fe6101203 100644
--- a/src/bundled/profiles/ProfileInstances.tsx
+++ b/src/bundled/profiles/ProfileInstances.tsx
@@ -13,6 +13,7 @@ export function ProfileInstances({
   communityOrigin,
   viewer,
   knownAgent,
+  errorHandledByActions = false,
 }: {
   control: AgentControl;
   navigation: Navigation | undefined;
@@ -21,6 +22,8 @@ export function ProfileInstances({
   communityOrigin: string | undefined;
   viewer: string | undefined;
   knownAgent: boolean;
+  /** The composed Info actions surface owns controller failure and recovery. */
+  errorHandledByActions?: boolean;
 }) {
   const state = useSyncExternalStore(
     control.subscribe,
@@ -32,12 +35,19 @@ export function ProfileInstances({
       void control.refresh();
   }, [control, communityOrigin, knownAgent, state.status]);
   if (!communityOrigin || state.status === "unavailable") return null;
-  const instances =
-    scope && state.status === "ready"
-      ? sameCommunityAgents(state.data?.agents ?? [], scope).filter(
-          (agent) => agent.pubkey === pubkey,
-        )
-      : [];
+  const matches = scope
+    ? sameCommunityAgents(state.data?.agents ?? [], scope).filter(
+        (agent) => agent.pubkey === pubkey,
+      )
+    : [];
+  // Actions own errors only with unknown inventory or one exact native match.
+  if (
+    state.status === "error" &&
+    errorHandledByActions &&
+    (!state.data || matches.length === 1)
+  )
+    return null;
+  const instances = state.status === "ready" ? matches : [];
   if (!knownAgent && !instances.length) return null;
   return (
     <section
@@ -49,7 +59,11 @@ export function ProfileInstances({
         <p role="status">Loading managed agents…</p>
       ) : state.status === "error" ? (
         <div>
-          <p role="alert">Could not refresh managed agents.</p>
+          <p role="alert">
+            {errorHandledByActions
+              ? "Managed agent status is unconfirmed."
+              : "Could not refresh managed agents."}
+          </p>
           <Button size="compact" onClick={() => void control.refresh()}>
             Retry agents
           </Button>
diff --git a/src/bundled/profiles/ProfilePanel.test.tsx b/src/bundled/profiles/ProfilePanel.test.tsx
index fe146f4df..eb1f7b55e 100644
--- a/src/bundled/profiles/ProfilePanel.test.tsx
+++ b/src/bundled/profiles/ProfilePanel.test.tsx
@@ -1,4 +1,8 @@
 // @vitest-environment jsdom
+import "@testing-library/jest-dom/vitest";
+import userEvent from "@testing-library/user-event";
+import { createAgentControl } from "../../features/agents/control";
+import { controlFixture } from "../../features/agents/control-testing";
 import { act, cleanup, render, screen, waitFor } from "@testing-library/react";
 import { afterEach, expect, it, vi } from "vitest";
 import { createRelaySession } from "../../features/relay/session";
@@ -187,3 +191,149 @@ it("recovers provider-owned names in the same live session and releases demand w
     owner.dispose();
   }
 });
+
+it.each(["action", "initial read"])(
+  "Info gives %s failures one recovery owner",
+  async (failure) => {
+    const fixture = controlFixture();
+    const person = keypair();
+    const owner = createRelaySession({
+      viewer: key,
+      relayAuthor: keypair().pubkey,
+      media: () => undefined,
+      query: async () => [
+        profile(person, { name: "Owned agent", is_agent: true }),
+      ],
+    });
+    const control = createAgentControl(fixture.host);
+    const snapshot = {
+      status: "ready" as const,
+      generation: 1,
+      scope: `https://relay.example.test:${key}`,
+      viewer: key,
+      session: owner.session,
+    };
+    const relay: RelayData = {
+      snapshot: () => snapshot,
+      subscribe: () => () => {},
+      retry() {},
+      disconnect() {},
+      clearCache: async () => {},
+    };
+    // Seed a known-agent hint; authority still comes only from the native snapshot.
+    fixture.agent.pubkey = person.pubkey;
+    await owner.session.profiles.ensure([person.pubkey]);
+    if (failure === "initial read")
+      vi.spyOn(fixture.host, "snapshot").mockRejectedValueOnce(
+        "snapshot rejected",
+      );
+    else
+      vi.spyOn(fixture.host, "action").mockRejectedValueOnce("stop rejected");
+    const user = userEvent.setup();
+    try {
+      render(
+        <ProfilePanel
+          relay={relay}
+          control={control}
+          target={profileTarget(person.pubkey) ?? ""}
+          close={() => {}}
+        />,
+      );
+      if (failure === "action")
+        await user.click(await screen.findByRole("button", { name: "Stop" }));
+      await screen.findByText(
+        failure === "action"
+          ? /stop rejected/
+          : /Could not refresh local agents/,
+      );
+      expect(screen.getAllByRole("alert")).toHaveLength(1);
+      expect(
+        screen.queryByRole("button", { name: "Retry agents" }),
+      ).not.toBeInTheDocument();
+      await user.click(screen.getByRole("button", { name: "Retry status" }));
+      await waitFor(() =>
+        expect(screen.queryByRole("alert")).not.toBeInTheDocument(),
+      );
+      expect(
+        screen.getByRole("region", { name: "Linked agent instances" }),
+      ).toHaveTextContent(fixture.agent.name);
+      expect(screen.getByRole("button", { name: "Stop" })).not.toHaveAttribute(
+        "aria-disabled",
+        "true",
+      );
+    } finally {
+      cleanup();
+      control.dispose();
+      owner.dispose();
+    }
+  },
+);
+
+it.each(["ambiguous", "unmatched"])(
+  "Info retains recovery for a known %s identity",
+  async (kind) => {
+    const fixture = controlFixture();
+    const person = keypair();
+    const owner = createRelaySession({
+      viewer: key,
+      relayAuthor: keypair().pubkey,
+      media: () => undefined,
+      query: async () => [
+        profile(person, { name: "Known agent", is_agent: true }),
+      ],
+    });
+    if (kind === "ambiguous") {
+      fixture.agent.pubkey = person.pubkey;
+      fixture.data.agents.push({ ...fixture.agent, id: "duplicate" });
+    }
+    await owner.session.profiles.ensure([person.pubkey]);
+    const control = createAgentControl(fixture.host);
+    const snapshot = {
+      status: "ready" as const,
+      generation: 1,
+      scope: `https://relay.example.test:${key}`,
+      viewer: key,
+      session: owner.session,
+    };
+    const relay: RelayData = {
+      snapshot: () => snapshot,
+      subscribe: () => () => {},
+      retry() {},
+      disconnect() {},
+      clearCache: async () => {},
+    };
+    try {
+      render(
+        <ProfilePanel
+          relay={relay}
+          control={control}
+          target={profileTarget(person.pubkey) ?? ""}
+          close={() => {}}
+        />,
+      );
+      await waitFor(() => expect(control.snapshot().status).toBe("ready"));
+      vi.spyOn(fixture.host, "snapshot").mockRejectedValueOnce("read failed");
+      await act(() => control.refresh());
+      expect(screen.getAllByRole("alert")).toHaveLength(1);
+      expect(screen.getByRole("alert")).toHaveTextContent(
+        "Managed agent status is unconfirmed.",
+      );
+      expect(
+        screen.queryByRole("region", { name: "Local agent actions" }),
+      ).not.toBeInTheDocument();
+      await userEvent
+        .setup()
+        .click(screen.getByRole("button", { name: "Retry agents" }));
+      await waitFor(() =>
+        expect(screen.queryByRole("alert")).not.toBeInTheDocument(),
+      );
+      expect(
+        screen.getByRole("region", { name: "Linked agent instances" }),
+      ).toBeInTheDocument();
+    } finally {
+      cleanup();
+      control.dispose();
+      owner.dispose();
+    }
+  },
+);
diff --git a/src/bundled/profiles/ProfilePanel.tsx b/src/bundled/profiles/ProfilePanel.tsx
index 2571dc494..cd16ed8cf 100644
--- a/src/bundled/profiles/ProfilePanel.tsx
+++ b/src/bundled/profiles/ProfilePanel.tsx
@@ -1,3 +1,4 @@
+import { ProfileAgentActions } from "./ProfileAgentActions";
 import { relayOrigin } from "../../features/communities/destination";
 import type { AgentControl } from "../../features/agents/control";
 import { ProfileInstances } from "./ProfileInstances";
@@ -6,6 +7,7 @@ import { ProfileChannels } from "./ProfileChannels";
 import { useChannelIdentityNames } from "../../features/identity-names/react";
 import { PresenceIndicator } from "../../features/presence/react";
 import {
+  type ReactNode,
   useEffect,
   useMemo,
   useRef,
@@ -52,10 +54,15 @@ export function ProfilePanel({
       control={control}
       scope={connection.scope}
       viewer={connection.viewer}
-    />
+    >
+      {control && (
+        <ProfileAgentActions control={control} relay={relay} pubkey={pubkey} />
+      )}
+    </ProfileDetails>
   );
 }
 function ProfileDetails({
+  children,
   session,
   pubkey,
   context,
@@ -64,6 +71,7 @@ function ProfileDetails({
   scope,
   viewer,
 }: {
+  children?: ReactNode;
   session: RelaySession;
   pubkey: string;
   context: PanelProps["context"];
@@ -167,6 +175,7 @@ function ProfileDetails({
                 {profile?.about && (
                   <p className={styles.about}>{profile.about}</p>
                 )}
+                {children}
                 <ProfileActivity
                   session={session}
                   pubkey={pubkey}
@@ -174,6 +183,7 @@ function ProfileDetails({
                 />
                 {control && (
                   <ProfileInstances
+                    errorHandledByActions
                     control={control}
                     pubkey={pubkey}
                     navigation={navigation}
diff --git a/src/features/agents/control-react.ts b/src/features/agents/control-react.ts
new file mode 100644
index 000000000..dff4356c6
--- /dev/null
+++ b/src/features/agents/control-react.ts
@@ -0,0 +1,23 @@
+import { useEffect, useSyncExternalStore } from "react";
+import type { AgentControl } from "./control";
+
+/** View lifetime owns observation only; native execution remains app-owned. */
+export function useAgentControl(control: AgentControl) {
+  const state = useSyncExternalStore(
+    control.subscribe,
+    control.snapshot,
+    control.snapshot,
+  );
+  useEffect(() => {
+    void control.refresh();
+    const timer = setInterval(() => {
+      if (
+        document.visibilityState !== "hidden" &&
+        control.snapshot().status === "ready"
+      )
+        void control.refresh();
+    }, 5000);
+    return () => clearInterval(timer);
+  }, [control]);
+  return state;
+}
diff --git a/src/features/agents/control.ts b/src/features/agents/control.ts
index e2c71cdf5..62c4bcaf3 100644
--- a/src/features/agents/control.ts
+++ b/src/features/agents/control.ts
@@ -131,6 +131,22 @@ export interface AgentControl {
   dismissMentionError(): void;
 }
 
+/** Shared launch availability; Stop intentionally has its own recovery policy. */
+export function agentLaunchBlock(
+  state: AgentControlState,
+  agent: AgentView,
+): string | null {
+  if (state.status !== "ready") return "Refresh status before starting.";
+  if (state.busy) return "Waiting for the current operation.";
+  if (!state.data?.runtimeAvailable)
+    return (
+      state.data?.runtimeMessage || "The bundled agent runtime is unavailable."
+    );
+  if (agent.status === "starting" || agent.status === "stopping")
+    return "Waiting for the process transition.";
+  return null;
+}
+
 /** Stop is recovery, not a launch: stale stopped/disabled evidence cannot veto it. */
 export function canStopAgent(state: AgentControlState, id: string): boolean {
   if (
diff --git a/tests/browser/profiles.spec.mjs b/tests/browser/profiles.spec.mjs
index 55fdd941a..aaa88ecbf 100644
--- a/tests/browser/profiles.spec.mjs
+++ b/tests/browser/profiles.spec.mjs
@@ -251,3 +251,98 @@ test("contextual panel callbacks retire with opening, channel, contribution and
   expect(await invoke()).toBe(false);
   await expect(panel).toHaveCount(0);
 });
+
+// Native button disabling/removal can move focus differently from jsdom. Exercise
+// actual keyboard focus in both engines with a gated synthetic host, not real agents.
+test("local agent actions retain keyboard focus through pending and success without stealing focus", async ({
+  page,
+}) => {
+  await page.goto("/tests/fixtures/profiles.html?agent-actions");
+  await page
+    .getByRole("button", { name: "View Mic profile", exact: true })
+    .click();
+  const panel = page.getByRole("region", { name: "Local agent actions" });
+  const start = panel.getByRole("button", { name: "Start", exact: true });
+  const stop = panel.getByRole("button", { name: "Stop", exact: true });
+  await start.focus();
+  await start.press("Enter");
+  try {
+    await page.waitForFunction(() => window.profilesFixture.launchPending());
+    await expect(start).toBeDisabled();
+    await expect(start).toBeFocused();
+  } finally {
+    await page.evaluate(() => window.profilesFixture.finishLaunch());
+  }
+  await expect(start).toHaveCount(0);
+  await expect(stop).toBeFocused();
+  await stop.press("Enter");
+  await expect(start).toBeEnabled();
+  await expect(stop).toBeDisabled();
+  await expect(stop).toBeFocused();
+  await stop.press("Enter");
+  await start.focus();
+  await start.press("Enter");
+  const copy = page.getByRole("button", { name: "Copy npub" });
+  try {
+    await page.waitForFunction(() => window.profilesFixture.launchPending());
+    await copy.focus();
+  } finally {
+    await page.evaluate(() => window.profilesFixture.finishLaunch());
+  }
+  await expect(start).toHaveCount(0);
+  await expect(copy).toBeFocused();
+  const restart = panel.getByRole("button", { name: "Restart", exact: true });
+  await restart.focus();
+  await restart.press("Enter");
+  try {
+    await page.waitForFunction(() => window.profilesFixture.launchPending());
+    await expect(restart).toBeDisabled();
+    await expect(restart).toBeFocused();
+    await restart.press("Enter");
+  } finally {
+    await page.evaluate(() => window.profilesFixture.finishLaunch());
+  }
+  await expect(restart).toBeEnabled();
+  await expect(restart).toBeFocused();
+  expect(await page.evaluate(() => window.profilesFixture.commands())).toEqual([
+    "start",
+    "stop",
+    "start",
+    "restart",
+  ]);
+});
+
+// Switching profile tabs must release the actions view, not its app-owned command.
+test("local agent command survives Info tab unmount without stealing tab focus", async ({
+  page,
+}) => {
+  await page.goto("/tests/fixtures/profiles.html?agent-actions");
+  await page
+    .getByRole("button", { name: "View Mic profile", exact: true })
+    .click();
+  const actions = page.getByRole("region", { name: "Local agent actions" });
+  await actions
+    .getByRole("button", { name: "Start", exact: true })
+    .press("Enter");
+  const channels = page.getByRole("tab", { name: "Channels", exact: true });
+  const info = page.getByRole("tab", { name: "Info", exact: true });
+  try {
+    await page.waitForFunction(() => window.profilesFixture.launchPending());
+    await channels.click();
+    await expect(actions).toHaveCount(0);
+  } finally {
+    await page.evaluate(() => window.profilesFixture.finishLaunch());
+  }
+  await expect(channels).toBeFocused();
+  await info.click();
+  await expect(
+    actions.getByRole("button", { name: "Start", exact: true }),
+  ).toHaveCount(0);
+  await expect(
+    actions.getByRole("button", { name: "Stop", exact: true }),
+  ).toBeEnabled();
+  await expect(info).toBeFocused();
+  expect(await page.evaluate(() => window.profilesFixture.commands())).toEqual([
+    "start",
+  ]);
+});
diff --git a/tests/fixtures/profiles.tsx b/tests/fixtures/profiles.tsx
index 494b99c56..10b8060f3 100644
--- a/tests/fixtures/profiles.tsx
+++ b/tests/fixtures/profiles.tsx
@@ -1,3 +1,4 @@
+import { controlFixture } from "../../src/features/agents/control-testing";
 // Real ChannelsPage, thread reader, shared directory, panel registry and plugin lifecycle.
 // Only the transport is synthetic. No dev broker, saved identity or live relay.
 import { StrictMode, useLayoutEffect, useState } from "react";
@@ -39,6 +40,7 @@ const viewer = keypair(),
   mic = keypair(),
   pinky = keypair(),
   missing = keypair();
+const actionsProbe = new URLSearchParams(location.search).has("agent-actions");
 const root = message(viewer, "one", "Hello @Mic", 10, [["p", mic.pubkey]]);
 const unknown = message(missing, "one", "Unknown author", 11);
 const reply = message(viewer, "one", "Thread @Pinky", 12, [
@@ -171,7 +173,22 @@ context.provide("relay", relay);
 const navigationHost = createNavigationController(createMemoryHistory());
 context.provide("navigation", navigationHost.navigation);
 context.effect(() => () => navigationHost.dispose());
-const agentControl = createAgentControl(null);
+const native = controlFixture();
+native.agent.pubkey = mic.pubkey;
+native.agent.status = "stopped";
+native.agent.enabled = false;
+let releaseLaunch: (() => void) | undefined;
+const commands: string[] = [];
+const action = native.host.action;
+native.host.action = async (id, command) => {
+  commands.push(command);
+  if (command === "start" || command === "restart")
+    await new Promise<void>((resolve) => {
+      releaseLaunch = resolve;
+    });
+  return action(id, command);
+};
+const agentControl = createAgentControl(actionsProbe ? native.host : null);
 context.provide("agentControl", agentControl);
 context.effect(() => () => agentControl.dispose());
 const contexts: PanelContext[] = [];
@@ -212,6 +229,12 @@ const providers = new TemplateProvidersService(context);
 Object.assign(window, {
   profilesFixture: {
     report,
+    commands: () => [...commands],
+    launchPending: () => !!releaseLaunch,
+    finishLaunch: () => {
+      releaseLaunch?.();
+      releaseLaunch = undefined;
+    },
     contexts,
     targets: {
       viewer: profileTarget(viewer.pubkey),