diff --git a/README.md b/README.md
index 1c85f08..d4f35d3 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@ The pictures below come from the [demo mode](#demo-mode), on Boite's fake core.
 
 ### Every session at a glance
 
-Point at the pill and the island opens as a deck of tabs. **Threads** lists every conversation running in Boite, however many there are, including those running on your other machines. Sub-agents fold under the conversation that started them. A click opens the thread in Boite.
+Point at the pill and the island opens as a deck of tabs. **Threads** lists every conversation running in Boite, however many there are, including those running on your other machines, each with its machine's name. Sub-agents fold under the conversation that started them. A click opens the thread in Boite.
 
 <p align="center">
   <img src="docs/media/sessions.png" width="720" alt="The deck open on its threads tab, listing the sessions at work, one of them unfolded on its sub-agents">
@@ -36,7 +36,7 @@ When an agent asks for a permission or has a question, the pill says so. Open it
 
 - **Threads**: the sessions at work and the requests waiting for you.
 - **Today**: the clock and the week, the next scheduled mission, your to-do list, a focus timer and the day's numbers.
-- **Chat**: your conversation with B.O.T.S.
+- **Chat**: your conversation with B.O.T.S, or with any agent of your Boite, on this machine or another one.
 - **Stats**: each subscription's quota windows and when they reset, the threads finished today with their files, time and tokens, and the memory your agents hold.
 - **Music**: the player, with the words.
 - **Apps**, **Clipboard**, **Wallpapers** and **System**: your computer, on Windows.
diff --git a/src/components/island/MachineChip.svelte b/src/components/island/MachineChip.svelte
new file mode 100644
index 0000000..348d7e0
--- /dev/null
+++ b/src/components/island/MachineChip.svelte
@@ -0,0 +1,31 @@
+<!--
+  The machine a thread or an agent of another machine of the group runs on,
+  as a small quiet chip: its name in the group's roster. This machine's own
+  get none, and nothing shows while the user has one machine.
+-->
+<script lang="ts">
+  import { fill, strings } from '../../lib/strings';
+
+  let { machine }: { machine: string } = $props();
+</script>
+
+<span class="machine" title={fill(strings.bots.onMachine, { machine })} data-testid="machine-chip">{machine}</span>
+
+<style>
+  .machine {
+    display: inline-block;
+    flex: none;
+    max-width: 9em;
+    padding: 0 6px;
+    border: 1px solid var(--island-line);
+    border-radius: 999px;
+    color: var(--island-muted);
+    font-size: 10.5px;
+    font-weight: 600;
+    line-height: 14px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    vertical-align: middle;
+    white-space: nowrap;
+  }
+</style>
diff --git a/src/components/island/assistant/AgentMenu.svelte b/src/components/island/assistant/AgentMenu.svelte
index 85faa5f..9aff6a8 100644
--- a/src/components/island/assistant/AgentMenu.svelte
+++ b/src/components/island/assistant/AgentMenu.svelte
@@ -1,7 +1,8 @@
 <!--
   Which of the user's Boite agents the assistant talks to: the one in use
   (its robot and name) as a quiet button, and a menu of the active agents
-  with their name and domain. A custom menu: arrows move, Enter picks,
+  of every machine of the group with their name and domain, another
+  machine's with its name in a chip. A custom menu: arrows move, Enter picks,
   Escape closes and gives the focus back. The island stays open while it is.
 -->
 <script lang="ts">
@@ -11,6 +12,7 @@
   import { useView } from '../../../lib/island/contract';
   import { fill, strings } from '../../../lib/strings';
   import RobotFace from '../../agents/RobotFace.svelte';
+  import MachineChip from '../MachineChip.svelte';
 
   let { assistant, open = $bindable(false) }: { assistant: Assistant; open?: boolean } = $props();
   const view = useView();
@@ -20,6 +22,7 @@
   let menu = $state<HTMLDivElement | null>(null);
 
   const agent = $derived(assistant.agent);
+  const current = $derived(assistant.placed?.key ?? null);
 
   $effect(() => {
     view.hold('assistant-agents', open);
@@ -51,8 +54,8 @@
     items[(at + (event.key === 'ArrowDown' ? 1 : -1) + items.length) % items.length]?.focus();
   }
 
-  function pick(id: string) {
-    assistant.pick(id);
+  function pick(key: string) {
+    assistant.pick(key);
     close();
   }
 </script>
@@ -71,20 +74,22 @@
     >
       <span class="avatar"><RobotFace robot={skinOf(agent)} state="still" /></span>
       <span class="name">{agent.name}</span>
+      {#if assistant.machine}<MachineChip machine={assistant.machine} />{/if}
       <ChevronDown size={13} />
     </button>
 
     {#if open}
       <div bind:this={menu} class="menu" role="menu" aria-label={copy.agents} tabindex="-1" onkeydown={keys} data-testid="assistant-agent-menu">
         <p class="label">{copy.agents}</p>
-        {#each assistant.agents as entry (entry.id)}
-          <button role="menuitemradio" aria-checked={entry.id === agent.id} class="item" onclick={() => pick(entry.id)}>
-            <span class="avatar"><RobotFace robot={skinOf(entry)} state="still" /></span>
+        {#each assistant.agents as entry (entry.key)}
+          <button role="menuitemradio" aria-checked={entry.key === current} class="item" onclick={() => pick(entry.key)} data-testid="assistant-agent-item">
+            <span class="avatar"><RobotFace robot={skinOf(entry.profile)} state="still" /></span>
             <span class="who">
-              <span class="item-name">{entry.name}</span>
-              {#if entry.domain}<span class="domain">{entry.domain}</span>{/if}
+              <span class="item-name">{entry.profile.name}</span>
+              {#if entry.profile.domain}<span class="domain">{entry.profile.domain}</span>{/if}
             </span>
-            {#if entry.id === agent.id}<Check size={13} />{/if}
+            {#if entry.machine}<MachineChip machine={entry.machine} />{/if}
+            {#if entry.key === current}<Check size={13} />{/if}
           </button>
         {/each}
       </div>
diff --git a/src/components/island/assistant/AssistantChat.svelte b/src/components/island/assistant/AssistantChat.svelte
index 862ee2f..3b7ce0f 100644
--- a/src/components/island/assistant/AssistantChat.svelte
+++ b/src/components/island/assistant/AssistantChat.svelte
@@ -123,7 +123,7 @@
           class="ghost icon reveal"
           aria-label={fill(copy.openAgent, { name })}
           title={fill(copy.openAgent, { name })}
-          onclick={() => agent && void showAgent(agent.id).catch(() => {})}
+          onclick={() => agent && void showAgent(agent.id, assistant.coreId).catch(() => {})}
           data-testid="assistant-reveal"
         >
           <SquareArrowOutUpRight size={13} />
diff --git a/src/components/island/sessions/SessionRow.svelte b/src/components/island/sessions/SessionRow.svelte
index 6dba5c6..a53d3ba 100644
--- a/src/components/island/sessions/SessionRow.svelte
+++ b/src/components/island/sessions/SessionRow.svelte
@@ -8,7 +8,8 @@
   here. An ended row offers to start the thread again, archive it, or show the
   changes in its folder (`NoticeActions.svelte`); archived, it can be undone
   for a few seconds (`archive-undo.ts`). A row can be followed in the pill
-  (`followed.ts`): a small eye before its time says so. The actions show on
+  (`followed.ts`): a small eye before its time says so. A thread of another
+  machine of the group names it in a chip after its project. The actions show on
   the row under the pointer or the focus, over the row's end and over its
   second line, so they take no room and the list never moves. The time
   reads calm (`session-time.ts`): seconds under a minute only.
@@ -25,12 +26,15 @@
   import { strings } from '../../../lib/strings';
   import RobotFace from '../../agents/RobotFace.svelte';
   import CompanionReply from '../../companion/CompanionReply.svelte';
+  import MachineChip from '../MachineChip.svelte';
   import NoticeActions from './NoticeActions.svelte';
   import SubAgentList from './SubAgentList.svelte';
 
   interface Props {
     row: SessionRow;
     project: string;
+    /** The machine of the group it runs on, when it is not this one. */
+    machine?: string | null;
     now: number;
     /** The sub-agents of its current run, in start order (`sub-agents.ts`). */
     agents: readonly SubAgent[];
@@ -47,7 +51,7 @@
     onarchive(): Promise<void>;
   }
 
-  let { row, project, now, agents, foldSpace, notice, notes, followed, onreveal, onfollow, onarchive }: Props = $props();
+  let { row, project, machine = null, now, agents, foldSpace, notice, notes, followed, onreveal, onfollow, onarchive }: Props = $props();
 
   const copy = strings.island.sessions;
   const foldable = $derived(agents.length > 0);
@@ -70,7 +74,7 @@
   <div class="head">
     <span class="avatar" aria-hidden="true"><RobotFace {robot} state={face} /></span>
     <button class="title" title={copy.reveal} onclick={() => onreveal(row.id)}>
-      <span class="name">{row.title}{#if project}<span class="project">&nbsp;· {project}</span>{/if}</span>
+      <span class="name">{row.title}{#if project}<span class="project">&nbsp;· {project}</span>{/if}{#if machine}&nbsp;<MachineChip {machine} />{/if}</span>
       <span class="sub" data-testid="session-line">
         <span class="state">{state}</span>{#if line}<span class="step">&nbsp;· {line}</span>{/if}
       </span>
diff --git a/src/components/island/sessions/SessionsList.svelte b/src/components/island/sessions/SessionsList.svelte
index 1b06aa4..c292176 100644
--- a/src/components/island/sessions/SessionsList.svelte
+++ b/src/components/island/sessions/SessionsList.svelte
@@ -5,9 +5,12 @@
   the lead robot naps beside "Nothing running": a few breaths, then still.
   An archived row leaves a line in its place for a few seconds, to undo it
   (`archive-undo.ts`); a row followed in the pill says so (`followed.ts`).
-  A row with sub-agents counts the ones at work and unfolds them all.
+  A row with sub-agents counts the ones at work and unfolds them all. A
+  thread of another machine of the group names it in a chip.
 -->
 <script lang="ts">
+  import { GroupClient } from '../../../lib/group/group-client';
+  import { unplacedName } from '../../../lib/group/routing';
   import { listed } from '../../../lib/island/archive-undo';
   import { useView } from '../../../lib/island/contract';
   import { posed } from '../../../lib/island/posed.svelte';
@@ -27,6 +30,7 @@
   const ended = $derived(new Set(sessions.ended));
   const notices = $derived(new Map(notes.notices.filter((notice) => ended.has(notice.threadId)).map((notice) => [notice.threadId, notice])));
   const copy = strings.island.sessions;
+  const group = $derived(view.core.client instanceof GroupClient ? view.core.client : null);
   const reveal = (threadId: string) => void view.reveal(threadId).catch(() => {});
   /** Some row has sub-agents: every row keeps the chevron's place, so that the times line up. */
   const foldSpace = $derived(rows.some((row) => (sessions.agents.get(row.id)?.length ?? 0) > 0));
@@ -51,9 +55,11 @@
           <ArchiveUndoLine line={undo} onundo={() => void sessions.undo.undo(row.id)} />
         {:else}
           {@const notice = notices.get(row.id) ?? null}
+          {@const machine = group?.machineOf(row.id) ?? null}
           <SessionRow
             {row}
-            project={(row.projectId && projects.get(row.projectId)) || ''}
+            project={unplacedName((row.projectId && projects.get(row.projectId)) || '', machine)}
+            {machine}
             now={sessions.now}
             agents={sessions.agents.get(row.id) ?? []}
             {foldSpace}
diff --git a/src/lib/companion/companion.svelte.ts b/src/lib/companion/companion.svelte.ts
index ba046d6..31bd71a 100644
--- a/src/lib/companion/companion.svelte.ts
+++ b/src/lib/companion/companion.svelte.ts
@@ -148,9 +148,10 @@ export class Companion {
   readonly assistant: Assistant = new Assistant({
     client: () => this.client,
     snapshot: () => this.crew.snapshot,
+    elsewhere: () => this.crew.elsewhere,
     reload: () => void this.crew.load(),
     remembered: () => this.prefs.assistantAgent,
-    remember: (agentId) => void (this.prefs = writeCompanionPrefs({ assistantAgent: agentId })),
+    remember: (key) => void (this.prefs = writeCompanionPrefs({ assistantAgent: key })),
     fallback: () => this.crew.members[0]?.id ?? null,
     outgoing: () => joinScreen(this.attached.held, this.shot),
     keep: async (files) => {
@@ -730,13 +731,16 @@ export class Companion {
     let assistantAgent: string | undefined;
     const initialize = async () => {
       let client: Client;
-      // The other machines of the group, as they come and go: their threads on the next read.
-      const changed = () => this.soon(0);
+      // The other machines of the group, as they come and go: their threads and agents on the next read.
+      const changed = () => {
+        this.soon(0);
+        this.crew.changed();
+      };
       if (fake) {
         const { FakeClient } = await import('../fake-client');
-        const { demoGroup } = await import('../fake-client/machines-demo');
+        const { demoGroup, DEMO_MACHINES } = await import('../fake-client/machines-demo');
         assistantAgent = (await import('../fake-client/assistant-demo')).ASSISTANT_DEMO_AGENT;
-        const local = new FakeClient({ hudDemo: true, sessionsDemo: true, assistantDemo: true });
+        const local = new FakeClient({ hudDemo: true, sessionsDemo: true, assistantDemo: true, coreName: DEMO_MACHINES.local });
         client = await demoGroup(local, new URLSearchParams(location.search).get('machines'), changed);
         this.notice = strings.bots.demo;
       } else {
diff --git a/src/lib/companion/crew.svelte.ts b/src/lib/companion/crew.svelte.ts
index b83297b..cb8c4c0 100644
--- a/src/lib/companion/crew.svelte.ts
+++ b/src/lib/companion/crew.svelte.ts
@@ -6,6 +6,10 @@
  * whose directives (`directives.ts`) are carried out once: the facts go to the
  * agent's own memory, the reminders to this computer, the rest to the page.
  *
+ * The other machines' agents are read too, after this machine's and without
+ * waiting on them (`group/agents.ts`): the island's assistant lists them. The
+ * companion's row, its roles and its memory stay this machine's.
+ *
  * The companion keeps its role in each of its agents' instructions
  * (`withRole`), with Boite's projects, and the first time it makes an agent of
  * its own, Bots, which takes over the facts the companion kept on this
@@ -13,6 +17,8 @@
  */
 import type { AgentConversationMessage, AgentProfile, AgentsSnapshot } from '@boite/contracts';
 import type { Client } from '@boite/ui/lib/client';
+import { GroupClient } from '../group/group-client';
+import { mergeElsewhere, type MachineAgents } from '../group/agents';
 import { fill, strings } from '../strings';
 import { COMPANION_DOMAIN, permissionModeOf, pickBrain, ROLE_START, roleBlock, settleModel, withoutRole, withRole } from './brain';
 import { CLASSIC_SKIN, companionAgent, FIRST_AGENT_NAME, lastMessageAt, liveMemories, membersOf, memoriesToForget, memoryToKeep, needsFirstAgent, profileWith, repliesAfter, sessionThreadOf } from './crew';
@@ -70,6 +76,8 @@ export async function releaseAgent(client: Client, profile: AgentProfile): Promi
 
 export class Crew {
   snapshot = $state.raw<AgentsSnapshot | null>(null);
+  /** The agents of the group's other connected machines, in roster order. */
+  elsewhere = $state.raw<MachineAgents[]>([]);
   /** Why the companion has no agent of its own yet: none could run, or making it failed. */
   problem = $state<string | null>(null);
 
@@ -117,6 +125,8 @@ export class Crew {
       return;
     }
     this.loading = true;
+    // Asked at the same time and never waited for: a slow member does not hold this machine's list.
+    if (client instanceof GroupClient) void this.readElsewhere(client);
     try {
       const snapshot = await client.call('agents.snapshot', {});
       if (this.disposed) return;
@@ -137,6 +147,15 @@ export class Crew {
     if (!this.disposed) this.host.loaded();
   }
 
+  /** The other machines' agents; a member that does not answer in time keeps its last list while connected. */
+  private async readElsewhere(client: GroupClient): Promise<void> {
+    const answers = await client.elsewhere('agents.snapshot', {});
+    if (this.disposed) return;
+    const read = answers.map(({ core, result }) => ({ coreId: core.coreId, machine: core.name, snapshot: result }));
+    this.elsewhere = mergeElsewhere(this.elsewhere, read, client.machines().filter((machine) => machine.state === 'ready'));
+    this.host.loaded();
+  }
+
   /**
    * The first agent tried again now, while none stands: the user asked, or an
    * account or a provider changed. At startup the core may still be checking
diff --git a/src/lib/companion/shell.ts b/src/lib/companion/shell.ts
index 3d8c88a..3313059 100644
--- a/src/lib/companion/shell.ts
+++ b/src/lib/companion/shell.ts
@@ -126,9 +126,9 @@ export async function showMain(threadId: string | null): Promise<void> {
   await reveal({ kind: 'thread', threadId });
 }
 
-/** Shows an agent's conversation in Boite's Agents page (`ui.reveal`). */
-export async function showAgent(agentId: string): Promise<void> {
-  await reveal({ kind: 'agent', agentId });
+/** Shows an agent's conversation in Boite's Agents page (`ui.reveal`); `coreId` names its machine when it is another of the group. */
+export async function showAgent(agentId: string, coreId: string | null = null): Promise<void> {
+  await reveal(coreId === null ? { kind: 'agent', agentId } : { kind: 'agent', agentId, coreId });
 }
 
 /** Opens Boite's app updates, where a newer Boite installs (`ui.reveal`). */
diff --git a/src/lib/fake-client.ts b/src/lib/fake-client.ts
index e490abc..c483fa1 100644
--- a/src/lib/fake-client.ts
+++ b/src/lib/fake-client.ts
@@ -34,7 +34,7 @@ import { seedHudDemo } from './fake-client/hud-demo';
 import { seedAssistantDemo } from './fake-client/assistant-demo';
 import { seedSessionsDemo } from './fake-client/sessions-demo';
 import { seedAllowDemo } from './fake-client/allow-demo';
-import { seedServerDemo } from './fake-client/server-demo';
+import { seedMachineDemo } from './fake-client/server-demo';
 import { groupMethods } from '@boite/ui/lib/fake-client/group';
 import { pairingMethods } from '@boite/ui/lib/fake-client/pairing';
 import { projectMethods } from '@boite/ui/lib/fake-client/projects';
@@ -78,8 +78,8 @@ export type BotsFakeOptions = FakeClientOptions & {
   hudDemo?: boolean;
   sessionsDemo?: boolean;
   assistantDemo?: boolean;
-  /** The other machine of the group's demo (`fake-client/server-demo.ts`); `ask` adds its request. */
-  serverDemo?: 'on' | 'ask';
+  /** Another machine of the group's demo (`fake-client/server-demo.ts`): the server, `ask` adding its request, or the laptop. */
+  serverDemo?: 'on' | 'ask' | 'laptop';
 };
 
 /**
@@ -119,7 +119,7 @@ export class FakeClient implements ObservableClient {
     if (options.assistantDemo) seedAssistantDemo(ctx, this.#methods);
     if (options.sessionsDemo) seedSessionsDemo(ctx);
     if (options.sessionsDemo && typeof location !== 'undefined') seedAllowDemo(ctx, this.#methods, new URLSearchParams(location.search));
-    if (options.serverDemo) seedServerDemo(ctx, options.serverDemo === 'ask');
+    if (options.serverDemo) seedMachineDemo(ctx, options.serverDemo === 'laptop' ? 'laptop' : 'server', options.serverDemo === 'ask');
     if (options.uninstalled) {
       ctx.providers = ctx.providers.filter(provider => provider.id !== 'echo').map(provider => ({
         ...provider, available: false, executable: null,
diff --git a/src/lib/fake-client/assistant-demo.ts b/src/lib/fake-client/assistant-demo.ts
index d2e5af4..994cc80 100644
--- a/src/lib/fake-client/assistant-demo.ts
+++ b/src/lib/fake-client/assistant-demo.ts
@@ -59,7 +59,7 @@ function idle(model: Thread, over: Partial<Thread>): Thread {
   return { ...structuredClone(model), status: 'idle', progress: null, runningSince: null, requestSince: null, doneAt: null, archived: false, unread: false, ...over } as Thread;
 }
 
-function profile(id: string, name: string, domain: string, model: string | null, createdAt: number): AgentProfile {
+export function profile(id: string, name: string, domain: string, model: string | null, createdAt: number): AgentProfile {
   return {
     id, revision: 1, createdAt, updatedAt: createdAt, name, domain,
     instructions: `You are ${name}. Answer briefly and plainly.`,
@@ -75,7 +75,7 @@ function profile(id: string, name: string, domain: string, model: string | null,
  * The agents' rows, written in place: the fake only takes new ones through
  * calls that give them fresh ids and start a run for every message sent.
  */
-function rowsOf(ctx: FakeContext): Map<string, AgentRecord> {
+export function rowsOf(ctx: FakeContext): Map<string, AgentRecord> {
   return (ctx.agents as unknown as { rows: Map<string, AgentRecord> }).rows;
 }
 
diff --git a/src/lib/fake-client/machines-demo.ts b/src/lib/fake-client/machines-demo.ts
index 56287b9..5d151ad 100644
--- a/src/lib/fake-client/machines-demo.ts
+++ b/src/lib/fake-client/machines-demo.ts
@@ -1,30 +1,58 @@
 /**
- * The group's demo, with `?fake=1&machines=1|ask`: a second fake core,
- * « Serveur » (`server-demo.ts`), joins this one's group, so Home, the pill
- * and the HUD show a thread of another machine (« Corriger le gameplay ·
- * Petites-Rives · Serveur »). With `ask`, that thread asks to push a moment
- * after the island opens: the request shows here and is answered there.
+ * The group's demo, with `?fake=1&machines=1|ask|away`: two more fake cores,
+ * « boite » (the server) and « laptop » (`server-demo.ts`), join this one's
+ * group, « PC ». Home, the pill and the HUD show a thread of each (« Corriger
+ * le gameplay » on boite, « Write the install guide » on laptop), and the
+ * island's Chat lists their agents, Forge and Scout, beside this machine's.
+ * With `ask`, boite's thread asks to push a moment after the island opens:
+ * the request shows here and is answered there. With `away`, laptop never
+ * answers: it shows as offline in the deck's machines tile, and nothing of it
+ * waits on it.
  *
- * Bots reaches the server the way it reaches a real member (`group.ticket`,
+ * Bots reaches each member the way it reaches a real one (`group.ticket`,
  * then a client of its own), except that the socket is the fake itself.
  */
 import { GroupClient } from '../group/group-client';
 import { memoryKeys } from '../group/member-keys';
 import { FakeClient } from '../fake-client';
 
-const SERVER_CORE = 'fake-core-serveur';
+export const DEMO_MACHINES = { local: 'PC', server: 'boite', laptop: 'laptop' } as const;
+export const SERVER_CORE = 'fake-core-boite';
+export const LAPTOP_CORE = 'fake-core-laptop';
+const SERVER_URL = 'http://100.64.0.2:8777';
+const LAPTOP_URL = 'http://100.64.0.3:8777';
+
+/** Whether the page asks for the group's demo. */
+export function wantsMachines(machines: string | null): boolean {
+  return machines === '1' || machines === 'ask' || machines === 'away';
+}
 
 /**
- * This fake core under the group client; with `machines`, grouped with the
- * server first, the way two machines are: one makes the group and invites,
- * the other joins.
+ * This fake core under the group client; with `machines`, grouped with
+ * boite and laptop first, the way machines are: one makes the group and
+ * invites, the others join.
  */
-export async function demoGroup(local: FakeClient, machines: string | null, changed: () => void): Promise<GroupClient> {
-  if (machines !== '1' && machines !== 'ask') return new GroupClient(local, { keys: memoryKeys(), changed });
-  const server = new FakeClient({ coreId: SERVER_CORE, coreName: 'Serveur', publicUrl: 'http://100.64.0.2:8777', hudDemo: false, serverDemo: machines === 'ask' ? 'ask' : 'on' });
-  await Promise.all([local.connect(), server.connect()]);
+export async function demoGroup(local: FakeClient, machines: string | null, changed: () => void, tests: { delayMs?: number; made?: FakeClient[] } = {}): Promise<GroupClient> {
+  if (!wantsMachines(machines)) return new GroupClient(local, { keys: memoryKeys(), changed });
+  const delay = tests.delayMs === undefined ? {} : { delayMs: tests.delayMs };
+  const server = new FakeClient({ ...delay, coreId: SERVER_CORE, coreName: DEMO_MACHINES.server, publicUrl: SERVER_URL, hudDemo: false, serverDemo: machines === 'ask' ? 'ask' : 'on' });
+  const laptop = new FakeClient({ ...delay, coreId: LAPTOP_CORE, coreName: DEMO_MACHINES.laptop, publicUrl: LAPTOP_URL, hudDemo: false, serverDemo: 'laptop' });
+  // A test closes them, the laptop out of reach included.
+  tests.made?.push(server, laptop);
+  await Promise.all([local.connect(), server.connect(), laptop.connect()]);
   await local.call('group.create', { name: 'Maison' });
-  const { invite } = await local.call('group.invite', {});
-  await server.call('group.join', { invite });
-  return new GroupClient(local, { keys: memoryKeys(), changed, open: () => server, reach: async (addresses) => addresses[0] ?? null });
+  for (const member of [server, laptop]) {
+    const { invite } = await local.call('group.invite', {});
+    await member.call('group.join', { invite });
+  }
+  const byUrl = new Map<string, FakeClient>([
+    [SERVER_URL, server],
+    [LAPTOP_URL, laptop]
+  ]);
+  return new GroupClient(local, {
+    keys: memoryKeys(),
+    changed,
+    open: (link) => byUrl.get(link.url) ?? server,
+    reach: async (addresses) => (machines === 'away' && addresses.includes(LAPTOP_URL) ? null : (addresses[0] ?? null))
+  });
 }
diff --git a/src/lib/fake-client/server-demo.ts b/src/lib/fake-client/server-demo.ts
index 5f4a205..f1f8fde 100644
--- a/src/lib/fake-client/server-demo.ts
+++ b/src/lib/fake-client/server-demo.ts
@@ -1,74 +1,119 @@
 /**
- * The fake core « Serveur » of the group's demo (`machines-demo.ts`): in place
- * of the fake's seed, one project, Petites-Rives, with a thread at work on its
- * gameplay; with `ask`, that thread asks to push a moment after it starts.
+ * The fake cores of the other machines in the group's demo
+ * (`machines-demo.ts`): in place of the fake's seed, each has one project, a
+ * thread at work in it and an agent of its own. « boite », the server, fixes
+ * a game's gameplay (with `ask`, that thread asks to push a moment after it
+ * starts) and has Forge; « laptop » writes a site's docs and has Scout.
  */
 import type { Message, MessagePart, PermissionRequest, Thread } from '@boite/contracts';
 import type { FakeContext } from '@boite/ui/lib/fake-client/context';
+import { profile, rowsOf } from './assistant-demo';
 
 export const SERVER_THREAD = 't-srv-gameplay';
 export const SERVER_PROJECT = 'p-srv-rives';
+export const SERVER_AGENT = 'agent-forge';
+export const LAPTOP_THREAD = 't-lap-docs';
+export const LAPTOP_AGENT = 'agent-scout';
 const ASK_AFTER_MS = 2_000;
 
+/** What one machine of the demo runs: one project, one thread at work with its steps, one agent. */
+interface MachineSeed {
+  thread: string;
+  project: { id: string; name: string; path: string };
+  title: string;
+  branch: string;
+  steps: [name: string, input: unknown, ago: number][];
+  agent: { id: string; name: string; domain: string };
+  /** How long the thread has been at work. */
+  minutes: number;
+}
+
+const SEEDS = {
+  server: {
+    thread: SERVER_THREAD,
+    project: { id: SERVER_PROJECT, name: 'Petites-Rives', path: '/srv/petites-rives' },
+    title: 'Corriger le gameplay',
+    branch: 'fix/gameplay',
+    steps: [
+      ['Read', { file_path: '/srv/petites-rives/Assets/Scripts/Player/PlayerController.cs' }, 80_000],
+      ['Grep', { pattern: 'jumpBuffer' }, 50_000],
+      ['Bash', { command: 'dotnet test Gameplay.Tests' }, 15_000]
+    ],
+    agent: { id: SERVER_AGENT, name: 'Forge', domain: 'Builds and deploys' },
+    minutes: 5
+  },
+  laptop: {
+    thread: LAPTOP_THREAD,
+    project: { id: 'p-lap-site', name: 'mtsu.dev', path: '/home/demo/mtsu.dev' },
+    title: 'Write the install guide',
+    branch: 'docs/install',
+    steps: [
+      ['Read', { file_path: '/home/demo/mtsu.dev/docs/index.md' }, 60_000],
+      ['Edit', { file_path: '/home/demo/mtsu.dev/docs/install.md' }, 20_000]
+    ],
+    agent: { id: LAPTOP_AGENT, name: 'Scout', domain: 'Research on the go' },
+    minutes: 2
+  }
+} satisfies Record<string, MachineSeed>;
+
 type ToolPart = Extract<MessagePart, { type: 'tool' }>;
 
 function tool(toolId: string, name: string, input: unknown, status: ToolPart['status'], at: number): ToolPart {
   return { type: 'tool', toolId, name, input, output: null, status, startedAt: at, finishedAt: status === 'running' ? null : at + 800 };
 }
 
-/** The server's own seed in place of the fake's: one project, one thread at work, and in `ask` a request on its way. */
-export function seedServerDemo(ctx: FakeContext, ask: boolean): void {
+/** A machine's own seed in place of the fake's: `server` or `laptop`; with `ask`, the server's request on its way. */
+export function seedMachineDemo(ctx: FakeContext, machine: keyof typeof SEEDS, ask = false): void {
+  const spec: MachineSeed = SEEDS[machine];
   const model = [...ctx.threads.values()].find((thread) => !thread.parentThreadId);
   const project = ctx.projects[0];
   if (!model || !project) return;
   const now = Date.now();
-  const started = now - 5 * 60_000 - 12_000;
-  const turnId = 'turn-srv-gameplay';
-  const cwd = '/srv/petites-rives';
+  const started = now - spec.minutes * 60_000 - 12_000;
+  const turnId = `turn-${spec.thread}`;
   ctx.threads.clear();
   ctx.pendingPermissions.clear();
   ctx.pendingQuestions.clear();
   ctx.importable = [];
   ctx.scheduler = { ...ctx.scheduler, running: [], queued: [] };
-  ctx.projects = [{ ...structuredClone(project), id: SERVER_PROJECT, name: 'Petites-Rives', path: cwd }];
+  ctx.projects = [{ ...structuredClone(project), ...spec.project }];
   const steps: Message = {
-    id: 'm-srv-1',
-    threadId: SERVER_THREAD,
+    id: `m-${spec.thread}`,
+    threadId: spec.thread,
     turnId,
     role: 'assistant',
     state: 'streaming',
     createdAt: started + 1_000,
-    parts: [
-      tool('sv-1', 'Read', { file_path: `${cwd}/Assets/Scripts/Player/PlayerController.cs` }, 'done', now - 80_000),
-      tool('sv-2', 'Grep', { pattern: 'jumpBuffer' }, 'done', now - 50_000),
-      tool('sv-3', 'Bash', { command: 'dotnet test Gameplay.Tests' }, 'running', now - 15_000)
-    ]
+    parts: spec.steps.map(([name, input, ago], index) => tool(`${spec.thread}-${index}`, name, input, index === spec.steps.length - 1 ? 'running' : 'done', now - ago))
   };
+  const last = spec.steps.at(-1)!;
   const thread: Thread = {
     ...structuredClone(model),
-    id: SERVER_THREAD,
-    projectId: SERVER_PROJECT,
-    title: 'Corriger le gameplay',
+    id: spec.thread,
+    projectId: spec.project.id,
+    title: spec.title,
     titleSource: 'user',
-    cwd,
-    branch: 'fix/gameplay',
+    cwd: spec.project.path,
+    branch: spec.branch,
     status: 'running',
     archived: false,
     pinned: false,
     unread: false,
-    sessionId: 'sess-srv-gameplay',
+    sessionId: `sess-${spec.thread}`,
     load: null,
     context: null,
     createdAt: started - 1_000,
     updatedAt: started,
-    turns: [{ id: turnId, threadId: SERVER_THREAD, status: 'running', queuedAt: started - 500, startedAt: started, finishedAt: null, usage: null, error: null }],
+    turns: [{ id: turnId, threadId: spec.thread, status: 'running', queuedAt: started - 500, startedAt: started, finishedAt: null, usage: null, error: null }],
     messages: [steps],
     background: [],
-    progress: { turnId, phase: 'tool', detail: 'Bash', at: now - 15_000, providerAt: now - 15_000 }
+    progress: { turnId, phase: 'tool', detail: last[0], at: now - last[2], providerAt: now - last[2] }
   };
   delete thread.parentThreadId;
   ctx.threads.set(thread.id, thread);
   ctx.scheduler.running.push({ turnId, threadId: thread.id, startedAt: started });
+  const agent = profile(spec.agent.id, spec.agent.name, spec.agent.domain, null, now - 3 * 24 * 3_600_000);
+  rowsOf(ctx).set(`profile:${agent.id}`, agent);
   if (ask) setTimeout(() => askToPush(ctx, thread), ASK_AFTER_MS);
 }
 
@@ -76,7 +121,7 @@ function askToPush(ctx: FakeContext, thread: Thread): void {
   const request: PermissionRequest = {
     id: 'perm-srv-push',
     threadId: thread.id,
-    turnId: thread.turns.at(-1)?.id ?? 'turn-srv-gameplay',
+    turnId: thread.turns.at(-1)?.id ?? `turn-${thread.id}`,
     toolName: 'Bash',
     input: { command: 'git push origin fix/gameplay', description: 'Push the gameplay fix' },
     description: 'git push origin fix/gameplay',
diff --git a/src/lib/group/agents.ts b/src/lib/group/agents.ts
new file mode 100644
index 0000000..5e0295f
--- /dev/null
+++ b/src/lib/group/agents.ts
@@ -0,0 +1,68 @@
+/*
+ * The agents of every machine of the group, as the island's assistant lists
+ * them: this machine's first, then each member's in roster order, each tagged
+ * with its machine. Pure: the crew reads the snapshots (`crew.svelte.ts`),
+ * the group client routes the calls (`GroupClient.at`).
+ *
+ * An agent is known by its machine and its id together: two machines may
+ * hold the same id. This machine's agents keep their bare id as their key, so
+ * the agent kept in Bots's settings before machines were named still opens.
+ */
+import type { AgentProfile, AgentsSnapshot } from '@boite/contracts';
+
+/** One member's agents, as its core answered `agents.snapshot`. */
+export interface MachineAgents {
+  coreId: string;
+  /** The member's name in the group's roster. */
+  machine: string;
+  snapshot: AgentsSnapshot;
+}
+
+/** An agent of some machine of the group. */
+export interface PlacedAgent {
+  /** Unique across machines: the id for this machine's, `coreId/id` for another's. */
+  key: string;
+  /** Null for this machine's. */
+  coreId: string | null;
+  /** The roster's name for its machine; null for this machine's. */
+  machine: string | null;
+  profile: AgentProfile;
+}
+
+export function agentKey(coreId: string | null, agentId: string): string {
+  return coreId === null ? agentId : `${coreId}/${agentId}`;
+}
+
+const active = (snapshot: AgentsSnapshot | null) => snapshot?.profiles.filter((profile) => profile.status === 'active') ?? [];
+
+/** The active agents of every machine: this one's first, then each member's. */
+export function placedAgents(local: AgentsSnapshot | null, elsewhere: readonly MachineAgents[]): PlacedAgent[] {
+  return [
+    ...active(local).map((profile) => ({ key: profile.id, coreId: null, machine: null, profile })),
+    ...elsewhere.flatMap(({ coreId, machine, snapshot }) => active(snapshot).map((profile) => ({ key: agentKey(coreId, profile.id), coreId, machine, profile })))
+  ];
+}
+
+/** The snapshot an agent's conversation, work and replies are read in: its own machine's. */
+export function snapshotAt(coreId: string | null, local: AgentsSnapshot | null, elsewhere: readonly MachineAgents[]): AgentsSnapshot | null {
+  return coreId === null ? local : (elsewhere.find((entry) => entry.coreId === coreId)?.snapshot ?? null);
+}
+
+/**
+ * The members' agents after a read: each that answered gives its new
+ * snapshot; one still connected but slow keeps its last, so a late answer
+ * does not empty the list; one out of reach gives none.
+ */
+export function mergeElsewhere(previous: readonly MachineAgents[], answers: readonly MachineAgents[], connected: readonly { coreId: string }[]): MachineAgents[] {
+  const answered = new Map(answers.map((entry) => [entry.coreId, entry]));
+  return connected.flatMap(({ coreId }) => answered.get(coreId) ?? previous.find((entry) => entry.coreId === coreId) ?? []);
+}
+
+/** The first of the wanted keys still listed, else the first agent. */
+export function pickPlaced(agents: readonly PlacedAgent[], ...wanted: (string | null | undefined)[]): PlacedAgent | null {
+  for (const key of wanted) {
+    const found = key ? agents.find((agent) => agent.key === key) : undefined;
+    if (found) return found;
+  }
+  return agents[0] ?? null;
+}
diff --git a/src/lib/group/group-client.ts b/src/lib/group/group-client.ts
index 47385d2..b53d8da 100644
--- a/src/lib/group/group-client.ts
+++ b/src/lib/group/group-client.ts
@@ -16,17 +16,20 @@
  *   member slow to answer gives its last list, one that is off gives none.
  * - A call that names a thread goes to that thread's machine, an answer to a
  *   permission to the machine that asked (`routing.ts`); the rest stays here.
- * - Events about threads are heard from every member; the rest from here only.
+ * - An agent's calls go to its own machine through `at(coreId)`: agents are
+ *   keyed by machine and id, as the same id may stand on two machines.
+ * - Events about threads and agents are heard from every member; the rest
+ *   from here only.
  *
  * Nothing waits on a member: this machine's calls and events never pass
  * through one, and no group, or a core older than groups, is the old Bots.
  * A timer runs only while a member is out of reach, once a minute.
  */
 import { RPC_PATH, RpcErrorCode, type CoreInfo, type Group, type GroupCore, type PermissionRequest, type Principal, type QuestionRequest, type RpcEventName, type RpcMethodName, type RpcParams, type RpcResult, type ThreadSummary } from '@boite/contracts';
-import { RpcFailure, WsClient, type CallOptions, type ClientState, type EventHandler, type ObservableClient, type Session } from '@boite/ui/lib/client';
+import { RpcFailure, WsClient, type CallOptions, type Client, type ClientState, type EventHandler, type ObservableClient, type Session } from '@boite/ui/lib/client';
 import { fill, strings } from '../strings';
 import type { MemberKeys } from './member-keys';
-import { isMerged, memberBackoff, membersOf, requestOfCall, THREAD_EVENTS, threadOfCall, threadOfEvent, type MergedMethod } from './routing';
+import { heardEverywhere, isMerged, memberBackoff, membersOf, requestOfCall, threadOfCall, threadOfEvent, type MergedMethod } from './routing';
 
 /** Between two tickets for one member, and between two tries of one that is out of reach (Boite's group links wait as long). */
 export const RETRY_MS = 60_000;
@@ -219,7 +222,7 @@ export class GroupClient implements ObservableClient {
       set = new Set();
       this.#handlers.set(event, set);
       this.#off.push(this.local.on(event, (payload) => this.#dispatch(event, payload, null)));
-      if (THREAD_EVENTS.has(event)) for (const member of this.#members.values()) this.#hear(member, event);
+      if (heardEverywhere(event)) for (const member of this.#members.values()) this.#hear(member, event);
     }
     const erased = handler as (payload: unknown) => void;
     set.add(erased);
@@ -230,6 +233,44 @@ export class GroupClient implements ObservableClient {
     if (this.#members.size > 0 && isMerged(method, params)) return this.#merged(method, params, options) as Promise<RpcResult<M>>;
     const coreId = this.#placeOf(method, params);
     if (coreId === null) return this.local.call(method, params, options);
+    return this.#callOn(coreId, method, params, options);
+  }
+
+  /**
+   * A client bound to one machine: this one for null or this core's own id, else
+   * that member, refused while it is out of reach. What an agent's calls go
+   * through, since an agent id does not say where it lives. Its events are the
+   * group's: the agents and threads of every member are heard here already.
+   */
+  at(coreId: string | null): Client {
+    if (coreId === null || coreId === this.#group?.self) return this.local;
+    const client = () => this.#members.get(coreId)?.client ?? null;
+    return {
+      connect: () => this.connect(),
+      call: (method, params, options) => this.#callOn(coreId, method, params, options),
+      on: (event, handler) => this.on(event, handler),
+      // The member's connection is the group client's to close.
+      close: () => undefined,
+      get state(): ClientState {
+        return client()?.state ?? 'closed';
+      },
+      get principal(): Principal | null {
+        return client()?.principal ?? null;
+      }
+    };
+  }
+
+  /** This machine's id in the group, null outside one. */
+  selfId(): string | null {
+    return this.#group?.self ?? null;
+  }
+
+  /** The name the roster gives a member; null for one not in it. */
+  nameOf(coreId: string): string | null {
+    return this.#members.get(coreId)?.core.name ?? null;
+  }
+
+  #callOn<M extends RpcMethodName>(coreId: string, method: M, params: RpcParams<M>, options?: CallOptions): Promise<RpcResult<M>> {
     const member = this.#members.get(coreId);
     if (!member?.client || member.client.state !== 'ready') {
       const machine = member?.core.name ?? coreId;
@@ -462,7 +503,7 @@ export class GroupClient implements ObservableClient {
         }
       })
     );
-    for (const event of this.#handlers.keys()) if (THREAD_EVENTS.has(event)) this.#hear(member, event);
+    for (const event of this.#handlers.keys()) if (heardEverywhere(event)) this.#hear(member, event);
     void client.connect().catch(() => undefined);
   }
 
diff --git a/src/lib/group/machines.test.ts b/src/lib/group/machines.test.ts
new file mode 100644
index 0000000..986c679
--- /dev/null
+++ b/src/lib/group/machines.test.ts
@@ -0,0 +1,207 @@
+import { afterEach, expect, test, vi } from 'vitest';
+import type { AgentProfile, AgentsSnapshot, PermissionRequest, ThreadSummary } from '@boite/contracts';
+import type { Client } from '@boite/ui/lib/client';
+import { Crew } from '../companion/crew.svelte';
+import { writeCompanionPrefs, readCompanionPrefs } from '../companion/prefs';
+import { FakeClient } from '../fake-client';
+import { ASSISTANT_DEMO_AGENT } from '../fake-client/assistant-demo';
+import { DEMO_MACHINES, demoGroup, LAPTOP_CORE, SERVER_CORE } from '../fake-client/machines-demo';
+import { LAPTOP_AGENT, LAPTOP_THREAD, SERVER_AGENT, SERVER_THREAD } from '../fake-client/server-demo';
+import { Assistant, type AssistantHost } from '../island/assistant.svelte';
+import { machineLoads } from '../island/deck-data';
+import { fill, strings } from '../strings';
+import { agentKey, mergeElsewhere, pickPlaced, placedAgents, snapshotAt, type MachineAgents } from './agents';
+import { GroupClient } from './group-client';
+import { AGENT_EVENTS, heardEverywhere, unplacedName } from './routing';
+
+const made: FakeClient[] = [];
+const groups: GroupClient[] = [];
+afterEach(() => {
+  groups.splice(0).forEach((group) => group.close());
+  made.splice(0).forEach((client) => client.close());
+  localStorage.clear();
+});
+
+/** The demo's group of three: « PC » here, « boite » and « laptop » (`away`: laptop never answers). */
+async function threeMachines(mode: '1' | 'ask' | 'away' = '1') {
+  const local = new FakeClient({ delayMs: 0, assistantDemo: true, hudDemo: false, coreName: DEMO_MACHINES.local });
+  made.push(local);
+  const group = await demoGroup(local, mode, () => {}, { delayMs: 0, made });
+  groups.push(group);
+  await group.connect();
+  const reachable = mode === 'away' ? 1 : 2;
+  await vi.waitFor(() => expect(group.machines().filter((machine) => machine.state === 'ready')).toHaveLength(reachable));
+  const localCall = vi.spyOn(local, 'call');
+  return { local, group, localCall };
+}
+
+function crewOf(group: GroupClient): Crew {
+  writeCompanionPrefs({ agents: [ASSISTANT_DEMO_AGENT], crewMade: true });
+  // No projects yet: the companion's roles and first agent stay out of these tests.
+  return new Crew({ client: () => group, prefs: readCompanionPrefs, projects: () => null, waiting: () => false, answered: () => {}, loaded: () => {} });
+}
+
+const ids = (threads: ThreadSummary[]) => threads.map((thread) => thread.id);
+
+test('the agents of every machine are listed, each with its machine, this one’s first', async () => {
+  const { group } = await threeMachines();
+  const crew = crewOf(group);
+  await crew.load();
+  await vi.waitFor(() => expect(crew.elsewhere).toHaveLength(2));
+  const listed = placedAgents(crew.snapshot, crew.elsewhere).map((agent) => [agent.profile.name, agent.machine, agent.key]);
+  expect(listed).toEqual([
+    ['Atlas', null, ASSISTANT_DEMO_AGENT],
+    ['Ledger', null, 'agent-ledger'],
+    ['Forge', DEMO_MACHINES.server, agentKey(SERVER_CORE, SERVER_AGENT)],
+    ['Scout', DEMO_MACHINES.laptop, agentKey(LAPTOP_CORE, LAPTOP_AGENT)]
+  ]);
+  // The companion's own row stays this machine's.
+  expect(crew.members.map((agent) => agent.id)).toEqual([ASSISTANT_DEMO_AGENT]);
+  crew.dispose();
+});
+
+test('the assistant talks to an agent of another machine on that machine', async () => {
+  const { group, localCall } = await threeMachines();
+  const crew = crewOf(group);
+  await crew.load();
+  await vi.waitFor(() => expect(crew.elsewhere).toHaveLength(2));
+  let kept: string | null = null;
+  const assistant = new Assistant({
+    client: () => group,
+    snapshot: () => crew.snapshot,
+    elsewhere: () => crew.elsewhere,
+    reload: () => void crew.load(),
+    remembered: () => kept,
+    remember: (key) => (kept = key),
+    fallback: () => null,
+    outgoing: () => [],
+    keep: async () => [],
+    sent: () => {},
+    giveBack: () => {}
+  });
+  const forge = agentKey(SERVER_CORE, SERVER_AGENT);
+  assistant.pick(forge);
+  expect(kept).toBe(forge);
+  expect(assistant.agent?.name).toBe('Forge');
+  expect(assistant.machine).toBe(DEMO_MACHINES.server);
+  expect(assistant.machines).toBe(true);
+  assistant.draft = 'Deploy the gameplay fix';
+  await assistant.send();
+  expect(assistant.problem).toBe('');
+  // The message is boite's: in its agents' snapshot, never in this machine's.
+  const there = await group.at(SERVER_CORE).call('agents.snapshot', {});
+  expect(there.messages.some((message) => message.text.startsWith('Deploy the gameplay fix'))).toBe(true);
+  expect(localCall.mock.calls.some(([method]) => method === 'agents.message.send')).toBe(false);
+  expect(localCall.mock.calls.some(([method]) => method === 'providers.probe')).toBe(false);
+  crew.dispose();
+});
+
+test('the same agent id on two machines does not collide: each call goes to the one picked', async () => {
+  const profile = (id: string, name: string) => ({ id, name, status: 'active', revision: 1, selection: { providerId: 'p', accountId: 'a', model: null, effort: 'high' } }) as unknown as AgentProfile;
+  const snapshot = (name: string) => ({ profiles: [profile('a1', name)], sessions: [], messages: [], work: [], deliveries: [], more: { message: false } }) as unknown as AgentsSnapshot;
+  const local = snapshot('Here');
+  const elsewhere: MachineAgents[] = [{ coreId: 'core-b', machine: 'boite', snapshot: snapshot('There') }];
+  const placed = placedAgents(local, elsewhere);
+  expect(placed.map((agent) => agent.key)).toEqual(['a1', 'core-b/a1']);
+  expect(pickPlaced(placed, 'core-b/a1')?.profile.name).toBe('There');
+  expect(snapshotAt('core-b', local, elsewhere)).toBe(elsewhere[0]!.snapshot);
+  expect(snapshotAt(null, local, elsewhere)).toBe(local);
+
+  const sent: [string | null, string, unknown][] = [];
+  const answer = (method: string) => (method === 'agents.message.send' ? { id: `m${sent.length}` } : method === 'providers.probe' ? { models: [] } : {});
+  const bound = (coreId: string | null): Client => ({ call: async (method: string, params: unknown) => (sent.push([coreId, method, params]), answer(method)), on: () => () => {} }) as unknown as Client;
+  const group = Object.assign(Object.create(GroupClient.prototype) as GroupClient, { ...bound(null), at: (coreId: string | null) => bound(coreId) });
+  const host: AssistantHost = { client: () => group, snapshot: () => local, elsewhere: () => elsewhere, reload: () => {}, remembered: () => null, remember: () => {}, fallback: () => null, outgoing: () => [], keep: async () => [], sent: () => {}, giveBack: () => {} };
+  const assistant = new Assistant(host);
+  assistant.pick('core-b/a1');
+  assistant.draft = 'one';
+  await assistant.send();
+  assistant.pick('a1');
+  assistant.draft = 'two';
+  await assistant.send();
+  const messages = sent.filter(([, method]) => method === 'agents.message.send').map(([coreId, , params]) => [coreId, (params as { text: string }).text]);
+  expect(messages).toEqual([
+    ['core-b', 'one'],
+    [null, 'two']
+  ]);
+});
+
+test('every thread call of the island for a thread of another machine goes to that machine', async () => {
+  const { group, localCall } = await threeMachines('ask');
+  const threads = await group.call('threads.list', { includeArchived: true });
+  expect(ids(threads)).toEqual(expect.arrayContaining([SERVER_THREAD, LAPTOP_THREAD]));
+  expect(group.machineOf(LAPTOP_THREAD)).toBe(DEMO_MACHINES.laptop);
+
+  // Sessions, the HUD, recap and finished cards, sub-agents, PR watch, archive.
+  await group.call('threads.subscribe', { threadId: SERVER_THREAD });
+  expect((await group.call('threads.get', { threadId: SERVER_THREAD, limit: 6 })).title).toBe('Corriger le gameplay');
+  await group.call('delegation.get', { threadId: SERVER_THREAD });
+  await group.call('questions.list', { threadId: SERVER_THREAD });
+  await group.call('threads.unsubscribe', { threadId: SERVER_THREAD });
+  await group.call('threads.pullRequestReview', { threadId: SERVER_THREAD, url: 'https://example.com/pull/1' }).catch(() => null);
+  await group.call('threads.archive', { threadId: LAPTOP_THREAD });
+  const thread = (method: string) => localCall.mock.calls.some(([called, params]) => called === method && [SERVER_THREAD, LAPTOP_THREAD].includes((params as { threadId?: string }).threadId ?? ''));
+  for (const method of ['threads.subscribe', 'threads.get', 'delegation.get', 'questions.list', 'threads.unsubscribe', 'threads.pullRequestReview', 'threads.archive']) expect(thread(method)).toBe(false);
+  expect((await group.at(LAPTOP_CORE).call('threads.list', { includeArchived: true })).find((entry) => entry.id === LAPTOP_THREAD)?.archived).toBe(true);
+
+  // boite's thread asks to push: the request shows here, the answer goes back there.
+  let request: PermissionRequest | undefined;
+  await vi.waitFor(async () => {
+    request = (await group.call('permissions.list', {})).find((entry) => entry.threadId === SERVER_THREAD);
+    expect(request).toBeDefined();
+  }, { timeout: 4_000 });
+  await group.call('permissions.answer', { requestId: request!.id, decision: 'allow' });
+  expect(localCall.mock.calls.some(([method]) => method === 'permissions.answer')).toBe(false);
+  expect(await group.at(SERVER_CORE).call('permissions.list', {})).toEqual([]);
+});
+
+test('a machine out of reach is shown offline in one place and holds nothing up', async () => {
+  const { group } = await threeMachines('away');
+  expect(group.machines().map((machine) => [machine.name, machine.state])).toEqual([
+    [DEMO_MACHINES.server, 'ready'],
+    [DEMO_MACHINES.laptop, 'unreached']
+  ]);
+  const threads = await group.call('threads.list', {});
+  expect(ids(threads)).toContain(SERVER_THREAD);
+  expect(ids(threads)).not.toContain(LAPTOP_THREAD);
+  const crew = crewOf(group);
+  await crew.load();
+  await vi.waitFor(() => expect(crew.elsewhere.map((entry) => entry.machine)).toEqual([DEMO_MACHINES.server]));
+  await expect(group.at(LAPTOP_CORE).call('agents.snapshot', {})).rejects.toThrow(fill(strings.bots.machineAway, { machine: DEMO_MACHINES.laptop }));
+  expect(group.at(LAPTOP_CORE).state).toBe('closed');
+  // The deck's machines tile is where it says so.
+  const loads = machineLoads(threads, (threadId) => group.coreIdOf(threadId), group.machines(), 'Ce PC');
+  expect(loads.map((load) => [load.name, load.online])).toEqual([
+    ['Ce PC', true],
+    [DEMO_MACHINES.server, true],
+    [DEMO_MACHINES.laptop, false]
+  ]);
+  crew.dispose();
+});
+
+test('a client bound to a machine: this one’s own core, or the member', async () => {
+  const { local, group } = await threeMachines();
+  expect(group.at(null)).toBe(local);
+  expect(group.at(group.selfId())).toBe(local);
+  expect(group.nameOf(SERVER_CORE)).toBe(DEMO_MACHINES.server);
+  expect(group.at(SERVER_CORE).state).toBe('ready');
+  const heard = vi.fn();
+  const off = group.at(SERVER_CORE).on('agents.changed', heard);
+  await group.at(SERVER_CORE).call('agents.profile.save', { value: { name: 'Mason', domain: '', instructions: '', avatar: '', status: 'active', tools: [], accountIntegration: 'provider', selection: { providerId: 'claude', accountId: 'a-claude-main', model: null, effort: 'high', permissionMode: 'default' } } } as never);
+  await vi.waitFor(() => expect(heard).toHaveBeenCalled());
+  off();
+});
+
+test('agent events are heard from every machine; a member slow to answer keeps its agents while connected', () => {
+  expect(AGENT_EVENTS.has('agents.changed')).toBe(true);
+  expect(heardEverywhere('agents.changed')).toBe(true);
+  expect(heardEverywhere('thread.updated')).toBe(true);
+  expect(heardEverywhere('quotas.updated' as never)).toBe(false);
+  const of = (coreId: string) => ({ coreId, machine: coreId, snapshot: { profiles: [] } as unknown as AgentsSnapshot });
+  const before = [of('a'), of('b')];
+  const fresh = of('a');
+  expect(mergeElsewhere(before, [fresh], [{ coreId: 'a' }, { coreId: 'b' }])).toEqual([fresh, before[1]]);
+  expect(mergeElsewhere(before, [fresh], [{ coreId: 'a' }])).toEqual([fresh]);
+  expect(unplacedName('Petites-Rives · boite', 'boite')).toBe('Petites-Rives');
+  expect(unplacedName('Petites-Rives', null)).toBe('Petites-Rives');
+});
diff --git a/src/lib/group/routing.ts b/src/lib/group/routing.ts
index 025ae9f..b164f23 100644
--- a/src/lib/group/routing.ts
+++ b/src/lib/group/routing.ts
@@ -6,8 +6,11 @@
  *   `questions.list` without a thread) are asked of every machine and merged.
  * - A call that names a thread goes to the machine that thread runs on; an
  *   answer to a permission, to the machine that asked it.
- * - Everything else is this machine's own: projects, the crew and the
- *   assistant chat, settings, quotas, resources, new threads.
+ * - An agent's calls go to the machine that owns it: the group client hands
+ *   a client bound to that machine (`GroupClient.at`), since an agent id says
+ *   nothing of where it lives and two machines may hold the same one.
+ * - Everything else is this machine's own: projects, the companion's crew,
+ *   settings, quotas, resources, new threads.
  */
 import type { GroupCore, RpcEventName, RpcMethodName } from '@boite/contracts';
 import { usableAddresses } from '@boite/ui/lib/group-addresses';
@@ -64,6 +67,14 @@ export const THREAD_EVENTS: ReadonlySet<RpcEventName> = new Set<RpcEventName>([
   'threads.pullRequestsChanged'
 ]);
 
+/** The events about agents, heard from every machine: the assistant lists the agents of all of them. */
+export const AGENT_EVENTS: ReadonlySet<RpcEventName> = new Set<RpcEventName>(['agents.changed']);
+
+/** An event every member is listened to for, not this machine alone. */
+export function heardEverywhere(event: RpcEventName): boolean {
+  return THREAD_EVENTS.has(event) || AGENT_EVENTS.has(event);
+}
+
 /** The thread an event is about: a summary carries its id, the others a `threadId`. */
 export function threadOfEvent(event: RpcEventName, payload: unknown): string | null {
   if (!payload || typeof payload !== 'object') return null;
@@ -86,3 +97,10 @@ export function memberBackoff(attempt: number): number {
 export function placedName(project: string, machine: string): string {
   return `${project} · ${machine}`;
 }
+
+/** The project's own name, for a row that shows its machine apart, as a chip. */
+export function unplacedName(label: string, machine: string | null): string {
+  if (machine === null) return label;
+  const suffix = ` · ${machine}`;
+  return label.endsWith(suffix) ? label.slice(0, -suffix.length) : label;
+}
diff --git a/src/lib/island/assistant.svelte.test.ts b/src/lib/island/assistant.svelte.test.ts
index b278f0e..e5b7e26 100644
--- a/src/lib/island/assistant.svelte.test.ts
+++ b/src/lib/island/assistant.svelte.test.ts
@@ -2,6 +2,7 @@ import type { AgentConversationMessage, AgentProfile, AgentsSnapshot, AgentWork,
 import { expect, test, vi } from 'vitest';
 import { FakeClient } from '../fake-client';
 import { ASSISTANT_DEMO_AGENT } from '../fake-client/assistant-demo';
+import { pickPlaced, placedAgents } from '../group/agents';
 import {
   applyCompleted,
   applyDelta,
@@ -16,7 +17,6 @@ import {
   liveText,
   offeredModels,
   openWork,
-  pickAgent,
   selectionSave,
   settled,
   splitFiles,
@@ -98,11 +98,12 @@ test('the newest request that failed says why', () => {
 });
 
 test('the agent in use is the chosen one, else the kept one, else the first active one', () => {
-  const agents = [profile('a'), profile('b'), profile('c')];
-  expect(pickAgent(agents, 'b', 'c')?.id).toBe('b');
-  expect(pickAgent(agents, null, 'gone', 'c')?.id).toBe('c');
-  expect(pickAgent(agents, 'gone')?.id).toBe('a');
-  expect(pickAgent([], 'a')).toBeNull();
+  const agents = placedAgents(snapshotOf({ profiles: [profile('a'), profile('b'), profile('c'), profile('d', { status: 'archived' } as Partial<AgentProfile>)] }), []);
+  expect(pickPlaced(agents, 'b', 'c')?.key).toBe('b');
+  expect(pickPlaced(agents, null, 'gone', 'c')?.key).toBe('c');
+  expect(pickPlaced(agents, 'gone')?.key).toBe('a');
+  expect(pickPlaced(agents, 'd')?.key).toBe('a');
+  expect(pickPlaced([], 'a')).toBeNull();
 });
 
 test('the tool line names the running call and its target', () => {
@@ -253,10 +254,10 @@ test('picking another agent keeps it for the next launch and starts clean', asyn
   const { assistant, load, kept, close } = harness(client);
   assistant.open(ASSISTANT_DEMO_AGENT);
   await load();
-  const other = assistant.agents.find((agent) => agent.id !== ASSISTANT_DEMO_AGENT)!;
-  assistant.pick(other.id);
-  expect(kept()).toBe(other.id);
-  expect(assistant.agentId).toBe(other.id);
+  const other = assistant.agents.find((agent) => agent.key !== ASSISTANT_DEMO_AGENT)!;
+  assistant.pick(other.key);
+  expect(kept()).toBe(other.key);
+  expect(assistant.agentId).toBe(other.profile.id);
   expect(assistant.bubbles.every((bubble) => bubble.id.startsWith('m-atlas') === false)).toBe(true);
   close();
   client.close();
diff --git a/src/lib/island/assistant.svelte.ts b/src/lib/island/assistant.svelte.ts
index ef73ab9..0e6c105 100644
--- a/src/lib/island/assistant.svelte.ts
+++ b/src/lib/island/assistant.svelte.ts
@@ -5,8 +5,11 @@
  * only engine; Bots reads and acts through the core alone, after Boite's own
  * `AgentConversation.svelte`.
  *
- * - Which agent: an active profile of `agents.snapshot`, picked in the chat;
- *   its id is kept in Bots's settings (`CompanionPrefs.assistantAgent`).
+ * - Which agent: an active profile of `agents.snapshot`, on this machine or
+ *   another of the group (`group/agents.ts`), picked in the chat; its key is
+ *   kept in Bots's settings (`CompanionPrefs.assistantAgent`). Every call for
+ *   it goes to its own machine (`GroupClient.at`), and its conversation is
+ *   read in that machine's snapshot.
  * - Sending: `agents.message.send` to the direct conversation, the dropped
  *   files kept on disk where the agent can open them, their paths at the end.
  *   Typing during a run sends a follow-up, as Boite does.
@@ -22,6 +25,8 @@
 import type { AgentConversationMessage, AgentProfile, AgentSave, AgentsSnapshot, AgentWork, Attachment, Message, MessagePart, ModelInfo, RpcEvents, ThreadSummary } from '@boite/contracts';
 import type { Client } from '@boite/ui/lib/client';
 import { directScope, replyTo, sessionThreadOf, workFor } from '../companion/crew';
+import { pickPlaced, placedAgents, snapshotAt, type MachineAgents, type PlacedAgent } from '../group/agents';
+import { GroupClient } from '../group/group-client';
 import { visibleReply } from '../companion/directives';
 import { describeTool } from '@boite/ui/lib/tool-summary';
 import { fill, strings } from '../strings';
@@ -126,15 +131,6 @@ export function failureOf(snapshot: AgentsSnapshot | null, messages: readonly Ag
   return work && ENDED.has(work.status) ? fill(copy().failed, { reason: work.error ?? work.status }) : null;
 }
 
-/** The first of the wanted agents still active, else the first active one. */
-export function pickAgent(agents: readonly AgentProfile[], ...wanted: (string | null | undefined)[]): AgentProfile | null {
-  for (const id of wanted) {
-    const found = id ? agents.find((agent) => agent.id === id) : undefined;
-    if (found) return found;
-  }
-  return agents[0] ?? null;
-}
-
 // ---------------------------------------------------------------------------
 // The answer as it comes, from the agent's thread
 // ---------------------------------------------------------------------------
@@ -238,13 +234,15 @@ export function selectionSave(profile: AgentProfile, change: { model?: string; e
 
 export interface AssistantHost {
   client(): Client | null;
-  /** The agents as the companion last read them. */
+  /** This machine's agents as the companion last read them. */
   snapshot(): AgentsSnapshot | null;
+  /** The other machines' agents, as last read; none without a group. */
+  elsewhere?(): readonly MachineAgents[];
   /** Reads the snapshot again now, after a change made here. */
   reload(): void;
-  /** The agent kept in Bots's settings, null when none. */
+  /** The agent kept in Bots's settings (its key, `group/agents.ts`), null when none. */
   remembered(): string | null;
-  remember(agentId: string): void;
+  remember(key: string): void;
   /** The agent to talk to when none is chosen: the row's leader. */
   fallback(): string | null;
   /** What goes with the next message, the dropped files and the capture, or why they cannot go. */
@@ -260,7 +258,7 @@ export interface AssistantHost {
 }
 
 export class Assistant {
-  /** The agent picked for this session; the kept one, else the leader, else the first. */
+  /** The agent picked for this session, by key; the kept one, else the leader, else the first. */
   chosen = $state<string | null>(null);
   /** Pages read back through `agents.history`. */
   older = $state.raw<AgentConversationMessage[]>([]);
@@ -281,10 +279,21 @@ export class Assistant {
   awaiting = $state<string[]>([]);
 
   // Read lazily, once the host is in: through a function, as TypeScript sees the order.
-  readonly snapshot = $derived.by(() => this.host.snapshot());
-  readonly agents = $derived(this.snapshot?.profiles.filter((profile) => profile.status === 'active') ?? []);
-  readonly agent = $derived.by(() => pickAgent(this.agents, this.chosen, this.host.remembered(), this.host.fallback()));
+  readonly #local = $derived.by(() => this.host.snapshot());
+  readonly #elsewhere = $derived.by(() => this.host.elsewhere?.() ?? []);
+  /** The active agents of every machine, this one's first. */
+  readonly agents = $derived<PlacedAgent[]>(placedAgents(this.#local, this.#elsewhere));
+  readonly placed = $derived.by(() => pickPlaced(this.agents, this.chosen, this.host.remembered(), this.host.fallback()));
+  readonly agent = $derived(this.placed?.profile ?? null);
   readonly agentId = $derived(this.agent?.id ?? null);
+  /** The machine the agent lives on: null for this one. */
+  readonly coreId = $derived(this.placed?.coreId ?? null);
+  /** Its machine's name, shown beside it only when it is another machine's. */
+  readonly machine = $derived(this.placed?.machine ?? null);
+  /** Shown beside each agent: there is more than one machine to tell apart. */
+  readonly machines = $derived(this.#elsewhere.length > 0);
+  /** The agent's own machine's snapshot: its conversation, work and replies. */
+  readonly snapshot = $derived(snapshotAt(this.coreId, this.#local, this.#elsewhere));
   /** The thread the agent works its conversation with the user in, once it has worked there. */
   readonly threadId = $derived(this.agentId ? sessionThreadOf(this.snapshot, this.agentId) : null);
   readonly messages = $derived(this.agentId ? conversation(this.snapshot, this.older, this.agentId) : []);
@@ -325,9 +334,9 @@ export class Assistant {
     return () => offs.forEach((off) => off());
   }
 
-  /** Opens on `agentId` for this session without keeping it (the demo's), else on the kept agent. */
-  open(agentId?: string): void {
-    if (agentId) this.chosen = agentId;
+  /** Opens on `key` for this session without keeping it (the demo's), else on the kept agent. */
+  open(key?: string): void {
+    if (key) this.chosen = key;
     this.follow();
   }
 
@@ -337,24 +346,32 @@ export class Assistant {
     this.follow();
   }
 
-  /** The user picked another agent: it is kept for the next launch. */
-  pick(agentId: string): void {
-    if (agentId === this.agentId) return;
-    this.chosen = agentId;
-    this.host.remember(agentId);
+  /** The user picked another agent, by key: it is kept for the next launch. */
+  pick(key: string): void {
+    if (key === this.placed?.key) return;
+    this.chosen = key;
+    this.host.remember(key);
     this.follow();
   }
 
+  /** The client the agent's calls go through: its own machine's. */
+  #client(): Client | null {
+    const client = this.host.client();
+    if (!client || this.coreId === null) return client;
+    return client instanceof GroupClient ? client.at(this.coreId) : null;
+  }
+
   /**
    * After each read of the snapshot: a new agent starts clean, its thread is
    * followed, its models read, and a short conversation reads a page back.
    */
   follow(): void {
-    const client = this.host.client();
+    const client = this.#client();
+    const placed = this.placed;
     const agent = this.agent;
-    if (!client || !agent) return;
-    if (this.followed !== agent.id) {
-      this.followed = agent.id;
+    if (!client || !placed || !agent) return;
+    if (this.followed !== placed.key) {
+      this.followed = placed.key;
       this.older = [];
       this.more = null;
       this.stream = [];
@@ -364,10 +381,10 @@ export class Assistant {
     }
     const threadId = this.threadId;
     if (threadId && threadId !== this.subscribed) void this.watch(client, threadId);
-    const engine = `${agent.selection.providerId}/${agent.selection.accountId}`;
+    const engine = `${placed.coreId ?? ''}/${agent.selection.providerId}/${agent.selection.accountId}`;
     if (engine !== this.probed) void this.readModels(client, engine, agent.selection.providerId, agent.selection.accountId);
-    if (this.messages.length < ASSISTANT_FILL && this.hasOlder && !this.filled.has(agent.id)) {
-      this.filled.add(agent.id);
+    if (this.messages.length < ASSISTANT_FILL && this.hasOlder && !this.filled.has(placed.key)) {
+      this.filled.add(placed.key);
       void this.loadOlder();
     }
   }
@@ -401,7 +418,7 @@ export class Assistant {
 
   /** Older messages, a page more, when the reader scrolls to the top. */
   async loadOlder(): Promise<void> {
-    const client = this.host.client();
+    const client = this.#client();
     const agentId = this.agentId;
     if (!client || !agentId || this.loadingOlder || !this.hasOlder) return;
     this.loadingOlder = true;
@@ -429,7 +446,7 @@ export class Assistant {
     const attachments = this.host.outgoing();
     if (typeof attachments === 'string') return void (this.problem = attachments);
     if (!prompt && attachments.length === 0) return;
-    const client = this.host.client();
+    const client = this.#client();
     if (!client) return void (this.problem = strings.companion.unreachable);
     const agent = this.agent;
     if (!agent) return void (this.problem = copy().noAgent);
@@ -460,7 +477,7 @@ export class Assistant {
 
   /** Cancels the agent's open work in this conversation; a message the core has not made work of yet is let go. */
   async stop(): Promise<void> {
-    const client = this.host.client();
+    const client = this.#client();
     const agentId = this.agentId;
     if (!client || !agentId || this.stopping) return;
     this.stopping = true;
@@ -490,7 +507,7 @@ export class Assistant {
 
   /** The agent's own model or effort, changed for it everywhere. */
   private async update(change: { model?: string; effort?: Effort }): Promise<void> {
-    const client = this.host.client();
+    const client = this.#client();
     const agent = this.agent;
     if (!client || !agent) return;
     try {
diff --git a/src/lib/island/pose.ts b/src/lib/island/pose.ts
index ea21c20..c6667c1 100644
--- a/src/lib/island/pose.ts
+++ b/src/lib/island/pose.ts
@@ -40,10 +40,11 @@
  *   shield shows (pair it with `calm=1`);
  * - `pr=green|red`: the tests thread opens PR #12, whose CI runs, then goes
  *   green or red (the fake core's side: `fake-client/allow-demo.ts`);
- * - `machines=1|ask`: a second machine of the group, « Serveur », whose
- *   « Corriger le gameplay » thread works among this machine's (`ask`: it
- *   asks to push two seconds in); read by the companion, the fake side in
- *   `fake-client/machines-demo.ts`.
+ * - `machines=1|ask|away`: two more machines of the group, « boite » and
+ *   « laptop », whose threads work among this machine's and whose agents
+ *   the Chat lists (`ask`: boite's thread asks to push two seconds in;
+ *   `away`: laptop is out of reach); read by the companion, the fake side
+ *   in `fake-client/machines-demo.ts`.
  * - `todo=1`: a to-do list in the today tab, one item ticked;
  * - `mission=ask|list`: a mission waiting for the user's word, or three set
  *   (one paused, one whose project is gone) for Settings;
diff --git a/src/lib/reveal.test.ts b/src/lib/reveal.test.ts
index ca44e03..7184914 100644
--- a/src/lib/reveal.test.ts
+++ b/src/lib/reveal.test.ts
@@ -56,15 +56,66 @@ test('without a client yet, the reveal fails quietly too', async () => {
   expect(failed).toHaveBeenCalledTimes(1);
 });
 
-test("a thread of another machine is not revealed here: the notice names where it runs", async () => {
+/** A group client whose thread `t-srv` runs on boite, `core-srv`; `features` is what this machine's core said at hello. */
+function groupWith(call: (method: string, params: unknown) => Promise<unknown>, features: Record<string, unknown> = {}): GroupClient {
+  const group = Object.create(GroupClient.prototype) as GroupClient;
+  Object.defineProperty(group, 'core', { value: { features } });
+  return Object.assign(group, {
+    call,
+    selfId: () => 'core-here',
+    coreIdOf: (threadId: string) => (threadId === 't-srv' ? 'core-srv' : null),
+    machineOf: (threadId: string) => (threadId === 't-srv' ? 'boite' : null),
+    nameOf: (coreId: string) => (coreId === 'core-srv' ? 'boite' : null)
+  });
+}
+
+test('a thread of another machine goes to this machine’s Boite with its machine named', async () => {
   const call = vi.fn(async () => ({ delivered: 1 }));
   const failed = vi.fn();
-  const group = Object.assign(Object.create(GroupClient.prototype) as GroupClient, { call, machineOf: (threadId: string) => (threadId === 't-srv' ? 'Serveur' : null) });
-  useReveal(group, failed);
+  useReveal(groupWith(call), failed);
+  expect(await reveal({ kind: 'thread', threadId: 't-srv' })).toBeNull();
+  expect(call).toHaveBeenCalledWith('ui.reveal', { target: { kind: 'thread', threadId: 't-srv', coreId: 'core-srv' } });
+  // This machine's own thread names none, as an older core expects.
+  await showMain('t-1');
+  expect(call).toHaveBeenLastCalledWith('ui.reveal', { target: { kind: 'thread', threadId: 't-1' } });
+  expect(failed).not.toHaveBeenCalled();
+});
+
+test('a Boite that does not know machines refuses the thread: the notice says where it runs', async () => {
+  const call = vi.fn(async () => {
+    throw new RpcFailure({ code: RpcErrorCode.InvalidParams, message: 'ui.reveal target.threadId t-srv is not a thread of this core' });
+  });
+  const failed = vi.fn();
+  useReveal(groupWith(call), failed);
   const told = await reveal({ kind: 'thread', threadId: 't-srv' });
-  expect(told).toBe(fill(strings.bots.revealElsewhere, { machine: 'Serveur' }));
+  expect(told).toBe(fill(strings.bots.revealElsewhere, { machine: 'boite' }));
   expect(failed).toHaveBeenCalledWith(told);
+});
+
+test('an agent of another machine goes only to a Boite known to take machines', async () => {
+  // Unknown: an older core would open an agent of its own with that id. Said instead of sent.
+  const call = vi.fn(async () => ({ delivered: 1 }));
+  const failed = vi.fn();
+  useReveal(groupWith(call), failed);
+  await showAgent('agent-forge', 'core-srv');
   expect(call).not.toHaveBeenCalled();
-  await showMain('t-1');
-  expect(call).toHaveBeenCalledWith('ui.reveal', { target: { kind: 'thread', threadId: 't-1' } });
-});
\ No newline at end of file
+  expect(failed).toHaveBeenCalledWith(fill(strings.bots.revealAgentElsewhere, { machine: 'boite' }));
+
+  // Its hello says so.
+  const said = vi.fn(async () => ({ delivered: 1 }));
+  useReveal(groupWith(said, { revealMachines: true }), () => {});
+  await showAgent('agent-forge', 'core-srv');
+  expect(said).toHaveBeenCalledWith('ui.reveal', { target: { kind: 'agent', agentId: 'agent-forge', coreId: 'core-srv' } });
+
+  // Or it already showed a thread of another machine.
+  const shown = vi.fn(async () => ({ delivered: 1 }));
+  const group = groupWith(shown);
+  useReveal(group, () => {});
+  await showMain('t-srv');
+  await showAgent('agent-forge', 'core-srv');
+  expect(shown).toHaveBeenLastCalledWith('ui.reveal', { target: { kind: 'agent', agentId: 'agent-forge', coreId: 'core-srv' } });
+
+  // This machine's agent names no machine.
+  await showAgent('agent-1', null);
+  expect(shown).toHaveBeenLastCalledWith('ui.reveal', { target: { kind: 'agent', agentId: 'agent-1' } });
+});
diff --git a/src/lib/reveal.ts b/src/lib/reveal.ts
index 1a0871b..6ef3f9f 100644
--- a/src/lib/reveal.ts
+++ b/src/lib/reveal.ts
@@ -3,6 +3,14 @@
  * `ui.reveal`, which the core passes to Boite's open windows and answers with
  * how many took it. Bots's windows have no page of their own for a thread.
  *
+ * A thread or an agent of another machine of the group goes to this
+ * machine's core all the same, its machine named by `coreId`: Boite's window
+ * here opens it under that machine. A core older than that refuses a thread
+ * it does not hold, and the notice says where it runs instead, as Bots did
+ * before. It would take an agent's id for one of its own, so an agent of
+ * another machine goes only to a core that says it knows machines
+ * (`features.revealMachines`), or that already showed a thread of another.
+ *
  * A Boite older than the RPC answers "method not found": that, like any other
  * failure, comes back as a short sentence for the window to show, never as a
  * thrown error.
@@ -13,11 +21,13 @@ import { GroupClient } from './group/group-client';
 import { fill, strings } from './strings';
 
 /**
- * `update`, Boite's app updates in its settings, came with beboite/boite#418:
- * the contract in vendor/boite does not name it yet. An older core refuses it
- * as invalid params.
+ * What Boite's window may be asked to show. `update`, Boite's app updates in
+ * its settings, came with beboite/boite#418; `coreId`, the machine a thread or
+ * an agent lives on, with the reveal across machines. The contract in
+ * vendor/boite names neither yet: an older core refuses `update` as invalid
+ * params, and a thread of another machine as not its own.
  */
-export type RevealTarget = UiRevealTarget | { kind: 'update' };
+export type RevealTarget = { kind: 'thread'; threadId: string; coreId?: string } | { kind: 'agent'; agentId: string; coreId?: string } | { kind: 'update' };
 
 let client: Client | null = null;
 let onfail: ((message: string) => void) | null = null;
@@ -37,23 +47,55 @@ export function revealProblem(error: unknown, target?: RevealTarget): string {
   return fill(strings.bots.revealFailed, { reason: reason.length > 120 ? `${reason.slice(0, 119)}…` : reason });
 }
 
+/** The cores that showed a thread of another machine: they know machines, whatever their features say. */
+const knowsMachines = new WeakSet<object>();
+
+function takesMachines(client: Client): boolean {
+  const features = (client as { core?: { features?: Record<string, unknown> } | null }).core?.features;
+  return features?.['revealMachines'] === true || knowsMachines.has(client);
+}
+
+/** The machine the target lives on, when it is another of the group: its id and its name. */
+function machineOf(target: RevealTarget, group: GroupClient | null): { coreId: string; name: string } | null {
+  if (target.kind === 'update' || !group) return null;
+  const coreId = target.coreId ?? (target.kind === 'thread' ? group.coreIdOf(target.threadId) : null);
+  if (coreId === null || coreId === group.selfId()) return null;
+  return { coreId, name: group.nameOf(coreId) ?? (target.kind === 'thread' ? group.machineOf(target.threadId) : null) ?? coreId };
+}
+
+/** The target as a core of any age takes it: a thread or an agent of this machine names no machine. */
+function here(target: RevealTarget): UiRevealTarget {
+  if (target.kind === 'thread') return { kind: 'thread', threadId: target.threadId };
+  if (target.kind === 'agent') return { kind: 'agent', agentId: target.agentId };
+  return target as unknown as UiRevealTarget;
+}
+
+function told(message: string): string {
+  onfail?.(message);
+  return message;
+}
+
 /** Asks Boite to show the target. Null when it went out, else the sentence that was told. */
 export async function reveal(target: RevealTarget): Promise<string | null> {
   try {
     if (!client) throw new Error(strings.bots.waiting);
-    // A thread of another machine: this machine's Boite takes `ui.reveal` for its own threads only,
-    // and that machine's core would bring Boite up over there. Said instead of sent.
-    const machine = target.kind === 'thread' && client instanceof GroupClient ? client.machineOf(target.threadId) : null;
-    if (machine !== null) {
-      const message = fill(strings.bots.revealElsewhere, { machine });
-      onfail?.(message);
-      return message;
+    const machine = machineOf(target, client instanceof GroupClient ? client : null);
+    if (machine === null) {
+      await client.call('ui.reveal', { target: here(target) });
+      return null;
+    }
+    const elsewhere = fill(target.kind === 'agent' ? strings.bots.revealAgentElsewhere : strings.bots.revealElsewhere, { machine: machine.name });
+    if (target.kind === 'agent' && !takesMachines(client)) return told(elsewhere);
+    try {
+      await client.call('ui.reveal', { target: { ...target, coreId: machine.coreId } as never });
+    } catch (error) {
+      // A core that does not know that machine, or does not know machines yet: where it runs is said instead.
+      if (error && typeof error === 'object' && (error as { code?: unknown }).code === RpcErrorCode.InvalidParams) return told(elsewhere);
+      throw error;
     }
-    await client.call('ui.reveal', { target: target as UiRevealTarget });
+    if (target.kind === 'thread') knowsMachines.add(client);
     return null;
   } catch (error) {
-    const message = revealProblem(error, target);
-    onfail?.(message);
-    return message;
+    return told(revealProblem(error, target));
   }
 }
diff --git a/src/lib/strings.en.ts b/src/lib/strings.en.ts
index 3b8c711..ab7d7ef 100644
--- a/src/lib/strings.en.ts
+++ b/src/lib/strings.en.ts
@@ -17,6 +17,10 @@ export const strings = {
     revealUnsupported: 'This version of Boite cannot show it. Update Boite, then try again.',
     /** A thread of another machine of the group: Boite's window here cannot be pointed at it yet. */
     revealElsewhere: 'This thread runs on {machine}: open it in Boite, under that machine.',
+    /** An agent of another machine, on a Boite that cannot be pointed at it yet. */
+    revealAgentElsewhere: 'This agent lives on {machine}: open it in Boite, under that machine.',
+    /** The chip on a thread or an agent of another machine of the group. */
+    onMachine: 'On {machine}',
     /** A call for a thread whose machine is not connected now. */
     machineAway: '{machine} is out of reach right now.',
     settingsTitle: 'B.O.T.S settings',
diff --git a/src/lib/strings.fr.ts b/src/lib/strings.fr.ts
index 1caed5f..a9e7d54 100644
--- a/src/lib/strings.fr.ts
+++ b/src/lib/strings.fr.ts
@@ -13,6 +13,8 @@ export const fr: Messages = {
     revealFailed: 'Boite n’a pas pu l’afficher : {reason}',
     revealUnsupported: 'Cette version de Boite ne sait pas encore l’afficher. Mettez Boite à jour, puis réessayez.',
     revealElsewhere: 'Ce fil tourne sur {machine} : ouvrez-le dans Boite, sous cette machine.',
+    revealAgentElsewhere: 'Cet agent vit sur {machine} : ouvrez-le dans Boite, sous cette machine.',
+    onMachine: 'Sur {machine}',
     machineAway: '{machine} est injoignable pour le moment.',
     settingsTitle: 'Réglages de B.O.T.S',
     tray: { tooltip: 'B.O.T.S', settings: 'Réglages', quit: 'Quitter' },