diff --git a/apps/server/src/modules/agent/acp/agent-cli.route.test.ts b/apps/server/src/modules/agent/acp/agent-cli.route.test.ts
index a8b3aae5c..194dd8d08 100644
--- a/apps/server/src/modules/agent/acp/agent-cli.route.test.ts
+++ b/apps/server/src/modules/agent/acp/agent-cli.route.test.ts
@@ -16,6 +16,8 @@ vi.mock('@agenetes/agentlet-host', () => ({
     getAgentlet: () => ({ status: 'connected' }),
     discoverHarnesses: mocks.discover,
   }),
+  resolveConnectedAgentletId: (target: string) =>
+    target === 'legacy-host' ? 'remote-machine' : target,
 }));
 
 let app: FastifyInstance | undefined;
@@ -119,7 +121,7 @@ describe('ACP agent CLI route', () => {
   });
 
   it('queries the edited Profile machine and projects Custom for older catalogues', async () => {
-    mocks.getProfile.mockReturnValue({ agentletId: 'remote-machine' });
+    mocks.getProfile.mockReturnValue({ agentletId: 'legacy-host' });
     mocks.discover.mockResolvedValue({ harnesses: [] });
     app = Fastify({ logger: false });
     await app.register(createAcpAgentCliRoutes(), { prefix: '/api/acp' });
diff --git a/apps/server/src/modules/agent/acp/agent-cli.route.ts b/apps/server/src/modules/agent/acp/agent-cli.route.ts
index 24d053434..a173f3737 100644
--- a/apps/server/src/modules/agent/acp/agent-cli.route.ts
+++ b/apps/server/src/modules/agent/acp/agent-cli.route.ts
@@ -18,6 +18,7 @@
 import {
   getAgentletGateway,
   getAgentProfileRegistry,
+  resolveConnectedAgentletId,
 } from '@agenetes/agentlet-host';
 import {
   CUSTOM_COMMAND_CAPABILITIES,
@@ -46,8 +47,12 @@ async function detectAgentClis(target: {
     : undefined;
   if (target.profileId && !profile)
     throw new Error('Agent Profile is unavailable');
-  const agentletId = profile?.agentletId ?? target.agentletId;
-  if (!agentletId) throw new Error('Agentlet target is required');
+  const requestedAgentletId = profile?.agentletId ?? target.agentletId;
+  if (!requestedAgentletId) throw new Error('Agentlet target is required');
+  const agentletId = profile
+    ? resolveConnectedAgentletId(requestedAgentletId)
+    : requestedAgentletId;
+  if (!agentletId) throw new Error('Agentlet is not connected');
   const connection = gateway.getAgentlet(agentletId);
   if (connection?.status !== 'connected')
     throw new Error('Agentlet is not connected');
diff --git a/apps/server/src/modules/agent/acp/external-agent-realization.ts b/apps/server/src/modules/agent/acp/external-agent-realization.ts
index 563117060..f10d864f8 100644
--- a/apps/server/src/modules/agent/acp/external-agent-realization.ts
+++ b/apps/server/src/modules/agent/acp/external-agent-realization.ts
@@ -6,6 +6,7 @@ import {
   ensureAcpSession,
   resolveAcpAgentletId,
 } from '@agenetes/acp-driver';
+import { resolveConnectedAgentletId } from '@agenetes/agentlet-host';
 
 import { canvasAcpNamespace } from '../../workspace/paths.js';
 import {
@@ -123,8 +124,10 @@ async function ensureSessionFromCanonicalSpec(
       ? { ...resolvedEnvironment, ...spec.spec.env }
       : undefined;
   const record = await agenetes.record(spec.namespace, spec.threadId);
+  const requestedAgentletId = resolveAcpAgentletId(spec);
   return ensureAcpSession({
-    agentletId: resolveAcpAgentletId(spec),
+    agentletId:
+      resolveConnectedAgentletId(requestedAgentletId) ?? requestedAgentletId,
     threadId: spec.threadId,
     binding: spec.spec.binding,
     namespace: spec.namespace,
diff --git a/apps/server/src/modules/agent/acp/harness-profile-discovery.test.ts b/apps/server/src/modules/agent/acp/harness-profile-discovery.test.ts
index e948a7029..3f3f935ef 100644
--- a/apps/server/src/modules/agent/acp/harness-profile-discovery.test.ts
+++ b/apps/server/src/modules/agent/acp/harness-profile-discovery.test.ts
@@ -63,7 +63,17 @@ function setup(initialMachines = ['machine-a']) {
     }),
   };
   const gateway = {
-    getAgentlets: () => initialMachines.map((agentletId) => ({ agentletId })),
+    getAgentlets: () =>
+      initialMachines.map((agentletId) => ({
+        agentletId,
+        agentletProfile: {
+          machine: {
+            hostname: agentletId,
+            platform: 'linux',
+            arch: 'x64',
+          },
+        },
+      })),
     onAgentletsChanged: (handler: (event: Event) => void) => {
       listener = handler;
       return vi.fn();
@@ -116,6 +126,7 @@ describe('automatic ordinary Profile provisioning', () => {
       },
     );
     expect(context.profiles[0]).toMatchObject({
+      alias: 'GitHub Copilot (machine-a: linux x64)',
       agentletId: 'machine-a',
       workingDirPath: '/home/user/.agentlet/workspace/copilot',
       launch: { kind: 'acp-command', command: 'copilot --acp' },
@@ -277,7 +288,7 @@ describe('automatic ordinary Profile provisioning', () => {
       const registry = createAgentProfileRegistry({ storageDir });
       const legacy = registry.createProfile({
         launchKind: 'acp-command',
-        alias: 'GitHub Copilot (machine-a)',
+        alias: 'GitHub Copilot (machine-a: linux x64)',
         agentletId: 'machine-a',
         workingDirPath: '/custom/work',
         command: 'copilot --acp --model old-model',
@@ -328,7 +339,7 @@ describe('automatic ordinary Profile provisioning', () => {
         .listProfiles()
         .find((profile) => profile.launch.kind === 'acp-harness');
       expect(typed).toMatchObject({
-        alias: 'GitHub Copilot (machine-a) [copilot]',
+        alias: 'GitHub Copilot (machine-a: linux x64) [copilot]',
         workingDirPath: observation.harnesses[0].workingDirPath,
         launch: {
           kind: 'acp-harness',
diff --git a/apps/server/src/modules/agent/acp/harness-profile-discovery.ts b/apps/server/src/modules/agent/acp/harness-profile-discovery.ts
index 3271b5c20..12c2133d8 100644
--- a/apps/server/src/modules/agent/acp/harness-profile-discovery.ts
+++ b/apps/server/src/modules/agent/acp/harness-profile-discovery.ts
@@ -3,6 +3,8 @@
 
 import { CUSTOM_COMMAND_WRAPPER_ID } from '@agentlet/protocol';
 
+import { formatAgentletDeviceDisplayName } from '../agentlet-device-display.js';
+
 import type {
   AgentProfile,
   AgentProfileRegistry,
@@ -76,7 +78,16 @@ export function mergeProfileCustomData(
 }
 
 interface DiscoveryGateway {
-  getAgentlets(filter: { status: 'connected' }): Array<{ agentletId: string }>;
+  getAgentlets(filter: { status: 'connected' }): Array<{
+    agentletId: string;
+    agentletProfile?: {
+      machine?: {
+        hostname?: string;
+        platform?: string;
+        arch?: string;
+      };
+    };
+  }>;
   onAgentletsChanged(
     handler: (event: {
       agentletId: string;
@@ -149,7 +160,12 @@ export function registerHarnessProfileDiscovery({
         );
       });
       if (existing) continue;
-      const defaultAlias = `${harness.displayName} (${agentletId})`;
+      const connection = gateway
+        .getAgentlets({ status: 'connected' })
+        .find((candidate) => candidate.agentletId === agentletId);
+      const defaultAlias = `${harness.displayName} (${formatAgentletDeviceDisplayName(
+        connection?.agentletProfile?.machine,
+      )})`;
       const common = {
         agentletId,
         alias:
diff --git a/apps/server/src/modules/agent/acp/profiles.route.test.ts b/apps/server/src/modules/agent/acp/profiles.route.test.ts
index dab86c012..ed5032b9a 100644
--- a/apps/server/src/modules/agent/acp/profiles.route.test.ts
+++ b/apps/server/src/modules/agent/acp/profiles.route.test.ts
@@ -51,6 +51,13 @@ vi.mock('@agenetes/agentlet-host', () => ({
         },
       })),
   }),
+  resolveConnectedAgentletId: (target: string) => {
+    if (mocks.connectedIds.has(target)) return target;
+    const matches = [...mocks.connectedIds].filter(
+      (agentletId) => `${agentletId}-host` === target,
+    );
+    return matches.length === 1 ? matches[0] : undefined;
+  },
 }));
 
 vi.mock('./profile-schema-cache.js', () => ({
@@ -190,6 +197,7 @@ describe('ordinary Profile catalog routes', () => {
       connectedDevices: [
         expect.objectContaining({
           agentletId: 'machine-a',
+          displayName: 'machine-a-host: linux x64',
           profileCount: 1,
         }),
         expect.objectContaining({
@@ -198,11 +206,39 @@ describe('ordinary Profile catalog routes', () => {
         }),
       ],
     });
+
     expect(mocks.registry.createProfile).not.toHaveBeenCalled();
     expect(mocks.initializeDefaults).not.toHaveBeenCalled();
     expect(mocks.discoverHarnesses).not.toHaveBeenCalled();
   });
 
+  it('maps one hostname-era Profile to the unique connected device', async () => {
+    const legacyProfile = {
+      ...commandProfile,
+      id: 'legacy-command',
+      agentletId: 'machine-a-host',
+    };
+    mocks.registry.listProfiles.mockReturnValue([legacyProfile]);
+    const server = await setup();
+    const response = await server.inject('/api/acp/profiles');
+
+    expect(response.statusCode).toBe(200);
+    expect(response.json()).toMatchObject({
+      profiles: [legacyProfile],
+      selectableProfileIds: ['legacy-command'],
+      connectedDevices: [
+        expect.objectContaining({
+          agentletId: 'machine-a',
+          profileCount: 1,
+        }),
+        expect.objectContaining({
+          agentletId: 'remote-machine',
+          profileCount: 0,
+        }),
+      ],
+    });
+  });
+
   it('rejects caller-created automatic provenance', async () => {
     const server = await setup();
     const response = await server.inject({
diff --git a/apps/server/src/modules/agent/acp/profiles.route.ts b/apps/server/src/modules/agent/acp/profiles.route.ts
index 9e4fe6d3d..0386a0a76 100644
--- a/apps/server/src/modules/agent/acp/profiles.route.ts
+++ b/apps/server/src/modules/agent/acp/profiles.route.ts
@@ -29,6 +29,7 @@ import {
   getAgentProfileRegistry,
   getAgentletGateway,
   getDaemonSupervisor,
+  resolveConnectedAgentletId,
 } from '@agenetes/agentlet-host';
 
 import {
@@ -48,6 +49,7 @@ import {
   getAgentDefaults,
   initializeAgentDefaults,
 } from '../agent-defaults.js';
+import { formatAgentletDeviceDisplayName } from '../agentlet-device-display.js';
 
 import type { AgentletConnection } from '@agenetes/agentlet-host';
 import type {
@@ -88,7 +90,10 @@ async function validateHarnessLaunch(
   try {
     const gateway = getAgentletGateway();
     if (!gateway) throw new Error('Agentlet Gateway is not ready');
-    const result = await gateway.discoverHarnesses(agentletId, {
+    const resolvedAgentletId = resolveConnectedAgentletId(agentletId);
+    if (!resolvedAgentletId)
+      throw new Error('The selected Agentlet is not connected');
+    const result = await gateway.discoverHarnesses(resolvedAgentletId, {
       prepareWorkspaces: false,
     });
     const harness = result.harnesses.find(
@@ -117,7 +122,7 @@ async function validateHarnessLaunch(
       });
       return false;
     }
-    await gateway.buildHarnessLaunch(agentletId, { launch });
+    await gateway.buildHarnessLaunch(resolvedAgentletId, { launch });
     return true;
   } catch (error) {
     request.log.warn(
@@ -156,7 +161,9 @@ const acpProfilesRoutes: FastifyPluginAsync = async (app) => {
       try {
         const gateway = getAgentletGateway();
         if (!gateway) throw new Error('Agentlet Gateway is not ready');
-        const agentletId = profile?.agentletId ?? parsed.data.agentletId;
+        const agentletId = profile
+          ? resolveConnectedAgentletId(profile.agentletId)
+          : parsed.data.agentletId;
         if (!agentletId || !isAgentletConnected(agentletId)) {
           return reply.status(409).send({
             code: 'agentlet_unavailable',
@@ -190,19 +197,18 @@ const acpProfilesRoutes: FastifyPluginAsync = async (app) => {
       }
       const profiles = registry.listProfiles();
       const connected = getConnectedAgentlets();
-      const connectedIds = new Set(
-        connected.map((connection) => connection.agentletId),
-      );
       const profileCounts = new Map<string, number>();
       for (const profile of profiles) {
-        profileCounts.set(
-          profile.agentletId,
-          (profileCounts.get(profile.agentletId) ?? 0) + 1,
-        );
+        const agentletId = resolveConnectedAgentletId(profile.agentletId);
+        if (!agentletId) continue;
+        profileCounts.set(agentletId, (profileCounts.get(agentletId) ?? 0) + 1);
       }
       const connectedDevices = connected
         .map((connection) => ({
           agentletId: connection.agentletId,
+          displayName: formatAgentletDeviceDisplayName(
+            connection.agentletProfile?.machine,
+          ),
           ...(connection.agentletProfile?.machine?.hostname
             ? { hostname: connection.agentletProfile.machine.hostname }
             : {}),
@@ -225,7 +231,7 @@ const acpProfilesRoutes: FastifyPluginAsync = async (app) => {
       return {
         profiles,
         selectableProfileIds: profiles
-          .filter((profile) => connectedIds.has(profile.agentletId))
+          .filter((profile) => resolveConnectedAgentletId(profile.agentletId))
           .map((profile) => profile.id),
         connectedDevices,
         agentlet: getDaemonSupervisor().getStatus(),
diff --git a/apps/server/src/modules/agent/acp/threads.route.cached-meta.test.ts b/apps/server/src/modules/agent/acp/threads.route.cached-meta.test.ts
index 66dfbc803..9c2b3a8ea 100644
--- a/apps/server/src/modules/agent/acp/threads.route.cached-meta.test.ts
+++ b/apps/server/src/modules/agent/acp/threads.route.cached-meta.test.ts
@@ -29,6 +29,11 @@ vi.mock('@agenetes/acp-driver', () => ({
   },
 }));
 
+vi.mock('@agenetes/agentlet-host', () => ({
+  resolveConnectedAgentletId: (agentletId: string) =>
+    agentletId === 'legacy-host' ? 'device-uuid' : agentletId,
+}));
+
 vi.mock('./external-agent-realization.js', () => ({
   externalAgentRealization: { realize: vi.fn(), ensureSession: vi.fn() },
   realizationHttpError: () => ({
@@ -115,6 +120,7 @@ describe('ACP cached-meta across awaited persistence', () => {
       usage: null,
       metaUpdatedAt: 32,
     });
+
     const server = await createApp();
 
     const response = await server.inject({
@@ -135,6 +141,30 @@ describe('ACP cached-meta across awaited persistence', () => {
     });
   });
 
+  it('finds a live session through unique hostname-era placement resolution', async () => {
+    mocks.record = externalRecord('legacy-host');
+    mocks.live.set('device-uuid\u0000thread-1', {
+      availableCommands: [{ name: 'review', description: 'Review changes' }],
+      commandsUpdatedAt: 5,
+      availableModes: [],
+      currentModeId: null,
+      availableModels: [],
+      currentModelId: null,
+      configOptions: [],
+      selections: {},
+      sessionInfo: null,
+      usage: null,
+      metaUpdatedAt: 6,
+    });
+    const response = await (await createApp()).inject(CACHED_META_URL);
+
+    expect(response.statusCode).toBe(200);
+    expect(response.json()).toMatchObject({
+      source: 'thread',
+      availableCommands: [{ name: 'review' }],
+    });
+  });
+
   it('does not invent a placement for a thread with no record', async () => {
     mocks.live.set('agentlet-supervised\u0000thread-1', {
       availableCommands: [],
diff --git a/apps/server/src/modules/agent/acp/threads.route.ts b/apps/server/src/modules/agent/acp/threads.route.ts
index df778ecb0..1950b9cbe 100644
--- a/apps/server/src/modules/agent/acp/threads.route.ts
+++ b/apps/server/src/modules/agent/acp/threads.route.ts
@@ -2,6 +2,7 @@
 // Licensed under the MIT license.
 
 import { acpSessionRegistry } from '@agenetes/acp-driver';
+import { resolveConnectedAgentletId } from '@agenetes/agentlet-host';
 
 import {
   acpPermissionDecisionSchema,
@@ -151,7 +152,8 @@ async function resolveThreadAgentletId(
       typeof driverSpec === 'object' &&
       typeof (driverSpec as { agentletId?: unknown }).agentletId === 'string'
     ) {
-      return (driverSpec as { agentletId: string }).agentletId;
+      const agentletId = (driverSpec as { agentletId: string }).agentletId;
+      return resolveConnectedAgentletId(agentletId) ?? agentletId;
     }
   }
   return undefined;
diff --git a/apps/server/src/modules/agent/agent-defaults.route.test.ts b/apps/server/src/modules/agent/agent-defaults.route.test.ts
index 7a98899d1..7832a8512 100644
--- a/apps/server/src/modules/agent/agent-defaults.route.test.ts
+++ b/apps/server/src/modules/agent/agent-defaults.route.test.ts
@@ -26,7 +26,8 @@ vi.mock('./agent-defaults.js', () => ({
 vi.mock('@agenetes/agentlet-host', () => ({
   getAgentProfileRegistry: () =>
     mocks.registryReady ? { getProfile: mocks.getProfile } : null,
-  getAgentletGateway: () => ({ getAgentlet: mocks.getAgentlet }),
+  resolveConnectedAgentletId: (target: string) =>
+    mocks.getAgentlet(target)?.status === 'connected' ? target : undefined,
 }));
 vi.mock('./acp/profile-schema-cache.js', () => ({
   getProfileSchemaCache: mocks.getCache,
diff --git a/apps/server/src/modules/agent/agent-defaults.route.ts b/apps/server/src/modules/agent/agent-defaults.route.ts
index 49d537e35..9412298bd 100644
--- a/apps/server/src/modules/agent/agent-defaults.route.ts
+++ b/apps/server/src/modules/agent/agent-defaults.route.ts
@@ -3,7 +3,7 @@
 
 import {
   getAgentProfileRegistry,
-  getAgentletGateway,
+  resolveConnectedAgentletId,
 } from '@agenetes/agentlet-host';
 
 import {
@@ -60,8 +60,7 @@ function projectDefaults(defaults: AgentDefaults): AgentDefaultsResponse {
           ? 'offline'
           : !profile
             ? 'deleted'
-            : getAgentletGateway()?.getAgentlet(profile.agentletId)?.status ===
-                'connected'
+            : resolveConnectedAgentletId(profile.agentletId)
               ? 'available'
               : 'offline',
     // Missing observations and editable CLI labels do not prove lack of support.
diff --git a/apps/server/src/modules/agent/agent-defaults.test.ts b/apps/server/src/modules/agent/agent-defaults.test.ts
index f900a4d99..0610c7cda 100644
--- a/apps/server/src/modules/agent/agent-defaults.test.ts
+++ b/apps/server/src/modules/agent/agent-defaults.test.ts
@@ -12,11 +12,8 @@ import {
 import type { AgentDefaults, AgentProfileView } from '@huabu/shared';
 
 vi.mock('@agenetes/agentlet-host', () => ({
-  getAgentletGateway: () => ({
-    getAgentlet: (id: string) => ({
-      status: id === 'connected' ? 'connected' : 'disconnected',
-    }),
-  }),
+  resolveConnectedAgentletId: (id: string) =>
+    id === 'connected' || id === 'legacy-host' ? 'connected' : undefined,
 }));
 
 function profile(
@@ -59,6 +56,19 @@ describe('installation Agent defaults', () => {
     }
   });
 
+  it('offers a uniquely resolved hostname-era candidate to initialization', () => {
+    const initialize = vi
+      .spyOn(AgentDefaultsService.prototype, 'initializeAgentDefaults')
+      .mockReturnValue({ profileId: null, functionalModel: '' });
+    try {
+      const legacy = profile('legacy', 'legacy-host');
+      initializeAgentDefaults([legacy]);
+      expect(initialize).toHaveBeenCalledWith([legacy]);
+    } finally {
+      initialize.mockRestore();
+    }
+  });
+
   it('requires an explicit external default instead of falling back to Huabu', () => {
     const { service, storage } = setup();
     expect(() => service.requireDefaultAgentProfileId()).toThrow(
diff --git a/apps/server/src/modules/agent/agent-defaults.ts b/apps/server/src/modules/agent/agent-defaults.ts
index 3d5c3af62..0accc5686 100644
--- a/apps/server/src/modules/agent/agent-defaults.ts
+++ b/apps/server/src/modules/agent/agent-defaults.ts
@@ -4,7 +4,7 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 
-import { getAgentletGateway } from '@agenetes/agentlet-host';
+import { resolveConnectedAgentletId } from '@agenetes/agentlet-host';
 
 import { agentDefaultsSchema } from '@huabu/shared';
 
@@ -134,9 +134,7 @@ export const initializeAgentDefaults = (
   profiles: readonly AgentProfileView[],
 ): AgentDefaults =>
   service.initializeAgentDefaults(
-    profiles.filter(
-      (profile) =>
-        getAgentletGateway()?.getAgentlet(profile.agentletId)?.status ===
-        'connected',
+    profiles.filter((profile) =>
+      resolveConnectedAgentletId(profile.agentletId),
     ),
   );
diff --git a/apps/server/src/modules/agent/agentlet-device-display.test.ts b/apps/server/src/modules/agent/agentlet-device-display.test.ts
new file mode 100644
index 000000000..a1ed05980
--- /dev/null
+++ b/apps/server/src/modules/agent/agentlet-device-display.test.ts
@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import { describe, expect, it } from 'vitest';
+
+import { formatAgentletDeviceDisplayName } from './agentlet-device-display.js';
+
+describe('formatAgentletDeviceDisplayName', () => {
+  it('combines hostname and environment without exposing device identity', () => {
+    expect(
+      formatAgentletDeviceDisplayName({
+        hostname: 'huabu',
+        platform: 'linux',
+        arch: 'x64',
+      }),
+    ).toBe('huabu: linux x64');
+  });
+
+  it('omits missing metadata and retains a non-identity fallback', () => {
+    expect(formatAgentletDeviceDisplayName({ hostname: 'huabu' })).toBe(
+      'huabu',
+    );
+    expect(
+      formatAgentletDeviceDisplayName({ platform: 'linux', arch: 'arm64' }),
+    ).toBe('Agentlet: linux arm64');
+    expect(formatAgentletDeviceDisplayName()).toBe('Agentlet');
+  });
+});
diff --git a/apps/server/src/modules/agent/agentlet-device-display.ts b/apps/server/src/modules/agent/agentlet-device-display.ts
new file mode 100644
index 000000000..e67aa270a
--- /dev/null
+++ b/apps/server/src/modules/agent/agentlet-device-display.ts
@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+interface AgentletMachineDisplayMetadata {
+  hostname?: string;
+  platform?: string;
+  arch?: string;
+}
+
+export function formatAgentletDeviceDisplayName(
+  machine?: AgentletMachineDisplayMetadata,
+): string {
+  const hostname = machine?.hostname?.trim() || 'Agentlet';
+  const environment = [machine?.platform, machine?.arch]
+    .map((value) => value?.trim())
+    .filter(Boolean)
+    .join(' ');
+  return environment ? `${hostname}: ${environment}` : hostname;
+}
diff --git a/apps/server/src/modules/agent/selectable-agent-profile.test.ts b/apps/server/src/modules/agent/selectable-agent-profile.test.ts
index 0f649404f..0ce944a7c 100644
--- a/apps/server/src/modules/agent/selectable-agent-profile.test.ts
+++ b/apps/server/src/modules/agent/selectable-agent-profile.test.ts
@@ -14,9 +14,13 @@ vi.mock('@agenetes/agentlet-host', () => ({
       host.profiles.find((profile) => profile.id === profileId),
     listProfiles: () => host.profiles,
   }),
-  getAgentletGateway: () => ({
-    getAgentlets: () => host.connectedIds.map((agentletId) => ({ agentletId })),
-  }),
+  resolveConnectedAgentletId: (target: string) => {
+    if (host.connectedIds.includes(target)) return target;
+    const matches = host.connectedIds.filter(
+      (agentletId) => `${agentletId}-host` === target,
+    );
+    return matches.length === 1 ? matches[0] : undefined;
+  },
 }));
 
 import {
@@ -75,6 +79,18 @@ describe('listAvailableAgentProfiles', () => {
     ]);
   });
 
+  it('projects a hostname-era Profile when exactly one device reports that hostname', () => {
+    host.profiles = [
+      { id: 'legacy', alias: 'Legacy', agentletId: 'device-a-host' },
+    ];
+    host.connectedIds = ['device-a'];
+
+    expect(listAvailableAgentProfiles()).toEqual([
+      { id: 'huabu', alias: 'Built-In Pi' },
+      { id: 'legacy', alias: 'Legacy', default: true },
+    ]);
+  });
+
   it('accepts the Huabu Profile without an external registry', () => {
     expect(() => requireAvailableAgentProfile('huabu', null)).not.toThrow();
   });
diff --git a/apps/server/src/modules/agent/selectable-agent-profile.ts b/apps/server/src/modules/agent/selectable-agent-profile.ts
index 8b69df24e..a67e1d315 100644
--- a/apps/server/src/modules/agent/selectable-agent-profile.ts
+++ b/apps/server/src/modules/agent/selectable-agent-profile.ts
@@ -3,7 +3,7 @@
 
 import {
   getAgentProfileRegistry,
-  getAgentletGateway,
+  resolveConnectedAgentletId,
 } from '@agenetes/agentlet-host';
 
 import { HUABU_AGENT_PROFILE_ID } from '@huabu/shared';
@@ -26,17 +26,11 @@ function getConnectedProfileRegistry(): AgentProfileRegistryPort | null {
   if (!registry) return null;
   return {
     getProfile: (profileId) => registry.getProfile(profileId),
-    listSelectableProfileIds: () => {
-      const connectedIds = new Set(
-        (getAgentletGateway()?.getAgentlets({ status: 'connected' }) ?? []).map(
-          (connection) => connection.agentletId,
-        ),
-      );
-      return registry
+    listSelectableProfileIds: () =>
+      registry
         .listProfiles()
-        .filter((profile) => connectedIds.has(profile.agentletId))
-        .map((profile) => profile.id);
-    },
+        .filter((profile) => resolveConnectedAgentletId(profile.agentletId))
+        .map((profile) => profile.id),
   };
 }
 
diff --git a/apps/web/src/components/Settings/agent-profiles/AgentProfileEditor.test.tsx b/apps/web/src/components/Settings/agent-profiles/AgentProfileEditor.test.tsx
index fc388e428..9df45744c 100644
--- a/apps/web/src/components/Settings/agent-profiles/AgentProfileEditor.test.tsx
+++ b/apps/web/src/components/Settings/agent-profiles/AgentProfileEditor.test.tsx
@@ -13,6 +13,7 @@ import type {
   AcpAgentCliInfo,
   AcpProfileLaunchPreviewResponse,
   AgentProfileView,
+  ConnectedAgentletDevice,
 } from '@huabu/shared';
 
 declare global {
@@ -65,7 +66,12 @@ vi.mock('@/components/Common/Select', () => ({
     ariaLabel,
   }: {
     value: string;
-    options: { value: string; label: string; disabled?: boolean }[];
+    options: {
+      value: string;
+      label: string;
+      description?: string;
+      disabled?: boolean;
+    }[];
     onChange: (value: string) => void;
     ariaLabel?: string;
   }) => (
@@ -82,6 +88,7 @@ vi.mock('@/components/Common/Select', () => ({
           disabled={option.disabled}
         >
           {option.label}
+          {option.description ? ` (${option.description})` : ''}
         </option>
       ))}
     </select>
@@ -148,6 +155,18 @@ function renderEditor(
   editing?: AgentProfileView,
   clis = agents,
   loaded = true,
+  connectedDevices: ConnectedAgentletDevice[] = [
+    {
+      agentletId: editing?.agentletId ?? 'device-1',
+      displayName: 'Test device: linux x64',
+      hostname: 'Test device',
+      platform: 'linux',
+      arch: 'x64',
+      version: '1.0.0',
+      connectedAt: '2026-01-01T00:00:00.000Z',
+      profileCount: 0,
+    },
+  ],
 ) {
   if (!container) {
     container = document.createElement('div');
@@ -162,17 +181,7 @@ function renderEditor(
           : ({ mode: 'create' } as const))}
         detectedClis={clis}
         detectionLoaded={loaded}
-        connectedDevices={[
-          {
-            agentletId: editing?.agentletId ?? 'device-1',
-            hostname: 'Test device',
-            platform: 'linux',
-            arch: 'x64',
-            version: '1.0.0',
-            connectedAt: '2026-01-01T00:00:00.000Z',
-            profileCount: 0,
-          },
-        ]}
+        connectedDevices={connectedDevices}
         agentletId={editing?.agentletId ?? 'device-1'}
         onAgentletChange={vi.fn()}
         onClose={onClose}
@@ -256,9 +265,40 @@ describe('AgentProfileEditor', () => {
       alias: 'Renamed',
       customData: legacy.customData,
     });
+
     expect(api.preview).not.toHaveBeenCalled();
   });
 
+  it('renders human-readable device labels while retaining UUID identity details', () => {
+    renderEditor();
+    const machine = container?.querySelector<HTMLSelectElement>(
+      'select[aria-label="settings.profileMachine"]',
+    );
+    expect(machine?.selectedOptions[0]?.textContent).toContain(
+      'Test device: linux x64',
+    );
+    expect(machine?.selectedOptions[0]?.textContent).toContain('device-1');
+  });
+
+  it('maps a hostname-era Profile to the unique connected device label', () => {
+    renderEditor({ ...legacy, agentletId: 'legacy-host' }, agents, true, [
+      {
+        agentletId: 'device-uuid',
+        displayName: 'legacy-host: linux x64',
+        hostname: 'legacy-host',
+        platform: 'linux',
+        arch: 'x64',
+        version: '1.0.0',
+        connectedAt: '2026-01-01T00:00:00.000Z',
+        profileCount: 1,
+      },
+    ]);
+
+    expect(container?.textContent).toContain(
+      'legacy-host: linux x64 (device-uuid)',
+    );
+  });
+
   it('edits custom command and cwd without changing wrapper, machine, metadata, or custom data', async () => {
     renderEditor({ ...legacy, revision: 9 });
     input('settings.launchCommand', 'new-agent --custom');
diff --git a/apps/web/src/components/Settings/agent-profiles/CommandProfileForm.tsx b/apps/web/src/components/Settings/agent-profiles/CommandProfileForm.tsx
index 752e2d8f2..107be07be 100644
--- a/apps/web/src/components/Settings/agent-profiles/CommandProfileForm.tsx
+++ b/apps/web/src/components/Settings/agent-profiles/CommandProfileForm.tsx
@@ -75,6 +75,18 @@ function displayNameFor(agent: string, cwd: string) {
   return folder ? `${agent} (${folder})` : agent;
 }
 
+function resolveConnectedDevice(
+  target: string,
+  devices: ConnectedAgentletDevice[],
+): ConnectedAgentletDevice | undefined {
+  const exact = devices.find((device) => device.agentletId === target);
+  if (exact) return exact;
+  const hostnameMatches = devices.filter(
+    (device) => device.hostname === target,
+  );
+  return hostnameMatches.length === 1 ? hostnameMatches[0] : undefined;
+}
+
 /** One capability-driven form for both structured and raw-command Profiles. */
 export function CommandProfileForm({
   editing,
@@ -200,6 +212,12 @@ export function CommandProfileForm({
       })),
     { value: 'custom', label: t('settings.customCommand') },
   ];
+  const editingDevice = editing
+    ? resolveConnectedDevice(editing.agentletId, connectedDevices)
+    : undefined;
+  const editingDeviceLabel = editingDevice
+    ? `${editingDevice.displayName} (${editingDevice.agentletId})`
+    : `${t('settings.agentUnavailable')} (${editing?.agentletId ?? ''})`;
 
   async function save() {
     if (saveDisabled) return;
@@ -248,14 +266,14 @@ export function CommandProfileForm({
       <SettingRow title={t('settings.profileMachine')}>
         <SettingControl>
           {editing ? (
-            <ReadOnlyField value={editing.agentletId} mono />
+            <ReadOnlyField value={editingDeviceLabel} />
           ) : (
             <Select
               value={agentletId}
               onChange={onAgentletChange}
               options={connectedDevices.map((device) => ({
                 value: device.agentletId,
-                label: device.hostname ?? device.agentletId,
+                label: device.displayName,
                 description: device.agentletId,
               }))}
               placeholder={t('settings.noConnectedDevices')}
diff --git a/apps/web/src/components/Settings/agent-profiles/ExternalAgentsSettings.test.tsx b/apps/web/src/components/Settings/agent-profiles/ExternalAgentsSettings.test.tsx
index 4a63c9ef1..24b9d1811 100644
--- a/apps/web/src/components/Settings/agent-profiles/ExternalAgentsSettings.test.tsx
+++ b/apps/web/src/components/Settings/agent-profiles/ExternalAgentsSettings.test.tsx
@@ -144,6 +144,7 @@ beforeEach(() => {
     connectedDevices: [
       {
         agentletId: 'local',
+        displayName: 'Local machine: linux x64',
         hostname: 'Local machine',
         platform: 'linux',
         arch: 'x64',
@@ -177,6 +178,7 @@ beforeEach(() => {
 });
 
 afterEach(() => {
+  vi.useRealTimers();
   act(() => root?.unmount());
   container?.remove();
   root = undefined;
@@ -186,9 +188,37 @@ afterEach(() => {
 });
 
 describe('ExternalAgentsSettings', () => {
+  it('refreshes Agent settings every five seconds only while visible and mounted', async () => {
+    vi.useFakeTimers();
+    let visibility: DocumentVisibilityState = 'visible';
+    vi.spyOn(document, 'visibilityState', 'get').mockImplementation(
+      () => visibility,
+    );
+    await renderSettings();
+    expect(apiMocks.list).toHaveBeenCalledOnce();
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(5_000);
+    });
+    expect(apiMocks.list).toHaveBeenCalledTimes(2);
+
+    visibility = 'hidden';
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(5_000);
+    });
+    expect(apiMocks.list).toHaveBeenCalledTimes(2);
+
+    act(() => root?.unmount());
+    root = undefined;
+    visibility = 'visible';
+    await vi.advanceTimersByTimeAsync(5_000);
+    expect(apiMocks.list).toHaveBeenCalledTimes(2);
+  });
+
   it('refreshes the singleton on every mount and lists all Profiles, including unavailable ones', async () => {
     await renderSettings();
     expect(container?.textContent).toContain('Reviewer');
+    expect(container?.textContent).toContain('Local machine: linux x64');
     expect(useAcpProfilesStore.getState().profiles).toEqual([profile]);
     profiles = [
       profile,
diff --git a/apps/web/src/components/Settings/agent-profiles/ExternalAgentsSettings.tsx b/apps/web/src/components/Settings/agent-profiles/ExternalAgentsSettings.tsx
index 3ff6d1f34..94504ca01 100644
--- a/apps/web/src/components/Settings/agent-profiles/ExternalAgentsSettings.tsx
+++ b/apps/web/src/components/Settings/agent-profiles/ExternalAgentsSettings.tsx
@@ -33,6 +33,8 @@ type EditorState =
   | { kind: 'create'; agentletId: string }
   | { kind: 'edit-command'; profile: AgentProfileView };
 
+const PROFILE_REFRESH_INTERVAL_MS = 5_000;
+
 interface PendingDelete {
   id: string;
   alias: string;
@@ -82,6 +84,15 @@ export function ExternalAgentsSettings({
     void refresh();
   }, [init, refresh]);
 
+  useEffect(() => {
+    const timer = window.setInterval(() => {
+      if (document.visibilityState === 'visible') {
+        void refresh({ background: true });
+      }
+    }, PROFILE_REFRESH_INTERVAL_MS);
+    return () => window.clearInterval(timer);
+  }, [refresh]);
+
   useEffect(() => {
     if (error) toast(error.message, { tone: 'danger' });
   }, [error]);
@@ -332,9 +343,8 @@ export function ExternalAgentsSettings({
                 connectedDevices.map((device) => (
                   <SettingRow
                     key={device.agentletId}
-                    title={device.hostname ?? device.agentletId}
+                    title={device.displayName}
                     description={[
-                      [device.platform, device.arch].filter(Boolean).join(' '),
                       t('settings.deviceProfileCount', {
                         count: device.profileCount,
                       }),
diff --git a/apps/web/src/store/acpProfilesStore.ts b/apps/web/src/store/acpProfilesStore.ts
index 694e16c27..06f12bbf6 100644
--- a/apps/web/src/store/acpProfilesStore.ts
+++ b/apps/web/src/store/acpProfilesStore.ts
@@ -118,7 +118,7 @@ interface AcpProfilesState {
   /** Idempotent first-load helper called by the hook on mount. */
   init: () => Promise<void>;
   /** Force a fresh GET. Safe to call concurrently. */
-  refresh: () => Promise<void>;
+  refresh: (options?: { background?: boolean }) => Promise<void>;
   loadDefaults: () => Promise<AgentDefaultsResponse>;
   saveDefaults: (config: AgentDefaults) => Promise<AgentDefaultsResponse>;
   rememberConversationAgent: (profileId: string) => void;
@@ -225,12 +225,13 @@ export const useAcpProfilesStore = create<AcpProfilesState>()((set, get) => ({
     writeRecentConversationProfileId(profileId);
     set({ recentConversationProfileId: profileId });
   },
-  refresh: async () => {
+  refresh: async (options) => {
     await defaultsSaveQueue;
     if (inFlightRefresh) return inFlightRefresh;
+    const background = options?.background === true;
     const revision = defaultsRevision;
     const request = (async () => {
-      set({ loading: true });
+      if (!background) set({ loading: true });
       try {
         const res = await listAcpProfiles();
         set({
@@ -248,10 +249,14 @@ export const useAcpProfilesStore = create<AcpProfilesState>()((set, get) => ({
       } catch (err) {
         // Leave the previous snapshot in place so transient errors
         // don't make the picker flicker between "available" and empty.
-        set({
-          error: err instanceof Error ? err : new Error(String(err)),
-          loading: false,
-        });
+        set(
+          background
+            ? { loading: false }
+            : {
+                error: err instanceof Error ? err : new Error(String(err)),
+                loading: false,
+              },
+        );
       }
     })();
     inFlightRefresh = request;
diff --git a/docs/architecture/agent-profiles.md b/docs/architecture/agent-profiles.md
index 04c7fd28f..48f379639 100644
--- a/docs/architecture/agent-profiles.md
+++ b/docs/architecture/agent-profiles.md
@@ -25,8 +25,14 @@ Huabu subscribes to machine connection events, includes machines already connect
 
 The Agentlet CLI owns its default device identity. On first start it atomically creates `~/.agentlet/device.json` containing `{ "version": 1, "deviceId": "<uuid>" }`; later starts reuse that UUID, so identity survives daemon, Huabu, OS-session, binary, upgrade, and worktree restarts while the home directory remains. A malformed or unreadable identity file fails explicitly instead of rotating identity. `--agentlet-id` remains an advanced exact override and does not rewrite the persisted UUID. Hello metadata reports the real hostname, platform, and architecture separately for display; none of those fields participates in identity. Windows and WSL naturally receive distinct identities because they use separate home directories.
 
+Hostname-era Profiles and frozen workload records remain compatible without rewriting persisted data. Live placement resolution first requires an exact connected `agentletId`; when none exists, it treats the stored target as a legacy hostname and accepts it only when exactly one connected Agentlet reports that hostname. The resolved UUID is used for availability, device projections, Profile operations, and ACP session routing. Zero or multiple hostname matches remain unavailable, so Windows/WSL collisions never route to an arbitrary device.
+
 Multiple Agentlets may share one Huabu connection token and connect concurrently. If an identity is already online, Gateway rejects the second live connection with guidance to retry using `--agentlet-id <unique-id>` instead of evicting the first device; once the prior connection is disconnected, the same identity follows the normal reconnect path. The embedded supervisor is special only as process-lifecycle infrastructure: it resolves, starts, restarts, stops, and diagnoses its child, but it neither assigns that Agentlet's identity nor acts as a placement default.
 
+Device-facing UI uses one human-readable `hostname: platform arch` display name, such as `huabu: linux x64`. UUID-backed `agentletId` remains a secondary identity detail for disambiguation and routing; it is not part of automatic Profile aliases or the primary device label. New automatic aliases include the device display name, while existing and user-customized aliases are never rewritten.
+
+Gateway sends a WebSocket heartbeat every 15 seconds and terminates connections that do not answer before the next heartbeat. While Agent Settings is mounted and the browser page is visible, its Profile and connected-device snapshot refreshes every 5 seconds; this refresh is scoped to Agent settings and does not reload Space or Workspace data. Disconnected connection records remain available for reconnect but are excluded from connected-device and selectable-Profile projections.
+
 ## Profile identity and customization
 
 A Profile has `id`, `alias`, `agentletId`, `workingDirPath`, a launch configuration, optional `metadata.cliId`, opaque `customData`, and configuration/execution revisions. Launch is either `{ kind: 'acp-command', command }` or a structured `{ kind: 'acp-harness', harnessId, options?: { autoApprove? } }`. Every Profile has exactly one wrapper, derived from this launch union: a command Profile uses the Custom command wrapper; a structured Profile uses its `harnessId`. Neither editable metadata nor command-text inspection determines capabilities. Profile ID, target machine, launch kind, and harness identity are immutable; alias, icon, cwd, and supported launch options are editable. Changing machine or wrapper requires a new Profile.
diff --git a/external/agenetes/packages/acp-driver/src/handle.ts b/external/agenetes/packages/acp-driver/src/handle.ts
index 986fd35fd..78a21e7f9 100644
--- a/external/agenetes/packages/acp-driver/src/handle.ts
+++ b/external/agenetes/packages/acp-driver/src/handle.ts
@@ -33,6 +33,7 @@
 
 import { randomUUID } from 'node:crypto';
 
+import { resolveConnectedAgentletId } from '@agenetes/agentlet-host';
 import { resolveAgentInputs } from '@agenetes/protocol';
 import {
   HistoryLoadDeniedError,
@@ -328,15 +329,25 @@ export class AcpAgentHandle<
       getIdleTimeoutSecs: () => 600,
     },
   ) {
-    this.agentletId = resolveAcpAgentletId(spec);
+    this.requestedAgentletId = resolveAcpAgentletId(spec);
+    this.agentletId =
+      resolveConnectedAgentletId(this.requestedAgentletId) ??
+      this.requestedAgentletId;
     // Jobs may share a durable thread or have none. Their live sessions must not.
     this.sessionThreadId =
       spec.workloadType === 'Job' ? `acp-job-${randomUUID()}` : spec.threadId;
   }
 
-  private readonly agentletId: string;
+  private readonly requestedAgentletId: string;
+  private agentletId: string;
   private readonly sessionThreadId: string;
 
+  private resolveAgentletId(): string {
+    this.agentletId =
+      resolveConnectedAgentletId(this.requestedAgentletId) ?? this.agentletId;
+    return this.agentletId;
+  }
+
   private async authorizeHistoryLoad(
     mode: 'recover' | 'fork',
     turns: readonly AgentTurn[],
@@ -425,8 +436,9 @@ export class AcpAgentHandle<
       this.spec.spec,
       this.runtimePolicy,
     );
+    const agentletId = this.resolveAgentletId();
     return ensureAcpSession({
-      agentletId: this.agentletId,
+      agentletId,
       threadId: this.sessionThreadId,
       workloadType: this.spec.workloadType,
       binding: this.spec.spec.binding,
diff --git a/external/agenetes/packages/acp-driver/src/placement.test.ts b/external/agenetes/packages/acp-driver/src/placement.test.ts
index 9b08f2aca..974d6df16 100644
--- a/external/agenetes/packages/acp-driver/src/placement.test.ts
+++ b/external/agenetes/packages/acp-driver/src/placement.test.ts
@@ -10,6 +10,28 @@ vi.mock('@agenetes/agentlet-host', async (importOriginal) => {
   return {
     ...actual,
     getAgentletGateway: () => host.gateway,
+    resolveConnectedAgentletId: (target: string) => {
+      const gateway = host.gateway as
+        | {
+            getAgentlet?: (
+              agentletId: string,
+            ) => { agentletId?: string; status?: string } | undefined;
+            getAgentlets?: () => Array<{
+              agentletId: string;
+              status: string;
+              agentletProfile?: { machine?: { hostname?: string } };
+            }>;
+          }
+        | undefined;
+      const exact = gateway?.getAgentlet?.(target);
+      if (exact?.status === 'connected') return exact.agentletId ?? target;
+      const matches = (gateway?.getAgentlets?.() ?? []).filter(
+        (connection) =>
+          connection.status === 'connected' &&
+          connection.agentletProfile?.machine?.hostname === target,
+      );
+      return matches.length === 1 ? matches[0]?.agentletId : undefined;
+    },
   };
 });
 
@@ -37,6 +59,40 @@ afterEach(() => {
 });
 
 describe('explicit ACP placement', () => {
+  it('routes a hostname-era workload to its unique connected device identity', async () => {
+    const sessions = new Map<string, { status: 'connected' }>();
+    const spawnOnAgentlet = vi.fn(
+      async (agentletId: string, params: { appId: string }) => {
+        const sessionId = `${agentletId}-${params.appId}`;
+        sessions.set(JSON.stringify([agentletId, sessionId]), {
+          status: 'connected',
+        });
+        return { sessionId, pid: 101 };
+      },
+    );
+    host.gateway = {
+      getAgentlet: () => undefined,
+      getAgentlets: () => [
+        {
+          agentletId: 'device-uuid',
+          status: 'connected',
+          agentletProfile: { machine: { hostname: 'legacy-host' } },
+        },
+      ],
+      getSession: (agentletId: string, sessionId: string) =>
+        sessions.get(JSON.stringify([agentletId, sessionId])),
+      spawnOnAgentlet,
+    };
+
+    await expect(
+      ensureAgentForThread('legacy-host', 'legacy-thread', recipe),
+    ).resolves.toMatchObject({ agentletId: 'device-uuid' });
+    expect(spawnOnAgentlet).toHaveBeenCalledWith(
+      'device-uuid',
+      expect.any(Object),
+    );
+  });
+
   it('forwards a persisted structured plan and retains it when reusing the live process', async () => {
     const launch = {
       kind: 'acp-harness' as const,
diff --git a/external/agenetes/packages/acp-driver/src/session-self-repair.test.ts b/external/agenetes/packages/acp-driver/src/session-self-repair.test.ts
index 6a47ec5c7..eadb42ec0 100644
--- a/external/agenetes/packages/acp-driver/src/session-self-repair.test.ts
+++ b/external/agenetes/packages/acp-driver/src/session-self-repair.test.ts
@@ -21,6 +21,7 @@ const clients = vi.hoisted(() => ({
 
 vi.mock('@agenetes/agentlet-host', () => ({
   getAgentletGateway: () => host.gateway,
+  resolveConnectedAgentletId: (agentletId: string) => agentletId,
 }));
 
 vi.mock('./spawn-orchestrator.js', () => orchestrator);
diff --git a/external/agenetes/packages/acp-driver/src/spawn-orchestrator.ts b/external/agenetes/packages/acp-driver/src/spawn-orchestrator.ts
index 6571149ba..b29a32123 100644
--- a/external/agenetes/packages/acp-driver/src/spawn-orchestrator.ts
+++ b/external/agenetes/packages/acp-driver/src/spawn-orchestrator.ts
@@ -40,6 +40,7 @@
 import {
   AgentletRequestError,
   getAgentletGateway,
+  resolveConnectedAgentletId,
 } from '@agenetes/agentlet-host';
 import {
   harnessLaunchPlanSchema,
@@ -96,10 +97,8 @@ function agentletThreadKey(agentletId: string, threadId: string): string {
 
 /** Resolve one explicitly targeted execution node. */
 function readTargetAgentlet(agentletId: string): { agentletId: string } | null {
-  const gateway = getAgentletGateway();
-  if (!gateway) return null;
-  const agentlet = gateway.getAgentlet(agentletId);
-  return agentlet?.status === 'connected' ? { agentletId } : null;
+  const resolved = resolveConnectedAgentletId(agentletId);
+  return resolved ? { agentletId: resolved } : null;
 }
 
 /**
@@ -205,7 +204,7 @@ export async function ensureAgentForThread(
     );
   }
 
-  const cacheKey = agentletThreadKey(agentletId, threadId);
+  const cacheKey = agentletThreadKey(agentlet.agentletId, threadId);
   const cached = threadToAgent.get(cacheKey);
   if (cached) {
     const gateway = getAgentletGateway();
diff --git a/external/agenetes/packages/agentlet-gateway/src/gateway.test.ts b/external/agenetes/packages/agentlet-gateway/src/gateway.test.ts
index ac4ec9847..bd4bb90bd 100644
--- a/external/agenetes/packages/agentlet-gateway/src/gateway.test.ts
+++ b/external/agenetes/packages/agentlet-gateway/src/gateway.test.ts
@@ -739,6 +739,44 @@ describe('AgentletGateway', () => {
     expect(changed).toHaveBeenCalledTimes(4);
   });
 
+  it('disconnects an Agentlet that stops answering heartbeats', async () => {
+    const { gateway, url } = await startHarness({ heartbeatInterval: 20 });
+    const changed = vi.fn();
+    gateway.onAgentletsChanged(changed);
+    const client = await connect(url, {
+      role: 'agentlet',
+      queryId: 'machine-a',
+      token: 'token-a',
+      hello: agentletHello('machine-a'),
+    });
+
+    client.socket.pause();
+    await waitUntil(
+      () => gateway.getAgentlet('machine-a')?.status === 'disconnected',
+    );
+    client.socket.resume();
+
+    expect(changed).toHaveBeenLastCalledWith({
+      agentletId: 'machine-a',
+      status: 'disconnected',
+    });
+    expect(gateway.getAgentlets({ status: 'connected' })).toEqual([]);
+  });
+
+  it('keeps an Agentlet connected while it answers heartbeats', async () => {
+    const { gateway, url } = await startHarness({ heartbeatInterval: 20 });
+    await connect(url, {
+      role: 'agentlet',
+      queryId: 'machine-a',
+      token: 'token-a',
+      hello: agentletHello('machine-a'),
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 80));
+
+    expect(gateway.getAgentlet('machine-a')?.status).toBe('connected');
+  });
+
   it('fails discovery for disconnected and unsupported targets without fallback', async () => {
     const { gateway, url } = await startHarness();
     await expect(
@@ -976,5 +1014,12 @@ describe('AgentletGateway', () => {
           inboundPreAttachBufferLimit: 0,
         }),
     ).toThrow('inboundPreAttachBufferLimit must be a positive integer');
+    expect(
+      () =>
+        new AgentletGateway({
+          authenticateAgentlet: () => ({}),
+          heartbeatInterval: 0,
+        }),
+    ).toThrow('heartbeatInterval must be a positive integer');
   });
 });
diff --git a/external/agenetes/packages/agentlet-gateway/src/gateway.ts b/external/agenetes/packages/agentlet-gateway/src/gateway.ts
index 181d5f6d3..7df5ef10a 100644
--- a/external/agenetes/packages/agentlet-gateway/src/gateway.ts
+++ b/external/agenetes/packages/agentlet-gateway/src/gateway.ts
@@ -42,6 +42,7 @@ import type { Duplex } from 'node:stream';
 const DEFAULT_HANDSHAKE_TIMEOUT_MS = 10_000;
 const DEFAULT_CONTROL_REQUEST_TIMEOUT_MS = 60_000;
 const DEFAULT_SPAWN_REQUEST_TIMEOUT_MS = 240_000;
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 15_000;
 const DEFAULT_OUTBOUND_BUFFER_LIMIT = 100;
 const DEFAULT_INBOUND_PRE_ATTACH_BUFFER_LIMIT = 1_000;
 
@@ -82,6 +83,9 @@ export class AgentletGateway {
   private readonly handshakeTimeout: number;
   private readonly controlRequestTimeout: number;
   private readonly spawnRequestTimeout: number;
+  private readonly heartbeatInterval: number;
+  private readonly heartbeatTimer: NodeJS.Timeout;
+  private readonly heartbeatAlive = new WeakMap<WebSocket, boolean>();
   private readonly outboundBufferLimit: number;
   private readonly inboundPreAttachBufferLimit: number;
   private readonly logger: AgentletGatewayLogger;
@@ -96,17 +100,25 @@ export class AgentletGateway {
       options.controlRequestTimeout ?? DEFAULT_CONTROL_REQUEST_TIMEOUT_MS;
     this.spawnRequestTimeout =
       options.spawnRequestTimeout ?? DEFAULT_SPAWN_REQUEST_TIMEOUT_MS;
+    this.heartbeatInterval =
+      options.heartbeatInterval ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
     this.outboundBufferLimit =
       options.outboundBufferLimit ?? DEFAULT_OUTBOUND_BUFFER_LIMIT;
     this.inboundPreAttachBufferLimit =
       options.inboundPreAttachBufferLimit ??
       DEFAULT_INBOUND_PRE_ATTACH_BUFFER_LIMIT;
     this.logger = options.logger ?? noopLogger;
+    this.assertPositiveInteger(this.heartbeatInterval, 'heartbeatInterval');
     this.assertPositiveInteger(this.outboundBufferLimit, 'outboundBufferLimit');
     this.assertPositiveInteger(
       this.inboundPreAttachBufferLimit,
       'inboundPreAttachBufferLimit',
     );
+    this.heartbeatTimer = setInterval(
+      () => this.checkConnectionHeartbeats(),
+      this.heartbeatInterval,
+    );
+    this.heartbeatTimer.unref();
   }
 
   get connectionCount(): number {
@@ -282,6 +294,7 @@ export class AgentletGateway {
   close(): void {
     if (this.closed) return;
     this.closed = true;
+    clearInterval(this.heartbeatTimer);
     for (const connection of this.allConnections()) {
       connection.disconnect('server_shutting_down');
     }
@@ -305,6 +318,8 @@ export class AgentletGateway {
 
   private onWebSocket(ws: WebSocket, request: IncomingMessage): void {
     let handshakeComplete = false;
+    this.heartbeatAlive.set(ws, true);
+    ws.on('pong', () => this.heartbeatAlive.set(ws, true));
     const url = new URL(request.url ?? '', 'http://localhost');
     const token = url.searchParams.get('token') ?? '';
     const queryRole = url.searchParams.get('role');
@@ -396,6 +411,18 @@ export class AgentletGateway {
     });
   }
 
+  private checkConnectionHeartbeats(): void {
+    for (const ws of this.wss.clients) {
+      if (ws.readyState !== WebSocket.OPEN) continue;
+      if (this.heartbeatAlive.get(ws) === false) {
+        ws.terminate();
+        continue;
+      }
+      this.heartbeatAlive.set(ws, false);
+      ws.ping();
+    }
+  }
+
   private async handleAgentletHello(
     ws: WebSocket,
     token: string,
diff --git a/external/agenetes/packages/agentlet-gateway/src/types.ts b/external/agenetes/packages/agentlet-gateway/src/types.ts
index 3634550fc..02d725d00 100644
--- a/external/agenetes/packages/agentlet-gateway/src/types.ts
+++ b/external/agenetes/packages/agentlet-gateway/src/types.ts
@@ -28,6 +28,7 @@ export interface AgentletGatewayOptions {
   handshakeTimeout?: number;
   controlRequestTimeout?: number;
   spawnRequestTimeout?: number;
+  heartbeatInterval?: number;
   outboundBufferLimit?: number;
   inboundPreAttachBufferLimit?: number;
   logger?: AgentletGatewayLogger;
diff --git a/external/agenetes/packages/agentlet-host/src/agentlet-resolution.test.ts b/external/agenetes/packages/agentlet-host/src/agentlet-resolution.test.ts
new file mode 100644
index 000000000..7c29230bb
--- /dev/null
+++ b/external/agenetes/packages/agentlet-host/src/agentlet-resolution.test.ts
@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+
+import { resolveConnectedAgentletIdFromConnections } from './agentlet-resolution.js';
+
+import type { AgentletConnection } from '@agenetes/agentlet-gateway';
+
+function connection(
+  agentletId: string,
+  hostname: string,
+  status: 'connected' | 'disconnected' = 'connected',
+): AgentletConnection {
+  return {
+    agentletId,
+    status,
+    connectedAt: new Date(),
+    agentletProfile: {
+      bridge: { name: 'agentlet', version: '1.0.0' },
+      machine: { hostname, platform: 'linux', arch: 'x64' },
+      capabilities: { autoRestart: true, bufferLimit: 1000 },
+    },
+  } as AgentletConnection;
+}
+
+describe('resolveConnectedAgentletIdFromConnections', () => {
+  it('prefers an exact connected identity over hostname compatibility', () => {
+    expect(
+      resolveConnectedAgentletIdFromConnections('device-a', [
+        connection('device-a', 'other-host'),
+        connection('device-b', 'device-a'),
+      ]),
+    ).toBe('device-a');
+  });
+
+  it('resolves one connected legacy hostname to its current identity', () => {
+    expect(
+      resolveConnectedAgentletIdFromConnections('legacy-host', [
+        connection('device-a', 'legacy-host'),
+      ]),
+    ).toBe('device-a');
+  });
+
+  it('does not resolve absent or ambiguous legacy hostnames', () => {
+    const devices = [
+      connection('device-a', 'shared-host'),
+      connection('device-b', 'shared-host'),
+      connection('device-c', 'offline-host', 'disconnected'),
+    ];
+
+    expect(
+      resolveConnectedAgentletIdFromConnections('missing-host', devices),
+    ).toBeUndefined();
+    expect(
+      resolveConnectedAgentletIdFromConnections('shared-host', devices),
+    ).toBeUndefined();
+    expect(
+      resolveConnectedAgentletIdFromConnections('offline-host', devices),
+    ).toBeUndefined();
+  });
+});
diff --git a/external/agenetes/packages/agentlet-host/src/agentlet-resolution.ts b/external/agenetes/packages/agentlet-host/src/agentlet-resolution.ts
new file mode 100644
index 000000000..4c04041cc
--- /dev/null
+++ b/external/agenetes/packages/agentlet-host/src/agentlet-resolution.ts
@@ -0,0 +1,35 @@
+import { getAgentletGateway } from './gateway-mount.js';
+
+import type { AgentletConnection } from '@agenetes/agentlet-gateway';
+
+type ConnectedAgentlet = Pick<
+  AgentletConnection,
+  'agentletId' | 'agentletProfile' | 'status'
+>;
+
+export function resolveConnectedAgentletIdFromConnections(
+  target: string,
+  connections: readonly ConnectedAgentlet[],
+): string | undefined {
+  const connected = connections.filter(
+    (connection) => connection.status === 'connected',
+  );
+  const exact = connected.find(
+    (connection) => connection.agentletId === target,
+  );
+  if (exact) return exact.agentletId;
+
+  const hostnameMatches = connected.filter(
+    (connection) => connection.agentletProfile?.machine?.hostname === target,
+  );
+  return hostnameMatches.length === 1
+    ? hostnameMatches[0]?.agentletId
+    : undefined;
+}
+
+export function resolveConnectedAgentletId(target: string): string | undefined {
+  return resolveConnectedAgentletIdFromConnections(
+    target,
+    getAgentletGateway()?.getAgentlets({ status: 'connected' }) ?? [],
+  );
+}
diff --git a/external/agenetes/packages/agentlet-host/src/index.ts b/external/agenetes/packages/agentlet-host/src/index.ts
index f0a3c4d88..ac27e0371 100644
--- a/external/agenetes/packages/agentlet-host/src/index.ts
+++ b/external/agenetes/packages/agentlet-host/src/index.ts
@@ -29,6 +29,10 @@ import type {
 import type { FastifyInstance } from 'fastify';
 
 export { getAgentProfileRegistry } from './agent-profile-mount.js';
+export {
+  resolveConnectedAgentletId,
+  resolveConnectedAgentletIdFromConnections,
+} from './agentlet-resolution.js';
 export {
   ACP_UPGRADE_PATH,
   getAgentletGateway,
diff --git a/packages/shared/src/types/api/acp.ts b/packages/shared/src/types/api/acp.ts
index 46b6bf1a0..10befbe49 100644
--- a/packages/shared/src/types/api/acp.ts
+++ b/packages/shared/src/types/api/acp.ts
@@ -588,6 +588,7 @@ export type AgentletConnectionCommandResponse = z.infer<
 /** Schema mirror of {@link AcpProfilesListResponse}. */
 export const connectedAgentletDeviceSchema = z.object({
   agentletId: z.string().min(1),
+  displayName: z.string().min(1),
   hostname: z.string().min(1).optional(),
   platform: z.string().min(1).optional(),
   arch: z.string().min(1).optional(),