diff --git a/electron/api/routes/agents.ts b/electron/api/routes/agents.ts
new file mode 100644
index 000000000..0444e2d1e
--- /dev/null
+++ b/electron/api/routes/agents.ts
@@ -0,0 +1,107 @@
+import type { IncomingMessage, ServerResponse } from 'http';
+import {
+  assignChannelToAgent,
+  clearChannelBinding,
+  createAgent,
+  deleteAgentConfig,
+  listAgentsSnapshot,
+  updateAgentName,
+} from '../../utils/agent-config';
+import { deleteChannelConfig } from '../../utils/channel-config';
+import type { HostApiContext } from '../context';
+import { parseJsonBody, sendJson } from '../route-utils';
+
+function scheduleGatewayReload(ctx: HostApiContext, reason: string): void {
+  if (ctx.gatewayManager.getStatus().state !== 'stopped') {
+    ctx.gatewayManager.debouncedReload();
+    return;
+  }
+  void reason;
+}
+
+export async function handleAgentRoutes(
+  req: IncomingMessage,
+  res: ServerResponse,
+  url: URL,
+  ctx: HostApiContext,
+): Promise<boolean> {
+  if (url.pathname === '/api/agents' && req.method === 'GET') {
+    sendJson(res, 200, { success: true, ...(await listAgentsSnapshot()) });
+    return true;
+  }
+
+  if (url.pathname === '/api/agents' && req.method === 'POST') {
+    try {
+      const body = await parseJsonBody<{ name: string }>(req);
+      const snapshot = await createAgent(body.name);
+      scheduleGatewayReload(ctx, 'create-agent');
+      sendJson(res, 200, { success: true, ...snapshot });
+    } catch (error) {
+      sendJson(res, 500, { success: false, error: String(error) });
+    }
+    return true;
+  }
+
+  if (url.pathname.startsWith('/api/agents/') && req.method === 'PUT') {
+    const suffix = url.pathname.slice('/api/agents/'.length);
+    const parts = suffix.split('/').filter(Boolean);
+
+    if (parts.length === 1) {
+      try {
+        const body = await parseJsonBody<{ name: string }>(req);
+        const agentId = decodeURIComponent(parts[0]);
+        const snapshot = await updateAgentName(agentId, body.name);
+        scheduleGatewayReload(ctx, 'update-agent');
+        sendJson(res, 200, { success: true, ...snapshot });
+      } catch (error) {
+        sendJson(res, 500, { success: false, error: String(error) });
+      }
+      return true;
+    }
+
+    if (parts.length === 3 && parts[1] === 'channels') {
+      try {
+        const agentId = decodeURIComponent(parts[0]);
+        const channelType = decodeURIComponent(parts[2]);
+        const snapshot = await assignChannelToAgent(agentId, channelType);
+        scheduleGatewayReload(ctx, 'assign-channel');
+        sendJson(res, 200, { success: true, ...snapshot });
+      } catch (error) {
+        sendJson(res, 500, { success: false, error: String(error) });
+      }
+      return true;
+    }
+  }
+
+  if (url.pathname.startsWith('/api/agents/') && req.method === 'DELETE') {
+    const suffix = url.pathname.slice('/api/agents/'.length);
+    const parts = suffix.split('/').filter(Boolean);
+
+    if (parts.length === 1) {
+      try {
+        const agentId = decodeURIComponent(parts[0]);
+        const snapshot = await deleteAgentConfig(agentId);
+        scheduleGatewayReload(ctx, 'delete-agent');
+        sendJson(res, 200, { success: true, ...snapshot });
+      } catch (error) {
+        sendJson(res, 500, { success: false, error: String(error) });
+      }
+      return true;
+    }
+
+    if (parts.length === 3 && parts[1] === 'channels') {
+      try {
+        const channelType = decodeURIComponent(parts[2]);
+        await deleteChannelConfig(channelType);
+        const snapshot = await clearChannelBinding(channelType);
+        scheduleGatewayReload(ctx, 'remove-agent-channel');
+        sendJson(res, 200, { success: true, ...snapshot });
+      } catch (error) {
+        sendJson(res, 500, { success: false, error: String(error) });
+      }
+      return true;
+    }
+  }
+
+  return false;
+}
diff --git a/electron/api/server.ts b/electron/api/server.ts
index 5fe1f3564..64523d086 100644
--- a/electron/api/server.ts
+++ b/electron/api/server.ts
@@ -6,6 +6,7 @@ import { handleAppRoutes } from './routes/app';
 import { handleGatewayRoutes } from './routes/gateway';
 import { handleSettingsRoutes } from './routes/settings';
 import { handleProviderRoutes } from './routes/providers';
+import { handleAgentRoutes } from './routes/agents';
 import { handleChannelRoutes } from './routes/channels';
 import { handleLogRoutes } from './routes/logs';
 import { handleUsageRoutes } from './routes/usage';
@@ -27,6 +28,7 @@ const routeHandlers: RouteHandler[] = [
   handleGatewayRoutes,
   handleSettingsRoutes,
   handleProviderRoutes,
+  handleAgentRoutes,
   handleChannelRoutes,
   handleSkillRoutes,
   handleFileRoutes,
diff --git a/electron/main/ipc-handlers.ts b/electron/main/ipc-handlers.ts
index 947833497..986e941be 100644
--- a/electron/main/ipc-handlers.ts
+++ b/electron/main/ipc-handlers.ts
@@ -51,6 +51,7 @@ import {
 } from '../services/providers/provider-runtime-sync';
 import { validateApiKeyWithProvider } from '../services/providers/provider-validation';
 import { appUpdater } from './updater';
+import { PORTS } from '../utils/config';
 
 type AppRequest = {
   id?: string;
@@ -141,8 +142,66 @@ export function registerIpcHandlers(
   registerFileHandlers();
 }
 
+type HostApiFetchRequest = {
+  path: string;
+  method?: string;
+  headers?: Record<string, string>;
+  body?: unknown;
+};
+
 function registerHostApiProxyHandlers(): void {
-  // Host API proxy handlers - currently disabled
+  ipcMain.handle('hostapi:fetch', async (_, request: HostApiFetchRequest) => {
+    try {
+      const path = typeof request?.path === 'string' ? request.path : '';
+      if (!path || !path.startsWith('/')) {
+        throw new Error(`Invalid host API path: ${String(request?.path)}`);
+      }
+
+      const method = (request.method || 'GET').toUpperCase();
+      const headers: Record<string, string> = { ...(request.headers || {}) };
+      let body: string | undefined;
+
+      if (request.body !== undefined && request.body !== null) {
+        if (typeof request.body === 'string') {
+          body = request.body;
+        } else {
+          body = JSON.stringify(request.body);
+          if (!headers['Content-Type'] && !headers['content-type']) {
+            headers['Content-Type'] = 'application/json';
+          }
+        }
+      }
+
+      const response = await proxyAwareFetch(`http://127.0.0.1:${PORTS.CLAWX_HOST_API}${path}`, {
+        method,
+        headers,
+        body,
+      });
+
+      const data: { status: number; ok: boolean; json?: unknown; text?: string } = {
+        status: response.status,
+        ok: response.ok,
+      };
+
+      if (response.status !== 204) {
+        const contentType = response.headers.get('content-type') || '';
+        if (contentType.includes('application/json')) {
+          data.json = await response.json().catch(() => undefined);
+        } else {
+          data.text = await response.text().catch(() => '');
+        }
+      }
+
+      return { ok: true, data };
+    } catch (error) {
+      return {
+        ok: false,
+        error: {
+          message: error instanceof Error ? error.message : String(error),
+        },
+      };
+    }
+  });
 }
 
 function mapAppErrorCode(error: unknown): AppErrorCode {
diff --git a/electron/utils/agent-config.ts b/electron/utils/agent-config.ts
new file mode 100644
index 000000000..29a05515b
--- /dev/null
+++ b/electron/utils/agent-config.ts
@@ -0,0 +1,452 @@
+import { access, copyFile, mkdir, readdir } from 'fs/promises';
+import { constants } from 'fs';
+import { join } from 'path';
+import { listConfiguredChannels, readOpenClawConfig, writeOpenClawConfig } from './channel-config';
+import { expandPath, getOpenClawConfigDir } from './paths';
+import * as logger from './logger';
+
+const MAIN_AGENT_ID = 'main';
+const MAIN_AGENT_NAME = 'Main';
+const DEFAULT_WORKSPACE_PATH = '~/.openclaw/workspace';
+const AGENT_BOOTSTRAP_FILES = [
+  'AGENTS.md',
+  'SOUL.md',
+  'TOOLS.md',
+  'USER.md',
+  'IDENTITY.md',
+  'HEARTBEAT.md',
+  'BOOT.md',
+];
+const AGENT_RUNTIME_FILES = [
+  'auth-profiles.json',
+  'models.json',
+];
+
+interface AgentModelConfig {
+  primary?: string;
+  [key: string]: unknown;
+}
+
+interface AgentDefaultsConfig {
+  workspace?: string;
+  model?: string | AgentModelConfig;
+  [key: string]: unknown;
+}
+
+interface AgentListEntry extends Record<string, unknown> {
+  id: string;
+  name?: string;
+  default?: boolean;
+  workspace?: string;
+  agentDir?: string;
+  model?: string | AgentModelConfig;
+}
+
+interface AgentsConfig extends Record<string, unknown> {
+  defaults?: AgentDefaultsConfig;
+  list?: AgentListEntry[];
+}
+
+interface BindingMatch extends Record<string, unknown> {
+  channel?: string;
+}
+
+interface BindingConfig extends Record<string, unknown> {
+  agentId?: string;
+  match?: BindingMatch;
+}
+
+interface AgentConfigDocument extends Record<string, unknown> {
+  agents?: AgentsConfig;
+  bindings?: BindingConfig[];
+}
+
+export interface AgentSummary {
+  id: string;
+  name: string;
+  isDefault: boolean;
+  modelDisplay: string;
+  inheritedModel: boolean;
+  workspace: string;
+  agentDir: string;
+  channelTypes: string[];
+}
+
+export interface AgentsSnapshot {
+  agents: AgentSummary[];
+  defaultAgentId: string;
+  configuredChannelTypes: string[];
+  channelOwners: Record<string, string>;
+}
+
+function formatModelLabel(model: unknown): string | null {
+  if (typeof model === 'string' && model.trim()) {
+    const trimmed = model.trim();
+    const parts = trimmed.split('/');
+    return parts[parts.length - 1] || trimmed;
+  }
+
+  if (model && typeof model === 'object') {
+    const primary = (model as AgentModelConfig).primary;
+    if (typeof primary === 'string' && primary.trim()) {
+      const parts = primary.trim().split('/');
+      return parts[parts.length - 1] || primary.trim();
+    }
+  }
+
+  return null;
+}
+
+function normalizeAgentName(name: string): string {
+  return name.trim() || 'Agent';
+}
+
+function slugifyAgentId(name: string): string {
+  const normalized = name
+    .normalize('NFKD')
+    .replace(/[^\w\s-]/g, '')
+    .toLowerCase()
+    .replace(/[_\s]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '');
+
+  if (!normalized) return 'agent';
+  if (normalized === MAIN_AGENT_ID) return 'agent';
+  return normalized;
+}
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function ensureDir(path: string): Promise<void> {
+  if (!(await fileExists(path))) {
+    await mkdir(path, { recursive: true });
+  }
+}
+
+function getDefaultWorkspacePath(config: AgentConfigDocument): string {
+  const defaults = (config.agents && typeof config.agents === 'object'
+    ? (config.agents as AgentsConfig).defaults
+    : undefined);
+  return typeof defaults?.workspace === 'string' && defaults.workspace.trim()
+    ? defaults.workspace
+    : DEFAULT_WORKSPACE_PATH;
+}
+
+function getDefaultAgentDirPath(agentId: string): string {
+  return `~/.openclaw/agents/${agentId}/agent`;
+}
+
+function createImplicitMainEntry(config: AgentConfigDocument): AgentListEntry {
+  return {
+    id: MAIN_AGENT_ID,
+    name: MAIN_AGENT_NAME,
+    default: true,
+    workspace: getDefaultWorkspacePath(config),
+    agentDir: getDefaultAgentDirPath(MAIN_AGENT_ID),
+  };
+}
+
+function normalizeAgentsConfig(config: AgentConfigDocument): {
+  agentsConfig: AgentsConfig;
+  entries: AgentListEntry[];
+  defaultAgentId: string;
+  syntheticMain: boolean;
+} {
+  const agentsConfig = (config.agents && typeof config.agents === 'object'
+    ? { ...(config.agents as AgentsConfig) }
+    : {}) as AgentsConfig;
+  const rawEntries = Array.isArray(agentsConfig.list)
+    ? agentsConfig.list.filter((entry): entry is AgentListEntry => (
+      Boolean(entry) && typeof entry === 'object' && typeof entry.id === 'string' && entry.id.trim().length > 0
+    ))
+    : [];
+
+  if (rawEntries.length === 0) {
+    const main = createImplicitMainEntry(config);
+    return {
+      agentsConfig,
+      entries: [main],
+      defaultAgentId: MAIN_AGENT_ID,
+      syntheticMain: true,
+    };
+  }
+
+  const defaultEntry = rawEntries.find((entry) => entry.default) ?? rawEntries[0];
+  return {
+    agentsConfig,
+    entries: rawEntries.map((entry) => ({ ...entry })),
+    defaultAgentId: defaultEntry.id,
+    syntheticMain: false,
+  };
+}
+
+function isSimpleChannelBinding(binding: unknown): binding is BindingConfig {
+  if (!binding || typeof binding !== 'object') return false;
+  const candidate = binding as BindingConfig;
+  if (typeof candidate.agentId !== 'string' || !candidate.agentId) return false;
+  if (!candidate.match || typeof candidate.match !== 'object' || Array.isArray(candidate.match)) return false;
+  const keys = Object.keys(candidate.match);
+  return keys.length === 1 && typeof candidate.match.channel === 'string' && Boolean(candidate.match.channel);
+}
+
+/** Normalize agent ID for consistent comparison (bindings vs entries). */
+function normalizeAgentIdForBinding(id: string): string {
+  return (id ?? '').trim().toLowerCase() || '';
+}
+
+function getSimpleChannelBindingMap(bindings: unknown): Map<string, string> {
+  const owners = new Map<string, string>();
+  if (!Array.isArray(bindings)) return owners;
+
+  for (const binding of bindings) {
+    if (!isSimpleChannelBinding(binding)) continue;
+    const agentId = normalizeAgentIdForBinding(binding.agentId!);
+    if (agentId) owners.set(binding.match.channel!, agentId);
+  }
+
+  return owners;
+}
+
+function upsertBindingsForChannel(
+  bindings: unknown,
+  channelType: string,
+  agentId: string | null,
+): BindingConfig[] | undefined {
+  const nextBindings = Array.isArray(bindings)
+    ? [...bindings as BindingConfig[]].filter((binding) => !(
+      isSimpleChannelBinding(binding) && binding.match.channel === channelType
+    ))
+    : [];
+
+  if (agentId) {
+    nextBindings.push({
+      agentId,
+      match: { channel: channelType },
+    });
+  }
+
+  return nextBindings.length > 0 ? nextBindings : undefined;
+}
+
+async function listExistingAgentIdsOnDisk(): Promise<Set<string>> {
+  const ids = new Set<string>();
+  const agentsDir = join(getOpenClawConfigDir(), 'agents');
+
+  try {
+    if (!(await fileExists(agentsDir))) return ids;
+    const entries = await readdir(agentsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) ids.add(entry.name);
+    }
+  } catch {
+    // ignore discovery failures
+  }
+
+  return ids;
+}
+
+async function copyBootstrapFiles(sourceWorkspace: string, targetWorkspace: string): Promise<void> {
+  await ensureDir(targetWorkspace);
+
+  for (const fileName of AGENT_BOOTSTRAP_FILES) {
+    const source = join(sourceWorkspace, fileName);
+    const target = join(targetWorkspace, fileName);
+    if (!(await fileExists(source)) || (await fileExists(target))) continue;
+    await copyFile(source, target);
+  }
+}
+
+async function copyRuntimeFiles(sourceAgentDir: string, targetAgentDir: string): Promise<void> {
+  await ensureDir(targetAgentDir);
+
+  for (const fileName of AGENT_RUNTIME_FILES) {
+    const source = join(sourceAgentDir, fileName);
+    const target = join(targetAgentDir, fileName);
+    if (!(await fileExists(source)) || (await fileExists(target))) continue;
+    await copyFile(source, target);
+  }
+}
+
+async function provisionAgentFilesystem(config: AgentConfigDocument, agent: AgentListEntry): Promise<void> {
+  const { entries } = normalizeAgentsConfig(config);
+  const mainEntry = entries.find((entry) => entry.id === MAIN_AGENT_ID) ?? createImplicitMainEntry(config);
+  const sourceWorkspace = expandPath(mainEntry.workspace || getDefaultWorkspacePath(config));
+  const targetWorkspace = expandPath(agent.workspace || `~/.openclaw/workspace-${agent.id}`);
+  const sourceAgentDir = expandPath(mainEntry.agentDir || getDefaultAgentDirPath(MAIN_AGENT_ID));
+  const targetAgentDir = expandPath(agent.agentDir || getDefaultAgentDirPath(agent.id));
+  const targetSessionsDir = join(getOpenClawConfigDir(), 'agents', agent.id, 'sessions');
+
+  await ensureDir(targetWorkspace);
+  await ensureDir(targetAgentDir);
+  await ensureDir(targetSessionsDir);
+
+  if (targetWorkspace !== sourceWorkspace) {
+    await copyBootstrapFiles(sourceWorkspace, targetWorkspace);
+  }
+  if (targetAgentDir !== sourceAgentDir) {
+    await copyRuntimeFiles(sourceAgentDir, targetAgentDir);
+  }
+}
+
+async function buildSnapshotFromConfig(config: AgentConfigDocument): Promise<AgentsSnapshot> {
+  const { entries, defaultAgentId } = normalizeAgentsConfig(config);
+  const configuredChannels = await listConfiguredChannels();
+  const explicitOwners = getSimpleChannelBindingMap(config.bindings);
+  const defaultAgentIdNorm = normalizeAgentIdForBinding(defaultAgentId);
+  const channelOwners: Record<string, string> = {};
+
+  for (const channelType of configuredChannels) {
+    channelOwners[channelType] = explicitOwners.get(channelType) || defaultAgentIdNorm;
+  }
+
+  const defaultModelLabel = formatModelLabel((config.agents as AgentsConfig | undefined)?.defaults?.model);
+  const agents: AgentSummary[] = entries.map((entry) => {
+    const modelLabel = formatModelLabel(entry.model) || defaultModelLabel || 'Not configured';
+    const inheritedModel = !formatModelLabel(entry.model) && Boolean(defaultModelLabel);
+    const entryIdNorm = normalizeAgentIdForBinding(entry.id);
+    return {
+      id: entry.id,
+      name: entry.name || (entry.id === MAIN_AGENT_ID ? MAIN_AGENT_NAME : entry.id),
+      isDefault: entry.id === defaultAgentId,
+      modelDisplay: modelLabel,
+      inheritedModel,
+      workspace: entry.workspace || (entry.id === MAIN_AGENT_ID ? getDefaultWorkspacePath(config) : `~/.openclaw/workspace-${entry.id}`),
+      agentDir: entry.agentDir || getDefaultAgentDirPath(entry.id),
+      channelTypes: configuredChannels.filter((channelType) => channelOwners[channelType] === entryIdNorm),
+    };
+  });
+
+  return {
+    agents,
+    defaultAgentId,
+    configuredChannelTypes: configuredChannels,
+    channelOwners,
+  };
+}
+
+export async function listAgentsSnapshot(): Promise<AgentsSnapshot> {
+  const config = await readOpenClawConfig() as AgentConfigDocument;
+  return buildSnapshotFromConfig(config);
+}
+
+export async function createAgent(name: string): Promise<AgentsSnapshot> {
+  const config = await readOpenClawConfig() as AgentConfigDocument;
+  const { agentsConfig, entries, syntheticMain } = normalizeAgentsConfig(config);
+  const normalizedName = normalizeAgentName(name);
+  const existingIds = new Set(entries.map((entry) => entry.id));
+  const diskIds = await listExistingAgentIdsOnDisk();
+  let nextId = slugifyAgentId(normalizedName);
+  let suffix = 2;
+
+  while (existingIds.has(nextId) || diskIds.has(nextId)) {
+    nextId = `${slugifyAgentId(normalizedName)}-${suffix}`;
+    suffix += 1;
+  }
+
+  const nextEntries = syntheticMain ? [createImplicitMainEntry(config), ...entries.filter((entry, index) => index > 0)] : [...entries];
+  const newAgent: AgentListEntry = {
+    id: nextId,
+    name: normalizedName,
+    workspace: `~/.openclaw/workspace-${nextId}`,
+    agentDir: getDefaultAgentDirPath(nextId),
+  };
+
+  if (!nextEntries.some((entry) => entry.id === MAIN_AGENT_ID) && syntheticMain) {
+    nextEntries.unshift(createImplicitMainEntry(config));
+  }
+  nextEntries.push(newAgent);
+
+  config.agents = {
+    ...agentsConfig,
+    list: nextEntries,
+  };
+
+  await provisionAgentFilesystem(config, newAgent);
+  await writeOpenClawConfig(config);
+  logger.info('Created agent config entry', { agentId: nextId });
+  return buildSnapshotFromConfig(config);
+}
+
+export async function updateAgentName(agentId: string, name: string): Promise<AgentsSnapshot> {
+  const config = await readOpenClawConfig() as AgentConfigDocument;
+  const { agentsConfig, entries } = normalizeAgentsConfig(config);
+  const normalizedName = normalizeAgentName(name);
+  const index = entries.findIndex((entry) => entry.id === agentId);
+  if (index === -1) {
+    throw new Error(`Agent "${agentId}" not found`);
+  }
+
+  entries[index] = {
+    ...entries[index],
+    name: normalizedName,
+  };
+
+  config.agents = {
+    ...agentsConfig,
+    list: entries,
+  };
+
+  await writeOpenClawConfig(config);
+  logger.info('Updated agent name', { agentId, name: normalizedName });
+  return buildSnapshotFromConfig(config);
+}
+
+export async function deleteAgentConfig(agentId: string): Promise<AgentsSnapshot> {
+  if (agentId === MAIN_AGENT_ID) {
+    throw new Error('The main agent cannot be deleted');
+  }
+
+  const config = await readOpenClawConfig() as AgentConfigDocument;
+  const { agentsConfig, entries, defaultAgentId } = normalizeAgentsConfig(config);
+  const nextEntries = entries.filter((entry) => entry.id !== agentId);
+  if (nextEntries.length === entries.length) {
+    throw new Error(`Agent "${agentId}" not found`);
+  }
+
+  config.agents = {
+    ...agentsConfig,
+    list: nextEntries,
+  };
+  config.bindings = Array.isArray(config.bindings)
+    ? config.bindings.filter((binding) => !(isSimpleChannelBinding(binding) && binding.agentId === agentId))
+    : undefined;
+
+  if (defaultAgentId === agentId && nextEntries.length > 0) {
+    nextEntries[0] = {
+      ...nextEntries[0],
+      default: true,
+    };
+  }
+
+  await writeOpenClawConfig(config);
+  logger.info('Deleted agent config entry', { agentId });
+  return buildSnapshotFromConfig(config);
+}
+
+export async function assignChannelToAgent(agentId: string, channelType: string): Promise<AgentsSnapshot> {
+  const config = await readOpenClawConfig() as AgentConfigDocument;
+  const { entries } = normalizeAgentsConfig(config);
+  if (!entries.some((entry) => entry.id === agentId)) {
+    throw new Error(`Agent "${agentId}" not found`);
+  }
+
+  config.bindings = upsertBindingsForChannel(config.bindings, channelType, agentId);
+  await writeOpenClawConfig(config);
+  logger.info('Assigned channel to agent', { agentId, channelType });
+  return buildSnapshotFromConfig(config);
+}
+
+export async function clearChannelBinding(channelType: string): Promise<AgentsSnapshot> {
+  const config = await readOpenClawConfig() as AgentConfigDocument;
+  config.bindings = upsertBindingsForChannel(config.bindings, channelType, null);
+  await writeOpenClawConfig(config);
+  logger.info('Cleared simplified channel binding', { channelType });
+  return buildSnapshotFromConfig(config);
+}
diff --git a/src/App.tsx b/src/App.tsx
index a7b47ea19..267a1ad08 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -11,6 +11,7 @@ import { MainLayout } from './components/layout/MainLayout';
 import { TooltipProvider } from '@/components/ui/tooltip';
 import { Models } from './pages/Models';
 import { Chat } from './pages/Chat';
+import { Agents } from './pages/Agents';
 import { Channels } from './pages/Channels';
 import { Skills } from './pages/Skills';
 import { Cron } from './pages/Cron';
@@ -165,6 +166,7 @@ function App() {
           <Route element={<MainLayout />}>
             <Route path="/" element={<Chat />} />
             <Route path="/models" element={<Models />} />
+            <Route path="/agents" element={<Agents />} />
             <Route path="/channels" element={<Channels />} />
             <Route path="/skills" element={<Skills />} />
             <Route path="/cron" element={<Cron />} />
diff --git a/src/components/channels/ChannelConfigModal.tsx b/src/components/channels/ChannelConfigModal.tsx
new file mode 100644
index 000000000..1add4262e
--- /dev/null
+++ b/src/components/channels/ChannelConfigModal.tsx
@@ -0,0 +1,720 @@
+import { useState, useEffect, useRef, useCallback } from 'react';
+import {
+  X,
+  Loader2,
+  QrCode,
+  ExternalLink,
+  BookOpen,
+  Eye,
+  EyeOff,
+  Check,
+  AlertCircle,
+  CheckCircle,
+  ShieldCheck,
+} from 'lucide-react';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card';
+import { Separator } from '@/components/ui/separator';
+import { Badge } from '@/components/ui/badge';
+import { useChannelsStore } from '@/stores/channels';
+import { useGatewayStore } from '@/stores/gateway';
+import { hostApiFetch } from '@/lib/host-api';
+import { subscribeHostEvent } from '@/lib/host-events';
+import { cn } from '@/lib/utils';
+import {
+  CHANNEL_ICONS,
+  CHANNEL_NAMES,
+  CHANNEL_META,
+  getPrimaryChannels,
+  type ChannelType,
+  type ChannelMeta,
+  type ChannelConfigField,
+} from '@/types/channel';
+import { toast } from 'sonner';
+import { useTranslation } from 'react-i18next';
+import telegramIcon from '@/assets/channels/telegram.svg';
+import discordIcon from '@/assets/channels/discord.svg';
+import whatsappIcon from '@/assets/channels/whatsapp.svg';
+import dingtalkIcon from '@/assets/channels/dingtalk.svg';
+import feishuIcon from '@/assets/channels/feishu.svg';
+import wecomIcon from '@/assets/channels/wecom.svg';
+import qqIcon from '@/assets/channels/qq.svg';
+
+interface ChannelConfigModalProps {
+  initialSelectedType?: ChannelType | null;
+  configuredTypes?: string[];
+  showChannelName?: boolean;
+  allowExistingConfig?: boolean;
+  onClose: () => void;
+  onChannelSaved?: (channelType: ChannelType) => void | Promise<void>;
+}
+
+const inputClasses = 'h-[44px] rounded-xl font-mono text-[13px] bg-[#eeece3] dark:bg-[#151514] border-black/10 dark:border-white/10 focus-visible:ring-2 focus-visible:ring-blue-500/50 focus-visible:border-blue-500 shadow-sm transition-all text-foreground placeholder:text-foreground/40';
+const labelClasses = 'text-[14px] text-foreground/80 font-bold';
+const outlineButtonClasses = 'h-9 text-[13px] font-medium rounded-full px-4 border-black/10 dark:border-white/10 bg-transparent hover:bg-black/5 dark:hover:bg-white/5 shadow-none text-foreground/80 hover:text-foreground';
+const primaryButtonClasses = 'h-9 text-[13px] font-medium rounded-full px-4 shadow-none';
+
+export function ChannelConfigModal({
+  initialSelectedType = null,
+  configuredTypes = [],
+  showChannelName = true,
+  allowExistingConfig = true,
+  onClose,
+  onChannelSaved,
+}: ChannelConfigModalProps) {
+  const { t } = useTranslation('channels');
+  const { channels, addChannel, fetchChannels } = useChannelsStore();
+  const [selectedType, setSelectedType] = useState<ChannelType | null>(initialSelectedType);
+  const [configValues, setConfigValues] = useState<Record<string, string>>({});
+  const [channelName, setChannelName] = useState('');
+  const [connecting, setConnecting] = useState(false);
+  const [showSecrets, setShowSecrets] = useState<Record<string, boolean>>({});
+  const [qrCode, setQrCode] = useState<string | null>(null);
+  const [validating, setValidating] = useState(false);
+  const [loadingConfig, setLoadingConfig] = useState(false);
+  const [isExistingConfig, setIsExistingConfig] = useState(false);
+  const firstInputRef = useRef<HTMLInputElement>(null);
+  const [validationResult, setValidationResult] = useState<{
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+  } | null>(null);
+
+  const meta: ChannelMeta | null = selectedType ? CHANNEL_META[selectedType] : null;
+
+  useEffect(() => {
+    setSelectedType(initialSelectedType);
+  }, [initialSelectedType]);
+
+  useEffect(() => {
+    if (!selectedType) {
+      setConfigValues({});
+      setChannelName('');
+      setIsExistingConfig(false);
+      setValidationResult(null);
+      setQrCode(null);
+      setConnecting(false);
+      hostApiFetch('/api/channels/whatsapp/cancel', { method: 'POST' }).catch(() => {});
+      return;
+    }
+
+    const shouldLoadExistingConfig = allowExistingConfig && configuredTypes.includes(selectedType);
+    if (!shouldLoadExistingConfig) {
+      setConfigValues({});
+      setIsExistingConfig(false);
+      setLoadingConfig(false);
+      setChannelName(showChannelName ? CHANNEL_NAMES[selectedType] : '');
+      return;
+    }
+
+    let cancelled = false;
+    setLoadingConfig(true);
+    setChannelName(showChannelName ? CHANNEL_NAMES[selectedType] : '');
+
+    (async () => {
+      try {
+        const result = await hostApiFetch<{ success: boolean; values?: Record<string, string> }>(
+          `/api/channels/config/${encodeURIComponent(selectedType)}`
+        );
+        if (cancelled) return;
+
+        if (result.success && result.values && Object.keys(result.values).length > 0) {
+          setConfigValues(result.values);
+          setIsExistingConfig(true);
+        } else {
+          setConfigValues({});
+          setIsExistingConfig(false);
+        }
+      } catch {
+        if (!cancelled) {
+          setConfigValues({});
+          setIsExistingConfig(false);
+        }
+      } finally {
+        if (!cancelled) setLoadingConfig(false);
+      }
+    })();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [allowExistingConfig, configuredTypes, selectedType, showChannelName]);
+
+  useEffect(() => {
+    if (selectedType && !loadingConfig && showChannelName && firstInputRef.current) {
+      firstInputRef.current.focus();
+    }
+  }, [selectedType, loadingConfig, showChannelName]);
+
+  const finishSave = useCallback(async (channelType: ChannelType) => {
+    const displayName = showChannelName && channelName.trim()
+      ? channelName.trim()
+      : CHANNEL_NAMES[channelType];
+    const existingChannel = channels.find((channel) => channel.type === channelType);
+
+    if (!existingChannel) {
+      await addChannel({
+        type: channelType,
+        name: displayName,
+        token: meta?.configFields[0]?.key ? configValues[meta.configFields[0].key] : undefined,
+      });
+    } else {
+      await fetchChannels();
+    }
+
+    await onChannelSaved?.(channelType);
+  }, [addChannel, channelName, channels, configValues, fetchChannels, meta?.configFields, onChannelSaved, showChannelName]);
+
+  useEffect(() => {
+    if (selectedType !== 'whatsapp') return;
+
+    const onQr = (...args: unknown[]) => {
+      const data = args[0] as { qr: string; raw: string };
+      void data.raw;
+      setQrCode(`data:image/png;base64,${data.qr}`);
+    };
+
+    const onSuccess = async (...args: unknown[]) => {
+      const data = args[0] as { accountId?: string } | undefined;
+      void data?.accountId;
+      toast.success(t('toast.whatsappConnected'));
+      try {
+        const saveResult = await hostApiFetch<{ success?: boolean; error?: string }>('/api/channels/config', {
+          method: 'POST',
+          body: JSON.stringify({ channelType: 'whatsapp', config: { enabled: true } }),
+        });
+        if (!saveResult?.success) {
+          throw new Error(saveResult?.error || 'Failed to save WhatsApp config');
+        }
+
+        await finishSave('whatsapp');
+        useGatewayStore.getState().restart().catch(console.error);
+        onClose();
+      } catch (error) {
+        toast.error(t('toast.configFailed', { error: String(error) }));
+        setConnecting(false);
+      }
+    };
+
+    const onError = (...args: unknown[]) => {
+      const err = args[0] as string;
+      toast.error(t('toast.whatsappFailed', { error: err }));
+      setQrCode(null);
+      setConnecting(false);
+    };
+
+    const removeQrListener = subscribeHostEvent('channel:whatsapp-qr', onQr);
+    const removeSuccessListener = subscribeHostEvent('channel:whatsapp-success', onSuccess);
+    const removeErrorListener = subscribeHostEvent('channel:whatsapp-error', onError);
+
+    return () => {
+      removeQrListener();
+      removeSuccessListener();
+      removeErrorListener();
+      hostApiFetch('/api/channels/whatsapp/cancel', { method: 'POST' }).catch(() => {});
+    };
+  }, [selectedType, finishSave, onClose, t]);
+
+  const handleValidate = async () => {
+    if (!selectedType) return;
+
+    setValidating(true);
+    setValidationResult(null);
+
+    try {
+      const result = await hostApiFetch<{
+        success: boolean;
+        valid?: boolean;
+        errors?: string[];
+        warnings?: string[];
+        details?: Record<string, string>;
+      }>('/api/channels/credentials/validate', {
+        method: 'POST',
+        body: JSON.stringify({ channelType: selectedType, config: configValues }),
+      });
+
+      const warnings = result.warnings || [];
+      if (result.valid && result.details) {
+        const details = result.details;
+        if (details.botUsername) warnings.push(`Bot: @${details.botUsername}`);
+        if (details.guildName) warnings.push(`Server: ${details.guildName}`);
+        if (details.channelName) warnings.push(`Channel: #${details.channelName}`);
+      }
+
+      setValidationResult({
+        valid: result.valid || false,
+        errors: result.errors || [],
+        warnings,
+      });
+    } catch (error) {
+      setValidationResult({
+        valid: false,
+        errors: [String(error)],
+        warnings: [],
+      });
+    } finally {
+      setValidating(false);
+    }
+  };
+
+  const handleConnect = async () => {
+    if (!selectedType || !meta) return;
+
+    setConnecting(true);
+    setValidationResult(null);
+
+    try {
+      if (meta.connectionType === 'qr') {
+        await hostApiFetch('/api/channels/whatsapp/start', {
+          method: 'POST',
+          body: JSON.stringify({ accountId: 'default' }),
+        });
+        return;
+      }
+
+      if (meta.connectionType === 'token') {
+        const validationResponse = await hostApiFetch<{
+          success: boolean;
+          valid?: boolean;
+          errors?: string[];
+          warnings?: string[];
+          details?: Record<string, string>;
+        }>('/api/channels/credentials/validate', {
+          method: 'POST',
+          body: JSON.stringify({ channelType: selectedType, config: configValues }),
+        });
+
+        if (!validationResponse.valid) {
+          setValidationResult({
+            valid: false,
+            errors: validationResponse.errors || ['Validation failed'],
+            warnings: validationResponse.warnings || [],
+          });
+          setConnecting(false);
+          return;
+        }
+
+        const warnings = validationResponse.warnings || [];
+        if (validationResponse.details) {
+          const details = validationResponse.details;
+          if (details.botUsername) warnings.push(`Bot: @${details.botUsername}`);
+          if (details.guildName) warnings.push(`Server: ${details.guildName}`);
+          if (details.channelName) warnings.push(`Channel: #${details.channelName}`);
+        }
+
+        setValidationResult({
+          valid: true,
+          errors: [],
+          warnings,
+        });
+      }
+
+      const config: Record<string, unknown> = { ...configValues };
+      const saveResult = await hostApiFetch<{
+        success?: boolean;
+        error?: string;
+        warning?: string;
+      }>('/api/channels/config', {
+        method: 'POST',
+        body: JSON.stringify({ channelType: selectedType, config }),
+      });
+      if (!saveResult?.success) {
+        throw new Error(saveResult?.error || 'Failed to save channel config');
+      }
+      if (typeof saveResult.warning === 'string' && saveResult.warning) {
+        toast.warning(saveResult.warning);
+      }
+
+      await finishSave(selectedType);
+
+      toast.success(t('toast.channelSaved', { name: meta.name }));
+      toast.success(t('toast.channelConnecting', { name: meta.name }));
+      await new Promise((resolve) => setTimeout(resolve, 800));
+      onClose();
+    } catch (error) {
+      toast.error(t('toast.configFailed', { error: String(error) }));
+      setConnecting(false);
+    }
+  };
+
+  const openDocs = () => {
+    if (!meta?.docsUrl) return;
+    const url = t(meta.docsUrl);
+    try {
+      if (window.electron?.openExternal) {
+        window.electron.openExternal(url);
+      } else {
+        window.open(url, '_blank');
+      }
+    } catch {
+      window.open(url, '_blank');
+    }
+  };
+
+  const isFormValid = () => {
+    if (!meta) return false;
+    return meta.configFields
+      .filter((field) => field.required)
+      .every((field) => configValues[field.key]?.trim());
+  };
+
+  const updateConfigValue = (key: string, value: string) => {
+    setConfigValues((prev) => ({ ...prev, [key]: value }));
+  };
+
+  const toggleSecretVisibility = (key: string) => {
+    setShowSecrets((prev) => ({ ...prev, [key]: !prev[key] }));
+  };
+
+  return (
+    <div className="fixed inset-0 z-50 bg-black/50 flex items-center justify-center p-4" onClick={onClose}>
+      <Card
+        className="w-full max-w-3xl max-h-[90vh] flex flex-col rounded-3xl border-0 shadow-2xl bg-[#f3f1e9] dark:bg-[#1a1a19] overflow-hidden"
+        onClick={(event) => event.stopPropagation()}
+      >
+        <CardHeader className="flex flex-row items-start justify-between pb-2 shrink-0">
+          <div>
+            <CardTitle className="text-2xl font-serif font-normal tracking-tight">
+              {selectedType
+                ? isExistingConfig
+                  ? t('dialog.updateTitle', { name: CHANNEL_NAMES[selectedType] })
+                  : t('dialog.configureTitle', { name: CHANNEL_NAMES[selectedType] })
+                : t('dialog.addTitle')}
+            </CardTitle>
+            <CardDescription className="text-[15px] mt-1 text-foreground/70">
+              {selectedType && isExistingConfig
+                ? t('dialog.existingDesc')
+                : meta ? t(meta.description.replace('channels:', '')) : t('dialog.selectDesc')}
+            </CardDescription>
+          </div>
+          <Button
+            variant="ghost"
+            size="icon"
+            onClick={onClose}
+            className="rounded-full h-8 w-8 -mr-2 -mt-2 text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5"
+          >
+            <X className="h-4 w-4" />
+          </Button>
+        </CardHeader>
+        <CardContent className="space-y-6 pt-4 overflow-y-auto flex-1 p-6">
+          {!selectedType ? (
+            <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
+              {getPrimaryChannels().map((type) => {
+                const channelMeta = CHANNEL_META[type];
+                const isConfigured = configuredTypes.includes(type);
+                return (
+                  <button
+                    key={type}
+                    onClick={() => setSelectedType(type)}
+                    className={cn(
+                      'group flex items-start gap-4 p-4 rounded-2xl transition-all text-left border relative overflow-hidden bg-[#eeece3] dark:bg-[#151514] shadow-sm',
+                      isConfigured
+                        ? 'border-green-500/40 bg-green-500/5 dark:bg-green-500/10'
+                        : 'border-black/5 dark:border-white/10 hover:bg-black/5 dark:hover:bg-white/5'
+                    )}
+                  >
+                    <div className="h-[46px] w-[46px] shrink-0 flex items-center justify-center text-foreground bg-black/5 dark:bg-white/5 border border-black/5 dark:border-white/10 rounded-full shadow-sm">
+                      <ChannelLogo type={type} />
+                    </div>
+                    <div className="flex flex-col flex-1 min-w-0 py-0.5 mt-1">
+                      <div className="flex items-center gap-2 mb-1">
+                        <p className="text-[16px] font-semibold text-foreground truncate">{channelMeta.name}</p>
+                        {channelMeta.isPlugin && (
+                          <Badge
+                            variant="secondary"
+                            className="font-mono text-[10px] font-medium px-2 py-0.5 rounded-full bg-black/[0.04] dark:bg-white/[0.08] border-0 shadow-none text-foreground/70"
+                          >
+                            {t('pluginBadge')}
+                          </Badge>
+                        )}
+                      </div>
+                      <p className="text-[13.5px] text-muted-foreground line-clamp-2 leading-[1.5]">
+                        {t(channelMeta.description.replace('channels:', ''))}
+                      </p>
+                      <p className="text-[12px] font-medium text-muted-foreground/80 mt-2">
+                        {channelMeta.connectionType === 'qr' ? t('dialog.qrCode') : t('dialog.token')}
+                      </p>
+                    </div>
+                    {isConfigured && (
+                      <Badge className="absolute top-3 right-3 text-[10px] font-medium rounded-full bg-green-600 hover:bg-green-600">
+                        {t('configuredBadge')}
+                      </Badge>
+                    )}
+                  </button>
+                );
+              })}
+            </div>
+          ) : qrCode ? (
+            <div className="text-center space-y-6">
+              <div className="bg-[#eeece3] dark:bg-[#151514] p-4 rounded-3xl inline-block shadow-sm border border-black/10 dark:border-white/10">
+                {qrCode.startsWith('data:image') ? (
+                  <img src={qrCode} alt="Scan QR Code" className="w-64 h-64 object-contain rounded-2xl" />
+                ) : (
+                  <div className="w-64 h-64 bg-white dark:bg-background rounded-2xl flex items-center justify-center">
+                    <QrCode className="h-32 w-32 text-gray-400" />
+                  </div>
+                )}
+              </div>
+              <p className="text-[14px] text-muted-foreground">
+                {t('dialog.scanQR', { name: meta?.name })}
+              </p>
+              <div className="flex justify-center gap-2">
+                <Button
+                  variant="outline"
+                  className={outlineButtonClasses}
+                  onClick={() => {
+                    setQrCode(null);
+                    void handleConnect();
+                  }}
+                >
+                  {t('dialog.refreshCode')}
+                </Button>
+              </div>
+            </div>
+          ) : loadingConfig ? (
+            <div className="flex items-center justify-center py-10 rounded-2xl bg-[#eeece3] dark:bg-[#151514] border border-black/10 dark:border-white/10">
+              <Loader2 className="h-6 w-6 animate-spin text-muted-foreground" />
+              <span className="ml-2 text-[14px] text-muted-foreground">{t('dialog.loadingConfig')}</span>
+            </div>
+          ) : (
+            <div className="space-y-6">
+              {isExistingConfig && (
+                <div className="bg-blue-500/10 text-blue-600 dark:text-blue-400 p-4 rounded-2xl text-[13.5px] flex items-center gap-2 border border-blue-500/20">
+                  <CheckCircle className="h-4 w-4 shrink-0" />
+                  <span>{t('dialog.existingHint')}</span>
+                </div>
+              )}
+
+              <div className="bg-[#eeece3] dark:bg-[#151514] p-4 rounded-2xl space-y-4 shadow-sm border border-black/10 dark:border-white/10">
+                <div className="flex items-center justify-between gap-3">
+                  <div>
+                    <p className={labelClasses}>{t('dialog.howToConnect')}</p>
+                    <p className="text-[13px] text-muted-foreground mt-1">
+                      {meta ? t(meta.description.replace('channels:', '')) : ''}
+                    </p>
+                  </div>
+                  <Button
+                    variant="outline"
+                    className={cn(outlineButtonClasses, 'h-8 px-3 shrink-0')}
+                    onClick={openDocs}
+                  >
+                    <BookOpen className="h-3 w-3 mr-1" />
+                    {t('dialog.viewDocs')}
+                    <ExternalLink className="h-3 w-3 ml-1" />
+                  </Button>
+                </div>
+                <ol className="list-decimal pl-5 text-[13px] text-muted-foreground leading-relaxed space-y-1.5">
+                  {meta?.instructions.map((instruction, index) => (
+                    <li key={index}>{t(instruction)}</li>
+                  ))}
+                </ol>
+              </div>
+
+              {showChannelName && (
+                <div className="space-y-2.5">
+                  <Label htmlFor="name" className={labelClasses}>{t('dialog.channelName')}</Label>
+                  <Input
+                    ref={firstInputRef}
+                    id="name"
+                    placeholder={t('dialog.channelNamePlaceholder', { name: meta?.name })}
+                    value={channelName}
+                    onChange={(event) => setChannelName(event.target.value)}
+                    className={inputClasses}
+                  />
+                </div>
+              )}
+
+              <div className="space-y-4">
+                {meta?.configFields.map((field) => (
+                  <ConfigField
+                    key={field.key}
+                    field={field}
+                    value={configValues[field.key] || ''}
+                    onChange={(value) => updateConfigValue(field.key, value)}
+                    showSecret={showSecrets[field.key] || false}
+                    onToggleSecret={() => toggleSecretVisibility(field.key)}
+                  />
+                ))}
+              </div>
+
+              {validationResult && (
+                <div
+                  className={cn(
+                    'p-4 rounded-2xl text-sm border',
+                    validationResult.valid
+                      ? 'bg-green-500/10 text-green-700 dark:text-green-400 border-green-500/20'
+                      : 'bg-destructive/10 text-destructive border-destructive/20'
+                  )}
+                >
+                  <div className="flex items-start gap-2">
+                    {validationResult.valid ? (
+                      <CheckCircle className="h-4 w-4 mt-0.5 shrink-0" />
+                    ) : (
+                      <AlertCircle className="h-4 w-4 mt-0.5 shrink-0" />
+                    )}
+                    <div className="min-w-0">
+                      <h4 className="font-medium mb-1">
+                        {validationResult.valid ? t('dialog.credentialsVerified') : t('dialog.validationFailed')}
+                      </h4>
+                      {validationResult.errors.length > 0 && (
+                        <ul className="list-disc list-inside space-y-0.5">
+                          {validationResult.errors.map((err, index) => (
+                            <li key={index}>{err}</li>
+                          ))}
+                        </ul>
+                      )}
+                      {validationResult.valid && validationResult.warnings.length > 0 && (
+                        <div className="mt-1 text-green-600 dark:text-green-400 space-y-0.5">
+                          {validationResult.warnings.map((info, index) => (
+                            <p key={index} className="text-xs">{info}</p>
+                          ))}
+                        </div>
+                      )}
+                      {!validationResult.valid && validationResult.warnings.length > 0 && (
+                        <div className="mt-2 text-yellow-600 dark:text-yellow-500">
+                          <p className="font-medium text-xs uppercase mb-1">{t('dialog.warnings')}</p>
+                          <ul className="list-disc list-inside space-y-0.5">
+                            {validationResult.warnings.map((warn, index) => (
+                              <li key={index}>{warn}</li>
+                            ))}
+                          </ul>
+                        </div>
+                      )}
+                    </div>
+                  </div>
+                </div>
+              )}
+
+              <Separator className="bg-black/10 dark:bg-white/10" />
+
+              <div className="flex flex-col-reverse sm:flex-row sm:justify-between gap-3 pt-2">
+                <Button variant="outline" onClick={() => setSelectedType(null)} className={outlineButtonClasses}>
+                  {t('dialog.back')}
+                </Button>
+                <div className="flex flex-col sm:flex-row gap-2">
+                  {meta?.connectionType === 'token' && (
+                    <Button
+                      variant="outline"
+                      onClick={handleValidate}
+                      disabled={validating}
+                      className={outlineButtonClasses}
+                    >
+                      {validating ? (
+                        <>
+                          <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                          {t('dialog.validating')}
+                        </>
+                      ) : (
+                        <>
+                          <ShieldCheck className="h-4 w-4 mr-2" />
+                          {t('dialog.validateConfig')}
+                        </>
+                      )}
+                    </Button>
+                  )}
+                  <Button
+                    onClick={() => {
+                      void handleConnect();
+                    }}
+                    disabled={connecting || !isFormValid()}
+                    className={primaryButtonClasses}
+                  >
+                    {connecting ? (
+                      <>
+                        <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                        {meta?.connectionType === 'qr' ? t('dialog.generatingQR') : t('dialog.validatingAndSaving')}
+                      </>
+                    ) : meta?.connectionType === 'qr' ? (
+                      t('dialog.generateQRCode')
+                    ) : (
+                      <>
+                        <Check className="h-4 w-4 mr-2" />
+                        {isExistingConfig ? t('dialog.updateAndReconnect') : t('dialog.saveAndConnect')}
+                      </>
+                    )}
+                  </Button>
+                </div>
+              </div>
+            </div>
+          )}
+        </CardContent>
+      </Card>
+    </div>
+  );
+}
+
+interface ConfigFieldProps {
+  field: ChannelConfigField;
+  value: string;
+  onChange: (value: string) => void;
+  showSecret: boolean;
+  onToggleSecret: () => void;
+}
+
+function ChannelLogo({ type }: { type: ChannelType }) {
+  switch (type) {
+    case 'telegram':
+      return <img src={telegramIcon} alt="Telegram" className="w-[22px] h-[22px] dark:invert" />;
+    case 'discord':
+      return <img src={discordIcon} alt="Discord" className="w-[22px] h-[22px] dark:invert" />;
+    case 'whatsapp':
+      return <img src={whatsappIcon} alt="WhatsApp" className="w-[22px] h-[22px] dark:invert" />;
+    case 'dingtalk':
+      return <img src={dingtalkIcon} alt="DingTalk" className="w-[22px] h-[22px] dark:invert" />;
+    case 'feishu':
+      return <img src={feishuIcon} alt="Feishu" className="w-[22px] h-[22px] dark:invert" />;
+    case 'wecom':
+      return <img src={wecomIcon} alt="WeCom" className="w-[22px] h-[22px] dark:invert" />;
+    case 'qqbot':
+      return <img src={qqIcon} alt="QQ" className="w-[22px] h-[22px] dark:invert" />;
+    default:
+      return <span className="text-[22px]">{CHANNEL_ICONS[type] || '💬'}</span>;
+  }
+}
+
+function ConfigField({ field, value, onChange, showSecret, onToggleSecret }: ConfigFieldProps) {
+  const { t } = useTranslation('channels');
+  const isPassword = field.type === 'password';
+
+  return (
+    <div className="space-y-2.5">
+      <Label htmlFor={field.key} className={labelClasses}>
+        {t(field.label)}
+        {field.required && <span className="text-destructive ml-1">*</span>}
+      </Label>
+      <div className="flex gap-2">
+        <Input
+          id={field.key}
+          type={isPassword && !showSecret ? 'password' : 'text'}
+          placeholder={field.placeholder ? t(field.placeholder) : undefined}
+          value={value}
+          onChange={(event) => onChange(event.target.value)}
+          className={inputClasses}
+        />
+        {isPassword && (
+          <Button
+            type="button"
+            variant="outline"
+            size="icon"
+            onClick={onToggleSecret}
+            className="h-[44px] w-[44px] rounded-xl bg-[#eeece3] dark:bg-[#151514] border-black/10 dark:border-white/10 text-muted-foreground hover:text-foreground shrink-0 shadow-sm"
+          >
+            {showSecret ? <EyeOff className="h-4 w-4" /> : <Eye className="h-4 w-4" />}
+          </Button>
+        )}
+      </div>
+      {field.description && (
+        <p className="text-[13px] text-muted-foreground leading-relaxed">
+          {t(field.description)}
+        </p>
+      )}
+      {field.envVar && (
+        <p className="text-[12px] text-muted-foreground/70 font-mono">
+          {t('dialog.envVar', { var: field.envVar })}
+        </p>
+      )}
+    </div>
+  );
+}
diff --git a/src/components/layout/Sidebar.tsx b/src/components/layout/Sidebar.tsx
index 1d5cb9dba..ee4ed654c 100644
--- a/src/components/layout/Sidebar.tsx
+++ b/src/components/layout/Sidebar.tsx
@@ -7,6 +7,7 @@ import { useEffect, useState } from 'react';
 import { NavLink, useLocation, useNavigate } from 'react-router-dom';
 import {
   Network,
+  Bot,
   Puzzle,
   Clock,
   Settings as SettingsIcon,
@@ -168,6 +169,7 @@ export function Sidebar() {
 
   const navItems = [
     { to: '/models', icon: <Cpu className="h-[18px] w-[18px]" strokeWidth={2} />, label: t('sidebar.models') },
+    { to: '/agents', icon: <Bot className="h-[18px] w-[18px]" strokeWidth={2} />, label: t('sidebar.agents') },
     { to: '/channels', icon: <Network className="h-[18px] w-[18px]" strokeWidth={2} />, label: t('sidebar.channels') },
     { to: '/skills', icon: <Puzzle className="h-[18px] w-[18px]" strokeWidth={2} />, label: t('sidebar.skills') },
     { to: '/cron', icon: <Clock className="h-[18px] w-[18px]" strokeWidth={2} />, label: t('sidebar.cronTasks') },
diff --git a/src/i18n/index.ts b/src/i18n/index.ts
index 84de778c3..5e0cc5253 100644
--- a/src/i18n/index.ts
+++ b/src/i18n/index.ts
@@ -7,6 +7,7 @@ import enSettings from './locales/en/settings.json';
 import enDashboard from './locales/en/dashboard.json';
 import enChat from './locales/en/chat.json';
 import enChannels from './locales/en/channels.json';
+import enAgents from './locales/en/agents.json';
 import enSkills from './locales/en/skills.json';
 import enCron from './locales/en/cron.json';
 import enSetup from './locales/en/setup.json';
@@ -17,6 +18,7 @@ import zhSettings from './locales/zh/settings.json';
 import zhDashboard from './locales/zh/dashboard.json';
 import zhChat from './locales/zh/chat.json';
 import zhChannels from './locales/zh/channels.json';
+import zhAgents from './locales/zh/agents.json';
 import zhSkills from './locales/zh/skills.json';
 import zhCron from './locales/zh/cron.json';
 import zhSetup from './locales/zh/setup.json';
@@ -27,6 +29,7 @@ import jaSettings from './locales/ja/settings.json';
 import jaDashboard from './locales/ja/dashboard.json';
 import jaChat from './locales/ja/chat.json';
 import jaChannels from './locales/ja/channels.json';
+import jaAgents from './locales/ja/agents.json';
 import jaSkills from './locales/ja/skills.json';
 import jaCron from './locales/ja/cron.json';
 import jaSetup from './locales/ja/setup.json';
@@ -46,6 +49,7 @@ const resources = {
         dashboard: enDashboard,
         chat: enChat,
         channels: enChannels,
+        agents: enAgents,
         skills: enSkills,
         cron: enCron,
         setup: enSetup,
@@ -56,6 +60,7 @@ const resources = {
         dashboard: zhDashboard,
         chat: zhChat,
         channels: zhChannels,
+        agents: zhAgents,
         skills: zhSkills,
         cron: zhCron,
         setup: zhSetup,
@@ -66,6 +71,7 @@ const resources = {
         dashboard: jaDashboard,
         chat: jaChat,
         channels: jaChannels,
+        agents: jaAgents,
         skills: jaSkills,
         cron: jaCron,
         setup: jaSetup,
@@ -79,7 +85,7 @@ i18n
         lng: 'en', // will be overridden by settings store
         fallbackLng: 'en',
         defaultNS: 'common',
-        ns: ['common', 'settings', 'dashboard', 'chat', 'channels', 'skills', 'cron', 'setup'],
+        ns: ['common', 'settings', 'dashboard', 'chat', 'channels', 'agents', 'skills', 'cron', 'setup'],
         interpolation: {
             escapeValue: false, // React already escapes
         },
diff --git a/src/i18n/locales/en/agents.json b/src/i18n/locales/en/agents.json
new file mode 100644
index 000000000..dfb09b4f4
--- /dev/null
+++ b/src/i18n/locales/en/agents.json
@@ -0,0 +1,51 @@
+{
+    "title": "Agents",
+    "subtitle": "Manage your OpenClaw agents and their channel ownership",
+    "refresh": "Refresh",
+    "addAgent": "Add Agent",
+    "gatewayWarning": "Gateway service is not running. Agent/channel changes may take a moment to apply.",
+    "defaultBadge": "default",
+    "inherited": "inherited",
+    "none": "none",
+    "modelLine": "Model: {{model}}{{suffix}}",
+    "channelsLine": "Channels: {{channels}}",
+    "deleteAgent": "Delete Agent",
+    "settings": "Settings",
+    "creating": "Creating...",
+    "createDialog": {
+        "title": "Add Agent",
+        "description": "Create a new agent by name. ClawX will copy the main agent's workspace bootstrap files and runtime auth setup.",
+        "nameLabel": "Agent Name",
+        "namePlaceholder": "Coding Helper"
+    },
+    "deleteDialog": {
+        "title": "Delete Agent",
+        "message": "Delete \"{{name}}\" from ClawX? Existing workspace and session files will be left on disk."
+    },
+    "settingsDialog": {
+        "title": "{{name}} Settings",
+        "description": "Update the agent name and manage which channels belong to this agent.",
+        "nameLabel": "Agent Name",
+        "agentIdLabel": "Agent ID",
+        "modelLabel": "Model",
+        "channelsTitle": "Channels",
+        "channelsDescription": "Each channel type has a single ClawX configuration. Saving a configured channel here moves ownership to this agent.",
+        "addChannel": "Add Channel",
+        "noChannels": "No channels are assigned to this agent yet."
+    },
+    "removeChannelDialog": {
+        "title": "Remove Channel",
+        "message": "Remove {{name}} from ClawX? This deletes the current channel configuration."
+    },
+    "toast": {
+        "agentCreated": "Agent created",
+        "agentCreateFailed": "Failed to create agent: {{error}}",
+        "agentDeleted": "Agent deleted",
+        "agentUpdated": "Agent updated",
+        "agentUpdateFailed": "Failed to update agent: {{error}}",
+        "channelAssigned": "{{channel}} assigned to agent",
+        "channelAssignFailed": "Failed to assign channel: {{error}}",
+        "channelRemoved": "{{channel}} removed",
+        "channelRemoveFailed": "Failed to remove channel: {{error}}"
+    }
+}
diff --git a/src/i18n/locales/en/common.json b/src/i18n/locales/en/common.json
index a0ed61c8a..5d821bdb4 100644
--- a/src/i18n/locales/en/common.json
+++ b/src/i18n/locales/en/common.json
@@ -4,6 +4,7 @@
         "newChat": "New Chat",
         "cronTasks": "Cron Tasks",
         "skills": "Skills",
+        "agents": "Agents",
         "channels": "Channels",
         "dashboard": "Dashboard",
         "settings": "Settings",
diff --git a/src/i18n/locales/ja/agents.json b/src/i18n/locales/ja/agents.json
new file mode 100644
index 000000000..8ed8230ba
--- /dev/null
+++ b/src/i18n/locales/ja/agents.json
@@ -0,0 +1,51 @@
+{
+    "title": "Agents",
+    "subtitle": "OpenClaw エージェントとチャンネルの所属を管理します",
+    "refresh": "更新",
+    "addAgent": "Agent を追加",
+    "gatewayWarning": "Gateway サービスが停止しています。Agent または Channel の変更が反映されるまで少し時間がかかる場合があります。",
+    "defaultBadge": "default",
+    "inherited": "継承",
+    "none": "なし",
+    "modelLine": "Model: {{model}}{{suffix}}",
+    "channelsLine": "Channels: {{channels}}",
+    "deleteAgent": "Agent を削除",
+    "settings": "設定",
+    "creating": "作成中...",
+    "createDialog": {
+        "title": "Agent を追加",
+        "description": "名前だけで新しい Agent を作成できます。ClawX はメイン Agent のワークスペース初期ファイルと認証設定をコピーします。",
+        "nameLabel": "Agent 名",
+        "namePlaceholder": "Coding Helper"
+    },
+    "deleteDialog": {
+        "title": "Agent を削除",
+        "message": "ClawX から「{{name}}」を削除しますか？既存のワークスペースとセッションファイルはディスク上に残ります。"
+    },
+    "settingsDialog": {
+        "title": "{{name}} Settings",
+        "description": "Agent 名を更新し、この Agent に属する Channel を管理します。",
+        "nameLabel": "Agent 名",
+        "agentIdLabel": "Agent ID",
+        "modelLabel": "Model",
+        "channelsTitle": "Channels",
+        "channelsDescription": "各 Channel 種別は ClawX で 1 つだけ設定されます。ここで既存の Channel を保存すると、この Agent に所属が移動します。",
+        "addChannel": "Channel を追加",
+        "noChannels": "この Agent にはまだ Channel が割り当てられていません。"
+    },
+    "removeChannelDialog": {
+        "title": "Channel を削除",
+        "message": "{{name}} を削除しますか？現在の Channel 設定も削除されます。"
+    },
+    "toast": {
+        "agentCreated": "Agent を作成しました",
+        "agentCreateFailed": "Agent の作成に失敗しました: {{error}}",
+        "agentDeleted": "Agent を削除しました",
+        "agentUpdated": "Agent を更新しました",
+        "agentUpdateFailed": "Agent の更新に失敗しました: {{error}}",
+        "channelAssigned": "{{channel}} を Agent に割り当てました",
+        "channelAssignFailed": "Channel の割り当てに失敗しました: {{error}}",
+        "channelRemoved": "{{channel}} を削除しました",
+        "channelRemoveFailed": "Channel の削除に失敗しました: {{error}}"
+    }
+}
diff --git a/src/i18n/locales/ja/common.json b/src/i18n/locales/ja/common.json
index 6784a7425..04907952d 100644
--- a/src/i18n/locales/ja/common.json
+++ b/src/i18n/locales/ja/common.json
@@ -4,6 +4,7 @@
         "newChat": "新しいチャット",
         "cronTasks": "定期タスク",
         "skills": "スキル",
+        "agents": "Agents",
         "channels": "チャンネル",
         "dashboard": "ダッシュボード",
         "settings": "設定",
diff --git a/src/i18n/locales/zh/agents.json b/src/i18n/locales/zh/agents.json
new file mode 100644
index 000000000..44a53e57f
--- /dev/null
+++ b/src/i18n/locales/zh/agents.json
@@ -0,0 +1,51 @@
+{
+    "title": "Agents",
+    "subtitle": "管理 OpenClaw Agent 以及它们的 Channel 归属",
+    "refresh": "刷新",
+    "addAgent": "添加 Agent",
+    "gatewayWarning": "Gateway 服务未运行。Agent 或 Channel 变更可能需要一点时间生效。",
+    "defaultBadge": "默认",
+    "inherited": "继承",
+    "none": "无",
+    "modelLine": "Model: {{model}}{{suffix}}",
+    "channelsLine": "Channels: {{channels}}",
+    "deleteAgent": "删除 Agent",
+    "settings": "设置",
+    "creating": "创建中...",
+    "createDialog": {
+        "title": "添加 Agent",
+        "description": "只需输入名称即可创建新 Agent。ClawX 会复制主 Agent 的工作区引导文件和运行时认证配置。",
+        "nameLabel": "Agent 名称",
+        "namePlaceholder": "Coding Helper"
+    },
+    "deleteDialog": {
+        "title": "删除 Agent",
+        "message": "确认从 ClawX 删除 “{{name}}”？已有的工作区和会话文件会保留在磁盘上。"
+    },
+    "settingsDialog": {
+        "title": "{{name}} 设置",
+        "description": "更新 Agent 名称，并管理哪些 Channel 归属于这个 Agent。",
+        "nameLabel": "Agent 名称",
+        "agentIdLabel": "Agent ID",
+        "modelLabel": "Model",
+        "channelsTitle": "Channels",
+        "channelsDescription": "每种 Channel 类型在 ClawX 中只保留一份配置。在这里保存已配置的 Channel 会将归属切换到当前 Agent。",
+        "addChannel": "添加 Channel",
+        "noChannels": "这个 Agent 还没有分配任何 Channel。"
+    },
+    "removeChannelDialog": {
+        "title": "移除 Channel",
+        "message": "确认移除 {{name}}？这会删除当前的 Channel 配置。"
+    },
+    "toast": {
+        "agentCreated": "Agent 已创建",
+        "agentCreateFailed": "创建 Agent 失败：{{error}}",
+        "agentDeleted": "Agent 已删除",
+        "agentUpdated": "Agent 已更新",
+        "agentUpdateFailed": "更新 Agent 失败：{{error}}",
+        "channelAssigned": "{{channel}} 已分配给 Agent",
+        "channelAssignFailed": "分配 Channel 失败：{{error}}",
+        "channelRemoved": "{{channel}} 已移除",
+        "channelRemoveFailed": "移除 Channel 失败：{{error}}"
+    }
+}
diff --git a/src/i18n/locales/zh/common.json b/src/i18n/locales/zh/common.json
index 418ab75ff..eb73c05b9 100644
--- a/src/i18n/locales/zh/common.json
+++ b/src/i18n/locales/zh/common.json
@@ -4,6 +4,7 @@
         "newChat": "新对话",
         "cronTasks": "定时任务",
         "skills": "技能",
+        "agents": "Agents",
         "channels": "频道",
         "dashboard": "仪表盘",
         "settings": "设置",
diff --git a/src/pages/Agents/index.tsx b/src/pages/Agents/index.tsx
new file mode 100644
index 000000000..2d2c33ded
--- /dev/null
+++ b/src/pages/Agents/index.tsx
@@ -0,0 +1,570 @@
+import { useEffect, useMemo, useState } from 'react';
+import { AlertCircle, Bot, Plus, RefreshCw, Settings2, Trash2, X } from 'lucide-react';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card';
+import { Badge } from '@/components/ui/badge';
+import { ConfirmDialog } from '@/components/ui/confirm-dialog';
+import { StatusBadge } from '@/components/common/StatusBadge';
+import { LoadingSpinner } from '@/components/common/LoadingSpinner';
+import { ChannelConfigModal } from '@/components/channels/ChannelConfigModal';
+import { useAgentsStore } from '@/stores/agents';
+import { useChannelsStore } from '@/stores/channels';
+import { useGatewayStore } from '@/stores/gateway';
+import { CHANNEL_ICONS, CHANNEL_NAMES, type ChannelType } from '@/types/channel';
+import type { AgentSummary } from '@/types/agent';
+import { useTranslation } from 'react-i18next';
+import { toast } from 'sonner';
+import { cn } from '@/lib/utils';
+import telegramIcon from '@/assets/channels/telegram.svg';
+import discordIcon from '@/assets/channels/discord.svg';
+import whatsappIcon from '@/assets/channels/whatsapp.svg';
+import dingtalkIcon from '@/assets/channels/dingtalk.svg';
+import feishuIcon from '@/assets/channels/feishu.svg';
+import wecomIcon from '@/assets/channels/wecom.svg';
+import qqIcon from '@/assets/channels/qq.svg';
+
+export function Agents() {
+  const { t } = useTranslation('agents');
+  const gatewayStatus = useGatewayStore((state) => state.status);
+  const {
+    agents,
+    loading,
+    error,
+    fetchAgents,
+    createAgent,
+    deleteAgent,
+  } = useAgentsStore();
+  const { channels, fetchChannels } = useChannelsStore();
+
+  const [showAddDialog, setShowAddDialog] = useState(false);
+  const [activeAgentId, setActiveAgentId] = useState<string | null>(null);
+  const [agentToDelete, setAgentToDelete] = useState<AgentSummary | null>(null);
+
+  useEffect(() => {
+    void Promise.all([fetchAgents(), fetchChannels()]);
+  }, [fetchAgents, fetchChannels]);
+  const activeAgent = useMemo(
+    () => agents.find((agent) => agent.id === activeAgentId) ?? null,
+    [activeAgentId, agents],
+  );
+  const handleRefresh = () => {
+    void Promise.all([fetchAgents(), fetchChannels()]);
+  };
+
+  if (loading) {
+    return (
+      <div className="flex flex-col -m-6 dark:bg-background min-h-[calc(100vh-2.5rem)] items-center justify-center">
+        <LoadingSpinner size="lg" />
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex flex-col -m-6 dark:bg-background h-[calc(100vh-2.5rem)] overflow-hidden">
+      <div className="w-full max-w-5xl mx-auto flex flex-col h-full p-10 pt-16">
+        <div className="flex flex-col md:flex-row md:items-start justify-between mb-12 shrink-0 gap-4">
+          <div>
+            <h1
+              className="text-5xl md:text-6xl font-serif text-foreground mb-3 font-normal tracking-tight"
+              style={{ fontFamily: 'Georgia, Cambria, "Times New Roman", Times, serif' }}
+            >
+              {t('title')}
+            </h1>
+            <p className="text-[17px] text-foreground/80 font-medium">{t('subtitle')}</p>
+          </div>
+          <div className="flex items-center gap-3 md:mt-2">
+            <Button
+              variant="outline"
+              onClick={handleRefresh}
+              className="h-9 text-[13px] font-medium rounded-full px-4 border-black/10 dark:border-white/10 bg-transparent hover:bg-black/5 dark:hover:bg-white/5 shadow-none text-foreground/80 hover:text-foreground transition-colors"
+            >
+              <RefreshCw className="h-3.5 w-3.5 mr-2" />
+              {t('refresh')}
+            </Button>
+            <Button
+              onClick={() => setShowAddDialog(true)}
+              className="h-9 text-[13px] font-medium rounded-full px-4 shadow-none"
+            >
+              <Plus className="h-3.5 w-3.5 mr-2" />
+              {t('addAgent')}
+            </Button>
+          </div>
+        </div>
+
+        <div className="flex-1 overflow-y-auto pr-2 pb-10 min-h-0 -mr-2">
+          {gatewayStatus.state !== 'running' && (
+            <div className="mb-8 p-4 rounded-xl border border-yellow-500/50 bg-yellow-500/10 flex items-center gap-3">
+              <AlertCircle className="h-5 w-5 text-yellow-600 dark:text-yellow-400" />
+              <span className="text-yellow-700 dark:text-yellow-400 text-sm font-medium">
+                {t('gatewayWarning')}
+              </span>
+            </div>
+          )}
+
+          {error && (
+            <div className="mb-8 p-4 rounded-xl border border-destructive/50 bg-destructive/10 flex items-center gap-3">
+              <AlertCircle className="h-5 w-5 text-destructive" />
+              <span className="text-destructive text-sm font-medium">
+                {error}
+              </span>
+            </div>
+          )}
+
+          <div className="space-y-3">
+            {agents.map((agent) => (
+              <AgentCard
+                key={agent.id}
+                agent={agent}
+                onOpenSettings={() => setActiveAgentId(agent.id)}
+                onDelete={() => setAgentToDelete(agent)}
+              />
+            ))}
+          </div>
+        </div>
+      </div>
+
+      {showAddDialog && (
+        <AddAgentDialog
+          onClose={() => setShowAddDialog(false)}
+          onCreate={async (name) => {
+            await createAgent(name);
+            setShowAddDialog(false);
+            toast.success(t('toast.agentCreated'));
+          }}
+        />
+      )}
+
+      {activeAgent && (
+        <AgentSettingsModal
+          agent={activeAgent}
+          channels={channels}
+          onClose={() => setActiveAgentId(null)}
+        />
+      )}
+
+      <ConfirmDialog
+        open={!!agentToDelete}
+        title={t('deleteDialog.title')}
+        message={agentToDelete ? t('deleteDialog.message', { name: agentToDelete.name }) : ''}
+        confirmLabel={t('common:actions.delete')}
+        cancelLabel={t('common:actions.cancel')}
+        variant="destructive"
+        onConfirm={async () => {
+          if (!agentToDelete) return;
+          await deleteAgent(agentToDelete.id);
+          setAgentToDelete(null);
+          if (activeAgentId === agentToDelete.id) {
+            setActiveAgentId(null);
+          }
+          toast.success(t('toast.agentDeleted'));
+        }}
+        onCancel={() => setAgentToDelete(null)}
+      />
+    </div>
+  );
+}
+
+function AgentCard({
+  agent,
+  onOpenSettings,
+  onDelete,
+}: {
+  agent: AgentSummary;
+  onOpenSettings: () => void;
+  onDelete: () => void;
+}) {
+  const { t } = useTranslation('agents');
+  const channelsText = agent.channelTypes.length > 0
+    ? agent.channelTypes.map((channelType) => CHANNEL_NAMES[channelType as ChannelType] || channelType).join(', ')
+    : t('none');
+
+  return (
+    <div
+      className={cn(
+        'group flex items-start gap-4 p-4 rounded-2xl transition-all text-left border relative overflow-hidden bg-transparent border-transparent hover:bg-black/5 dark:hover:bg-white/5',
+        agent.isDefault && 'bg-black/[0.04] dark:bg-white/[0.06]'
+      )}
+    >
+      <div className="h-[46px] w-[46px] shrink-0 flex items-center justify-center text-primary bg-primary/10 rounded-full shadow-sm mb-3">
+        <Bot className="h-[22px] w-[22px]" />
+      </div>
+      <div className="flex flex-col flex-1 min-w-0 py-0.5 mt-1">
+        <div className="flex items-center justify-between gap-3 mb-1">
+          <div className="flex items-center gap-2 min-w-0">
+            <h2 className="text-[16px] font-semibold text-foreground truncate">{agent.name}</h2>
+            {agent.isDefault && (
+              <Badge
+                variant="secondary"
+                className="font-mono text-[10px] font-medium px-2 py-0.5 rounded-full bg-black/[0.04] dark:bg-white/[0.08] border-0 shadow-none text-foreground/70"
+              >
+                {t('defaultBadge')}
+              </Badge>
+            )}
+          </div>
+          <div className="flex items-center gap-1 shrink-0">
+            {!agent.isDefault && (
+              <Button
+                variant="ghost"
+                size="icon"
+                className="opacity-0 group-hover:opacity-100 h-7 w-7 text-muted-foreground hover:text-destructive hover:bg-destructive/10 transition-all"
+                onClick={onDelete}
+                title={t('deleteAgent')}
+              >
+                <Trash2 className="h-4 w-4" />
+              </Button>
+            )}
+            <Button
+              variant="ghost"
+              size="icon"
+              className={cn(
+                'h-7 w-7 text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/10 transition-all',
+                !agent.isDefault && 'opacity-0 group-hover:opacity-100',
+              )}
+              onClick={onOpenSettings}
+              title={t('settings')}
+            >
+              <Settings2 className="h-4 w-4" />
+            </Button>
+          </div>
+        </div>
+        <p className="text-[13.5px] text-muted-foreground line-clamp-2 leading-[1.5]">
+          {t('modelLine', {
+            model: agent.modelDisplay,
+            suffix: agent.inheritedModel ? ` (${t('inherited')})` : '',
+          })}
+        </p>
+        <p className="text-[13.5px] text-muted-foreground line-clamp-2 leading-[1.5]">
+          {t('channelsLine', { channels: channelsText })}
+        </p>
+      </div>
+    </div>
+  );
+}
+
+const inputClasses = 'h-[44px] rounded-xl font-mono text-[13px] bg-[#eeece3] dark:bg-[#151514] border-black/10 dark:border-white/10 focus-visible:ring-2 focus-visible:ring-blue-500/50 focus-visible:border-blue-500 shadow-sm transition-all text-foreground placeholder:text-foreground/40';
+const labelClasses = 'text-[14px] text-foreground/80 font-bold';
+
+function ChannelLogo({ type }: { type: ChannelType }) {
+  switch (type) {
+    case 'telegram':
+      return <img src={telegramIcon} alt="Telegram" className="w-[20px] h-[20px] dark:invert" />;
+    case 'discord':
+      return <img src={discordIcon} alt="Discord" className="w-[20px] h-[20px] dark:invert" />;
+    case 'whatsapp':
+      return <img src={whatsappIcon} alt="WhatsApp" className="w-[20px] h-[20px] dark:invert" />;
+    case 'dingtalk':
+      return <img src={dingtalkIcon} alt="DingTalk" className="w-[20px] h-[20px] dark:invert" />;
+    case 'feishu':
+      return <img src={feishuIcon} alt="Feishu" className="w-[20px] h-[20px] dark:invert" />;
+    case 'wecom':
+      return <img src={wecomIcon} alt="WeCom" className="w-[20px] h-[20px] dark:invert" />;
+    case 'qqbot':
+      return <img src={qqIcon} alt="QQ" className="w-[20px] h-[20px] dark:invert" />;
+    default:
+      return <span className="text-[20px] leading-none">{CHANNEL_ICONS[type] || '💬'}</span>;
+  }
+}
+
+function AddAgentDialog({
+  onClose,
+  onCreate,
+}: {
+  onClose: () => void;
+  onCreate: (name: string) => Promise<void>;
+}) {
+  const { t } = useTranslation('agents');
+  const [name, setName] = useState('');
+  const [saving, setSaving] = useState(false);
+
+  const handleSubmit = async () => {
+    if (!name.trim()) return;
+    setSaving(true);
+    try {
+      await onCreate(name.trim());
+    } catch (error) {
+      toast.error(t('toast.agentCreateFailed', { error: String(error) }));
+      setSaving(false);
+      return;
+    }
+    setSaving(false);
+  };
+
+  return (
+    <div className="fixed inset-0 z-50 bg-black/50 flex items-center justify-center p-4">
+      <Card className="w-full max-w-md rounded-3xl border-0 shadow-2xl bg-[#f3f1e9] dark:bg-[#1a1a19] overflow-hidden">
+        <CardHeader className="pb-2">
+          <CardTitle className="text-2xl font-serif font-normal tracking-tight">
+            {t('createDialog.title')}
+          </CardTitle>
+          <CardDescription className="text-[15px] mt-1 text-foreground/70">
+            {t('createDialog.description')}
+          </CardDescription>
+        </CardHeader>
+        <CardContent className="space-y-6 pt-4 p-6">
+          <div className="space-y-2.5">
+            <Label htmlFor="agent-name" className={labelClasses}>{t('createDialog.nameLabel')}</Label>
+            <Input
+              id="agent-name"
+              value={name}
+              onChange={(event) => setName(event.target.value)}
+              placeholder={t('createDialog.namePlaceholder')}
+              className={inputClasses}
+            />
+          </div>
+          <div className="flex justify-end gap-2">
+            <Button
+              variant="outline"
+              onClick={onClose}
+              className="h-9 text-[13px] font-medium rounded-full px-4 border-black/10 dark:border-white/10 bg-transparent hover:bg-black/5 dark:hover:bg-white/5 shadow-none text-foreground/80 hover:text-foreground"
+            >
+              {t('common:actions.cancel')}
+            </Button>
+            <Button
+              onClick={() => void handleSubmit()}
+              disabled={saving || !name.trim()}
+              className="h-9 text-[13px] font-medium rounded-full px-4 shadow-none"
+            >
+              {saving ? (
+                <>
+                  <RefreshCw className="h-4 w-4 mr-2 animate-spin" />
+                  {t('creating')}
+                </>
+              ) : (
+                t('common:actions.save')
+              )}
+            </Button>
+          </div>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}
+
+function AgentSettingsModal({
+  agent,
+  channels,
+  onClose,
+}: {
+  agent: AgentSummary;
+  channels: Array<{ type: string; name: string; status: 'connected' | 'connecting' | 'disconnected' | 'error'; error?: string }>;
+  onClose: () => void;
+}) {
+  const { t } = useTranslation('agents');
+  const { updateAgent, assignChannel, removeChannel } = useAgentsStore();
+  const { fetchChannels } = useChannelsStore();
+  const [name, setName] = useState(agent.name);
+  const [savingName, setSavingName] = useState(false);
+  const [showChannelModal, setShowChannelModal] = useState(false);
+  const [channelToRemove, setChannelToRemove] = useState<ChannelType | null>(null);
+
+  useEffect(() => {
+    setName(agent.name);
+  }, [agent.name]);
+
+  const runtimeChannelsByType = useMemo(
+    () => Object.fromEntries(channels.map((channel) => [channel.type, channel])),
+    [channels],
+  );
+
+  const handleSaveName = async () => {
+    if (!name.trim() || name.trim() === agent.name) return;
+    setSavingName(true);
+    try {
+      await updateAgent(agent.id, name.trim());
+      toast.success(t('toast.agentUpdated'));
+    } catch (error) {
+      toast.error(t('toast.agentUpdateFailed', { error: String(error) }));
+    } finally {
+      setSavingName(false);
+    }
+  };
+
+  const handleChannelSaved = async (channelType: ChannelType) => {
+    try {
+      await assignChannel(agent.id, channelType);
+      await fetchChannels();
+      toast.success(t('toast.channelAssigned', { channel: CHANNEL_NAMES[channelType] || channelType }));
+    } catch (error) {
+      toast.error(t('toast.channelAssignFailed', { error: String(error) }));
+      throw error;
+    }
+  };
+
+  const assignedChannels = agent.channelTypes.map((channelType) => {
+    const runtimeChannel = runtimeChannelsByType[channelType];
+    return {
+      channelType: channelType as ChannelType,
+      name: runtimeChannel?.name || CHANNEL_NAMES[channelType as ChannelType] || channelType,
+      status: runtimeChannel?.status || 'disconnected',
+      error: runtimeChannel?.error,
+    };
+  });
+
+  return (
+    <div className="fixed inset-0 z-50 bg-black/50 flex items-center justify-center p-4">
+      <Card className="w-full max-w-2xl max-h-[90vh] flex flex-col rounded-3xl border-0 shadow-2xl bg-[#f3f1e9] dark:bg-[#1a1a19] overflow-hidden">
+        <CardHeader className="flex flex-row items-start justify-between pb-2 shrink-0">
+          <div>
+            <CardTitle className="text-2xl font-serif font-normal tracking-tight">
+              {t('settingsDialog.title', { name: agent.name })}
+            </CardTitle>
+            <CardDescription className="text-[15px] mt-1 text-foreground/70">
+              {t('settingsDialog.description')}
+            </CardDescription>
+          </div>
+          <Button
+            variant="ghost"
+            size="icon"
+            onClick={onClose}
+            className="rounded-full h-8 w-8 -mr-2 -mt-2 text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5"
+          >
+            <X className="h-4 w-4" />
+          </Button>
+        </CardHeader>
+        <CardContent className="space-y-6 pt-4 overflow-y-auto flex-1 p-6">
+          <div className="space-y-4">
+            <div className="space-y-2.5">
+              <Label htmlFor="agent-settings-name" className={labelClasses}>{t('settingsDialog.nameLabel')}</Label>
+              <div className="flex gap-2">
+                <Input
+                  id="agent-settings-name"
+                  value={name}
+                  onChange={(event) => setName(event.target.value)}
+                  readOnly={agent.isDefault}
+                  className={inputClasses}
+                />
+                {!agent.isDefault && (
+                  <Button
+                    variant="outline"
+                    onClick={() => void handleSaveName()}
+                    disabled={savingName || !name.trim() || name.trim() === agent.name}
+                    className="h-[44px] text-[13px] font-medium rounded-xl px-4 border-black/10 dark:border-white/10 bg-[#eeece3] dark:bg-[#151514] hover:bg-black/5 dark:hover:bg-white/5 shadow-none text-foreground/80 hover:text-foreground"
+                  >
+                    {savingName ? (
+                      <RefreshCw className="h-4 w-4 animate-spin" />
+                    ) : (
+                      t('common:actions.save')
+                    )}
+                  </Button>
+                )}
+              </div>
+            </div>
+
+            <div className="grid gap-4 md:grid-cols-2">
+              <div className="space-y-1 rounded-2xl bg-black/5 dark:bg-white/5 border border-transparent p-4">
+                <p className="text-[11px] uppercase tracking-[0.08em] text-muted-foreground/80 font-medium">
+                  {t('settingsDialog.agentIdLabel')}
+                </p>
+                <p className="font-mono text-[13px] text-foreground">{agent.id}</p>
+              </div>
+              <div className="space-y-1 rounded-2xl bg-black/5 dark:bg-white/5 border border-transparent p-4">
+                <p className="text-[11px] uppercase tracking-[0.08em] text-muted-foreground/80 font-medium">
+                  {t('settingsDialog.modelLabel')}
+                </p>
+                <p className="text-[13.5px] text-foreground">
+                  {agent.modelDisplay}
+                  {agent.inheritedModel ? ` (${t('inherited')})` : ''}
+                </p>
+              </div>
+            </div>
+          </div>
+
+          <div className="space-y-4">
+            <div className="flex items-start justify-between gap-4">
+              <div>
+                <h3 className="text-xl font-serif text-foreground font-normal tracking-tight">
+                  {t('settingsDialog.channelsTitle')}
+                </h3>
+                <p className="text-[14px] text-foreground/70 mt-1">{t('settingsDialog.channelsDescription')}</p>
+              </div>
+              <Button
+                onClick={() => setShowChannelModal(true)}
+                className="h-9 text-[13px] font-medium rounded-full px-4 shadow-none"
+              >
+                <Plus className="h-3.5 w-3.5 mr-2" />
+                {t('settingsDialog.addChannel')}
+              </Button>
+            </div>
+
+            {assignedChannels.length === 0 ? (
+              <div className="rounded-2xl border border-dashed border-black/10 dark:border-white/10 bg-black/5 dark:bg-white/5 p-4 text-[13.5px] text-muted-foreground">
+                {t('settingsDialog.noChannels')}
+              </div>
+            ) : (
+              <div className="space-y-3">
+                {assignedChannels.map((channel) => (
+                  <div key={channel.channelType} className="flex items-center justify-between rounded-2xl bg-black/5 dark:bg-white/5 border border-transparent p-4">
+                    <div className="flex items-center gap-3 min-w-0">
+                      <div className="h-[40px] w-[40px] shrink-0 flex items-center justify-center text-foreground bg-black/5 dark:bg-white/5 border border-black/5 dark:border-white/10 rounded-full shadow-sm">
+                        <ChannelLogo type={channel.channelType} />
+                      </div>
+                      <div className="min-w-0">
+                        <p className="text-[15px] font-semibold text-foreground">{channel.name}</p>
+                        <p className="text-[13.5px] text-muted-foreground">
+                          {CHANNEL_NAMES[channel.channelType]}
+                        </p>
+                        {channel.error && (
+                          <p className="text-xs text-destructive mt-1">{channel.error}</p>
+                        )}
+                      </div>
+                    </div>
+                    <div className="flex items-center gap-2 shrink-0">
+                      <StatusBadge status={channel.status} />
+                      <Button
+                        variant="ghost"
+                        size="icon"
+                        className="h-7 w-7 text-muted-foreground hover:text-destructive hover:bg-destructive/10"
+                        onClick={() => setChannelToRemove(channel.channelType)}
+                      >
+                        <Trash2 className="h-4 w-4" />
+                      </Button>
+                    </div>
+                  </div>
+                ))}
+              </div>
+            )}
+          </div>
+        </CardContent>
+      </Card>
+
+      {showChannelModal && (
+        <ChannelConfigModal
+          configuredTypes={agent.channelTypes}
+          showChannelName={false}
+          allowExistingConfig
+          onClose={() => setShowChannelModal(false)}
+          onChannelSaved={async (channelType) => {
+            await handleChannelSaved(channelType);
+            setShowChannelModal(false);
+          }}
+        />
+      )}
+
+      <ConfirmDialog
+        open={!!channelToRemove}
+        title={t('removeChannelDialog.title')}
+        message={channelToRemove ? t('removeChannelDialog.message', { name: CHANNEL_NAMES[channelToRemove] || channelToRemove }) : ''}
+        confirmLabel={t('common:actions.delete')}
+        cancelLabel={t('common:actions.cancel')}
+        variant="destructive"
+        onConfirm={async () => {
+          if (!channelToRemove) return;
+          try {
+            await removeChannel(agent.id, channelToRemove);
+            await fetchChannels();
+            toast.success(t('toast.channelRemoved', { channel: CHANNEL_NAMES[channelToRemove] || channelToRemove }));
+          } catch (error) {
+            toast.error(t('toast.channelRemoveFailed', { error: String(error) }));
+          } finally {
+            setChannelToRemove(null);
+          }
+        }}
+        onCancel={() => setChannelToRemove(null)}
+      />
+    </div>
+  );
+}
+
+export default Agents;
diff --git a/src/pages/Channels/index.tsx b/src/pages/Channels/index.tsx
index 92acc8994..89d6178d1 100644
--- a/src/pages/Channels/index.tsx
+++ b/src/pages/Channels/index.tsx
@@ -2,27 +2,9 @@
  * Channels Page
  * Manage messaging channel connections with configuration UI
  */
-import { useState, useEffect, useCallback, useRef } from 'react';
-import {
-  RefreshCw,
-  Trash2,
-  QrCode,
-  Loader2,
-  X,
-  ExternalLink,
-  BookOpen,
-  Eye,
-  EyeOff,
-  Check,
-  AlertCircle,
-  CheckCircle,
-  ShieldCheck,
-} from 'lucide-react';
+import { useState, useEffect, useCallback } from 'react';
+import { RefreshCw, Trash2, AlertCircle } from 'lucide-react';
 import { Button } from '@/components/ui/button';
-import { Input } from '@/components/ui/input';
-import { Label } from '@/components/ui/label';
-import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card';
-import { Separator } from '@/components/ui/separator';
 import { Badge } from '@/components/ui/badge';
 import { ConfirmDialog } from '@/components/ui/confirm-dialog';
 import { useChannelsStore } from '@/stores/channels';
@@ -30,7 +12,7 @@ import { useGatewayStore } from '@/stores/gateway';
 import { LoadingSpinner } from '@/components/common/LoadingSpinner';
 import { hostApiFetch } from '@/lib/host-api';
 import { subscribeHostEvent } from '@/lib/host-events';
-import { invokeIpc } from '@/lib/api-client';
+import { ChannelConfigModal } from '@/components/channels/ChannelConfigModal';
 import { cn } from '@/lib/utils';
 import {
   CHANNEL_ICONS,
@@ -39,10 +21,7 @@ import {
   getPrimaryChannels,
   type ChannelType,
   type Channel,
-  type ChannelMeta,
-  type ChannelConfigField,
 } from '@/types/channel';
-import { toast } from 'sonner';
 import { useTranslation } from 'react-i18next';
 
 import telegramIcon from '@/assets/channels/telegram.svg';
@@ -63,12 +42,10 @@ export function Channels() {
   const [configuredTypes, setConfiguredTypes] = useState<string[]>([]);
   const [channelToDelete, setChannelToDelete] = useState<{ id: string } | null>(null);
 
-  // Fetch channels on mount
   useEffect(() => {
-    fetchChannels();
+    void fetchChannels();
   }, [fetchChannels]);
 
-  // Fetch configured channel types from config file
   const fetchConfiguredTypes = useCallback(async () => {
     try {
       const result = await hostApiFetch<{
@@ -79,19 +56,21 @@ export function Channels() {
         setConfiguredTypes(result.channels);
       }
     } catch {
-      // ignore
+      // Ignore refresh errors here and keep the last known state.
     }
   }, []);
 
   useEffect(() => {
-    // eslint-disable-next-line react-hooks/set-state-in-effect
-    void fetchConfiguredTypes();
+    const timer = window.setTimeout(() => {
+      void fetchConfiguredTypes();
+    }, 0);
+    return () => window.clearTimeout(timer);
   }, [fetchConfiguredTypes]);
 
   useEffect(() => {
     const unsubscribe = subscribeHostEvent('gateway:channel-status', () => {
-      fetchChannels();
-      fetchConfiguredTypes();
+      void fetchChannels();
+      void fetchConfiguredTypes();
     });
     return () => {
       if (typeof unsubscribe === 'function') {
@@ -100,9 +79,12 @@ export function Channels() {
     };
   }, [fetchChannels, fetchConfiguredTypes]);
 
-  // Get channel types to display
   const displayedChannelTypes = getPrimaryChannels();
 
+  const handleRefresh = () => {
+    void Promise.all([fetchChannels(), fetchConfiguredTypes()]);
+  };
+
   if (loading) {
     return (
       <div className="flex flex-col -m-6 dark:bg-background min-h-[calc(100vh-2.5rem)] items-center justify-center">
@@ -116,9 +98,7 @@ export function Channels() {
   return (
     <div className="flex flex-col -m-6 dark:bg-background h-[calc(100vh-2.5rem)] overflow-hidden">
       <div className="w-full max-w-5xl mx-auto flex flex-col h-full p-10 pt-16">
-
-        {/* Header */}
-        <div className="flex flex-col md:flex-row md:items-start justify-between mb-8 shrink-0 gap-4">
+        <div className="flex flex-col md:flex-row md:items-start justify-between mb-12 shrink-0 gap-4">
           <div>
             <h1 className="text-5xl md:text-6xl font-serif text-foreground mb-3 font-normal tracking-tight" style={{ fontFamily: 'Georgia, Cambria, "Times New Roman", Times, serif' }}>
               {t('title')}
@@ -131,10 +111,7 @@ export function Channels() {
           <div className="flex items-center gap-3 md:mt-2">
             <Button
               variant="outline"
-              onClick={() => {
-                void fetchChannels();
-                void fetchConfiguredTypes();
-              }}
+              onClick={handleRefresh}
               disabled={gatewayStatus.state !== 'running'}
               className="h-9 text-[13px] font-medium rounded-full px-4 border-black/10 dark:border-white/10 bg-transparent hover:bg-black/5 dark:hover:bg-white/5 shadow-none text-foreground/80 hover:text-foreground transition-colors"
             >
@@ -143,10 +120,8 @@ export function Channels() {
             </Button>
           </div>
         </div>
-        {/* Content Area */}
-        <div className="flex-1 overflow-y-auto min-h-0 pr-2 -mr-2 space-y-8 pb-10">
 
-          {/* Gateway Warning */}
+        <div className="flex-1 overflow-y-auto pr-2 pb-10 min-h-0 -mr-2">
           {gatewayStatus.state !== 'running' && (
             <div className="mb-8 p-4 rounded-xl border border-yellow-500/50 bg-yellow-500/10 flex items-center gap-3">
               <AlertCircle className="h-5 w-5 text-yellow-600 dark:text-yellow-400" />
@@ -156,7 +131,6 @@ export function Channels() {
             </div>
           )}
 
-          {/* Error Display */}
           {error && (
             <div className="mb-8 p-4 rounded-xl border border-destructive/50 bg-destructive/10 flex items-center gap-3">
               <AlertCircle className="h-5 w-5 text-destructive" />
@@ -166,13 +140,12 @@ export function Channels() {
             </div>
           )}
 
-          {/* Available Channels (Configured) */}
           {safeChannels.length > 0 && (
             <div className="mb-12">
               <h2 className="text-3xl font-serif text-foreground mb-6 font-normal tracking-tight" style={{ fontFamily: 'Georgia, Cambria, "Times New Roman", Times, serif' }}>
                 {t('availableChannels')}
               </h2>
-              <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
+              <div className="grid grid-cols-1 md:grid-cols-2 gap-x-6 gap-y-4">
                 {safeChannels.map((channel) => (
                   <ChannelCard
                     key={channel.id}
@@ -184,7 +157,6 @@ export function Channels() {
             </div>
           )}
 
-          {/* Supported Channels (Not yet configured) */}
           <div className="mb-8">
             <h2 className="text-3xl font-serif text-foreground mb-6 font-normal tracking-tight" style={{ fontFamily: 'Georgia, Cambria, "Times New Roman", Times, serif' }}>
               {t('supportedChannels')}
@@ -193,9 +165,8 @@ export function Channels() {
             <div className="grid grid-cols-1 md:grid-cols-2 gap-x-6 gap-y-4">
               {displayedChannelTypes.map((type) => {
                 const meta = CHANNEL_META[type];
-                const isConfigured = safeChannels.some(c => c.type === type) || configuredTypes.includes(type);
-
-                // Hide already configured channels from "Supported Channels" section
+                const isConfigured = safeChannels.some((channel) => channel.type === type)
+                  || configuredTypes.includes(type);
                 if (isConfigured) return null;
 
                 return (
@@ -206,7 +177,7 @@ export function Channels() {
                       setShowAddDialog(true);
                     }}
                     className={cn(
-                      "group flex items-start gap-4 p-4 rounded-2xl transition-all text-left border relative overflow-hidden bg-transparent border-transparent hover:bg-black/5 dark:hover:bg-white/5"
+                      'group flex items-start gap-4 p-4 rounded-2xl transition-all text-left border relative overflow-hidden bg-transparent border-transparent hover:bg-black/5 dark:hover:bg-white/5'
                     )}
                   >
                     <div className="h-[46px] w-[46px] shrink-0 flex items-center justify-center text-foreground bg-black/5 dark:bg-white/5 border border-black/5 dark:border-white/10 rounded-full shadow-sm mb-3">
@@ -230,22 +201,19 @@ export function Channels() {
               })}
             </div>
           </div>
-
         </div>
       </div>
 
-      {/* Add Channel Dialog */}
       {showAddDialog && (
-        <AddChannelDialog
-          selectedType={selectedChannelType}
-          onSelectType={setSelectedChannelType}
+        <ChannelConfigModal
+          initialSelectedType={selectedChannelType}
+          configuredTypes={configuredTypes}
           onClose={() => {
             setShowAddDialog(false);
             setSelectedChannelType(null);
           }}
-          onChannelAdded={() => {
-            fetchChannels();
-            fetchConfiguredTypes();
+          onChannelSaved={async () => {
+            await Promise.all([fetchChannels(), fetchConfiguredTypes()]);
             setShowAddDialog(false);
             setSelectedChannelType(null);
           }}
@@ -262,8 +230,7 @@ export function Channels() {
         onConfirm={async () => {
           if (channelToDelete) {
             await deleteChannel(channelToDelete.id);
-            // Immediately update configuredTypes state so it disappears from available and appears in supported
-            const channelType = channelToDelete.id.split('-')[0];
+            const [channelType] = channelToDelete.id.split('-');
             setConfiguredTypes((prev) => prev.filter((type) => type !== channelType));
             setChannelToDelete(null);
           }
@@ -274,7 +241,6 @@ export function Channels() {
   );
 }
 
-// ==================== Channel Logo Component ====================
 function ChannelLogo({ type }: { type: ChannelType }) {
   switch (type) {
     case 'telegram':
@@ -296,8 +262,6 @@ function ChannelLogo({ type }: { type: ChannelType }) {
   }
 }
 
-// ==================== Channel Card Component ====================
-
 interface ChannelCardProps {
   channel: Channel;
   onDelete: () => void;
@@ -317,17 +281,23 @@ function ChannelCard({ channel, onDelete }: ChannelCardProps) {
           <div className="flex items-center gap-2 min-w-0">
             <h3 className="text-[16px] font-semibold text-foreground truncate">{channel.name}</h3>
             {meta?.isPlugin && (
-              <Badge variant="secondary" className="font-mono text-[10px] font-medium px-2 py-0.5 rounded-full bg-black/[0.04] dark:bg-white/[0.08] border-0 shadow-none text-foreground/70">
+              <Badge
+                variant="secondary"
+                className="font-mono text-[10px] font-medium px-2 py-0.5 rounded-full bg-black/[0.04] dark:bg-white/[0.08] border-0 shadow-none text-foreground/70"
+              >
                 {t('pluginBadge', 'Plugin')}
               </Badge>
             )}
             <div
               className={cn(
-                "w-2 h-2 rounded-full shrink-0",
-                channel.status === 'connected' ? "bg-green-500" :
-                  channel.status === 'connecting' ? "bg-yellow-500 animate-pulse" :
-                    channel.status === 'error' ? "bg-destructive" :
-                      "bg-muted-foreground"
+                'w-2 h-2 rounded-full shrink-0',
+                channel.status === 'connected'
+                  ? 'bg-green-500'
+                  : channel.status === 'connecting'
+                    ? 'bg-yellow-500 animate-pulse'
+                    : channel.status === 'error'
+                      ? 'bg-destructive'
+                      : 'bg-muted-foreground'
               )}
               title={channel.status}
             />
@@ -337,8 +307,8 @@ function ChannelCard({ channel, onDelete }: ChannelCardProps) {
             variant="ghost"
             size="icon"
             className="opacity-0 group-hover:opacity-100 h-7 w-7 text-muted-foreground hover:text-destructive hover:bg-destructive/10 transition-all shrink-0 -mr-2"
-            onClick={(e) => {
-              e.stopPropagation();
+            onClick={(event) => {
+              event.stopPropagation();
               onDelete();
             }}
           >
@@ -360,613 +330,4 @@ function ChannelCard({ channel, onDelete }: ChannelCardProps) {
   );
 }
 
-// ==================== Add Channel Dialog ====================
-
-interface AddChannelDialogProps {
-  selectedType: ChannelType | null;
-  onSelectType: (type: ChannelType | null) => void;
-  onClose: () => void;
-  onChannelAdded: () => void;
-}
-
-function AddChannelDialog({ selectedType, onSelectType, onClose, onChannelAdded }: AddChannelDialogProps) {
-  const { t } = useTranslation('channels');
-  const { addChannel } = useChannelsStore();
-  const [configValues, setConfigValues] = useState<Record<string, string>>({});
-  const [channelName, setChannelName] = useState('');
-  const [connecting, setConnecting] = useState(false);
-  const [showSecrets, setShowSecrets] = useState<Record<string, boolean>>({});
-  const [qrCode, setQrCode] = useState<string | null>(null);
-  const [validating, setValidating] = useState(false);
-  const [loadingConfig, setLoadingConfig] = useState(false);
-  const [isExistingConfig, setIsExistingConfig] = useState(false);
-  const firstInputRef = useRef<HTMLInputElement>(null);
-  const [validationResult, setValidationResult] = useState<{
-    valid: boolean;
-    errors: string[];
-    warnings: string[];
-  } | null>(null);
-
-  const meta: ChannelMeta | null = selectedType ? CHANNEL_META[selectedType] : null;
-
-  // Load existing config when a channel type is selected
-  useEffect(() => {
-    if (!selectedType) {
-      setConfigValues({});
-      setChannelName('');
-      setIsExistingConfig(false);
-      setChannelName('');
-      setIsExistingConfig(false);
-      // Ensure we clean up any pending QR session if switching away
-      hostApiFetch('/api/channels/whatsapp/cancel', { method: 'POST' }).catch(() => { });
-      return;
-    }
-
-    let cancelled = false;
-    setLoadingConfig(true);
-
-    (async () => {
-      try {
-        const result = await invokeIpc(
-          'channel:getFormValues',
-          selectedType
-        ) as { success: boolean; values?: Record<string, string> };
-
-        if (cancelled) return;
-
-        if (result.success && result.values && Object.keys(result.values).length > 0) {
-          setConfigValues(result.values);
-          setIsExistingConfig(true);
-        } else {
-          setConfigValues({});
-          setIsExistingConfig(false);
-        }
-      } catch {
-        if (!cancelled) {
-          setConfigValues({});
-          setIsExistingConfig(false);
-        }
-      } finally {
-        if (!cancelled) setLoadingConfig(false);
-      }
-    })();
-
-    return () => { cancelled = true; };
-  }, [selectedType]);
-
-  // Focus first input when form is ready (avoids Windows focus loss after native dialogs)
-  useEffect(() => {
-    if (selectedType && !loadingConfig && firstInputRef.current) {
-      firstInputRef.current.focus();
-    }
-  }, [selectedType, loadingConfig]);
-
-  // Listen for WhatsApp QR events
-  useEffect(() => {
-    if (selectedType !== 'whatsapp') return;
-
-    const onQr = (...args: unknown[]) => {
-      const data = args[0] as { qr: string; raw: string };
-      setQrCode(`data:image/png;base64,${data.qr}`);
-    };
-
-    const onSuccess = async (...args: unknown[]) => {
-      const data = args[0] as { accountId?: string } | undefined;
-      toast.success(t('toast.whatsappConnected'));
-      const accountId = data?.accountId || channelName.trim() || 'default';
-      try {
-        const saveResult = await hostApiFetch<{ success?: boolean; error?: string }>('/api/channels/config', {
-          method: 'POST',
-          body: JSON.stringify({ channelType: 'whatsapp', config: { enabled: true } }),
-        });
-        if (!saveResult?.success) {
-          console.error('Failed to save WhatsApp config:', saveResult?.error);
-        } else {
-          console.info('Saved WhatsApp config for account:', accountId);
-        }
-      } catch (error) {
-        console.error('Failed to save WhatsApp config:', error);
-      }
-      // Register the channel locally so it shows up immediately
-      addChannel({
-        type: 'whatsapp',
-        name: channelName || 'WhatsApp',
-      }).then(() => {
-        // Restart gateway to pick up the new session
-        useGatewayStore.getState().restart().catch(console.error);
-        onChannelAdded();
-      });
-    };
-
-    const onError = (...args: unknown[]) => {
-      const err = args[0] as string;
-      console.error('WhatsApp Login Error:', err);
-      toast.error(t('toast.whatsappFailed', { error: err }));
-      setQrCode(null);
-      setConnecting(false);
-    };
-
-    const removeQrListener = subscribeHostEvent('channel:whatsapp-qr', onQr);
-    const removeSuccessListener = subscribeHostEvent('channel:whatsapp-success', onSuccess);
-    const removeErrorListener = subscribeHostEvent('channel:whatsapp-error', onError);
-
-    return () => {
-      if (typeof removeQrListener === 'function') removeQrListener();
-      if (typeof removeSuccessListener === 'function') removeSuccessListener();
-      if (typeof removeErrorListener === 'function') removeErrorListener();
-      // Cancel when unmounting or switching types
-      hostApiFetch('/api/channels/whatsapp/cancel', { method: 'POST' }).catch(() => { });
-    };
-  }, [selectedType, addChannel, channelName, onChannelAdded, t]);
-
-  const handleValidate = async () => {
-    if (!selectedType) return;
-
-    setValidating(true);
-    setValidationResult(null);
-
-    try {
-      const result = await hostApiFetch<{
-        success: boolean;
-        valid?: boolean;
-        errors?: string[];
-        warnings?: string[];
-        details?: Record<string, string>;
-      }>('/api/channels/credentials/validate', {
-        method: 'POST',
-        body: JSON.stringify({ channelType: selectedType, config: configValues }),
-      });
-
-      const warnings = result.warnings || [];
-      if (result.valid && result.details) {
-        const details = result.details;
-        if (details.botUsername) warnings.push(`Bot: @${details.botUsername}`);
-        if (details.guildName) warnings.push(`Server: ${details.guildName}`);
-        if (details.channelName) warnings.push(`Channel: #${details.channelName}`);
-      }
-
-      setValidationResult({
-        valid: result.valid || false,
-        errors: result.errors || [],
-        warnings,
-      });
-    } catch (error) {
-      setValidationResult({
-        valid: false,
-        errors: [String(error)],
-        warnings: [],
-      });
-    } finally {
-      setValidating(false);
-    }
-  };
-
-
-  const handleConnect = async () => {
-    if (!selectedType || !meta) return;
-
-    setConnecting(true);
-    setValidationResult(null);
-
-    try {
-      // For QR-based channels, request QR code
-      if (meta.connectionType === 'qr') {
-        const accountId = channelName.trim() || 'default';
-        await hostApiFetch('/api/channels/whatsapp/start', {
-          method: 'POST',
-          body: JSON.stringify({ accountId }),
-        });
-        // The QR code will be set via event listener
-        return;
-      }
-
-      // Step 1: Validate credentials against the actual service API
-      if (meta.connectionType === 'token') {
-        const validationResponse = await hostApiFetch<{
-          success: boolean;
-          valid?: boolean;
-          errors?: string[];
-          warnings?: string[];
-          details?: Record<string, string>;
-        }>('/api/channels/credentials/validate', {
-          method: 'POST',
-          body: JSON.stringify({ channelType: selectedType, config: configValues }),
-        });
-
-        if (!validationResponse.valid) {
-          setValidationResult({
-            valid: false,
-            errors: validationResponse.errors || ['Validation failed'],
-            warnings: validationResponse.warnings || [],
-          });
-          setConnecting(false);
-          return;
-        }
-
-        // Show success details (bot name, guild name, etc.) as warnings/info
-        const warnings = validationResponse.warnings || [];
-        if (validationResponse.details) {
-          const details = validationResponse.details;
-          if (details.botUsername) {
-            warnings.push(`Bot: @${details.botUsername}`);
-          }
-          if (details.guildName) {
-            warnings.push(`Server: ${details.guildName}`);
-          }
-          if (details.channelName) {
-            warnings.push(`Channel: #${details.channelName}`);
-          }
-        }
-
-        // Show validation success with details
-        setValidationResult({
-          valid: true,
-          errors: [],
-          warnings,
-        });
-      }
-
-      // Step 2: Save channel configuration via IPC
-      const config: Record<string, unknown> = { ...configValues };
-      const saveResult = await hostApiFetch<{
-        success?: boolean;
-        error?: string;
-        warning?: string;
-        pluginInstalled?: boolean;
-      }>('/api/channels/config', {
-        method: 'POST',
-        body: JSON.stringify({ channelType: selectedType, config }),
-      });
-      if (!saveResult?.success) {
-        throw new Error(saveResult?.error || 'Failed to save channel config');
-      }
-      if (typeof saveResult.warning === 'string' && saveResult.warning) {
-        toast.warning(saveResult.warning);
-      }
-
-      // Step 3: Add a local channel entry for the UI
-      await addChannel({
-        type: selectedType,
-        name: channelName || CHANNEL_NAMES[selectedType],
-        token: configValues[meta.configFields[0]?.key] || undefined,
-      });
-
-      toast.success(t('toast.channelSaved', { name: meta.name }));
-
-      // Gateway restart is now handled server-side via debouncedRestart()
-      // inside the channel:saveConfig IPC handler, so we don't need to
-      // trigger it explicitly here.  This avoids cascading restarts when
-      // multiple config changes happen in quick succession (e.g. during
-      // the setup wizard).
-      toast.success(t('toast.channelConnecting', { name: meta.name }));
-
-      // Brief delay so user can see the success state before dialog closes
-      await new Promise((resolve) => setTimeout(resolve, 800));
-      onChannelAdded();
-    } catch (error) {
-      toast.error(t('toast.configFailed', { error }));
-      setConnecting(false);
-    }
-  };
-
-  const openDocs = () => {
-    if (meta?.docsUrl) {
-      const url = t(meta.docsUrl.replace('channels:', ''));
-      try {
-        if (window.electron?.openExternal) {
-          window.electron.openExternal(url);
-        } else {
-          // Fallback: open in new window
-          window.open(url, '_blank');
-        }
-      } catch (error) {
-        console.error('Failed to open docs:', error);
-        // Fallback: open in new window
-        window.open(url, '_blank');
-      }
-    }
-  };
-
-
-  const isFormValid = () => {
-    if (!meta) return false;
-
-    // Check all required fields are filled
-    return meta.configFields
-      .filter((field) => field.required)
-      .every((field) => configValues[field.key]?.trim());
-  };
-
-  const updateConfigValue = (key: string, value: string) => {
-    setConfigValues((prev) => ({ ...prev, [key]: value }));
-  };
-
-  const toggleSecretVisibility = (key: string) => {
-    setShowSecrets((prev) => ({ ...prev, [key]: !prev[key] }));
-  };
-
-  return (
-    <div className="fixed inset-0 z-50 bg-black/50 flex items-center justify-center p-4">
-      <Card className="w-full max-w-lg max-h-[90vh] flex flex-col rounded-3xl border-0 shadow-2xl bg-[#f3f1e9] dark:bg-[#1a1a19] overflow-hidden">
-        <CardHeader className="flex flex-row items-start justify-between pb-2 shrink-0">
-          <div>
-            <CardTitle className="text-2xl font-serif font-normal">
-              {selectedType
-                ? isExistingConfig
-                  ? t('dialog.updateTitle', { name: CHANNEL_NAMES[selectedType] })
-                  : t('dialog.configureTitle', { name: CHANNEL_NAMES[selectedType] })
-                : t('dialog.addTitle')}
-            </CardTitle>
-            <CardDescription className="text-[15px] mt-1 text-foreground/70">
-              {selectedType && isExistingConfig
-                ? t('dialog.existingDesc')
-                : meta ? t(meta.description.replace('channels:', '')) : t('dialog.selectDesc')}
-            </CardDescription>
-          </div>
-          <Button variant="ghost" size="icon" onClick={onClose} className="rounded-full h-8 w-8 -mr-2 -mt-2 text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5">
-            <X className="h-4 w-4" />
-          </Button>
-        </CardHeader>
-        <CardContent className="space-y-6 pt-4 overflow-y-auto flex-1 p-6">
-          {!selectedType ? (
-            // Channel type selection
-            <div className="grid grid-cols-2 gap-4">
-              {getPrimaryChannels().map((type) => {
-                const channelMeta = CHANNEL_META[type];
-                return (
-                  <button
-                    key={type}
-                    onClick={() => onSelectType(type)}
-                    className="p-4 rounded-2xl border border-black/5 dark:border-white/5 hover:bg-black/5 dark:hover:bg-white/5 transition-all text-left group"
-                  >
-                    <div className="h-[46px] w-[46px] shrink-0 flex items-center justify-center text-foreground bg-black/5 dark:bg-white/5 border border-black/5 dark:border-white/10 rounded-full shadow-sm mb-3 group-hover:scale-105 transition-transform">
-                      <ChannelLogo type={type} />
-                    </div>
-                    <p className="font-semibold text-[15px]">{channelMeta.name}</p>
-                    <p className="text-[13px] text-muted-foreground mt-0.5">
-                      {channelMeta.connectionType === 'qr' ? t('dialog.qrCode') : t('dialog.token')}
-                    </p>
-                  </button>
-                );
-              })}
-            </div>
-          ) : qrCode ? (
-            // QR Code display
-            <div className="text-center space-y-5 py-4">
-              <div className="bg-white p-5 rounded-3xl inline-block shadow-sm border border-black/5">
-                {qrCode.startsWith('data:image') ? (
-                  <img src={qrCode} alt="Scan QR Code" className="w-64 h-64 object-contain" />
-                ) : (
-                  <div className="w-64 h-64 bg-gray-50 rounded-2xl flex items-center justify-center">
-                    <QrCode className="h-24 w-24 text-gray-300" />
-                  </div>
-                )}
-              </div>
-              <p className="text-[14px] text-muted-foreground font-medium">
-                {t('dialog.scanQR', { name: meta?.name })}
-              </p>
-              <div className="flex justify-center gap-2 pt-2">
-                <Button variant="outline" onClick={() => {
-                  setQrCode(null);
-                  handleConnect(); // Retry
-                }} className="rounded-full px-6 h-[42px] text-[13px] font-semibold border-black/20 dark:border-white/20 bg-transparent hover:bg-black/5 dark:hover:bg-white/5 text-foreground/80 hover:text-foreground shadow-sm">
-                  {t('dialog.refreshCode')}
-                </Button>
-              </div>
-            </div>
-          ) : loadingConfig ? (
-            // Loading saved config
-            <div className="flex flex-col items-center justify-center py-12 space-y-4">
-              <Loader2 className="h-8 w-8 animate-spin text-muted-foreground/50" />
-              <span className="text-[14px] font-medium text-muted-foreground">{t('dialog.loadingConfig')}</span>
-            </div>
-          ) : (
-            // Connection form
-            <div className="space-y-4">
-              {/* Existing config hint */}
-              {isExistingConfig && (
-                <div className="bg-[#eeece3] dark:bg-[#151514] text-foreground/80 font-medium p-4 rounded-2xl text-[13.5px] flex items-center gap-2.5 shadow-sm border border-black/5 dark:border-white/5">
-                  <CheckCircle className="h-4 w-4 shrink-0 text-blue-500" />
-                  <span>{t('dialog.existingHint')}</span>
-                </div>
-              )}
-
-              {/* Instructions */}
-              <div className="bg-[#eeece3] dark:bg-[#151514] p-5 rounded-2xl space-y-3 shadow-sm border border-black/5 dark:border-white/5">
-                <div className="flex items-center justify-between">
-                  <p className="font-semibold text-[14px] text-foreground/80">{t('dialog.howToConnect')}</p>
-                  <Button
-                    variant="link"
-                    className="p-0 h-auto text-[13px] text-muted-foreground hover:text-foreground"
-                    onClick={openDocs}
-                  >
-                    <BookOpen className="h-3.5 w-3.5 mr-1.5" />
-                    {t('dialog.viewDocs')}
-                    <ExternalLink className="h-3 w-3 ml-1" />
-                  </Button>
-                </div>
-                <ol className="list-decimal list-inside text-[13.5px] text-muted-foreground space-y-1.5 leading-relaxed">
-                  {meta?.instructions.map((instruction, i) => (
-                    <li key={i}>{t(instruction.replace('channels:', ''))}</li>
-                  ))}
-                </ol>
-              </div>
-
-              {/* Channel name */}
-              <div className="space-y-2.5">
-                <Label htmlFor="name" className="text-[14px] text-foreground/80 font-bold">{t('dialog.channelName')}</Label>
-                <Input
-                  ref={firstInputRef}
-                  id="name"
-                  placeholder={t('dialog.channelNamePlaceholder', { name: meta?.name })}
-                  value={channelName}
-                  onChange={(e) => setChannelName(e.target.value)}
-                  className="h-[44px] rounded-xl font-mono text-[13px] bg-[#eeece3] dark:bg-[#151514] border-black/10 dark:border-white/10 focus-visible:ring-2 focus-visible:ring-blue-500/50 focus-visible:border-blue-500 shadow-sm transition-all text-foreground placeholder:text-foreground/40"
-                />
-              </div>
-
-              {/* Configuration fields */}
-              {meta?.configFields.map((field) => (
-                <ConfigField
-                  key={field.key}
-                  field={field}
-                  value={configValues[field.key] || ''}
-                  onChange={(value) => updateConfigValue(field.key, value)}
-                  showSecret={showSecrets[field.key] || false}
-                  onToggleSecret={() => toggleSecretVisibility(field.key)}
-                />
-              ))}
-
-              {/* Validation Results */}
-              {validationResult && (
-                <div className={`p-4 rounded-2xl text-[13.5px] shadow-sm border border-black/5 dark:border-white/5 ${validationResult.valid ? 'bg-[#eeece3] dark:bg-[#151514] text-foreground/80' : 'bg-destructive/10 text-destructive'
-                  }`}>
-                  <div className="flex items-start gap-2.5">
-                    {validationResult.valid ? (
-                      <CheckCircle className="h-4 w-4 mt-0.5 shrink-0 text-green-500" />
-                    ) : (
-                      <AlertCircle className="h-4 w-4 mt-0.5 shrink-0" />
-                    )}
-                    <div className="min-w-0">
-                      <h4 className="font-bold mb-1">
-                        {validationResult.valid ? t('dialog.credentialsVerified') : t('dialog.validationFailed')}
-                      </h4>
-                      {validationResult.errors.length > 0 && (
-                        <ul className="list-disc list-inside space-y-0.5 font-medium">
-                          {validationResult.errors.map((err, i) => (
-                            <li key={i}>{err}</li>
-                          ))}
-                        </ul>
-                      )}
-                      {validationResult.valid && validationResult.warnings.length > 0 && (
-                        <div className="mt-1 text-green-600 dark:text-green-500 space-y-0.5 font-medium">
-                          {validationResult.warnings.map((info, i) => (
-                            <p key={i} className="text-[13px]">{info}</p>
-                          ))}
-                        </div>
-                      )}
-                      {!validationResult.valid && validationResult.warnings.length > 0 && (
-                        <div className="mt-2 text-yellow-600 dark:text-yellow-500 font-medium">
-                          <p className="font-bold text-[12px] uppercase mb-1">{t('dialog.warnings')}</p>
-                          <ul className="list-disc list-inside space-y-0.5">
-                            {validationResult.warnings.map((warn, i) => (
-                              <li key={i}>{warn}</li>
-                            ))}
-                          </ul>
-                        </div>
-                      )}
-                    </div>
-                  </div>
-                </div>
-              )}
-
-              <Separator className="bg-black/10 dark:bg-white/10" />
-
-              <div className="flex justify-end pt-4">
-                <div className="flex gap-3">
-                  {/* Validation Button - Only for token-based channels for now */}
-                  {meta?.connectionType === 'token' && (
-                    <Button
-                      variant="secondary"
-                      onClick={handleValidate}
-                      disabled={validating}
-                      className="rounded-full px-6 h-[42px] text-[13px] font-semibold bg-black/5 dark:bg-white/5 hover:bg-black/10 dark:hover:bg-white/10 text-foreground shadow-sm"
-                    >
-                      {validating ? (
-                        <>
-                          <Loader2 className="h-4 w-4 mr-2 animate-spin" />
-                          {t('dialog.validating')}
-                        </>
-                      ) : (
-                        <>
-                          <ShieldCheck className="h-4 w-4 mr-2" />
-                          {t('dialog.validateConfig')}
-                        </>
-                      )}
-                    </Button>
-                  )}
-                  <Button
-                    onClick={handleConnect}
-                    disabled={connecting || !isFormValid()}
-                    className="rounded-full px-6 h-[42px] text-[13px] font-semibold bg-[#0a84ff] hover:bg-[#007aff] text-white shadow-sm border border-transparent transition-all"
-                  >
-                    {connecting ? (
-                      <>
-                        <Loader2 className="h-4 w-4 mr-2 animate-spin" />
-                        {meta?.connectionType === 'qr' ? t('dialog.generatingQR') : t('dialog.validatingAndSaving')}
-                      </>
-                    ) : meta?.connectionType === 'qr' ? (
-                      t('dialog.generateQRCode')
-                    ) : (
-                      <>
-                        <Check className="h-4 w-4 mr-2" />
-                        {isExistingConfig ? t('dialog.updateAndReconnect') : t('dialog.saveAndConnect')}
-                      </>
-                    )}
-                  </Button>
-                </div>
-              </div>
-            </div>
-          )}
-        </CardContent>
-      </Card>
-    </div >
-  );
-}
-
-// ==================== Config Field Component ====================
-
-interface ConfigFieldProps {
-  field: ChannelConfigField;
-  value: string;
-  onChange: (value: string) => void;
-  showSecret: boolean;
-  onToggleSecret: () => void;
-}
-
-function ConfigField({ field, value, onChange, showSecret, onToggleSecret }: ConfigFieldProps) {
-  const { t } = useTranslation('channels');
-  const isPassword = field.type === 'password';
-
-  return (
-    <div className="space-y-2.5">
-      <Label htmlFor={field.key} className="text-[14px] text-foreground/80 font-bold">
-        {t(field.label.replace('channels:', ''))}
-        {field.required && <span className="text-destructive ml-1">*</span>}
-      </Label>
-      <div className="flex gap-2">
-        <Input
-          id={field.key}
-          type={isPassword && !showSecret ? 'password' : 'text'}
-          placeholder={field.placeholder ? t(field.placeholder.replace('channels:', '')) : undefined}
-          value={value}
-          onChange={(e) => onChange(e.target.value)}
-          className="h-[44px] rounded-xl font-mono text-[13px] bg-[#eeece3] dark:bg-[#151514] border-black/10 dark:border-white/10 focus-visible:ring-2 focus-visible:ring-blue-500/50 focus-visible:border-blue-500 shadow-sm transition-all text-foreground placeholder:text-foreground/40"
-        />
-        {isPassword && (
-          <Button
-            type="button"
-            variant="outline"
-            size="icon"
-            onClick={onToggleSecret}
-            className="h-[44px] w-[44px] rounded-xl bg-[#eeece3] dark:bg-[#151514] border-black/10 dark:border-white/10 text-muted-foreground hover:text-foreground shrink-0 shadow-sm"
-          >
-            {showSecret ? <EyeOff className="h-4 w-4" /> : <Eye className="h-4 w-4" />}
-          </Button>
-        )}
-      </div>
-      {field.description && (
-        <p className="text-[13px] text-muted-foreground leading-relaxed">
-          {t(field.description.replace('channels:', ''))}
-        </p>
-      )}
-      {field.envVar && (
-        <p className="text-[12px] text-muted-foreground/70 font-mono">
-          {t('dialog.envVar', { var: field.envVar })}
-        </p>
-      )}
-    </div>
-  );
-}
-
 export default Channels;
diff --git a/src/stores/agents.ts b/src/stores/agents.ts
new file mode 100644
index 000000000..6533ce26f
--- /dev/null
+++ b/src/stores/agents.ts
@@ -0,0 +1,126 @@
+import { create } from 'zustand';
+import { hostApiFetch } from '@/lib/host-api';
+import type { ChannelType } from '@/types/channel';
+import type { AgentSummary, AgentsSnapshot } from '@/types/agent';
+
+interface AgentsState {
+  agents: AgentSummary[];
+  defaultAgentId: string;
+  configuredChannelTypes: string[];
+  channelOwners: Record<string, string>;
+  loading: boolean;
+  error: string | null;
+  fetchAgents: () => Promise<void>;
+  createAgent: (name: string) => Promise<void>;
+  updateAgent: (agentId: string, name: string) => Promise<void>;
+  deleteAgent: (agentId: string) => Promise<void>;
+  assignChannel: (agentId: string, channelType: ChannelType) => Promise<void>;
+  removeChannel: (agentId: string, channelType: ChannelType) => Promise<void>;
+  clearError: () => void;
+}
+
+function applySnapshot(snapshot: AgentsSnapshot | undefined) {
+  return snapshot ? {
+    agents: snapshot.agents,
+    defaultAgentId: snapshot.defaultAgentId,
+    configuredChannelTypes: snapshot.configuredChannelTypes,
+    channelOwners: snapshot.channelOwners,
+  } : {};
+}
+
+export const useAgentsStore = create<AgentsState>((set) => ({
+  agents: [],
+  defaultAgentId: 'main',
+  configuredChannelTypes: [],
+  channelOwners: {},
+  loading: false,
+  error: null,
+
+  fetchAgents: async () => {
+    set({ loading: true, error: null });
+    try {
+      const snapshot = await hostApiFetch<AgentsSnapshot & { success?: boolean }>('/api/agents');
+      set({
+        ...applySnapshot(snapshot),
+        loading: false,
+      });
+    } catch (error) {
+      set({ loading: false, error: String(error) });
+    }
+  },
+
+  createAgent: async (name: string) => {
+    set({ error: null });
+    try {
+      const snapshot = await hostApiFetch<AgentsSnapshot & { success?: boolean }>('/api/agents', {
+        method: 'POST',
+        body: JSON.stringify({ name }),
+      });
+      set(applySnapshot(snapshot));
+    } catch (error) {
+      set({ error: String(error) });
+      throw error;
+    }
+  },
+
+  updateAgent: async (agentId: string, name: string) => {
+    set({ error: null });
+    try {
+      const snapshot = await hostApiFetch<AgentsSnapshot & { success?: boolean }>(
+        `/api/agents/${encodeURIComponent(agentId)}`,
+        {
+          method: 'PUT',
+          body: JSON.stringify({ name }),
+        }
+      );
+      set(applySnapshot(snapshot));
+    } catch (error) {
+      set({ error: String(error) });
+      throw error;
+    }
+  },
+
+  deleteAgent: async (agentId: string) => {
+    set({ error: null });
+    try {
+      const snapshot = await hostApiFetch<AgentsSnapshot & { success?: boolean }>(
+        `/api/agents/${encodeURIComponent(agentId)}`,
+        { method: 'DELETE' }
+      );
+      set(applySnapshot(snapshot));
+    } catch (error) {
+      set({ error: String(error) });
+      throw error;
+    }
+  },
+
+  assignChannel: async (agentId: string, channelType: ChannelType) => {
+    set({ error: null });
+    try {
+      const snapshot = await hostApiFetch<AgentsSnapshot & { success?: boolean }>(
+        `/api/agents/${encodeURIComponent(agentId)}/channels/${encodeURIComponent(channelType)}`,
+        { method: 'PUT' }
+      );
+      set(applySnapshot(snapshot));
+    } catch (error) {
+      set({ error: String(error) });
+      throw error;
+    }
+  },
+
+  removeChannel: async (agentId: string, channelType: ChannelType) => {
+    set({ error: null });
+    try {
+      const snapshot = await hostApiFetch<AgentsSnapshot & { success?: boolean }>(
+        `/api/agents/${encodeURIComponent(agentId)}/channels/${encodeURIComponent(channelType)}`,
+        { method: 'DELETE' }
+      );
+      set(applySnapshot(snapshot));
+    } catch (error) {
+      set({ error: String(error) });
+      throw error;
+    }
+  },
+
+  clearError: () => set({ error: null }),
+}));
diff --git a/src/stores/chat.ts b/src/stores/chat.ts
index 1ceab93ba..1d49182b3 100644
--- a/src/stores/chat.ts
+++ b/src/stores/chat.ts
@@ -87,6 +87,7 @@ interface ChatState {
   // Sessions
   sessions: ChatSession[];
   currentSessionKey: string;
+  currentAgentId: string;
   /** First user message text per session key, used as display label */
   sessionLabels: Record<string, string>;
   /** Last message timestamp (ms) per session key, used for sorting */
@@ -657,6 +658,19 @@ function getCanonicalPrefixFromSessions(sessions: ChatSession[]): string | null
   return `${parts[0]}:${parts[1]}`;
 }
 
+function getAgentIdFromSessionKey(sessionKey: string): string {
+  if (!sessionKey.startsWith('agent:')) return 'main';
+  const parts = sessionKey.split(':');
+  return parts[1] || 'main';
+}
+
+function getCanonicalPrefixFromSessionKey(sessionKey: string): string | null {
+  if (!sessionKey.startsWith('agent:')) return null;
+  const parts = sessionKey.split(':');
+  if (parts.length < 2) return null;
+  return `${parts[0]}:${parts[1]}`;
+}
+
 function isToolOnlyMessage(message: RawMessage | undefined): boolean {
   if (!message) return false;
   if (isToolResultRole(message.role)) return true;
@@ -923,6 +937,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
 
   sessions: [],
   currentSessionKey: DEFAULT_SESSION_KEY,
+  currentAgentId: 'main',
   sessionLabels: {},
   sessionLastActivity: {},
 
@@ -964,7 +979,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
           return true;
         });
 
-        const { currentSessionKey } = get();
+        const { currentSessionKey, sessions: localSessions } = get();
         let nextSessionKey = currentSessionKey || DEFAULT_SESSION_KEY;
         if (!nextSessionKey.startsWith('agent:')) {
           const canonicalMatch = canonicalBySuffix.get(nextSessionKey);
@@ -973,9 +988,10 @@ export const useChatStore = create<ChatState>((set, get) => ({
           }
         }
         if (!dedupedSessions.find((s) => s.key === nextSessionKey) && dedupedSessions.length > 0) {
-          // Current session not found in the backend list
-          const isNewEmptySession = get().messages.length === 0;
-          if (!isNewEmptySession) {
+          // Preserve only locally-created pending sessions. On initial boot the
+          // default ghost key (`agent:main:main`) should yield to real history.
+          const hasLocalPendingSession = localSessions.some((session) => session.key === nextSessionKey);
+          if (!hasLocalPendingSession) {
             nextSessionKey = dedupedSessions[0].key;
           }
         }
@@ -987,7 +1003,11 @@ export const useChatStore = create<ChatState>((set, get) => ({
           ]
           : dedupedSessions;
 
-        set({ sessions: sessionsWithCurrent, currentSessionKey: nextSessionKey });
+        set({
+          sessions: sessionsWithCurrent,
+          currentSessionKey: nextSessionKey,
+          currentAgentId: getAgentIdFromSessionKey(nextSessionKey),
+        });
 
         if (currentSessionKey !== nextSessionKey) {
           get().loadHistory();
@@ -1038,6 +1058,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
     const leavingEmpty = !currentSessionKey.endsWith(':main') && messages.length === 0;
     set((s) => ({
       currentSessionKey: key,
+      currentAgentId: getAgentIdFromSessionKey(key),
       messages: [],
       streamingText: '',
       streamingMessage: null,
@@ -1108,6 +1129,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
         lastUserMessageAt: null,
         pendingToolImages: [],
         currentSessionKey: next?.key ?? DEFAULT_SESSION_KEY,
+        currentAgentId: getAgentIdFromSessionKey(next?.key ?? DEFAULT_SESSION_KEY),
       }));
       if (next) {
         get().loadHistory();
@@ -1128,13 +1150,16 @@ export const useChatStore = create<ChatState>((set, get) => ({
     // NOTE: We intentionally do NOT call sessions.reset on the old session.
     // sessions.reset archives (renames) the session JSONL file, making old
     // conversation history inaccessible when the user switches back to it.
-    const { currentSessionKey, messages } = get();
+    const { currentSessionKey, messages, sessions } = get();
     const leavingEmpty = !currentSessionKey.endsWith(':main') && messages.length === 0;
-    const prefix = getCanonicalPrefixFromSessions(get().sessions) ?? DEFAULT_CANONICAL_PREFIX;
+    const prefix = getCanonicalPrefixFromSessionKey(currentSessionKey)
+      ?? getCanonicalPrefixFromSessions(sessions)
+      ?? DEFAULT_CANONICAL_PREFIX;
     const newKey = `${prefix}:session-${Date.now()}`;
     const newSessionEntry: ChatSession = { key: newKey, displayName: newKey };
     set((s) => ({
       currentSessionKey: newKey,
+      currentAgentId: getAgentIdFromSessionKey(newKey),
       sessions: [
         ...(leavingEmpty ? s.sessions.filter((sess) => sess.key !== currentSessionKey) : s.sessions),
         newSessionEntry,
diff --git a/src/types/agent.ts b/src/types/agent.ts
new file mode 100644
index 000000000..eeadd9ef9
--- /dev/null
+++ b/src/types/agent.ts
@@ -0,0 +1,17 @@
+export interface AgentSummary {
+  id: string;
+  name: string;
+  isDefault: boolean;
+  modelDisplay: string;
+  inheritedModel: boolean;
+  workspace: string;
+  agentDir: string;
+  channelTypes: string[];
+}
+
+export interface AgentsSnapshot {
+  agents: AgentSummary[];
+  defaultAgentId: string;
+  configuredChannelTypes: string[];
+  channelOwners: Record<string, string>;
+}