diff --git a/README.md b/README.md
index 2808df807..3d0f1ec12 100644
--- a/README.md
+++ b/README.md
@@ -434,6 +434,12 @@ token = "env:DISCORD_BOT_TOKEN"
 agent_id = "my-agent"
 channel = "discord"
 guild_id = "your-discord-guild-id"
+
+# Optional: route a named adapter instance
+[[bindings]]
+agent_id = "my-agent"
+channel = "discord"
+adapter = "ops"
 ```
 
 ```bash
diff --git a/docs/content/docs/(configuration)/config.mdx b/docs/content/docs/(configuration)/config.mdx
index 7c6350003..1ef0bb116 100644
--- a/docs/content/docs/(configuration)/config.mdx
+++ b/docs/content/docs/(configuration)/config.mdx
@@ -596,16 +596,79 @@ Channel/worker temporal context timezone precedence is:
 |-----|------|---------|-------------|
 | `enabled` | bool | false | Enable Discord adapter |
 | `token` | string | None | Bot token (or `env:VAR_NAME`) |
+| `instances` | table[] | [] | Optional named Discord bot instances |
 | `dm_allowed_users` | string[] | [] | User IDs allowed to DM the bot |
 
+### `[[messaging.discord.instances]]`
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `name` | string | **required** | Instance selector used by bindings (`adapter = "name"`) |
+| `enabled` | bool | true | Enable this named instance |
+| `token` | string | **required** | Bot token (or `env:VAR_NAME`) |
+| `dm_allowed_users` | string[] | [] | User IDs allowed to DM this instance |
+| `allow_bot_messages` | bool | false | Whether this instance accepts bot-authored messages |
+
+### `[messaging.slack]`
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `enabled` | bool | false | Enable Slack adapter |
+| `bot_token` | string | None | Bot token (or `env:VAR_NAME`) |
+| `app_token` | string | None | App-level token (or `env:VAR_NAME`) |
+| `instances` | table[] | [] | Optional named Slack app instances |
+| `dm_allowed_users` | string[] | [] | Slack user IDs allowed to DM the bot |
+
+### `[[messaging.slack.instances]]`
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `name` | string | **required** | Instance selector used by bindings (`adapter = "name"`) |
+| `enabled` | bool | true | Enable this named instance |
+| `bot_token` | string | **required** | Bot token (or `env:VAR_NAME`) |
+| `app_token` | string | **required** | App-level token (or `env:VAR_NAME`) |
+| `dm_allowed_users` | string[] | [] | Slack user IDs allowed to DM this instance |
+
 ### `[messaging.telegram]`
 
 | Key | Type | Default | Description |
 |-----|------|---------|-------------|
 | `enabled` | bool | false | Enable Telegram adapter |
 | `token` | string | None | Bot token from @BotFather (or `env:VAR_NAME`). Falls back to `TELEGRAM_BOT_TOKEN` env var |
+| `instances` | table[] | [] | Optional named Telegram bot instances |
 | `dm_allowed_users` | string[] | [] | User IDs allowed to DM the bot. Empty = DMs from anyone accepted |
 
+### `[[messaging.telegram.instances]]`
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `name` | string | **required** | Instance selector used by bindings (`adapter = "name"`) |
+| `enabled` | bool | true | Enable this named instance |
+| `token` | string | **required** | Bot token (or `env:VAR_NAME`) |
+| `dm_allowed_users` | string[] | [] | User IDs allowed to DM this instance |
+
+### `[messaging.twitch]`
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `enabled` | bool | false | Enable Twitch adapter |
+| `username` | string | None | Bot login username |
+| `oauth_token` | string | None | OAuth token (`oauth:...` or plain token) |
+| `instances` | table[] | [] | Optional named Twitch bot instances |
+| `channels` | string[] | [] | Channels to join |
+| `trigger_prefix` | string | None | Optional prefix required to trigger replies |
+
+### `[[messaging.twitch.instances]]`
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `name` | string | **required** | Instance selector used by bindings (`adapter = "name"`) |
+| `enabled` | bool | true | Enable this named instance |
+| `username` | string | **required** | Bot login username |
+| `oauth_token` | string | **required** | OAuth token (`oauth:...` or plain token) |
+| `channels` | string[] | [] | Channels to join for this instance |
+| `trigger_prefix` | string | None | Optional prefix required to trigger replies |
+
 ### `[messaging.email]`
 
 | Key | Type | Default | Description |
@@ -629,6 +692,30 @@ Channel/worker temporal context timezone precedence is:
 | `max_body_bytes` | integer | 262144 | Max inbound body bytes before truncation |
 | `max_attachment_bytes` | integer | 10485760 | Max attachment bytes to process metadata for |
 
+### `[[messaging.email.instances]]`
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `name` | string | **required** | Instance selector used by bindings (`adapter = "name"`) |
+| `enabled` | bool | true | Enable this named instance |
+| `imap_host` | string | **required** | IMAP host (or `env:VAR_NAME`) |
+| `imap_port` | integer | 993 | IMAP port |
+| `imap_username` | string | **required** | IMAP username (or `env:VAR_NAME`) |
+| `imap_password` | string | **required** | IMAP password (or `env:VAR_NAME`) |
+| `imap_use_tls` | bool | true | Use direct TLS for IMAP |
+| `smtp_host` | string | **required** | SMTP host (or `env:VAR_NAME`) |
+| `smtp_port` | integer | 587 | SMTP port |
+| `smtp_username` | string | None | SMTP username (defaults to IMAP username) |
+| `smtp_password` | string | None | SMTP password (defaults to IMAP password) |
+| `smtp_use_starttls` | bool | true | Use STARTTLS for SMTP |
+| `from_address` | string | None | Sender address (defaults to SMTP username) |
+| `from_name` | string | None | Optional sender display name |
+| `poll_interval_secs` | integer | 30 | How often to check for new email |
+| `folders` | string[] | `["INBOX"]` | IMAP folders to poll |
+| `allowed_senders` | string[] | `[]` | Optional allowlist (empty = all) |
+| `max_body_bytes` | integer | 262144 | Max inbound body bytes |
+| `max_attachment_bytes` | integer | 10485760 | Max attachment bytes |
+
 ### `[messaging.webhook]`
 
 | Key | Type | Default | Description |
@@ -645,6 +732,7 @@ Routes platform conversations to agents. Checked in order; first match wins. Unm
 |-----|------|---------|-------------|
 | `agent_id` | string | **required** | Which agent handles matched messages |
 | `channel` | string | **required** | Platform name (`discord`, `slack`, `telegram`, `twitch`, `email`, `webhook`) |
+| `adapter` | string | None | Optional named adapter selector (e.g. `ops` => `discord:ops`) |
 | `guild_id` | string | None | Discord guild filter |
 | `chat_id` | string | None | Telegram chat filter |
 | `channel_ids` | string[] | [] | Discord channel ID filter (includes threads in those channels) |
diff --git a/docs/content/docs/(messaging)/messaging.mdx b/docs/content/docs/(messaging)/messaging.mdx
index 4804d3148..2856c4dbe 100644
--- a/docs/content/docs/(messaging)/messaging.mdx
+++ b/docs/content/docs/(messaging)/messaging.mdx
@@ -44,6 +44,7 @@ Go to **Settings** → **Bindings** tab to create and manage bindings.
 Each binding specifies:
 - Which **agent** handles the messages
 - Which **platform** (Discord, Slack, Telegram, Twitch, Email)
+- Optionally which **adapter instance** on that platform
 - Optionally which **server/workspace/chat** to scope it to
 - Optionally which **channels** within that server
 
@@ -57,6 +58,13 @@ agent_id = "main"
 channel = "discord"
 guild_id = "123456789"
 
+# Route only the named Discord adapter instance `ops`
+[[bindings]]
+agent_id = "main"
+channel = "discord"
+adapter = "ops"
+guild_id = "987654321"
+
 # Route a Slack workspace to the main agent
 [[bindings]]
 agent_id = "main"
@@ -75,6 +83,8 @@ chat_id = "-100123456789"
 
 Without any filtering (no guild ID, workspace ID, or chat ID), a binding accepts messages from anywhere on that platform.
 
+Named adapters use `adapter = "<name>"` in bindings. Omit `adapter` to target the platform default adapter (`discord`, `slack`, `telegram`, `twitch`, `email`, `webhook`).
+
 If no binding matches an incoming message, it's routed to the default agent automatically. This means the bot responds everywhere out of the box — add bindings to restrict it to specific channels or servers.
 
 ## Multiple Agents
diff --git a/interface/src/api/client.ts b/interface/src/api/client.ts
index f329b9432..620efe03d 100644
--- a/interface/src/api/client.ts
+++ b/interface/src/api/client.ts
@@ -952,6 +952,15 @@ export interface PlatformStatus {
 	enabled: boolean;
 }
 
+export interface AdapterInstanceStatus {
+	platform: string;
+	name: string | null;
+	runtime_key: string;
+	configured: boolean;
+	enabled: boolean;
+	binding_count: number;
+}
+
 export interface MessagingStatusResponse {
 	discord: PlatformStatus;
 	slack: PlatformStatus;
@@ -959,11 +968,52 @@ export interface MessagingStatusResponse {
 	webhook: PlatformStatus;
 	twitch: PlatformStatus;
 	email: PlatformStatus;
+	instances: AdapterInstanceStatus[];
+}
+
+export interface CreateMessagingInstanceRequest {
+	platform: string;
+	name?: string;
+	enabled?: boolean;
+	credentials: {
+		discord_token?: string;
+		slack_bot_token?: string;
+		slack_app_token?: string;
+		telegram_token?: string;
+		twitch_username?: string;
+		twitch_oauth_token?: string;
+		twitch_client_id?: string;
+		twitch_client_secret?: string;
+		twitch_refresh_token?: string;
+		email_imap_host?: string;
+		email_imap_port?: number;
+		email_imap_username?: string;
+		email_imap_password?: string;
+		email_smtp_host?: string;
+		email_smtp_port?: number;
+		email_smtp_username?: string;
+		email_smtp_password?: string;
+		email_from_address?: string;
+		webhook_port?: number;
+		webhook_bind?: string;
+		webhook_auth_token?: string;
+	};
+}
+
+export interface DeleteMessagingInstanceRequest {
+	platform: string;
+	name?: string;
+}
+
+export interface MessagingInstanceActionResponse {
+	success: boolean;
+	message: string;
 }
 
 export interface BindingInfo {
 	agent_id: string;
 	channel: string;
+	adapter: string | null;
 	guild_id: string | null;
 	workspace_id: string | null;
 	chat_id: string | null;
@@ -979,6 +1029,7 @@ export interface BindingsListResponse {
 export interface CreateBindingRequest {
 	agent_id: string;
 	channel: string;
+	adapter?: string;
 	guild_id?: string;
 	workspace_id?: string;
 	chat_id?: string;
@@ -1017,11 +1068,13 @@ export interface CreateBindingResponse {
 export interface UpdateBindingRequest {
 	original_agent_id: string;
 	original_channel: string;
+	original_adapter?: string;
 	original_guild_id?: string;
 	original_workspace_id?: string;
 	original_chat_id?: string;
 	agent_id: string;
 	channel: string;
+	adapter?: string;
 	guild_id?: string;
 	workspace_id?: string;
 	chat_id?: string;
@@ -1038,6 +1091,7 @@ export interface UpdateBindingResponse {
 export interface DeleteBindingRequest {
 	agent_id: string;
 	channel: string;
+	adapter?: string;
 	guild_id?: string;
 	workspace_id?: string;
 	chat_id?: string;
@@ -1564,11 +1618,13 @@ export const api = {
 		return response.json() as Promise<DeleteBindingResponse>;
 	},
 
-	togglePlatform: async (platform: string, enabled: boolean) => {
+	togglePlatform: async (platform: string, enabled: boolean, adapter?: string) => {
+		const body: Record<string, unknown> = { platform, enabled };
+		if (adapter) body.adapter = adapter;
 		const response = await fetch(`${API_BASE}/messaging/toggle`, {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({ platform, enabled }),
+			body: JSON.stringify(body),
 		});
 		if (!response.ok) {
 			throw new Error(`API error: ${response.status}`);
@@ -1576,11 +1632,13 @@ export const api = {
 		return response.json() as Promise<{ success: boolean; message: string }>;
 	},
 
-	disconnectPlatform: async (platform: string) => {
+	disconnectPlatform: async (platform: string, adapter?: string) => {
+		const body: Record<string, unknown> = { platform };
+		if (adapter) body.adapter = adapter;
 		const response = await fetch(`${API_BASE}/messaging/disconnect`, {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({ platform }),
+			body: JSON.stringify(body),
 		});
 		if (!response.ok) {
 			throw new Error(`API error: ${response.status}`);
@@ -1588,6 +1646,30 @@ export const api = {
 		return response.json() as Promise<{ success: boolean; message: string }>;
 	},
 
+	createMessagingInstance: async (request: CreateMessagingInstanceRequest) => {
+		const response = await fetch(`${API_BASE}/messaging/instances`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(request),
+		});
+		if (!response.ok) {
+			throw new Error(`API error: ${response.status}`);
+		}
+		return response.json() as Promise<MessagingInstanceActionResponse>;
+	},
+
+	deleteMessagingInstance: async (request: DeleteMessagingInstanceRequest) => {
+		const response = await fetch(`${API_BASE}/messaging/instances`, {
+			method: "DELETE",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(request),
+		});
+		if (!response.ok) {
+			throw new Error(`API error: ${response.status}`);
+		}
+		return response.json() as Promise<MessagingInstanceActionResponse>;
+	},
+
 	// Global Settings API
 	globalSettings: () => fetchJson<GlobalSettingsResponse>("/settings"),
 	
diff --git a/interface/src/components/ChannelSettingCard.tsx b/interface/src/components/ChannelSettingCard.tsx
index 55dae6906..2ce506ea9 100644
--- a/interface/src/components/ChannelSettingCard.tsx
+++ b/interface/src/components/ChannelSettingCard.tsx
@@ -1,7 +1,12 @@
 import {useState} from "react";
 import {AnimatePresence, motion} from "framer-motion";
 import {useMutation, useQuery, useQueryClient} from "@tanstack/react-query";
-import {api, type PlatformStatus, type BindingInfo} from "@/api/client";
+import {
+	api,
+	type AdapterInstanceStatus,
+	type BindingInfo,
+	type CreateMessagingInstanceRequest,
+} from "@/api/client";
 import {
 	Button,
 	Input,
@@ -20,42 +25,101 @@ import {
 import {PlatformIcon} from "@/lib/platformIcons";
 import {TagInput} from "@/components/TagInput";
 import {FontAwesomeIcon} from "@fortawesome/react-fontawesome";
-import {faChevronDown} from "@fortawesome/free-solid-svg-icons";
+import {faChevronDown, faPlus} from "@fortawesome/free-solid-svg-icons";
 
 type Platform = "discord" | "slack" | "telegram" | "twitch" | "email" | "webhook";
 
-interface ChannelSettingCardProps {
-	platform: Platform;
-	name: string;
-	description: string;
-	status?: PlatformStatus;
+const PLATFORM_LABELS: Record<Platform, string> = {
+	discord: "Discord",
+	slack: "Slack",
+	telegram: "Telegram",
+	twitch: "Twitch",
+	email: "Email",
+	webhook: "Webhook",
+};
+
+const DOC_LINKS: Partial<Record<Platform, string>> = {
+	discord: "https://docs.spacebot.sh/discord-setup",
+	slack: "https://docs.spacebot.sh/slack-setup",
+	telegram: "https://docs.spacebot.sh/telegram-setup",
+	twitch: "https://docs.spacebot.sh/twitch-setup",
+};
+
+// --- Platform Catalog (Left Column) ---
+
+interface PlatformCatalogProps {
+	onAddInstance: (platform: Platform) => void;
+}
+
+export function PlatformCatalog({onAddInstance}: PlatformCatalogProps) {
+	const PLATFORMS: {platform: Platform; description: string}[] = [
+		{platform: "discord", description: "Discord bot integration"},
+		{platform: "slack", description: "Slack bot integration"},
+		{platform: "telegram", description: "Telegram bot integration"},
+		{platform: "twitch", description: "Twitch chat integration"},
+		{platform: "email", description: "IMAP/SMTP email integration"},
+		{platform: "webhook", description: "HTTP webhook receiver"},
+	];
+
+	const COMING_SOON = [
+		{platform: "whatsapp", name: "WhatsApp"},
+		{platform: "matrix", name: "Matrix"},
+		{platform: "imessage", name: "iMessage"},
+		{platform: "irc", name: "IRC"},
+		{platform: "lark", name: "Lark"},
+		{platform: "dingtalk", name: "DingTalk"},
+	];
+
+	return (
+		<div className="flex flex-col gap-1">
+			<h3 className="text-xs font-semibold text-ink-faint uppercase tracking-wider mb-2">
+				Available
+			</h3>
+			{PLATFORMS.map(({platform, description}) => (
+				<button
+					key={platform}
+					type="button"
+					onClick={() => onAddInstance(platform)}
+					className="flex items-center gap-2.5 rounded-md px-3 py-2 text-left hover:bg-app-hover transition-colors group"
+				>
+					<PlatformIcon platform={platform} size="sm" className="text-ink-faint" />
+					<span className="flex-1 text-sm text-ink">{PLATFORM_LABELS[platform]}</span>
+					<FontAwesomeIcon
+						icon={faPlus}
+						className="text-ink-faint opacity-0 group-hover:opacity-100 transition-opacity text-xs"
+					/>
+				</button>
+			))}
+
+			<h3 className="text-xs font-semibold text-ink-faint uppercase tracking-wider mt-4 mb-2">
+				Coming Soon
+			</h3>
+			{COMING_SOON.map(({platform, name}) => (
+				<div
+					key={platform}
+					className="flex items-center gap-2.5 rounded-md px-3 py-2 opacity-40"
+				>
+					<PlatformIcon platform={platform} size="sm" className="text-ink-faint/50" />
+					<span className="flex-1 text-sm text-ink-dull">{name}</span>
+				</div>
+			))}
+		</div>
+	);
+}
+
+// --- Instance Card (Right Column) ---
+
+interface InstanceCardProps {
+	instance: AdapterInstanceStatus;
 	expanded: boolean;
-	onToggle: () => void;
+	onToggleExpand: () => void;
 }
 
-export function ChannelSettingCard({
-	platform,
-	name,
-	description,
-	status,
-	expanded,
-	onToggle,
-}: ChannelSettingCardProps) {
+export function InstanceCard({instance, expanded, onToggleExpand}: InstanceCardProps) {
 	const queryClient = useQueryClient();
-	const configured = status?.configured ?? false;
-	const enabled = status?.enabled ?? false;
-
-	const [credentialInputs, setCredentialInputs] = useState<
-		Record<string, string>
-	>({});
-	const [message, setMessage] = useState<{
-		text: string;
-		type: "success" | "error";
-	} | null>(null);
-	const [confirmDisconnect, setConfirmDisconnect] = useState(false);
-	const [editingBinding, setEditingBinding] = useState<BindingInfo | null>(
-		null,
-	);
+	const [message, setMessage] = useState<{text: string; type: "success" | "error"} | null>(null);
+	const [confirmRemove, setConfirmRemove] = useState(false);
+	const [editingBinding, setEditingBinding] = useState<BindingInfo | null>(null);
 	const [addingBinding, setAddingBinding] = useState(false);
 	const [bindingForm, setBindingForm] = useState({
 		agent_id: "main",
@@ -67,11 +131,16 @@ export function ChannelSettingCard({
 		dm_allowed_users: [] as string[],
 	});
 
+	const platform = instance.platform as Platform;
+	const instanceLabel = instance.name
+		? `${PLATFORM_LABELS[platform]} "${instance.name}"`
+		: PLATFORM_LABELS[platform];
+
 	const {data: bindingsData} = useQuery({
 		queryKey: ["bindings"],
 		queryFn: () => api.bindings(),
 		staleTime: 5_000,
-		enabled: expanded && configured,
+		enabled: expanded,
 	});
 
 	const {data: agentsData} = useQuery({
@@ -81,35 +150,35 @@ export function ChannelSettingCard({
 		enabled: expanded,
 	});
 
-	const platformBindings =
-		bindingsData?.bindings?.filter((b) => b.channel === platform) ?? [];
+	// Filter bindings for this specific instance
+	const instanceBindings = (bindingsData?.bindings ?? []).filter((binding) => {
+		if (binding.channel !== platform) return false;
+		if (instance.name === null) return !binding.adapter;
+		return binding.adapter === instance.name;
+	});
 
 	const toggleEnabled = useMutation({
 		mutationFn: (newEnabled: boolean) =>
-			api.togglePlatform(platform, newEnabled),
+			api.togglePlatform(platform, newEnabled, instance.name ?? undefined),
 		onSuccess: () => {
 			queryClient.invalidateQueries({queryKey: ["messaging-status"]});
 		},
-		onError: (error) =>
-			setMessage({text: `Failed: ${error.message}`, type: "error"}),
+		onError: (error) => setMessage({text: `Failed: ${error.message}`, type: "error"}),
 	});
 
-	// --- Mutations ---
-
-	const saveCreds = useMutation({
-		mutationFn: api.createBinding,
+	const deleteInstance = useMutation({
+		mutationFn: () =>
+			api.deleteMessagingInstance({platform, name: instance.name ?? undefined}),
 		onSuccess: (result) => {
 			if (result.success) {
-				setCredentialInputs({});
-				setMessage({text: result.message, type: "success"});
+				setConfirmRemove(false);
 				queryClient.invalidateQueries({queryKey: ["messaging-status"]});
 				queryClient.invalidateQueries({queryKey: ["bindings"]});
 			} else {
 				setMessage({text: result.message, type: "error"});
 			}
 		},
-		onError: (error) =>
-			setMessage({text: `Failed: ${error.message}`, type: "error"}),
+		onError: (error) => setMessage({text: `Failed: ${error.message}`, type: "error"}),
 	});
 
 	const addBindingMutation = useMutation({
@@ -120,12 +189,12 @@ export function ChannelSettingCard({
 				resetBindingForm();
 				setMessage({text: result.message, type: "success"});
 				queryClient.invalidateQueries({queryKey: ["bindings"]});
+				queryClient.invalidateQueries({queryKey: ["messaging-status"]});
 			} else {
 				setMessage({text: result.message, type: "error"});
 			}
 		},
-		onError: (error) =>
-			setMessage({text: `Failed: ${error.message}`, type: "error"}),
+		onError: (error) => setMessage({text: `Failed: ${error.message}`, type: "error"}),
 	});
 
 	const updateBindingMutation = useMutation({
@@ -136,12 +205,12 @@ export function ChannelSettingCard({
 				resetBindingForm();
 				setMessage({text: result.message, type: "success"});
 				queryClient.invalidateQueries({queryKey: ["bindings"]});
+				queryClient.invalidateQueries({queryKey: ["messaging-status"]});
 			} else {
 				setMessage({text: result.message, type: "error"});
 			}
 		},
-		onError: (error) =>
-			setMessage({text: `Failed: ${error.message}`, type: "error"}),
+		onError: (error) => setMessage({text: `Failed: ${error.message}`, type: "error"}),
 	});
 
 	const deleteBindingMutation = useMutation({
@@ -150,24 +219,12 @@ export function ChannelSettingCard({
 			if (result.success) {
 				setMessage({text: result.message, type: "success"});
 				queryClient.invalidateQueries({queryKey: ["bindings"]});
+				queryClient.invalidateQueries({queryKey: ["messaging-status"]});
 			} else {
 				setMessage({text: result.message, type: "error"});
 			}
 		},
-		onError: (error) =>
-			setMessage({text: `Failed: ${error.message}`, type: "error"}),
-	});
-
-	const disconnectMutation = useMutation({
-		mutationFn: () => api.disconnectPlatform(platform),
-		onSuccess: () => {
-			setConfirmDisconnect(false);
-			setMessage(null);
-			queryClient.invalidateQueries({queryKey: ["messaging-status"]});
-			queryClient.invalidateQueries({queryKey: ["bindings"]});
-		},
-		onError: (error) =>
-			setMessage({text: `Failed: ${error.message}`, type: "error"}),
+		onError: (error) => setMessage({text: `Failed: ${error.message}`, type: "error"}),
 	});
 
 	function resetBindingForm() {
@@ -182,90 +239,15 @@ export function ChannelSettingCard({
 		});
 	}
 
-	function handleSaveCredentials() {
-		const request: any = {agent_id: "main", channel: platform};
-		if (platform === "discord") {
-			if (!credentialInputs.discord_token?.trim()) return;
-			request.platform_credentials = {
-				discord_token: credentialInputs.discord_token.trim(),
-			};
-		} else if (platform === "slack") {
-			if (
-				!credentialInputs.slack_bot_token?.trim() ||
-				!credentialInputs.slack_app_token?.trim()
-			)
-				return;
-			request.platform_credentials = {
-				slack_bot_token: credentialInputs.slack_bot_token.trim(),
-				slack_app_token: credentialInputs.slack_app_token.trim(),
-			};
-		} else if (platform === "telegram") {
-			if (!credentialInputs.telegram_token?.trim()) return;
-			request.platform_credentials = {
-				telegram_token: credentialInputs.telegram_token.trim(),
-			};
-		} else if (platform === "twitch") {
-			if (!credentialInputs.twitch_username?.trim() || !credentialInputs.twitch_oauth_token?.trim()) return;
-			request.platform_credentials = {
-				twitch_username: credentialInputs.twitch_username.trim(),
-				twitch_oauth_token: credentialInputs.twitch_oauth_token.trim(),
-				twitch_client_id: credentialInputs.twitch_client_id?.trim(),
-				twitch_client_secret: credentialInputs.twitch_client_secret?.trim(),
-				twitch_refresh_token: credentialInputs.twitch_refresh_token?.trim(),
-			};
-		} else if (platform === "email") {
-			if (
-				!credentialInputs.email_imap_host?.trim() ||
-				!credentialInputs.email_imap_username?.trim() ||
-				!credentialInputs.email_imap_password ||
-				!credentialInputs.email_smtp_host?.trim() ||
-				!credentialInputs.email_smtp_username?.trim() ||
-				!credentialInputs.email_smtp_password ||
-				!credentialInputs.email_from_address?.trim()
-			)
-				return;
-
-			const parsePort = (rawPort?: string): number | undefined => {
-				const value = rawPort?.trim();
-				if (!value) return undefined;
-				if (!/^\d+$/.test(value)) return Number.NaN;
-
-				const port = Number(value);
-				if (!Number.isInteger(port) || port < 1 || port > 65535)
-					return Number.NaN;
-
-				return port;
-			};
-
-			const parsedImapPort = parsePort(credentialInputs.email_imap_port);
-			const parsedSmtpPort = parsePort(credentialInputs.email_smtp_port);
-
-			if (Number.isNaN(parsedImapPort) || Number.isNaN(parsedSmtpPort)) {
-				setMessage({
-					text: "Ports must be integers between 1 and 65535.",
-					type: "error",
-				});
-				return;
-			}
-
-			request.platform_credentials = {
-				email_imap_host: credentialInputs.email_imap_host.trim(),
-				email_imap_port: parsedImapPort,
-				email_imap_username: credentialInputs.email_imap_username.trim(),
-				email_imap_password: credentialInputs.email_imap_password,
-				email_smtp_host: credentialInputs.email_smtp_host.trim(),
-				email_smtp_port: parsedSmtpPort,
-				email_smtp_username: credentialInputs.email_smtp_username.trim(),
-				email_smtp_password: credentialInputs.email_smtp_password,
-				email_from_address: credentialInputs.email_from_address.trim(),
-				email_from_name: credentialInputs.email_from_name?.trim() || undefined,
-			};
-		}
-		saveCreds.mutate(request);
-	}
-
 	function handleAddBinding() {
-		const request: any = {agent_id: bindingForm.agent_id, channel: platform};
+		const request: Record<string, unknown> = {
+			agent_id: bindingForm.agent_id,
+			channel: platform,
+		};
+		// Auto-populate adapter for named instances
+		if (instance.name) {
+			request.adapter = instance.name;
+		}
 		if (platform === "discord" && bindingForm.guild_id.trim())
 			request.guild_id = bindingForm.guild_id.trim();
 		if (platform === "slack" && bindingForm.workspace_id.trim())
@@ -278,20 +260,24 @@ export function ChannelSettingCard({
 			request.require_mention = true;
 		if (bindingForm.dm_allowed_users.length > 0)
 			request.dm_allowed_users = bindingForm.dm_allowed_users;
-		addBindingMutation.mutate(request);
+		addBindingMutation.mutate(request as any);
 	}
 
 	function handleUpdateBinding() {
 		if (!editingBinding) return;
-		const request: any = {
+		const request: Record<string, unknown> = {
 			original_agent_id: editingBinding.agent_id,
 			original_channel: editingBinding.channel,
+			original_adapter: editingBinding.adapter || undefined,
 			original_guild_id: editingBinding.guild_id || undefined,
 			original_workspace_id: editingBinding.workspace_id || undefined,
 			original_chat_id: editingBinding.chat_id || undefined,
 			agent_id: bindingForm.agent_id,
 			channel: platform,
 		};
+		if (instance.name) {
+			request.adapter = instance.name;
+		}
 		if (platform === "discord" && bindingForm.guild_id.trim())
 			request.guild_id = bindingForm.guild_id.trim();
 		if (platform === "slack" && bindingForm.workspace_id.trim())
@@ -299,18 +285,21 @@ export function ChannelSettingCard({
 		if (platform === "telegram" && bindingForm.chat_id.trim())
 			request.chat_id = bindingForm.chat_id.trim();
 		request.channel_ids = bindingForm.channel_ids;
-		request.require_mention =
-			platform === "discord" ? bindingForm.require_mention : false;
+		request.require_mention = platform === "discord" ? bindingForm.require_mention : false;
 		request.dm_allowed_users = bindingForm.dm_allowed_users;
-		updateBindingMutation.mutate(request);
+		updateBindingMutation.mutate(request as any);
 	}
 
 	function handleDeleteBinding(binding: BindingInfo) {
-		const request: any = {agent_id: binding.agent_id, channel: binding.channel};
+		const request: Record<string, unknown> = {
+			agent_id: binding.agent_id,
+			channel: binding.channel,
+		};
+		if (binding.adapter) request.adapter = binding.adapter;
 		if (binding.guild_id) request.guild_id = binding.guild_id;
 		if (binding.workspace_id) request.workspace_id = binding.workspace_id;
 		if (binding.chat_id) request.chat_id = binding.chat_id;
-		deleteBindingMutation.mutate(request);
+		deleteBindingMutation.mutate(request as any);
 	}
 
 	function startEditBinding(binding: BindingInfo) {
@@ -331,29 +320,29 @@ export function ChannelSettingCard({
 
 	return (
 		<div className="rounded-lg border border-app-line bg-app-box">
-			{/* Header — always visible, acts as toggle */}
-			<div
-				role="button"
-				onClick={onToggle}
-				className="flex w-full items-center gap-3 p-4 text-left cursor-pointer"
+			{/* Collapsed summary header */}
+			<button
+				type="button"
+				onClick={onToggleExpand}
+				aria-expanded={expanded}
+				className="flex w-full items-center gap-3 p-3 text-left cursor-pointer"
 			>
-				<PlatformIcon
-					platform={platform}
-					size="lg"
-					className="text-ink-faint"
-				/>
+				<PlatformIcon platform={platform} size="sm" className="text-ink-faint" />
 				<div className="flex-1 min-w-0">
 					<div className="flex items-center gap-2">
-						<span className="text-sm font-medium text-ink">{name}</span>
-						{configured && (
-							<span
-								className={`text-tiny ${enabled ? "text-green-400" : "text-ink-faint"}`}
-							>
-								{enabled ? "● Active" : "○ Disabled"}
-							</span>
-						)}
+						<span className="text-sm font-medium text-ink">
+							{PLATFORM_LABELS[platform]}
+						</span>
+						<span className="rounded bg-app-selected/60 px-1.5 py-0.5 text-[10px] font-medium uppercase leading-none text-ink-faint">
+							{instance.name || "default"}
+						</span>
+						<span className={`text-tiny ${instance.enabled ? "text-green-400" : "text-ink-faint"}`}>
+							{instance.enabled ? "● Active" : "○ Disabled"}
+						</span>
 					</div>
-					<p className="mt-0.5 text-sm text-ink-dull">{description}</p>
+					<p className="text-tiny text-ink-faint mt-0.5">
+						{instance.binding_count} binding{instance.binding_count !== 1 ? "s" : ""}
+					</p>
 				</div>
 				<motion.div
 					animate={{rotate: expanded ? 180 : 0}}
@@ -362,7 +351,7 @@ export function ChannelSettingCard({
 				>
 					<FontAwesomeIcon icon={faChevronDown} size="sm" />
 				</motion.div>
-			</div>
+			</button>
 
 			{/* Expanded content */}
 			<AnimatePresence initial={false}>
@@ -374,67 +363,126 @@ export function ChannelSettingCard({
 						transition={{duration: 0.25, ease: [0.4, 0, 0.2, 1]}}
 						className="overflow-hidden"
 					>
-						<div className="border-t border-app-line/50 bg-app-darkBox px-4 pb-4 pt-4 flex flex-col gap-4">
+						<div className="border-t border-app-line/50 bg-app-darkBox px-4 pb-4 pt-3 flex flex-col gap-4">
 							{/* Enable/Disable toggle */}
-							{configured && (
+							<div className="flex items-center justify-between">
+								<div>
+									<span className="text-sm font-medium text-ink">Enabled</span>
+									<p className="mt-0.5 text-sm text-ink-dull">
+										{instance.enabled ? "Receiving messages" : "Adapter paused"}
+									</p>
+								</div>
+								<Toggle
+									checked={instance.enabled}
+									onCheckedChange={(checked) => toggleEnabled.mutate(checked)}
+									disabled={toggleEnabled.isPending}
+								/>
+							</div>
+
+							{/* Bindings section (scoped to this instance) */}
+							<div className="flex flex-col gap-3 border-t border-app-line/50 pt-3">
 								<div className="flex items-center justify-between">
-									<div>
-										<span className="text-sm font-medium text-ink">
-											Enabled
-										</span>
-										<p className="mt-0.5 text-sm text-ink-dull">
-											{enabled
-												? `${name} is receiving messages`
-												: `${name} is disconnected`}
-										</p>
-									</div>
-									<Toggle
-										checked={enabled}
-										onCheckedChange={(checked) => toggleEnabled.mutate(checked)}
-										disabled={toggleEnabled.isPending}
-									/>
+									<h3 className="text-sm font-medium text-ink">Bindings</h3>
+									<Button
+										size="sm"
+										variant="outline"
+										onClick={() => {
+											setAddingBinding(true);
+											setEditingBinding(null);
+											resetBindingForm();
+											setMessage(null);
+										}}
+									>
+										Add
+									</Button>
 								</div>
-							)}
-							{/* Credentials */}
-							<CredentialsSection
-								platform={platform}
-								configured={configured}
-								credentialInputs={credentialInputs}
-								setCredentialInputs={setCredentialInputs}
-								onSave={handleSaveCredentials}
-								saving={saveCreds.isPending}
-							/>
 
-							{/* Bindings (only when connected) */}
-							{configured && (
-								<BindingsSection
-									platform={platform}
-									bindings={platformBindings}
-									agents={agentsData?.agents ?? []}
-									isEditingOrAdding={isEditingOrAdding}
-									editingBinding={editingBinding}
-									bindingForm={bindingForm}
-									setBindingForm={setBindingForm}
-									onStartAdd={() => {
-										setAddingBinding(true);
-										setEditingBinding(null);
-										resetBindingForm();
-										setMessage(null);
-									}}
-									onStartEdit={startEditBinding}
-									onCancelEdit={() => {
-										setEditingBinding(null);
-										setAddingBinding(false);
-										setMessage(null);
+								{instanceBindings.length > 0 ? (
+									<div className="rounded-md border border-app-line bg-app-box">
+										{instanceBindings.map((binding, idx) => (
+											<div
+												key={idx}
+												className="flex items-center gap-2 border-b border-app-line/50 px-3 py-2 last:border-b-0"
+											>
+												<div className="flex-1 min-w-0">
+													<span className="text-sm text-ink">{binding.agent_id}</span>
+													<div className="flex flex-wrap gap-1.5 mt-0.5 text-tiny text-ink-faint">
+														{binding.guild_id && <span>Guild: {binding.guild_id}</span>}
+														{binding.workspace_id && <span>Workspace: {binding.workspace_id}</span>}
+														{binding.chat_id && <span>Chat: {binding.chat_id}</span>}
+														{binding.channel_ids.length > 0 && (
+															<span>
+																{binding.channel_ids.length} channel{binding.channel_ids.length > 1 ? "s" : ""}
+															</span>
+														)}
+														{binding.dm_allowed_users.length > 0 && (
+															<span>
+																{binding.dm_allowed_users.length} DM user{binding.dm_allowed_users.length > 1 ? "s" : ""}
+															</span>
+														)}
+														{binding.require_mention && <span>Mention only</span>}
+														{!binding.guild_id &&
+															!binding.workspace_id &&
+															!binding.chat_id &&
+															binding.channel_ids.length === 0 && (
+																<span>All conversations</span>
+															)}
+													</div>
+												</div>
+												<Button size="sm" variant="outline" onClick={() => startEditBinding(binding)}>
+													Edit
+												</Button>
+												<Button
+													size="sm"
+													variant="outline"
+													onClick={() => handleDeleteBinding(binding)}
+													loading={deleteBindingMutation.isPending}
+												>
+													Remove
+												</Button>
+											</div>
+										))}
+									</div>
+								) : (
+									<p className="text-sm text-ink-faint py-1">
+										No bindings. Messages will route to the default agent.
+									</p>
+								)}
+
+								{/* Add/Edit binding modal */}
+								<Dialog
+									open={isEditingOrAdding}
+									onOpenChange={(open) => {
+										if (!open) {
+											setEditingBinding(null);
+											setAddingBinding(false);
+											setMessage(null);
+										}
 									}}
-									onAdd={handleAddBinding}
-									onUpdate={handleUpdateBinding}
-									onDelete={handleDeleteBinding}
-									addPending={addBindingMutation.isPending}
-									updatePending={updateBindingMutation.isPending}
-									deletePending={deleteBindingMutation.isPending}
-								/>
-							)}
+								>
+									<DialogContent className="max-w-md">
+										<DialogHeader>
+											<DialogTitle>
+												{editingBinding ? "Edit Binding" : "Add Binding"}
+											</DialogTitle>
+										</DialogHeader>
+										<BindingForm
+											platform={platform}
+											agents={agentsData?.agents ?? []}
+											bindingForm={bindingForm}
+											setBindingForm={setBindingForm}
+											editing={!!editingBinding}
+											onSave={editingBinding ? handleUpdateBinding : handleAddBinding}
+											onCancel={() => {
+												setEditingBinding(null);
+												setAddingBinding(false);
+												setMessage(null);
+											}}
+											saving={editingBinding ? updateBindingMutation.isPending : addBindingMutation.isPending}
+										/>
+									</DialogContent>
+								</Dialog>
+							</div>
 
 							{/* Status message */}
 							{message && (
@@ -449,16 +497,38 @@ export function ChannelSettingCard({
 								</div>
 							)}
 
-							{/* Disconnect */}
-							{configured && platform !== "webhook" && (
-								<DisconnectSection
-									name={name}
-									confirmDisconnect={confirmDisconnect}
-									setConfirmDisconnect={setConfirmDisconnect}
-									onDisconnect={() => disconnectMutation.mutate()}
-									disconnecting={disconnectMutation.isPending}
-								/>
-							)}
+							{/* Remove instance */}
+							<div className="border-t border-app-line/50 pt-3">
+									{!confirmRemove ? (
+										<Button
+											variant="outline"
+											size="sm"
+											onClick={() => setConfirmRemove(true)}
+										>
+											Remove {instanceLabel}
+										</Button>
+									) : (
+										<div className="flex flex-col gap-2">
+											<p className="text-sm text-red-400">
+												This will remove credentials and bindings for {instanceLabel}.
+												The adapter will stop immediately.
+											</p>
+											<div className="flex gap-2">
+												<Button variant="ghost" size="sm" onClick={() => setConfirmRemove(false)}>
+													Cancel
+												</Button>
+												<Button
+													size="sm"
+													onClick={() => deleteInstance.mutate()}
+													loading={deleteInstance.isPending}
+													className="bg-red-500/20 text-red-400 hover:bg-red-500/30"
+												>
+													Confirm Remove
+												</Button>
+											</div>
+										</div>
+									)}
+								</div>
 						</div>
 					</motion.div>
 				)}
@@ -467,637 +537,430 @@ export function ChannelSettingCard({
 	);
 }
 
-// --- Disabled card for coming soon platforms ---
+// --- Add Instance Inline Card ---
 
-interface DisabledChannelCardProps {
-	platform: string;
-	name: string;
-	description: string;
+interface AddInstanceCardProps {
+	platform: Platform;
+	isDefault: boolean;
+	onCancel: () => void;
+	onCreated: () => void;
 }
 
-export function DisabledChannelCard({
-	platform,
-	name,
-	description,
-}: DisabledChannelCardProps) {
-	return (
-		<div className="rounded-lg border border-app-line bg-app-box p-4 opacity-40">
-			<div className="flex items-center gap-3">
-				<PlatformIcon
-					platform={platform}
-					size="lg"
-					className="text-ink-faint/50"
-				/>
-				<div className="flex-1">
-					<span className="text-sm font-medium text-ink">{name}</span>
-					<p className="mt-0.5 text-sm text-ink-dull">{description}</p>
-				</div>
-				<Button variant="outline" size="sm" disabled>
-					Coming Soon
-				</Button>
-			</div>
-		</div>
-	);
-}
+export function AddInstanceCard({platform, isDefault, onCancel, onCreated}: AddInstanceCardProps) {
+	const queryClient = useQueryClient();
+	const [instanceName, setInstanceName] = useState("");
+	const [credentialInputs, setCredentialInputs] = useState<Record<string, string>>({});
+	const [message, setMessage] = useState<{text: string; type: "success" | "error"} | null>(null);
 
-// --- Sub-sections ---
+	const createInstance = useMutation({
+		mutationFn: api.createMessagingInstance,
+		onSuccess: (result) => {
+			if (result.success) {
+				queryClient.invalidateQueries({queryKey: ["messaging-status"]});
+				queryClient.invalidateQueries({queryKey: ["bindings"]});
+				onCreated();
+			} else {
+				setMessage({text: result.message, type: "error"});
+			}
+		},
+		onError: (error) => setMessage({text: `Failed: ${error.message}`, type: "error"}),
+	});
 
-function CredentialsSection({
-	platform,
-	configured,
-	credentialInputs,
-	setCredentialInputs,
-	onSave,
-	saving,
-}: {
-	platform: Platform;
-	configured: boolean;
-	credentialInputs: Record<string, string>;
-	setCredentialInputs: (inputs: Record<string, string>) => void;
-	onSave: () => void;
-	saving: boolean;
-}) {
-	return (
-		<div className="flex flex-col gap-3">
-			<h3 className="text-sm font-medium text-ink">
-				{configured ? "Update Credentials" : "Credentials"}
-			</h3>
+	function handleSave() {
+		const credentials: CreateMessagingInstanceRequest["credentials"] = {};
 
-			{platform === "discord" && (
-				<div>
-					<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-						Bot Token
-					</label>
-					<Input
-						type="password"
-						size="lg"
-						value={credentialInputs.discord_token ?? ""}
-						onChange={(e) =>
-							setCredentialInputs({
-								...credentialInputs,
-								discord_token: e.target.value,
-							})
-						}
-						placeholder={
-							configured
-								? "Enter new token to update"
-								: "MTk4NjIyNDgzNDcxOTI1MjQ4.D..."
-						}
-						onKeyDown={(e) => {
-							if (e.key === "Enter") onSave();
-						}}
-					/>
-					<p className="mt-1.5 text-xs text-ink-faint">
-						Need help?{" "}
-						<a href="https://docs.spacebot.sh/discord-setup" target="_blank" rel="noopener noreferrer" className="text-accent hover:underline">
-							Read the Discord setup docs &rarr;
-						</a>
-					</p>
+		if (platform === "discord") {
+			if (!credentialInputs.discord_token?.trim()) {
+				setMessage({text: "Bot token is required", type: "error"});
+				return;
+			}
+			credentials.discord_token = credentialInputs.discord_token.trim();
+		} else if (platform === "slack") {
+			if (!credentialInputs.slack_bot_token?.trim() || !credentialInputs.slack_app_token?.trim()) {
+				setMessage({text: "Both bot token and app token are required", type: "error"});
+				return;
+			}
+			credentials.slack_bot_token = credentialInputs.slack_bot_token.trim();
+			credentials.slack_app_token = credentialInputs.slack_app_token.trim();
+		} else if (platform === "telegram") {
+			if (!credentialInputs.telegram_token?.trim()) {
+				setMessage({text: "Bot token is required", type: "error"});
+				return;
+			}
+			credentials.telegram_token = credentialInputs.telegram_token.trim();
+		} else if (platform === "twitch") {
+			if (!credentialInputs.twitch_username?.trim() || !credentialInputs.twitch_oauth_token?.trim()) {
+				setMessage({text: "Username and OAuth token are required", type: "error"});
+				return;
+			}
+			credentials.twitch_username = credentialInputs.twitch_username.trim();
+			credentials.twitch_oauth_token = credentialInputs.twitch_oauth_token.trim();
+			if (credentialInputs.twitch_client_id?.trim())
+				credentials.twitch_client_id = credentialInputs.twitch_client_id.trim();
+			if (credentialInputs.twitch_client_secret?.trim())
+				credentials.twitch_client_secret = credentialInputs.twitch_client_secret.trim();
+			if (credentialInputs.twitch_refresh_token?.trim())
+				credentials.twitch_refresh_token = credentialInputs.twitch_refresh_token.trim();
+		} else if (platform === "email") {
+			if (!credentialInputs.email_imap_host?.trim() || !credentialInputs.email_smtp_host?.trim()) {
+				setMessage({text: "IMAP host and SMTP host are required", type: "error"});
+				return;
+			}
+			if (!credentialInputs.email_imap_username?.trim() || !credentialInputs.email_imap_password?.trim()) {
+				setMessage({text: "IMAP username and password are required", type: "error"});
+				return;
+			}
+			if (!credentialInputs.email_smtp_username?.trim() || !credentialInputs.email_smtp_password?.trim()) {
+				setMessage({text: "SMTP username and password are required", type: "error"});
+				return;
+			}
+			if (!credentialInputs.email_from_address?.trim()) {
+				setMessage({text: "From address is required", type: "error"});
+				return;
+			}
+			credentials.email_imap_host = credentialInputs.email_imap_host.trim();
+			credentials.email_imap_username = credentialInputs.email_imap_username.trim();
+			credentials.email_imap_password = credentialInputs.email_imap_password.trim();
+			credentials.email_smtp_host = credentialInputs.email_smtp_host.trim();
+			credentials.email_smtp_username = credentialInputs.email_smtp_username.trim();
+			credentials.email_smtp_password = credentialInputs.email_smtp_password.trim();
+			credentials.email_from_address = credentialInputs.email_from_address.trim();
+			if (credentialInputs.email_imap_port?.trim())
+				credentials.email_imap_port = parseInt(credentialInputs.email_imap_port.trim(), 10) || undefined;
+			if (credentialInputs.email_smtp_port?.trim())
+				credentials.email_smtp_port = parseInt(credentialInputs.email_smtp_port.trim(), 10) || undefined;
+		} else if (platform === "webhook") {
+			if (credentialInputs.webhook_port?.trim())
+				credentials.webhook_port = parseInt(credentialInputs.webhook_port.trim(), 10) || undefined;
+			if (credentialInputs.webhook_bind?.trim())
+				credentials.webhook_bind = credentialInputs.webhook_bind.trim();
+			if (credentialInputs.webhook_auth_token?.trim())
+				credentials.webhook_auth_token = credentialInputs.webhook_auth_token.trim();
+		}
+
+		if (!isDefault && !instanceName.trim()) {
+			setMessage({text: "Instance name is required", type: "error"});
+			return;
+		}
+
+		createInstance.mutate({
+			platform,
+			name: isDefault ? undefined : instanceName.trim(),
+			credentials,
+		});
+	}
+
+	const docLink = DOC_LINKS[platform];
+
+	return (
+		<div className="rounded-lg border border-accent/30 bg-app-box">
+			<div className="p-4 flex flex-col gap-3">
+				<div className="flex items-center gap-2">
+					<PlatformIcon platform={platform} size="sm" className="text-ink-faint" />
+					<span className="text-sm font-medium text-ink">
+						{isDefault
+							? `Add ${PLATFORM_LABELS[platform]}`
+							: `Add ${PLATFORM_LABELS[platform]} Instance`}
+					</span>
 				</div>
-			)}
 
-			{platform === "slack" && (
-				<>
+				{/* Instance name (only for non-default) */}
+				{!isDefault && (
 					<div>
-						<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-							Bot Token
+						<label className="mb-1 block text-sm font-medium text-ink-dull">
+							Instance Name
 						</label>
 						<Input
-							type="password"
 							size="lg"
-							value={credentialInputs.slack_bot_token ?? ""}
-							onChange={(e) =>
-								setCredentialInputs({
-									...credentialInputs,
-									slack_bot_token: e.target.value,
-								})
-							}
-							placeholder={
-								configured ? "Enter new token to update" : "xoxb-..."
-							}
+							value={instanceName}
+							onChange={(e) => setInstanceName(e.target.value)}
+							placeholder='e.g. "support", "sales"'
 						/>
 					</div>
+				)}
+
+				{/* Platform-specific credential fields */}
+				{platform === "discord" && (
 					<div>
-						<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-							App Token
-						</label>
+						<label className="mb-1.5 block text-sm font-medium text-ink-dull">Bot Token</label>
 						<Input
 							type="password"
 							size="lg"
-							value={credentialInputs.slack_app_token ?? ""}
-							onChange={(e) =>
-								setCredentialInputs({
-									...credentialInputs,
-									slack_app_token: e.target.value,
-								})
-							}
-							placeholder={
-								configured ? "Enter new token to update" : "xapp-..."
-							}
-							onKeyDown={(e) => {
-								if (e.key === "Enter") onSave();
-							}}
+							value={credentialInputs.discord_token ?? ""}
+							onChange={(e) => setCredentialInputs({...credentialInputs, discord_token: e.target.value})}
+							placeholder="MTk4NjIyNDgzNDcxOTI1MjQ4.D..."
+							onKeyDown={(e) => { if (e.key === "Enter") handleSave(); }}
 						/>
 					</div>
-					<p className="text-xs text-ink-faint">
-						Need help?{" "}
-						<a href="https://docs.spacebot.sh/slack-setup" target="_blank" rel="noopener noreferrer" className="text-accent hover:underline">
-							Read the Slack setup docs &rarr;
-						</a>
-					</p>
-				</>
-			)}
-
-			{platform === "telegram" && (
-				<div>
-					<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-						Bot Token
-					</label>
-					<Input
-						type="password"
-						size="lg"
-						value={credentialInputs.telegram_token ?? ""}
-						onChange={(e) =>
-							setCredentialInputs({
-								...credentialInputs,
-								telegram_token: e.target.value,
-							})
-						}
-						placeholder={
-							configured
-								? "Enter new token to update"
-								: "123456789:ABCdefGHI..."
-						}
-						onKeyDown={(e) => {
-							if (e.key === "Enter") onSave();
-						}}
-					/>
-					<p className="mt-1.5 text-xs text-ink-faint">
-						Need help?{" "}
-						<a href="https://docs.spacebot.sh/telegram-setup" target="_blank" rel="noopener noreferrer" className="text-accent hover:underline">
-							Read the Telegram setup docs &rarr;
-						</a>
-					</p>
-				</div>
-			)}
+				)}
 
-			{platform === "twitch" && (
-				<>
-					<div>
-						<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-							Bot Username
-						</label>
-						<Input
-							size="lg"
-							value={credentialInputs.twitch_username ?? ""}
-							onChange={(e) =>
-								setCredentialInputs({
-									...credentialInputs,
-									twitch_username: e.target.value,
-								})
-							}
-							placeholder={
-								configured ? "Enter new username to update" : "my_bot"
-							}
-						/>
-					</div>
-					<div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+				{platform === "slack" && (
+					<>
 						<div>
-							<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-								Client ID
-							</label>
-							<Input
-								size="lg"
-								value={credentialInputs.twitch_client_id ?? ""}
-								onChange={(e) =>
-									setCredentialInputs({
-										...credentialInputs,
-										twitch_client_id: e.target.value,
-									})
-								}
-								placeholder={
-									configured ? "Enter new client id to update" : "your-app-client-id"
-								}
-							/>
-						</div>
-						<div>
-							<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-								Client Secret
-							</label>
+							<label className="mb-1.5 block text-sm font-medium text-ink-dull">Bot Token</label>
 							<Input
 								type="password"
 								size="lg"
-								value={credentialInputs.twitch_client_secret ?? ""}
-								onChange={(e) =>
-									setCredentialInputs({
-										...credentialInputs,
-										twitch_client_secret: e.target.value,
-									})
-								}
-								placeholder={
-									configured ? "Enter new client secret to update" : "your-app-client-secret"
-								}
+								value={credentialInputs.slack_bot_token ?? ""}
+								onChange={(e) => setCredentialInputs({...credentialInputs, slack_bot_token: e.target.value})}
+								placeholder="xoxb-..."
 							/>
 						</div>
-					</div>
-					<div className="grid grid-cols-1 md:grid-cols-2 gap-4">
 						<div>
-							<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-								OAuth Access Token
-							</label>
+							<label className="mb-1.5 block text-sm font-medium text-ink-dull">App Token</label>
 							<Input
 								type="password"
 								size="lg"
-								value={credentialInputs.twitch_oauth_token ?? ""}
-								onChange={(e) =>
-									setCredentialInputs({
-										...credentialInputs,
-										twitch_oauth_token: e.target.value,
-									})
-								}
-								placeholder={
-									configured ? "Enter new token to update" : "abcd1234..."
-								}
-								onKeyDown={(e) => {
-									if (e.key === "Enter") onSave();
-								}}
-							/>
-						</div>
-						<div>
-							<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-								OAuth Refresh Token
-							</label>
-							<Input
-								type="password"
-								size="lg"
-								value={credentialInputs.twitch_refresh_token ?? ""}
-								onChange={(e) =>
-									setCredentialInputs({
-										...credentialInputs,
-										twitch_refresh_token: e.target.value,
-									})
-								}
-								placeholder={
-									configured ? "Enter new refresh token to update" : "refresh-token-from-twitch"
-								}
+								value={credentialInputs.slack_app_token ?? ""}
+								onChange={(e) => setCredentialInputs({...credentialInputs, slack_app_token: e.target.value})}
+								placeholder="xapp-..."
+								onKeyDown={(e) => { if (e.key === "Enter") handleSave(); }}
 							/>
 						</div>
+					</>
+				)}
+
+				{platform === "telegram" && (
+					<div>
+						<label className="mb-1.5 block text-sm font-medium text-ink-dull">Bot Token</label>
+						<Input
+							type="password"
+							size="lg"
+							value={credentialInputs.telegram_token ?? ""}
+							onChange={(e) => setCredentialInputs({...credentialInputs, telegram_token: e.target.value})}
+							placeholder="123456789:ABCdefGHI..."
+							onKeyDown={(e) => { if (e.key === "Enter") handleSave(); }}
+						/>
 					</div>
-					<p className="mt-1 text-xs text-ink-faint">
-						Use tokens from your Twitch application with chat:read and chat:write scopes enabled. Tokens are stored in your Spacebot instance and refreshed automatically while running.
-					</p>
-					<p className="mt-1.5 text-xs text-ink-faint">
-						Need help?{" "}
-						<a href="https://docs.spacebot.sh/twitch-setup" target="_blank" rel="noopener noreferrer" className="text-accent hover:underline">
-							Read the Twitch setup docs &rarr;
-						</a>
-					</p>
-				</>
-			)}
+				)}
 
-			{platform === "email" && (
-				<>
-					<div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+				{platform === "twitch" && (
+					<>
 						<div>
-							<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-								IMAP Host
-							</label>
+							<label className="mb-1.5 block text-sm font-medium text-ink-dull">Bot Username</label>
 							<Input
 								size="lg"
-								value={credentialInputs.email_imap_host ?? ""}
-								onChange={(e) =>
-									setCredentialInputs({
-										...credentialInputs,
-										email_imap_host: e.target.value,
-									})
-								}
-								placeholder="imap.example.com"
+								value={credentialInputs.twitch_username ?? ""}
+								onChange={(e) => setCredentialInputs({...credentialInputs, twitch_username: e.target.value})}
+								placeholder="my_bot"
 							/>
 						</div>
-						<div>
-							<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-								IMAP Port
-							</label>
-							<Input
-								size="lg"
-								value={credentialInputs.email_imap_port ?? ""}
-								onChange={(e) =>
-									setCredentialInputs({
-										...credentialInputs,
-										email_imap_port: e.target.value,
-									})
-								}
-								placeholder="993"
-							/>
-						</div>
-					</div>
-					<div className="grid grid-cols-1 md:grid-cols-2 gap-4">
-						<div>
-							<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-								IMAP Username
-							</label>
-							<Input
-								size="lg"
-								value={credentialInputs.email_imap_username ?? ""}
-								onChange={(e) =>
-									setCredentialInputs({
-										...credentialInputs,
-										email_imap_username: e.target.value,
-									})
-								}
-								placeholder="inbox@example.com"
-							/>
+						<div className="grid grid-cols-2 gap-3">
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">Client ID</label>
+								<Input
+									size="lg"
+									value={credentialInputs.twitch_client_id ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, twitch_client_id: e.target.value})}
+									placeholder="your-client-id"
+								/>
+							</div>
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">Client Secret</label>
+								<Input
+									type="password"
+									size="lg"
+									value={credentialInputs.twitch_client_secret ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, twitch_client_secret: e.target.value})}
+									placeholder="your-client-secret"
+								/>
+							</div>
 						</div>
-						<div>
-							<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-								IMAP Password
-							</label>
-							<Input
-								type="password"
-								size="lg"
-								value={credentialInputs.email_imap_password ?? ""}
-								onChange={(e) =>
-									setCredentialInputs({
-										...credentialInputs,
-										email_imap_password: e.target.value,
-									})
-								}
-								placeholder={configured ? "Enter new password to update" : "App password"}
-							/>
+						<div className="grid grid-cols-2 gap-3">
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">OAuth Token</label>
+								<Input
+									type="password"
+									size="lg"
+									value={credentialInputs.twitch_oauth_token ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, twitch_oauth_token: e.target.value})}
+									placeholder="abcd1234..."
+									onKeyDown={(e) => { if (e.key === "Enter") handleSave(); }}
+								/>
+							</div>
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">Refresh Token</label>
+								<Input
+									type="password"
+									size="lg"
+									value={credentialInputs.twitch_refresh_token ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, twitch_refresh_token: e.target.value})}
+									placeholder="refresh-token"
+								/>
+							</div>
 						</div>
-					</div>
-					<div className="grid grid-cols-1 md:grid-cols-2 gap-4">
-						<div>
-							<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-								SMTP Host
-							</label>
-							<Input
-								size="lg"
-								value={credentialInputs.email_smtp_host ?? ""}
-								onChange={(e) =>
-									setCredentialInputs({
-										...credentialInputs,
-										email_smtp_host: e.target.value,
-									})
-								}
-								placeholder="smtp.example.com"
-							/>
+					</>
+				)}
+
+				{platform === "email" && (
+					<>
+						<div className="grid grid-cols-2 gap-3">
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">IMAP Host</label>
+								<Input
+									size="lg"
+									value={credentialInputs.email_imap_host ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, email_imap_host: e.target.value})}
+									placeholder="imap.gmail.com"
+								/>
+							</div>
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">IMAP Port</label>
+								<Input
+									size="lg"
+									value={credentialInputs.email_imap_port ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, email_imap_port: e.target.value})}
+									placeholder="993"
+								/>
+							</div>
 						</div>
-						<div>
-							<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-								SMTP Port
-							</label>
-							<Input
-								size="lg"
-								value={credentialInputs.email_smtp_port ?? ""}
-								onChange={(e) =>
-									setCredentialInputs({
-										...credentialInputs,
-										email_smtp_port: e.target.value,
-									})
-								}
-								placeholder="587"
-							/>
+						<div className="grid grid-cols-2 gap-3">
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">IMAP Username</label>
+								<Input
+									size="lg"
+									value={credentialInputs.email_imap_username ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, email_imap_username: e.target.value})}
+									placeholder="user@example.com"
+								/>
+							</div>
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">IMAP Password</label>
+								<Input
+									type="password"
+									size="lg"
+									value={credentialInputs.email_imap_password ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, email_imap_password: e.target.value})}
+									placeholder="App password"
+								/>
+							</div>
 						</div>
-					</div>
-					<div className="grid grid-cols-1 md:grid-cols-2 gap-4">
-						<div>
-							<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-								SMTP Username
-							</label>
-							<Input
-								size="lg"
-								value={credentialInputs.email_smtp_username ?? ""}
-								onChange={(e) =>
-									setCredentialInputs({
-										...credentialInputs,
-										email_smtp_username: e.target.value,
-									})
-								}
-								placeholder="inbox@example.com"
-							/>
+						<div className="grid grid-cols-2 gap-3">
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">SMTP Host</label>
+								<Input
+									size="lg"
+									value={credentialInputs.email_smtp_host ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, email_smtp_host: e.target.value})}
+									placeholder="smtp.gmail.com"
+								/>
+							</div>
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">SMTP Port</label>
+								<Input
+									size="lg"
+									value={credentialInputs.email_smtp_port ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, email_smtp_port: e.target.value})}
+									placeholder="587"
+								/>
+							</div>
 						</div>
-						<div>
-							<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-								SMTP Password
-							</label>
-							<Input
-								type="password"
-								size="lg"
-								value={credentialInputs.email_smtp_password ?? ""}
-								onChange={(e) =>
-									setCredentialInputs({
-										...credentialInputs,
-										email_smtp_password: e.target.value,
-									})
-								}
-								placeholder={configured ? "Enter new password to update" : "App password"}
-								onKeyDown={(e) => {
-									if (e.key === "Enter") onSave();
-								}}
-							/>
+						<div className="grid grid-cols-2 gap-3">
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">SMTP Username</label>
+								<Input
+									size="lg"
+									value={credentialInputs.email_smtp_username ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, email_smtp_username: e.target.value})}
+									placeholder="user@example.com"
+								/>
+							</div>
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">SMTP Password</label>
+								<Input
+									type="password"
+									size="lg"
+									value={credentialInputs.email_smtp_password ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, email_smtp_password: e.target.value})}
+									placeholder="App password"
+								/>
+							</div>
 						</div>
-					</div>
-					<div className="grid grid-cols-1 md:grid-cols-2 gap-4">
 						<div>
-							<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-								From Address
-							</label>
+							<label className="mb-1.5 block text-sm font-medium text-ink-dull">From Address</label>
 							<Input
 								size="lg"
 								value={credentialInputs.email_from_address ?? ""}
-								onChange={(e) =>
-									setCredentialInputs({
-										...credentialInputs,
-										email_from_address: e.target.value,
-									})
-								}
+								onChange={(e) => setCredentialInputs({...credentialInputs, email_from_address: e.target.value})}
 								placeholder="bot@example.com"
+								onKeyDown={(e) => { if (e.key === "Enter") handleSave(); }}
 							/>
 						</div>
+					</>
+				)}
+
+				{platform === "webhook" && (
+					<>
+						<div className="grid grid-cols-2 gap-3">
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">Port</label>
+								<Input
+									size="lg"
+									value={credentialInputs.webhook_port ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, webhook_port: e.target.value})}
+									placeholder="18789"
+								/>
+							</div>
+							<div>
+								<label className="mb-1.5 block text-sm font-medium text-ink-dull">Bind Address</label>
+								<Input
+									size="lg"
+									value={credentialInputs.webhook_bind ?? ""}
+									onChange={(e) => setCredentialInputs({...credentialInputs, webhook_bind: e.target.value})}
+									placeholder="127.0.0.1"
+								/>
+							</div>
+						</div>
 						<div>
-							<label className="mb-1.5 block text-sm font-medium text-ink-dull">
-								From Name (optional)
-							</label>
+							<label className="mb-1.5 block text-sm font-medium text-ink-dull">Auth Token</label>
 							<Input
+								type="password"
 								size="lg"
-								value={credentialInputs.email_from_name ?? ""}
-								onChange={(e) =>
-									setCredentialInputs({
-										...credentialInputs,
-										email_from_name: e.target.value,
-									})
-								}
-								placeholder="Spacebot"
+								value={credentialInputs.webhook_auth_token ?? ""}
+								onChange={(e) => setCredentialInputs({...credentialInputs, webhook_auth_token: e.target.value})}
+								placeholder="Optional — leave empty for no auth"
+								onKeyDown={(e) => { if (e.key === "Enter") handleSave(); }}
 							/>
 						</div>
-					</div>
+					</>
+				)}
+
+				{docLink && (
 					<p className="text-xs text-ink-faint">
-						Use provider app passwords where possible. If ports are omitted, Spacebot defaults to IMAP 993 and SMTP 587.
+						Need help?{" "}
+						<a href={docLink} target="_blank" rel="noopener noreferrer" className="text-accent hover:underline">
+							Read the {PLATFORM_LABELS[platform]} setup docs &rarr;
+						</a>
 					</p>
-				</>
-			)}
-
-			{platform === "webhook" && (
-				<p className="text-sm text-ink-dull">
-					Webhook receiver requires no additional credentials.
-				</p>
-			)}
-
-			{platform !== "webhook" &&
-				Object.values(credentialInputs).some((v) => v?.trim()) && (
-					<Button onClick={onSave} loading={saving} size="sm">
-						{configured ? "Update Credentials" : "Connect"}
-					</Button>
 				)}
-		</div>
-	);
-}
 
-function BindingsSection({
-	platform,
-	bindings,
-	agents,
-	isEditingOrAdding,
-	editingBinding,
-	bindingForm,
-	setBindingForm,
-	onStartAdd,
-	onStartEdit,
-	onCancelEdit,
-	onAdd,
-	onUpdate,
-	onDelete,
-	addPending,
-	updatePending,
-	deletePending,
-}: {
-	platform: Platform;
-	bindings: BindingInfo[];
-	agents: {id: string}[];
-	isEditingOrAdding: boolean;
-	editingBinding: BindingInfo | null;
-	bindingForm: {
-		agent_id: string;
-		guild_id: string;
-		workspace_id: string;
-		chat_id: string;
-		channel_ids: string[];
-		require_mention: boolean;
-		dm_allowed_users: string[];
-	};
-	setBindingForm: (form: any) => void;
-	onStartAdd: () => void;
-	onStartEdit: (binding: BindingInfo) => void;
-	onCancelEdit: () => void;
-	onAdd: () => void;
-	onUpdate: () => void;
-	onDelete: (binding: BindingInfo) => void;
-	addPending: boolean;
-	updatePending: boolean;
-	deletePending: boolean;
-}) {
-	return (
-		<div className="flex flex-col gap-3 border-t border-app-line/50 pt-4">
-			<div className="flex items-center justify-between">
-				<h3 className="text-sm font-medium text-ink">Bindings</h3>
-				<Button size="sm" variant="outline" onClick={onStartAdd}>
-					Add
-				</Button>
-			</div>
+				{message && (
+					<div
+						className={`rounded-md border px-3 py-2 text-sm ${
+							message.type === "success"
+								? "border-green-500/20 bg-green-500/10 text-green-400"
+								: "border-red-500/20 bg-red-500/10 text-red-400"
+						}`}
+					>
+						{message.text}
+					</div>
+				)}
 
-			{/* Binding list */}
-			{bindings.length > 0 ? (
-				<div className="rounded-md border border-app-line bg-app-box">
-					{bindings.map((binding, idx) => (
-						<div
-							key={idx}
-							className="flex items-center gap-2 border-b border-app-line/50 px-3 py-2 last:border-b-0"
-						>
-							<div className="flex-1 min-w-0">
-								<span className="text-sm text-ink">{binding.agent_id}</span>
-								<div className="flex flex-wrap gap-1.5 mt-0.5 text-tiny text-ink-faint">
-									{binding.guild_id && <span>Guild: {binding.guild_id}</span>}
-									{binding.workspace_id && (
-										<span>Workspace: {binding.workspace_id}</span>
-									)}
-									{binding.chat_id && <span>Chat: {binding.chat_id}</span>}
-									{binding.channel_ids.length > 0 && (
-										<span>
-											{binding.channel_ids.length} channel
-											{binding.channel_ids.length > 1 ? "s" : ""}
-										</span>
-									)}
-									{binding.dm_allowed_users.length > 0 && (
-										<span>
-											{binding.dm_allowed_users.length} DM user
-											{binding.dm_allowed_users.length > 1 ? "s" : ""}
-										</span>
-									)}
-									{binding.require_mention && (
-										<span>Mention only</span>
-									)}
-									{!binding.guild_id &&
-										!binding.workspace_id &&
-										!binding.chat_id &&
-										binding.channel_ids.length === 0 && (
-											<span>All conversations</span>
-										)}
-								</div>
-							</div>
-							<Button
-								size="sm"
-								variant="outline"
-								onClick={() => onStartEdit(binding)}
-							>
-								Edit
-							</Button>
-							<Button
-								size="sm"
-								variant="outline"
-								onClick={() => onDelete(binding)}
-								loading={deletePending}
-							>
-								Remove
-							</Button>
-						</div>
-					))}
+				<div className="flex gap-2 justify-end">
+					<Button size="sm" variant="ghost" onClick={onCancel}>
+						Cancel
+					</Button>
+					<Button size="sm" onClick={handleSave} loading={createInstance.isPending}>
+						{isDefault ? "Connect" : "Create Instance"}
+					</Button>
 				</div>
-			) : (
-				<p className="text-sm text-ink-faint py-2">
-					No bindings. Messages will route to the default agent.
-				</p>
-			)}
-
-			{/* Add/Edit binding modal */}
-			<Dialog
-				open={isEditingOrAdding}
-				onOpenChange={(open) => {
-					if (!open) onCancelEdit();
-				}}
-			>
-				<DialogContent className="max-w-md">
-					<DialogHeader>
-						<DialogTitle>
-							{editingBinding ? "Edit Binding" : "Add Binding"}
-						</DialogTitle>
-					</DialogHeader>
-					<BindingForm
-						platform={platform}
-						agents={agents}
-						bindingForm={bindingForm}
-						setBindingForm={setBindingForm}
-						editing={!!editingBinding}
-						onSave={editingBinding ? onUpdate : onAdd}
-						onCancel={onCancelEdit}
-						saving={editingBinding ? updatePending : addPending}
-					/>
-				</DialogContent>
-			</Dialog>
+			</div>
 		</div>
 	);
 }
 
+// --- Binding Form (shared between add/edit) ---
+
 function BindingForm({
 	platform,
 	agents,
@@ -1116,6 +979,7 @@ function BindingForm({
 		workspace_id: string;
 		chat_id: string;
 		channel_ids: string[];
+		require_mention: boolean;
 		dm_allowed_users: string[];
 	};
 	setBindingForm: (form: any) => void;
@@ -1127,21 +991,15 @@ function BindingForm({
 	return (
 		<div className="flex flex-col gap-3">
 			<div>
-				<label className="mb-1 block text-sm font-medium text-ink-dull">
-					Agent
-				</label>
+				<label className="mb-1 block text-sm font-medium text-ink-dull">Agent</label>
 				<Select
 					value={bindingForm.agent_id}
 					onValueChange={(v) => setBindingForm({...bindingForm, agent_id: v})}
 				>
-					<SelectTrigger>
-						<SelectValue />
-					</SelectTrigger>
+					<SelectTrigger><SelectValue /></SelectTrigger>
 					<SelectContent>
 						{agents.map((a) => (
-							<SelectItem key={a.id} value={a.id}>
-								{a.id}
-							</SelectItem>
+							<SelectItem key={a.id} value={a.id}>{a.id}</SelectItem>
 						)) ?? <SelectItem value="main">main</SelectItem>}
 					</SelectContent>
 				</Select>
@@ -1149,62 +1007,46 @@ function BindingForm({
 
 			{platform === "discord" && (
 				<div>
-					<label className="mb-1 block text-sm font-medium text-ink-dull">
-						Guild ID
-					</label>
+					<label className="mb-1 block text-sm font-medium text-ink-dull">Guild ID</label>
 					<Input
 						size="lg"
 						value={bindingForm.guild_id}
-						onChange={(e) =>
-							setBindingForm({...bindingForm, guild_id: e.target.value})
-						}
-						placeholder="Optional — leave empty for all servers"
+						onChange={(e) => setBindingForm({...bindingForm, guild_id: e.target.value})}
+						placeholder="Optional -- leave empty for all servers"
 					/>
 				</div>
 			)}
 
 			{platform === "slack" && (
 				<div>
-					<label className="mb-1 block text-sm font-medium text-ink-dull">
-						Workspace ID
-					</label>
+					<label className="mb-1 block text-sm font-medium text-ink-dull">Workspace ID</label>
 					<Input
 						size="lg"
 						value={bindingForm.workspace_id}
-						onChange={(e) =>
-							setBindingForm({...bindingForm, workspace_id: e.target.value})
-						}
-						placeholder="Optional — leave empty for all workspaces"
+						onChange={(e) => setBindingForm({...bindingForm, workspace_id: e.target.value})}
+						placeholder="Optional -- leave empty for all workspaces"
 					/>
 				</div>
 			)}
 
 			{platform === "telegram" && (
 				<div>
-					<label className="mb-1 block text-sm font-medium text-ink-dull">
-						Chat ID
-					</label>
+					<label className="mb-1 block text-sm font-medium text-ink-dull">Chat ID</label>
 					<Input
 						size="lg"
 						value={bindingForm.chat_id}
-						onChange={(e) =>
-							setBindingForm({...bindingForm, chat_id: e.target.value})
-						}
-						placeholder="Optional — leave empty for all chats"
+						onChange={(e) => setBindingForm({...bindingForm, chat_id: e.target.value})}
+						placeholder="Optional -- leave empty for all chats"
 					/>
 				</div>
 			)}
 
 			{(platform === "discord" || platform === "slack") && (
 				<div>
-					<label className="mb-1 block text-sm font-medium text-ink-dull">
-						Channel IDs
-					</label>
+					<label className="mb-1 block text-sm font-medium text-ink-dull">Channel IDs</label>
 					<TagInput
 						value={bindingForm.channel_ids}
-						onChange={(ids) =>
-							setBindingForm({...bindingForm, channel_ids: ids})
-						}
+						onChange={(ids) => setBindingForm({...bindingForm, channel_ids: ids})}
 						placeholder="Add channel ID..."
 					/>
 				</div>
@@ -1215,49 +1057,35 @@ function BindingForm({
 					<input
 						type="checkbox"
 						checked={bindingForm.require_mention}
-						onChange={(e) =>
-							setBindingForm({...bindingForm, require_mention: e.target.checked})
-						}
+						onChange={(e) => setBindingForm({...bindingForm, require_mention: e.target.checked})}
 						className="h-4 w-4 rounded border-app-line bg-app-box"
 					/>
-					<label className="text-sm text-ink-dull">
-						Require @mention or reply to bot
-					</label>
+					<label className="text-sm text-ink-dull">Require @mention or reply to bot</label>
 				</div>
 			)}
 
 			{platform === "twitch" && (
 				<div>
-					<label className="mb-1 block text-sm font-medium text-ink-dull">
-						Channels
-					</label>
+					<label className="mb-1 block text-sm font-medium text-ink-dull">Channels</label>
 					<TagInput
 						value={bindingForm.channel_ids}
-						onChange={(ids) =>
-							setBindingForm({...bindingForm, channel_ids: ids})
-						}
+						onChange={(ids) => setBindingForm({...bindingForm, channel_ids: ids})}
 						placeholder="Add channel name..."
 					/>
 				</div>
 			)}
 
 			<div>
-				<label className="mb-1 block text-sm font-medium text-ink-dull">
-					DM Allowed Users
-				</label>
+				<label className="mb-1 block text-sm font-medium text-ink-dull">DM Allowed Users</label>
 				<TagInput
 					value={bindingForm.dm_allowed_users}
-					onChange={(users) =>
-						setBindingForm({...bindingForm, dm_allowed_users: users})
-					}
+					onChange={(users) => setBindingForm({...bindingForm, dm_allowed_users: users})}
 					placeholder="Add user ID..."
 				/>
 			</div>
 
 			<DialogFooter>
-				<Button size="sm" variant="ghost" onClick={onCancel}>
-					Cancel
-				</Button>
+				<Button size="sm" variant="ghost" onClick={onCancel}>Cancel</Button>
 				<Button size="sm" onClick={onSave} loading={saving}>
 					{editing ? "Update" : "Add Binding"}
 				</Button>
@@ -1266,54 +1094,29 @@ function BindingForm({
 	);
 }
 
-function DisconnectSection({
+// --- Backward compat: keep DisabledChannelCard export for any other consumers ---
+
+export function DisabledChannelCard({
+	platform,
 	name,
-	confirmDisconnect,
-	setConfirmDisconnect,
-	onDisconnect,
-	disconnecting,
+	description,
 }: {
+	platform: string;
 	name: string;
-	confirmDisconnect: boolean;
-	setConfirmDisconnect: (v: boolean) => void;
-	onDisconnect: () => void;
-	disconnecting: boolean;
+	description: string;
 }) {
 	return (
-		<div className="border-t border-app-line/50 pt-4">
-			{!confirmDisconnect ? (
-				<Button
-					variant="outline"
-					size="sm"
-					onClick={() => setConfirmDisconnect(true)}
-				>
-					Disconnect {name}
-				</Button>
-			) : (
-				<div className="flex flex-col gap-2">
-					<p className="text-sm text-red-400">
-						This will remove all credentials and bindings for {name}. The bot
-						will stop responding immediately.
-					</p>
-					<div className="flex gap-2">
-						<Button
-							variant="ghost"
-							size="sm"
-							onClick={() => setConfirmDisconnect(false)}
-						>
-							Cancel
-						</Button>
-						<Button
-							size="sm"
-							onClick={onDisconnect}
-							loading={disconnecting}
-							className="bg-red-500/20 text-red-400 hover:bg-red-500/30"
-						>
-							Confirm Disconnect
-						</Button>
-					</div>
+		<div className="rounded-lg border border-app-line bg-app-box p-4 opacity-40">
+			<div className="flex items-center gap-3">
+				<PlatformIcon platform={platform} size="lg" className="text-ink-faint/50" />
+				<div className="flex-1">
+					<span className="text-sm font-medium text-ink">{name}</span>
+					<p className="mt-0.5 text-sm text-ink-dull">{description}</p>
 				</div>
-			)}
+				<Button variant="outline" size="sm" disabled>
+					Coming Soon
+				</Button>
+			</div>
 		</div>
 	);
 }
diff --git a/interface/src/components/Sidebar.tsx b/interface/src/components/Sidebar.tsx
index ef51575b8..863b9bc48 100644
--- a/interface/src/components/Sidebar.tsx
+++ b/interface/src/components/Sidebar.tsx
@@ -35,12 +35,13 @@ interface SidebarProps {
 
 interface SortableAgentItemProps {
 	agentId: string;
+	displayName?: string;
 	activity?: { workers: number; branches: number };
 	isActive: boolean;
 	collapsed: boolean;
 }
 
-function SortableAgentItem({ agentId, activity, isActive, collapsed }: SortableAgentItemProps) {
+function SortableAgentItem({ agentId, displayName, activity, isActive, collapsed }: SortableAgentItemProps) {
 	const {
 		attributes,
 		listeners,
@@ -67,9 +68,9 @@ function SortableAgentItem({ agentId, activity, isActive, collapsed }: SortableA
 						isActive ? "bg-sidebar-selected text-sidebar-ink" : "text-sidebar-inkDull hover:bg-sidebar-selected/50"
 					}`}
 					style={{ pointerEvents: isDragging ? 'none' : 'auto' }}
-					title={agentId}
+					title={displayName ?? agentId}
 				>
-					{agentId.charAt(0).toUpperCase()}
+					{(displayName ?? agentId).charAt(0).toUpperCase()}
 				</Link>
 			</div>
 		);
@@ -87,7 +88,7 @@ function SortableAgentItem({ agentId, activity, isActive, collapsed }: SortableA
 				}`}
 				style={{ pointerEvents: isDragging ? 'none' : 'auto' }}
 			>
-				<span className="flex-1 truncate">{agentId}</span>
+				<span className="flex-1 truncate">{displayName ?? agentId}</span>
 				{activity && (activity.workers > 0 || activity.branches > 0) && (
 					<div className="flex items-center gap-1">
 						{activity.workers > 0 && (
@@ -126,6 +127,11 @@ export function Sidebar({ liveStates, collapsed, onToggle }: SidebarProps) {
 	const channels = channelsData?.channels ?? [];
 	
 	const agentIds = useMemo(() => agents.map((a) => a.id), [agents]);
+	const agentDisplayNames = useMemo(() => {
+		const map: Record<string, string | undefined> = {};
+		for (const a of agents) map[a.id] = a.display_name;
+		return map;
+	}, [agents]);
 	const [agentOrder, setAgentOrder] = useAgentOrder(agentIds);
 
 	const matchRoute = useMatchRoute();
@@ -225,17 +231,18 @@ export function Sidebar({ liveStates, collapsed, onToggle }: SidebarProps) {
 					onDragEnd={handleDragEnd}
 				>
 					<SortableContext items={agentOrder} strategy={verticalListSortingStrategy}>
-						{agentOrder.map((agentId) => {
-							const isActive = !!matchRoute({ to: "/agents/$agentId", params: { agentId }, fuzzy: true });
-							return (
-								<SortableAgentItem
-									key={agentId}
-									agentId={agentId}
-									isActive={isActive}
-									collapsed={true}
-								/>
-							);
-						})}
+					{agentOrder.map((agentId) => {
+						const isActive = !!matchRoute({ to: "/agents/$agentId", params: { agentId }, fuzzy: true });
+						return (
+							<SortableAgentItem
+								key={agentId}
+								agentId={agentId}
+								displayName={agentDisplayNames[agentId]}
+								isActive={isActive}
+								collapsed={true}
+							/>
+						);
+					})}
 					</SortableContext>
 				</DndContext>
 				<button
@@ -289,20 +296,21 @@ export function Sidebar({ liveStates, collapsed, onToggle }: SidebarProps) {
 							>
 								<SortableContext items={agentOrder} strategy={verticalListSortingStrategy}>
 									<div className="flex flex-col gap-0.5">
-										{agentOrder.map((agentId) => {
-											const activity = agentActivity[agentId];
-											const isActive = !!matchRoute({ to: "/agents/$agentId", params: { agentId }, fuzzy: true });
+									{agentOrder.map((agentId) => {
+										const activity = agentActivity[agentId];
+										const isActive = !!matchRoute({ to: "/agents/$agentId", params: { agentId }, fuzzy: true });
 
-											return (
-												<SortableAgentItem
-													key={agentId}
-													agentId={agentId}
-													activity={activity}
-													isActive={isActive}
-													collapsed={false}
-												/>
-											);
-										})}
+										return (
+											<SortableAgentItem
+												key={agentId}
+												agentId={agentId}
+												displayName={agentDisplayNames[agentId]}
+												activity={activity}
+												isActive={isActive}
+												collapsed={false}
+											/>
+										);
+									})}
 									</div>
 								</SortableContext>
 							</DndContext>
diff --git a/interface/src/routes/AgentDetail.tsx b/interface/src/routes/AgentDetail.tsx
index 97528a299..bb614da78 100644
--- a/interface/src/routes/AgentDetail.tsx
+++ b/interface/src/routes/AgentDetail.tsx
@@ -90,14 +90,15 @@ export function AgentDetail({ agentId, liveStates }: AgentDetailProps) {
 	return (
 		<div className="h-full overflow-y-auto">
 			<div className="mx-auto max-w-6xl p-6 pb-24">
-				{/* Hero Section */}
-				<HeroSection
-					agentId={agentId}
-					channelCount={agentChannels.length}
-					workers={activity.workers}
-					branches={activity.branches}
-					hasLiveActivity={hasLiveActivity}
-					onDelete={() => setDeleteOpen(true)}
+			{/* Hero Section */}
+			<HeroSection
+				agentId={agentId}
+				displayName={agent.display_name}
+				channelCount={agentChannels.length}
+				workers={activity.workers}
+				branches={activity.branches}
+				hasLiveActivity={hasLiveActivity}
+				onDelete={() => setDeleteOpen(true)}
 				/>
 				<DeleteAgentDialog open={deleteOpen} onOpenChange={setDeleteOpen} agentId={agentId} />
 
@@ -224,6 +225,7 @@ export function AgentDetail({ agentId, liveStates }: AgentDetailProps) {
 
 function HeroSection({
 	agentId,
+	displayName,
 	channelCount,
 	workers,
 	branches,
@@ -231,6 +233,7 @@ function HeroSection({
 	onDelete,
 }: {
 	agentId: string;
+	displayName?: string;
 	channelCount: number;
 	workers: number;
 	branches: number;
@@ -241,7 +244,12 @@ function HeroSection({
 		<div className="flex flex-col gap-4 border-b border-app-line pb-6">
 			<div className="flex items-start justify-between">
 				<div>
-					<h1 className="font-plex text-3xl font-semibold text-ink">{agentId}</h1>
+					<h1 className="font-plex text-3xl font-semibold text-ink">
+						{displayName?.trim() ? displayName : agentId}
+					</h1>
+					{displayName?.trim() && (
+						<span className="mt-0.5 text-sm text-ink-faint">{agentId}</span>
+					)}
 					<div className="mt-2 flex items-center gap-4 text-sm">
 						<div className="flex items-center gap-2">
 							<div className={`h-2 w-2 rounded-full ${hasLiveActivity ? "animate-pulse bg-amber-400" : "bg-green-500"}`} />
diff --git a/interface/src/routes/Settings.tsx b/interface/src/routes/Settings.tsx
index b0156e7f3..a867da2a4 100644
--- a/interface/src/routes/Settings.tsx
+++ b/interface/src/routes/Settings.tsx
@@ -3,7 +3,7 @@ import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
 import { api, type GlobalSettingsResponse, type UpdateStatus } from "@/api/client";
 import { Button, Input, SettingSidebarButton, Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, DialogFooter, Select, SelectTrigger, SelectValue, SelectContent, SelectItem, Toggle } from "@/ui";
 import { useSearch, useNavigate } from "@tanstack/react-router";
-import { ChannelSettingCard, DisabledChannelCard } from "@/components/ChannelSettingCard";
+import { PlatformCatalog, InstanceCard, AddInstanceCard } from "@/components/ChannelSettingCard";
 import { ModelSelect } from "@/components/ModelSelect";
 import { ProviderIcon } from "@/lib/providerIcons";
 import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
@@ -782,8 +782,11 @@ export function Settings() {
 	);
 }
 
+type Platform = "discord" | "slack" | "telegram" | "twitch" | "email" | "webhook";
+
 function ChannelsSection() {
-	const [expandedPlatform, setExpandedPlatform] = useState<string | null>(null);
+	const [expandedKey, setExpandedKey] = useState<string | null>(null);
+	const [addingPlatform, setAddingPlatform] = useState<Platform | null>(null);
 
 	const { data: messagingStatus, isLoading } = useQuery({
 		queryKey: ["messaging-status"],
@@ -791,26 +794,22 @@ function ChannelsSection() {
 		staleTime: 5_000,
 	});
 
-	const PLATFORMS = [
-		{ platform: "discord" as const, name: "Discord", description: "Discord bot integration" },
-		{ platform: "slack" as const, name: "Slack", description: "Slack bot integration" },
-		{ platform: "telegram" as const, name: "Telegram", description: "Telegram bot integration" },
-		{ platform: "twitch" as const, name: "Twitch", description: "Twitch chat integration" },
-		{ platform: "email" as const, name: "Email", description: "IMAP polling for inbound, SMTP for outbound" },
-		{ platform: "webhook" as const, name: "Webhook", description: "HTTP webhook receiver" },
-	] as const;
-
-	const COMING_SOON = [
-		{ platform: "whatsapp", name: "WhatsApp", description: "Meta Cloud API integration" },
-		{ platform: "matrix", name: "Matrix", description: "Decentralized chat protocol" },
-		{ platform: "imessage", name: "iMessage", description: "macOS-only AppleScript bridge" },
-		{ platform: "irc", name: "IRC", description: "TLS socket connection" },
-		{ platform: "lark", name: "Lark", description: "Feishu/Lark webhook integration" },
-		{ platform: "dingtalk", name: "DingTalk", description: "Chinese enterprise webhook integration" },
-	];
+	const instances = messagingStatus?.instances ?? [];
+
+	// Determine whether to show default or named add form
+	function handleAddInstance(platform: Platform) {
+		setAddingPlatform(platform);
+	}
+
+	function isDefaultAdd(): boolean {
+		if (!addingPlatform) return true;
+		return !instances.some(
+			(inst) => inst.platform === addingPlatform && inst.name === null,
+		);
+	}
 
 	return (
-		<div className="mx-auto max-w-2xl px-6 py-6">
+		<div className="mx-auto max-w-3xl px-6 py-6">
 			<div className="mb-6">
 				<h2 className="font-plex text-sm font-semibold text-ink">Messaging Platforms</h2>
 				<p className="mt-1 text-sm text-ink-dull">
@@ -824,21 +823,49 @@ function ChannelsSection() {
 					Loading channels...
 				</div>
 			) : (
-				<div className="flex flex-col gap-3">
-					{PLATFORMS.map(({ platform: p, name: n, description: d }) => (
-						<ChannelSettingCard
-							key={p}
-							platform={p}
-							name={n}
-							description={d}
-							status={messagingStatus?.[p]}
-							expanded={expandedPlatform === p}
-							onToggle={() => setExpandedPlatform(expandedPlatform === p ? null : p)}
-						/>
-					))}
-					{COMING_SOON.map(({ platform: p, name: n, description: d }) => (
-						<DisabledChannelCard key={p} platform={p} name={n} description={d} />
-					))}
+				<div className="grid grid-cols-[200px_1fr] gap-6">
+					{/* Left column: Platform catalog */}
+					<div className="flex-shrink-0">
+						<PlatformCatalog onAddInstance={handleAddInstance} />
+					</div>
+
+					{/* Right column: Configured instances */}
+					<div className="flex flex-col gap-3 min-w-0">
+						{/* Active add-instance card */}
+						{addingPlatform && (
+							<AddInstanceCard
+								platform={addingPlatform}
+								isDefault={isDefaultAdd()}
+								onCancel={() => setAddingPlatform(null)}
+								onCreated={() => setAddingPlatform(null)}
+							/>
+						)}
+
+						{/* Configured instance cards */}
+						{instances.length > 0 ? (
+							instances.map((instance) => (
+								<InstanceCard
+									key={instance.runtime_key}
+									instance={instance}
+									expanded={expandedKey === instance.runtime_key}
+									onToggleExpand={() =>
+										setExpandedKey(
+											expandedKey === instance.runtime_key ? null : instance.runtime_key,
+										)
+									}
+								/>
+							))
+						) : !addingPlatform ? (
+							<div className="rounded-lg border border-app-line border-dashed bg-app-box/50 p-8 text-center">
+								<p className="text-sm text-ink-dull">
+									No messaging platforms configured yet.
+								</p>
+								<p className="mt-1 text-sm text-ink-faint">
+									Click a platform on the left to get started.
+								</p>
+							</div>
+						) : null}
+					</div>
 				</div>
 			)}
 		</div>
diff --git a/src/agent/channel.rs b/src/agent/channel.rs
index d572e47f1..d965aaa14 100644
--- a/src/agent/channel.rs
+++ b/src/agent/channel.rs
@@ -1771,6 +1771,7 @@ impl Channel {
         let synthetic = InboundMessage {
             id: uuid::Uuid::new_v4().to_string(),
             source: "system".into(),
+            adapter: None,
             conversation_id: conversation_id.clone(),
             sender_id: "system".into(),
             agent_id: None,
@@ -3343,6 +3344,7 @@ mod tests {
             conversation_id: "conv".to_string(),
             content: crate::MessageContent::Text("".to_string()),
             source: "discord".to_string(),
+            adapter: Some("discord".to_string()),
             metadata: HashMap::new(),
             formatted_author: Some("TestUser".to_string()),
             timestamp: Utc::now(),
@@ -3373,6 +3375,7 @@ mod tests {
             conversation_id: "conv".to_string(),
             content: crate::MessageContent::Text("".to_string()),
             source: "system".to_string(),
+            adapter: None,
             metadata: HashMap::new(),
             formatted_author: None,
             timestamp: Utc::now(),
@@ -3419,6 +3422,7 @@ mod tests {
             conversation_id: "conv".to_string(),
             content: crate::MessageContent::Text("hello".to_string()),
             source: "discord".to_string(),
+            adapter: Some("discord".to_string()),
             metadata: metadata_only,
             formatted_author: None,
             timestamp: Utc::now(),
@@ -3437,6 +3441,7 @@ mod tests {
             conversation_id: "conv".to_string(),
             content: crate::MessageContent::Text("hello".to_string()),
             source: "discord".to_string(),
+            adapter: Some("discord".to_string()),
             metadata: both_metadata,
             formatted_author: Some("Formatted Author".to_string()),
             timestamp: Utc::now(),
@@ -3453,6 +3458,7 @@ mod tests {
             conversation_id: "conv".to_string(),
             content: crate::MessageContent::Text("hello".to_string()),
             source: "discord".to_string(),
+            adapter: Some("discord".to_string()),
             metadata: HashMap::new(),
             formatted_author: None,
             timestamp: Utc::now(),
diff --git a/src/api/bindings.rs b/src/api/bindings.rs
index 55ec0d735..42446bdaf 100644
--- a/src/api/bindings.rs
+++ b/src/api/bindings.rs
@@ -10,6 +10,7 @@ use std::sync::Arc;
 pub(super) struct BindingResponse {
     agent_id: String,
     channel: String,
+    adapter: Option<String>,
     guild_id: Option<String>,
     workspace_id: Option<String>,
     chat_id: Option<String>,
@@ -34,6 +35,8 @@ pub(super) struct CreateBindingRequest {
     agent_id: String,
     channel: String,
     #[serde(default)]
+    adapter: Option<String>,
+    #[serde(default)]
     guild_id: Option<String>,
     #[serde(default)]
     workspace_id: Option<String>,
@@ -105,6 +108,8 @@ pub(super) struct DeleteBindingRequest {
     agent_id: String,
     channel: String,
     #[serde(default)]
+    adapter: Option<String>,
+    #[serde(default)]
     guild_id: Option<String>,
     #[serde(default)]
     workspace_id: Option<String>,
@@ -123,6 +128,8 @@ pub(super) struct UpdateBindingRequest {
     original_agent_id: String,
     original_channel: String,
     #[serde(default)]
+    original_adapter: Option<String>,
+    #[serde(default)]
     original_guild_id: Option<String>,
     #[serde(default)]
     original_workspace_id: Option<String>,
@@ -132,6 +139,8 @@ pub(super) struct UpdateBindingRequest {
     agent_id: String,
     channel: String,
     #[serde(default)]
+    adapter: Option<String>,
+    #[serde(default)]
     guild_id: Option<String>,
     #[serde(default)]
     workspace_id: Option<String>,
@@ -172,6 +181,7 @@ pub(super) async fn list_bindings(
         .map(|b| BindingResponse {
             agent_id: b.agent_id,
             channel: b.channel,
+            adapter: b.adapter,
             guild_id: b.guild_id,
             workspace_id: b.workspace_id,
             chat_id: b.chat_id,
@@ -406,6 +416,14 @@ pub(super) async fn create_binding(
     let mut binding_table = toml_edit::Table::new();
     binding_table["agent_id"] = toml_edit::value(&request.agent_id);
     binding_table["channel"] = toml_edit::value(&request.channel);
+    if let Some(adapter) = request
+        .adapter
+        .as_deref()
+        .map(str::trim)
+        .filter(|s| !s.is_empty())
+    {
+        binding_table["adapter"] = toml_edit::value(adapter);
+    }
     if let Some(guild_id) = &request.guild_id {
         binding_table["guild_id"] = toml_edit::value(guild_id.as_str());
     }
@@ -500,7 +518,11 @@ pub(super) async fn create_binding(
                         }
                     }
                 };
-                let adapter = crate::messaging::discord::DiscordAdapter::new(&token, discord_perms);
+                let adapter = crate::messaging::discord::DiscordAdapter::new(
+                    "discord",
+                    &token,
+                    discord_perms,
+                );
                 if let Err(error) = manager.register_and_start(adapter).await {
                     tracing::error!(%error, "failed to hot-start discord adapter");
                 }
@@ -537,6 +559,7 @@ pub(super) async fn create_binding(
                     .map(|s| s.commands.clone())
                     .unwrap_or_default();
                 match crate::messaging::slack::SlackAdapter::new(
+                    "slack",
                     &bot_token,
                     &app_token,
                     slack_perms,
@@ -565,8 +588,11 @@ pub(super) async fn create_binding(
                     );
                     std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(perms))
                 };
-                let adapter =
-                    crate::messaging::telegram::TelegramAdapter::new(&token, telegram_perms);
+                let adapter = crate::messaging::telegram::TelegramAdapter::new(
+                    "telegram",
+                    &token,
+                    telegram_perms,
+                );
                 if let Err(error) = manager.register_and_start(adapter).await {
                     tracing::error!(%error, "failed to hot-start telegram adapter");
                 }
@@ -605,6 +631,7 @@ pub(super) async fn create_binding(
                 let instance_dir = state.instance_dir.load();
                 let token_path = instance_dir.join("twitch_token.json");
                 let adapter = crate::messaging::twitch::TwitchAdapter::new(
+                    "twitch",
                     &username,
                     &oauth_token,
                     twitch_config.client_id.clone(),
@@ -665,6 +692,13 @@ pub(super) async fn update_binding(
             .get("channel")
             .and_then(|v| v.as_str())
             .is_some_and(|v| v == request.original_channel);
+        let matches_adapter = match &request.original_adapter {
+            Some(adapter) => table
+                .get("adapter")
+                .and_then(|v| v.as_str())
+                .is_some_and(|v| v == adapter),
+            None => table.get("adapter").is_none(),
+        };
         let matches_guild = match &request.original_guild_id {
             Some(gid) => table
                 .get("guild_id")
@@ -686,7 +720,13 @@ pub(super) async fn update_binding(
                 .is_some_and(|v| v == cid),
             None => table.get("chat_id").is_none(),
         };
-        if matches_agent && matches_channel && matches_guild && matches_workspace && matches_chat {
+        if matches_agent
+            && matches_channel
+            && matches_adapter
+            && matches_guild
+            && matches_workspace
+            && matches_chat
+        {
             match_idx = Some(i);
             break;
         }
@@ -706,10 +746,20 @@ pub(super) async fn update_binding(
     binding["agent_id"] = toml_edit::value(&request.agent_id);
     binding["channel"] = toml_edit::value(&request.channel);
 
+    binding.remove("adapter");
     binding.remove("guild_id");
     binding.remove("workspace_id");
     binding.remove("chat_id");
 
+    if let Some(adapter) = request
+        .adapter
+        .as_deref()
+        .map(str::trim)
+        .filter(|s| !s.is_empty())
+    {
+        binding["adapter"] = toml_edit::value(adapter);
+    }
+
     if let Some(ref guild_id) = request.guild_id
         && !guild_id.is_empty()
     {
@@ -836,6 +886,13 @@ pub(super) async fn delete_binding(
             .get("channel")
             .and_then(|v: &toml_edit::Item| v.as_str())
             .is_some_and(|v| v == request.channel);
+        let matches_adapter = match &request.adapter {
+            Some(adapter) => table
+                .get("adapter")
+                .and_then(|v: &toml_edit::Item| v.as_str())
+                .is_some_and(|v| v == adapter),
+            None => table.get("adapter").is_none(),
+        };
         let matches_guild = match &request.guild_id {
             Some(gid) => table
                 .get("guild_id")
@@ -857,7 +914,13 @@ pub(super) async fn delete_binding(
                 .is_some_and(|v| v == cid),
             None => table.get("chat_id").is_none(),
         };
-        if matches_agent && matches_channel && matches_guild && matches_workspace && matches_chat {
+        if matches_agent
+            && matches_channel
+            && matches_adapter
+            && matches_guild
+            && matches_workspace
+            && matches_chat
+        {
             match_idx = Some(i);
             break;
         }
diff --git a/src/api/messaging.rs b/src/api/messaging.rs
index f9e0b4903..692dea009 100644
--- a/src/api/messaging.rs
+++ b/src/api/messaging.rs
@@ -12,6 +12,17 @@ pub(super) struct PlatformStatus {
     enabled: bool,
 }
 
+#[derive(Serialize, Clone)]
+pub(super) struct AdapterInstanceStatus {
+    platform: String,
+    /// `None` means the default instance for the platform.
+    name: Option<String>,
+    runtime_key: String,
+    configured: bool,
+    enabled: bool,
+    binding_count: usize,
+}
+
 #[derive(Serialize)]
 pub(super) struct MessagingStatusResponse {
     discord: PlatformStatus,
@@ -20,17 +31,153 @@ pub(super) struct MessagingStatusResponse {
     email: PlatformStatus,
     webhook: PlatformStatus,
     twitch: PlatformStatus,
+    instances: Vec<AdapterInstanceStatus>,
 }
 
 #[derive(Deserialize)]
 pub(super) struct DisconnectPlatformRequest {
     platform: String,
+    #[serde(default)]
+    adapter: Option<String>,
 }
 
 #[derive(Deserialize)]
 pub(super) struct TogglePlatformRequest {
     platform: String,
+    #[serde(default)]
+    adapter: Option<String>,
+    enabled: bool,
+}
+
+#[derive(Deserialize, Default)]
+pub(super) struct InstanceCredentials {
+    #[serde(default)]
+    discord_token: Option<String>,
+    #[serde(default)]
+    slack_bot_token: Option<String>,
+    #[serde(default)]
+    slack_app_token: Option<String>,
+    #[serde(default)]
+    telegram_token: Option<String>,
+    #[serde(default)]
+    twitch_username: Option<String>,
+    #[serde(default)]
+    twitch_oauth_token: Option<String>,
+    #[serde(default)]
+    twitch_client_id: Option<String>,
+    #[serde(default)]
+    twitch_client_secret: Option<String>,
+    #[serde(default)]
+    twitch_refresh_token: Option<String>,
+    // Email credentials
+    #[serde(default)]
+    email_imap_host: Option<String>,
+    #[serde(default)]
+    email_imap_port: Option<u16>,
+    #[serde(default)]
+    email_imap_username: Option<String>,
+    #[serde(default)]
+    email_imap_password: Option<String>,
+    #[serde(default)]
+    email_smtp_host: Option<String>,
+    #[serde(default)]
+    email_smtp_port: Option<u16>,
+    #[serde(default)]
+    email_smtp_username: Option<String>,
+    #[serde(default)]
+    email_smtp_password: Option<String>,
+    #[serde(default)]
+    email_from_address: Option<String>,
+    // Webhook credentials
+    #[serde(default)]
+    webhook_port: Option<u16>,
+    #[serde(default)]
+    webhook_bind: Option<String>,
+    #[serde(default)]
+    webhook_auth_token: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct CreateMessagingInstanceRequest {
+    platform: String,
+    #[serde(default)]
+    name: Option<String>,
+    #[serde(default)]
+    enabled: Option<bool>,
+    #[serde(default)]
+    credentials: InstanceCredentials,
+}
+
+#[derive(Deserialize)]
+pub(super) struct DeleteMessagingInstanceRequest {
+    platform: String,
+    #[serde(default)]
+    name: Option<String>,
+}
+
+#[derive(Serialize)]
+pub(super) struct MessagingInstanceActionResponse {
+    success: bool,
+    message: String,
+}
+
+fn normalize_adapter_selector(value: Option<&str>) -> Option<String> {
+    value
+        .map(str::trim)
+        .filter(|candidate| !candidate.is_empty())
+        .map(str::to_string)
+}
+
+fn binding_count_for(
+    bindings: Option<&toml_edit::ArrayOfTables>,
+    platform: &str,
+    adapter: Option<&str>,
+) -> usize {
+    let Some(bindings) = bindings else {
+        return 0;
+    };
+
+    bindings
+        .iter()
+        .filter(|table| {
+            let Some(channel) = table.get("channel").and_then(|value| value.as_str()) else {
+                return false;
+            };
+            if channel != platform {
+                return false;
+            }
+
+            let binding_adapter =
+                normalize_adapter_selector(table.get("adapter").and_then(|value| value.as_str()));
+
+            match (binding_adapter.as_deref(), adapter) {
+                (None, None) => true,
+                (Some(binding_adapter), Some(adapter)) => binding_adapter == adapter,
+                _ => false,
+            }
+        })
+        .count()
+}
+
+fn push_instance_status(
+    instances: &mut Vec<AdapterInstanceStatus>,
+    bindings: Option<&toml_edit::ArrayOfTables>,
+    platform: &str,
+    name: Option<String>,
+    configured: bool,
     enabled: bool,
+) {
+    let runtime_key = crate::config::binding_runtime_adapter_key(platform, name.as_deref());
+    let binding_count = binding_count_for(bindings, platform, name.as_deref());
+
+    instances.push(AdapterInstanceStatus {
+        platform: platform.to_string(),
+        name,
+        runtime_key,
+        configured,
+        enabled,
+        binding_count,
+    });
 }
 
 /// Get which messaging platforms are configured and enabled.
@@ -39,7 +186,7 @@ pub(super) async fn messaging_status(
 ) -> Result<Json<MessagingStatusResponse>, StatusCode> {
     let config_path = state.config_path.read().await.clone();
 
-    let (discord, slack, telegram, email, webhook, twitch) = if config_path.exists() {
+    let (discord, slack, telegram, email, webhook, twitch, instances) = if config_path.exists() {
         let content = tokio::fs::read_to_string(&config_path)
             .await
             .map_err(|error| {
@@ -51,6 +198,11 @@ pub(super) async fn messaging_status(
             StatusCode::INTERNAL_SERVER_ERROR
         })?;
 
+        let mut instances: Vec<AdapterInstanceStatus> = Vec::new();
+        let bindings = doc
+            .get("bindings")
+            .and_then(|value| value.as_array_of_tables());
+
         let discord_status = doc
             .get("messaging")
             .and_then(|m| m.get("discord"))
@@ -60,6 +212,44 @@ pub(super) async fn messaging_status(
                     .and_then(|v| v.as_str())
                     .is_some_and(|s| !s.is_empty());
                 let enabled = d.get("enabled").and_then(|v| v.as_bool()).unwrap_or(false);
+
+                if has_token {
+                    push_instance_status(&mut instances, bindings, "discord", None, true, enabled);
+                }
+
+                if let Some(named_instances) = d
+                    .get("instances")
+                    .and_then(|value| value.as_array_of_tables())
+                {
+                    for instance in named_instances {
+                        let instance_name = normalize_adapter_selector(
+                            instance.get("name").and_then(|value| value.as_str()),
+                        );
+                        let instance_enabled = instance
+                            .get("enabled")
+                            .and_then(|value| value.as_bool())
+                            .unwrap_or(true)
+                            && enabled;
+                        let instance_configured = instance
+                            .get("token")
+                            .and_then(|value| value.as_str())
+                            .is_some_and(|token| !token.is_empty());
+
+                        if let Some(instance_name) = instance_name
+                            && instance_configured
+                        {
+                            push_instance_status(
+                                &mut instances,
+                                bindings,
+                                "discord",
+                                Some(instance_name),
+                                true,
+                                instance_enabled,
+                            );
+                        }
+                    }
+                }
+
                 PlatformStatus {
                     configured: has_token,
                     enabled: has_token && enabled,
@@ -83,6 +273,49 @@ pub(super) async fn messaging_status(
                     .and_then(|v| v.as_str())
                     .is_some_and(|t| !t.is_empty());
                 let enabled = s.get("enabled").and_then(|v| v.as_bool()).unwrap_or(false);
+
+                if has_bot_token && has_app_token {
+                    push_instance_status(&mut instances, bindings, "slack", None, true, enabled);
+                }
+
+                if let Some(named_instances) = s
+                    .get("instances")
+                    .and_then(|value| value.as_array_of_tables())
+                {
+                    for instance in named_instances {
+                        let instance_name = normalize_adapter_selector(
+                            instance.get("name").and_then(|value| value.as_str()),
+                        );
+                        let has_instance_bot = instance
+                            .get("bot_token")
+                            .and_then(|value| value.as_str())
+                            .is_some_and(|value| !value.is_empty());
+                        let has_instance_app = instance
+                            .get("app_token")
+                            .and_then(|value| value.as_str())
+                            .is_some_and(|value| !value.is_empty());
+                        let instance_enabled = instance
+                            .get("enabled")
+                            .and_then(|value| value.as_bool())
+                            .unwrap_or(true)
+                            && enabled;
+
+                        if let Some(instance_name) = instance_name
+                            && has_instance_bot
+                            && has_instance_app
+                        {
+                            push_instance_status(
+                                &mut instances,
+                                bindings,
+                                "slack",
+                                Some(instance_name),
+                                true,
+                                instance_enabled,
+                            );
+                        }
+                    }
+                }
+
                 PlatformStatus {
                     configured: has_bot_token && has_app_token,
                     enabled: has_bot_token && has_app_token && enabled,
@@ -98,6 +331,9 @@ pub(super) async fn messaging_status(
             .and_then(|m| m.get("webhook"))
             .map(|w| {
                 let enabled = w.get("enabled").and_then(|v| v.as_bool()).unwrap_or(false);
+
+                push_instance_status(&mut instances, bindings, "webhook", None, true, enabled);
+
                 PlatformStatus {
                     configured: true,
                     enabled,
@@ -137,6 +373,10 @@ pub(super) async fn messaging_status(
                     .and_then(|v| v.as_bool())
                     .unwrap_or(false);
 
+                if configured {
+                    push_instance_status(&mut instances, bindings, "email", None, true, enabled);
+                }
+
                 PlatformStatus {
                     configured,
                     enabled: configured && enabled,
@@ -156,6 +396,44 @@ pub(super) async fn messaging_status(
                     .and_then(|v| v.as_str())
                     .is_some_and(|s| !s.is_empty());
                 let enabled = t.get("enabled").and_then(|v| v.as_bool()).unwrap_or(false);
+
+                if has_token {
+                    push_instance_status(&mut instances, bindings, "telegram", None, true, enabled);
+                }
+
+                if let Some(named_instances) = t
+                    .get("instances")
+                    .and_then(|value| value.as_array_of_tables())
+                {
+                    for instance in named_instances {
+                        let instance_name = normalize_adapter_selector(
+                            instance.get("name").and_then(|value| value.as_str()),
+                        );
+                        let instance_enabled = instance
+                            .get("enabled")
+                            .and_then(|value| value.as_bool())
+                            .unwrap_or(true)
+                            && enabled;
+                        let instance_configured = instance
+                            .get("token")
+                            .and_then(|value| value.as_str())
+                            .is_some_and(|value| !value.is_empty());
+
+                        if let Some(instance_name) = instance_name
+                            && instance_configured
+                        {
+                            push_instance_status(
+                                &mut instances,
+                                bindings,
+                                "telegram",
+                                Some(instance_name),
+                                true,
+                                instance_enabled,
+                            );
+                        }
+                    }
+                }
+
                 PlatformStatus {
                     configured: has_token,
                     enabled: has_token && enabled,
@@ -179,6 +457,49 @@ pub(super) async fn messaging_status(
                     .and_then(|v| v.as_str())
                     .is_some_and(|s| !s.is_empty());
                 let enabled = t.get("enabled").and_then(|v| v.as_bool()).unwrap_or(false);
+
+                if has_username && has_token {
+                    push_instance_status(&mut instances, bindings, "twitch", None, true, enabled);
+                }
+
+                if let Some(named_instances) = t
+                    .get("instances")
+                    .and_then(|value| value.as_array_of_tables())
+                {
+                    for instance in named_instances {
+                        let instance_name = normalize_adapter_selector(
+                            instance.get("name").and_then(|value| value.as_str()),
+                        );
+                        let instance_enabled = instance
+                            .get("enabled")
+                            .and_then(|value| value.as_bool())
+                            .unwrap_or(true)
+                            && enabled;
+                        let has_instance_username = instance
+                            .get("username")
+                            .and_then(|value| value.as_str())
+                            .is_some_and(|value| !value.is_empty());
+                        let has_instance_token = instance
+                            .get("oauth_token")
+                            .and_then(|value| value.as_str())
+                            .is_some_and(|value| !value.is_empty());
+
+                        if let Some(instance_name) = instance_name
+                            && has_instance_username
+                            && has_instance_token
+                        {
+                            push_instance_status(
+                                &mut instances,
+                                bindings,
+                                "twitch",
+                                Some(instance_name),
+                                true,
+                                instance_enabled,
+                            );
+                        }
+                    }
+                }
+
                 PlatformStatus {
                     configured: has_username && has_token,
                     enabled: has_username && has_token && enabled,
@@ -196,6 +517,7 @@ pub(super) async fn messaging_status(
             email_status,
             webhook_status,
             twitch_status,
+            instances,
         )
     } else {
         let default = PlatformStatus {
@@ -209,6 +531,7 @@ pub(super) async fn messaging_status(
             default.clone(),
             default.clone(),
             default,
+            Vec::new(),
         )
     };
 
@@ -219,16 +542,26 @@ pub(super) async fn messaging_status(
         email,
         webhook,
         twitch,
+        instances,
     }))
 }
 
 /// Disconnect a messaging platform: remove credentials from config, remove all
 /// bindings for that platform, and shut down the adapter.
+///
+/// When `adapter` is set, only the specified named instance is disconnected.
+/// When `adapter` is absent, the entire platform section (default + all named
+/// instances) is removed.
 pub(super) async fn disconnect_platform(
     State(state): State<Arc<ApiState>>,
     Json(request): Json<DisconnectPlatformRequest>,
 ) -> Result<Json<serde_json::Value>, StatusCode> {
     let platform = &request.platform;
+    let adapter_name = request
+        .adapter
+        .as_deref()
+        .map(str::trim)
+        .filter(|s| !s.is_empty());
     let config_path = state.config_path.read().await.clone();
 
     let content = tokio::fs::read_to_string(&config_path)
@@ -242,25 +575,76 @@ pub(super) async fn disconnect_platform(
         StatusCode::INTERNAL_SERVER_ERROR
     })?;
 
-    if let Some(messaging) = doc.get_mut("messaging").and_then(|m| m.as_table_mut()) {
-        messaging.remove(platform);
-    }
+    if let Some(adapter_name) = adapter_name {
+        // Disconnect a specific named instance only
+        if let Some(instances) = doc
+            .get_mut("messaging")
+            .and_then(|m| m.get_mut(platform.as_str()))
+            .and_then(|p| p.get_mut("instances"))
+            .and_then(|item| item.as_array_of_tables_mut())
+        {
+            let mut index = 0;
+            while index < instances.len() {
+                let matches = instances
+                    .get(index)
+                    .and_then(|t| t.get("name"))
+                    .and_then(|v| v.as_str())
+                    .is_some_and(|name| name == adapter_name);
+                if matches {
+                    instances.remove(index);
+                    break;
+                }
+                index += 1;
+            }
+        }
 
-    if let Some(bindings) = doc
-        .get_mut("bindings")
-        .and_then(|b| b.as_array_of_tables_mut())
-    {
-        let mut i = 0;
-        while i < bindings.len() {
-            let matches = bindings
-                .get(i)
-                .and_then(|t| t.get("channel"))
-                .and_then(|v| v.as_str())
-                .is_some_and(|ch| ch == platform);
-            if matches {
-                bindings.remove(i);
-            } else {
-                i += 1;
+        // Remove bindings targeting this specific adapter
+        if let Some(bindings) = doc
+            .get_mut("bindings")
+            .and_then(|b| b.as_array_of_tables_mut())
+        {
+            let mut index = 0;
+            while index < bindings.len() {
+                let binding_channel = bindings
+                    .get(index)
+                    .and_then(|t| t.get("channel"))
+                    .and_then(|v| v.as_str());
+                let binding_adapter = bindings
+                    .get(index)
+                    .and_then(|t| t.get("adapter"))
+                    .and_then(|v| v.as_str());
+
+                if binding_channel.is_some_and(|ch| ch == platform)
+                    && binding_adapter.is_some_and(|ba| ba == adapter_name)
+                {
+                    bindings.remove(index);
+                } else {
+                    index += 1;
+                }
+            }
+        }
+    } else {
+        // Disconnect entire platform — remove the whole section and all bindings
+        if let Some(messaging) = doc.get_mut("messaging").and_then(|m| m.as_table_mut()) {
+            messaging.remove(platform);
+        }
+
+        if let Some(bindings) = doc
+            .get_mut("bindings")
+            .and_then(|b| b.as_array_of_tables_mut())
+        {
+            let mut i = 0;
+            while i < bindings.len() {
+                let matches = bindings
+                    .get(i)
+                    .and_then(|t| t.get("channel"))
+                    .and_then(|v| v.as_str())
+                    .is_some_and(|ch| ch == platform);
+                if matches {
+                    bindings.remove(i);
+                } else {
+                    i += 1;
+                }
             }
         }
     }
@@ -280,35 +664,71 @@ pub(super) async fn disconnect_platform(
     }
 
     let manager_guard = state.messaging_manager.read().await;
-    if let Some(manager) = manager_guard.as_ref()
-        && let Err(error) = manager.remove_adapter(platform).await
-    {
-        tracing::warn!(%error, platform = %platform, "failed to shut down adapter during disconnect");
+    if let Some(manager) = manager_guard.as_ref() {
+        if let Some(adapter_name) = adapter_name {
+            // Disconnect only the specific named adapter
+            let runtime_key =
+                crate::config::binding_runtime_adapter_key(platform, Some(adapter_name));
+            if let Err(error) = manager.remove_adapter(&runtime_key).await {
+                tracing::warn!(%error, adapter = %runtime_key, "failed to shut down adapter during disconnect");
+            }
+        } else {
+            // Disconnect all adapters for this platform
+            if let Err(error) = manager.remove_platform_adapters(platform).await {
+                tracing::warn!(%error, platform = %platform, "failed to shut down adapters during disconnect");
+            }
+        }
     }
 
     if platform == "twitch" {
         let instance_dir = state.instance_dir.load();
-        let token_path = instance_dir.join("twitch_token.json");
-        match tokio::fs::remove_file(&token_path).await {
-            Ok(()) => {
-                tracing::info!(path = %token_path.display(), "twitch token file deleted");
+        if let Some(name) = adapter_name {
+            let safe_name: String = name
+                .chars()
+                .map(|ch| if ch.is_ascii_alphanumeric() { ch } else { '_' })
+                .collect();
+            let token_path = instance_dir.join(format!("twitch_token_{safe_name}.json"));
+            match tokio::fs::remove_file(&token_path).await {
+                Ok(()) => {
+                    tracing::info!(path = %token_path.display(), "twitch token file deleted");
+                }
+                Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
+                Err(error) => {
+                    tracing::warn!(
+                        %error,
+                        path = %token_path.display(),
+                        "failed to delete twitch token file"
+                    );
+                }
             }
-            Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
-            Err(error) => {
-                tracing::warn!(
-                    %error,
-                    path = %token_path.display(),
-                    "failed to delete twitch token file"
-                );
+        } else {
+            let token_path = instance_dir.join("twitch_token.json");
+            match tokio::fs::remove_file(&token_path).await {
+                Ok(()) => {
+                    tracing::info!(path = %token_path.display(), "twitch token file deleted");
+                }
+                Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
+                Err(error) => {
+                    tracing::warn!(
+                        %error,
+                        path = %token_path.display(),
+                        "failed to delete twitch token file"
+                    );
+                }
             }
         }
     }
 
-    tracing::info!(platform = %platform, "platform disconnected via API");
+    let label = if let Some(name) = adapter_name {
+        format!("{platform}:{name}")
+    } else {
+        platform.to_string()
+    };
+    tracing::info!(platform = %platform, adapter = %label, "platform disconnected via API");
 
     Ok(Json(serde_json::json!({
         "success": true,
-        "message": format!("{platform} disconnected")
+        "message": format!("{label} disconnected")
     })))
 }
 
@@ -345,7 +765,36 @@ pub(super) async fn toggle_platform(
         })));
     };
 
-    table["enabled"] = toml_edit::value(request.enabled);
+    if let Some(adapter_name) = &request.adapter {
+        // Toggle a specific named instance
+        let adapter_name = adapter_name.trim();
+        let mut found = false;
+        if let Some(instances) = table
+            .get_mut("instances")
+            .and_then(|item| item.as_array_of_tables_mut())
+        {
+            for instance in instances.iter_mut() {
+                if instance
+                    .get("name")
+                    .and_then(|v| v.as_str())
+                    .is_some_and(|n| n == adapter_name)
+                {
+                    instance["enabled"] = toml_edit::value(request.enabled);
+                    found = true;
+                    break;
+                }
+            }
+        }
+        if !found {
+            return Ok(Json(serde_json::json!({
+                "success": false,
+                "message": format!("instance '{adapter_name}' not found for {platform}")
+            })));
+        }
+    } else {
+        // Toggle the default (root-level) instance
+        table["enabled"] = toml_edit::value(request.enabled);
+    }
 
     tokio::fs::write(&config_path, doc.to_string())
         .await
@@ -364,81 +813,177 @@ pub(super) async fn toggle_platform(
             match platform.as_str() {
                 "discord" => {
                     if let Some(discord_config) = &new_config.messaging.discord {
-                        let perms = {
-                            let perms_guard = state.discord_permissions.read().await;
-                            match perms_guard.as_ref() {
-                                Some(existing) => existing.clone(),
-                                None => {
-                                    drop(perms_guard);
-                                    let perms = crate::config::DiscordPermissions::from_config(
-                                        discord_config,
-                                        &new_config.bindings,
-                                    );
-                                    let arc_swap =
-                                        std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(perms));
-                                    state.set_discord_permissions(arc_swap.clone()).await;
-                                    arc_swap
+                        if !discord_config.token.is_empty() {
+                            let perms = {
+                                let perms_guard = state.discord_permissions.read().await;
+                                match perms_guard.as_ref() {
+                                    Some(existing) => existing.clone(),
+                                    None => {
+                                        drop(perms_guard);
+                                        let perms = crate::config::DiscordPermissions::from_config(
+                                            discord_config,
+                                            &new_config.bindings,
+                                        );
+                                        let arc_swap = std::sync::Arc::new(
+                                            arc_swap::ArcSwap::from_pointee(perms),
+                                        );
+                                        state.set_discord_permissions(arc_swap.clone()).await;
+                                        arc_swap
+                                    }
                                 }
+                            };
+                            let adapter = crate::messaging::discord::DiscordAdapter::new(
+                                "discord",
+                                &discord_config.token,
+                                perms,
+                            );
+                            if let Err(error) = manager.register_and_start(adapter).await {
+                                tracing::error!(%error, "failed to start discord adapter on toggle");
+                            }
+                        }
+
+                        for instance in discord_config
+                            .instances
+                            .iter()
+                            .filter(|instance| instance.enabled)
+                        {
+                            let runtime_key = crate::config::binding_runtime_adapter_key(
+                                "discord",
+                                Some(instance.name.as_str()),
+                            );
+                            let perms = std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(
+                                crate::config::DiscordPermissions::from_instance_config(
+                                    instance,
+                                    &new_config.bindings,
+                                ),
+                            ));
+                            let adapter = crate::messaging::discord::DiscordAdapter::new(
+                                runtime_key,
+                                &instance.token,
+                                perms,
+                            );
+                            if let Err(error) = manager.register_and_start(adapter).await {
+                                tracing::error!(%error, adapter = %instance.name, "failed to start named discord adapter on toggle");
                             }
-                        };
-                        let adapter = crate::messaging::discord::DiscordAdapter::new(
-                            &discord_config.token,
-                            perms,
-                        );
-                        if let Err(error) = manager.register_and_start(adapter).await {
-                            tracing::error!(%error, "failed to start discord adapter on toggle");
                         }
                     }
                 }
                 "slack" => {
                     if let Some(slack_config) = &new_config.messaging.slack {
-                        let perms = {
-                            let perms_guard = state.slack_permissions.read().await;
-                            match perms_guard.as_ref() {
-                                Some(existing) => existing.clone(),
-                                None => {
-                                    drop(perms_guard);
-                                    let perms = crate::config::SlackPermissions::from_config(
-                                        slack_config,
-                                        &new_config.bindings,
-                                    );
-                                    let arc_swap =
-                                        std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(perms));
-                                    state.set_slack_permissions(arc_swap.clone()).await;
-                                    arc_swap
+                        if !slack_config.bot_token.is_empty() && !slack_config.app_token.is_empty()
+                        {
+                            let perms = {
+                                let perms_guard = state.slack_permissions.read().await;
+                                match perms_guard.as_ref() {
+                                    Some(existing) => existing.clone(),
+                                    None => {
+                                        drop(perms_guard);
+                                        let perms = crate::config::SlackPermissions::from_config(
+                                            slack_config,
+                                            &new_config.bindings,
+                                        );
+                                        let arc_swap = std::sync::Arc::new(
+                                            arc_swap::ArcSwap::from_pointee(perms),
+                                        );
+                                        state.set_slack_permissions(arc_swap.clone()).await;
+                                        arc_swap
+                                    }
                                 }
-                            }
-                        };
-                        match crate::messaging::slack::SlackAdapter::new(
-                            &slack_config.bot_token,
-                            &slack_config.app_token,
-                            perms,
-                            slack_config.commands.clone(),
-                        ) {
-                            Ok(adapter) => {
-                                if let Err(error) = manager.register_and_start(adapter).await {
-                                    tracing::error!(%error, "failed to start slack adapter on toggle");
+                            };
+                            match crate::messaging::slack::SlackAdapter::new(
+                                "slack",
+                                &slack_config.bot_token,
+                                &slack_config.app_token,
+                                perms,
+                                slack_config.commands.clone(),
+                            ) {
+                                Ok(adapter) => {
+                                    if let Err(error) = manager.register_and_start(adapter).await {
+                                        tracing::error!(%error, "failed to start slack adapter on toggle");
+                                    }
+                                }
+                                Err(error) => {
+                                    tracing::error!(%error, "failed to build slack adapter on toggle");
                                 }
                             }
-                            Err(error) => {
-                                tracing::error!(%error, "failed to build slack adapter on toggle");
+                        }
+
+                        for instance in slack_config
+                            .instances
+                            .iter()
+                            .filter(|instance| instance.enabled)
+                        {
+                            let runtime_key = crate::config::binding_runtime_adapter_key(
+                                "slack",
+                                Some(instance.name.as_str()),
+                            );
+                            let perms = std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(
+                                crate::config::SlackPermissions::from_instance_config(
+                                    instance,
+                                    &new_config.bindings,
+                                ),
+                            ));
+                            match crate::messaging::slack::SlackAdapter::new(
+                                runtime_key,
+                                &instance.bot_token,
+                                &instance.app_token,
+                                perms,
+                                instance.commands.clone(),
+                            ) {
+                                Ok(adapter) => {
+                                    if let Err(error) = manager.register_and_start(adapter).await {
+                                        tracing::error!(%error, adapter = %instance.name, "failed to start named slack adapter on toggle");
+                                    }
+                                }
+                                Err(error) => {
+                                    tracing::error!(%error, adapter = %instance.name, "failed to build named slack adapter on toggle");
+                                }
                             }
                         }
                     }
                 }
                 "telegram" => {
                     if let Some(telegram_config) = &new_config.messaging.telegram {
-                        let perms = crate::config::TelegramPermissions::from_config(
-                            telegram_config,
-                            &new_config.bindings,
-                        );
-                        let arc_swap = std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(perms));
-                        let adapter = crate::messaging::telegram::TelegramAdapter::new(
-                            &telegram_config.token,
-                            arc_swap,
-                        );
-                        if let Err(error) = manager.register_and_start(adapter).await {
-                            tracing::error!(%error, "failed to start telegram adapter on toggle");
+                        if !telegram_config.token.is_empty() {
+                            let perms = crate::config::TelegramPermissions::from_config(
+                                telegram_config,
+                                &new_config.bindings,
+                            );
+                            let arc_swap =
+                                std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(perms));
+                            let adapter = crate::messaging::telegram::TelegramAdapter::new(
+                                "telegram",
+                                &telegram_config.token,
+                                arc_swap,
+                            );
+                            if let Err(error) = manager.register_and_start(adapter).await {
+                                tracing::error!(%error, "failed to start telegram adapter on toggle");
+                            }
+                        }
+
+                        for instance in telegram_config
+                            .instances
+                            .iter()
+                            .filter(|instance| instance.enabled)
+                        {
+                            let runtime_key = crate::config::binding_runtime_adapter_key(
+                                "telegram",
+                                Some(instance.name.as_str()),
+                            );
+                            let perms = std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(
+                                crate::config::TelegramPermissions::from_instance_config(
+                                    instance,
+                                    &new_config.bindings,
+                                ),
+                            ));
+                            let adapter = crate::messaging::telegram::TelegramAdapter::new(
+                                runtime_key,
+                                &instance.token,
+                                perms,
+                            );
+                            if let Err(error) = manager.register_and_start(adapter).await {
+                                tracing::error!(%error, adapter = %instance.name, "failed to start named telegram adapter on toggle");
+                            }
                         }
                     }
                 }
@@ -470,36 +1015,91 @@ pub(super) async fn toggle_platform(
                 }
                 "twitch" => {
                     if let Some(twitch_config) = &new_config.messaging.twitch {
-                        let perms = crate::config::TwitchPermissions::from_config(
-                            twitch_config,
-                            &new_config.bindings,
-                        );
-                        let arc_swap = std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(perms));
-                        let instance_dir = state.instance_dir.load();
-                        let token_path = instance_dir.join("twitch_token.json");
-                        let adapter = crate::messaging::twitch::TwitchAdapter::new(
-                            &twitch_config.username,
-                            &twitch_config.oauth_token,
-                            twitch_config.client_id.clone(),
-                            twitch_config.client_secret.clone(),
-                            twitch_config.refresh_token.clone(),
-                            Some(token_path),
-                            twitch_config.channels.clone(),
-                            twitch_config.trigger_prefix.clone(),
-                            arc_swap,
-                        );
-                        if let Err(error) = manager.register_and_start(adapter).await {
-                            tracing::error!(%error, "failed to start twitch adapter on toggle");
+                        if !twitch_config.username.is_empty()
+                            && !twitch_config.oauth_token.is_empty()
+                        {
+                            let perms = crate::config::TwitchPermissions::from_config(
+                                twitch_config,
+                                &new_config.bindings,
+                            );
+                            let arc_swap =
+                                std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(perms));
+                            let instance_dir = state.instance_dir.load();
+                            let token_path = instance_dir.join("twitch_token.json");
+                            let adapter = crate::messaging::twitch::TwitchAdapter::new(
+                                "twitch",
+                                &twitch_config.username,
+                                &twitch_config.oauth_token,
+                                twitch_config.client_id.clone(),
+                                twitch_config.client_secret.clone(),
+                                twitch_config.refresh_token.clone(),
+                                Some(token_path),
+                                twitch_config.channels.clone(),
+                                twitch_config.trigger_prefix.clone(),
+                                arc_swap,
+                            );
+                            if let Err(error) = manager.register_and_start(adapter).await {
+                                tracing::error!(%error, "failed to start twitch adapter on toggle");
+                            }
+                        }
+
+                        for instance in twitch_config
+                            .instances
+                            .iter()
+                            .filter(|instance| instance.enabled)
+                        {
+                            let runtime_key = crate::config::binding_runtime_adapter_key(
+                                "twitch",
+                                Some(instance.name.as_str()),
+                            );
+                            let token_file_name = format!(
+                                "twitch_token_{}.json",
+                                instance
+                                    .name
+                                    .chars()
+                                    .map(|ch| if ch.is_ascii_alphanumeric() { ch } else { '_' })
+                                    .collect::<String>()
+                            );
+                            let instance_dir = state.instance_dir.load();
+                            let token_path = instance_dir.join(token_file_name);
+                            let perms = std::sync::Arc::new(arc_swap::ArcSwap::from_pointee(
+                                crate::config::TwitchPermissions::from_instance_config(
+                                    instance,
+                                    &new_config.bindings,
+                                ),
+                            ));
+                            let adapter = crate::messaging::twitch::TwitchAdapter::new(
+                                runtime_key,
+                                &instance.username,
+                                &instance.oauth_token,
+                                instance.client_id.clone(),
+                                instance.client_secret.clone(),
+                                instance.refresh_token.clone(),
+                                Some(token_path),
+                                instance.channels.clone(),
+                                instance.trigger_prefix.clone(),
+                                perms,
+                            );
+                            if let Err(error) = manager.register_and_start(adapter).await {
+                                tracing::error!(%error, adapter = %instance.name, "failed to start named twitch adapter on toggle");
+                            }
                         }
                     }
                 }
                 _ => {}
             }
         }
-    } else if let Some(manager) = manager
-        && let Err(error) = manager.remove_adapter(platform).await
-    {
-        tracing::warn!(%error, platform = %platform, "failed to shut down adapter on toggle");
+    } else if let Some(manager) = manager {
+        if let Some(ref adapter_name) = request.adapter {
+            // Shut down only the specific named instance.
+            let runtime_key =
+                crate::config::binding_runtime_adapter_key(platform, Some(adapter_name.trim()));
+            if let Err(error) = manager.remove_adapter(&runtime_key).await {
+                tracing::warn!(%error, adapter = %runtime_key, "failed to shut down named adapter on toggle");
+            }
+        } else if let Err(error) = manager.remove_platform_adapters(platform).await {
+            tracing::warn!(%error, platform = %platform, "failed to shut down adapters on toggle");
+        }
     }
 
     let action = if request.enabled {
@@ -514,3 +1114,522 @@ pub(super) async fn toggle_platform(
         "message": format!("{platform} {action}")
     })))
 }
+
+/// Create a new adapter instance for a platform.
+///
+/// If `name` is `None`, creates/updates the default instance (root-level credentials).
+/// If `name` is `Some`, adds a `[[messaging.<platform>.instances]]` entry.
+/// Starts the adapter at runtime and reloads bindings.
+pub(super) async fn create_messaging_instance(
+    State(state): State<Arc<ApiState>>,
+    Json(request): Json<CreateMessagingInstanceRequest>,
+) -> Result<Json<MessagingInstanceActionResponse>, StatusCode> {
+    let platform = &request.platform;
+
+    if !matches!(
+        platform.as_str(),
+        "discord" | "slack" | "telegram" | "twitch" | "email" | "webhook"
+    ) {
+        return Ok(Json(MessagingInstanceActionResponse {
+            success: false,
+            message: format!("instances are not supported for '{platform}'"),
+        }));
+    }
+
+    // Validate instance name
+    if let Some(name) = &request.name {
+        let trimmed = name.trim();
+        if trimmed.is_empty() || trimmed.eq_ignore_ascii_case("default") {
+            return Ok(Json(MessagingInstanceActionResponse {
+                success: false,
+                message: "instance name cannot be empty or 'default'".to_string(),
+            }));
+        }
+        if trimmed.contains(':') || trimmed.contains(' ') {
+            return Ok(Json(MessagingInstanceActionResponse {
+                success: false,
+                message: "instance name cannot contain ':' or spaces".to_string(),
+            }));
+        }
+    }
+
+    let config_path = state.config_path.read().await.clone();
+    let content = tokio::fs::read_to_string(&config_path)
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, "failed to read config.toml");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+    let mut doc: toml_edit::DocumentMut = content.parse().map_err(|error| {
+        tracing::warn!(%error, "failed to parse config.toml");
+        StatusCode::INTERNAL_SERVER_ERROR
+    })?;
+
+    // Ensure [messaging] and [messaging.<platform>] tables exist
+    if doc.get("messaging").is_none() {
+        doc["messaging"] = toml_edit::Item::Table(toml_edit::Table::new());
+    }
+    let messaging = doc["messaging"].as_table_mut().ok_or_else(|| {
+        tracing::warn!("messaging is not a table");
+        StatusCode::INTERNAL_SERVER_ERROR
+    })?;
+
+    if messaging.get(platform.as_str()).is_none() {
+        let mut platform_table = toml_edit::Table::new();
+        platform_table["enabled"] = toml_edit::value(true);
+        messaging[platform.as_str()] = toml_edit::Item::Table(platform_table);
+    }
+    let platform_table = messaging
+        .get_mut(platform.as_str())
+        .and_then(|item| item.as_table_mut())
+        .ok_or_else(|| {
+            tracing::warn!(platform = %platform, "platform config is not a table");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+
+    let credentials = &request.credentials;
+    let enabled = request.enabled.unwrap_or(true);
+
+    match request.name {
+        None => {
+            // Default instance — set root-level credential fields
+            match platform.as_str() {
+                "discord" => {
+                    if let Some(token) = &credentials.discord_token {
+                        platform_table["token"] = toml_edit::value(token.as_str());
+                    }
+                }
+                "slack" => {
+                    if let Some(token) = &credentials.slack_bot_token {
+                        platform_table["bot_token"] = toml_edit::value(token.as_str());
+                    }
+                    if let Some(token) = &credentials.slack_app_token {
+                        platform_table["app_token"] = toml_edit::value(token.as_str());
+                    }
+                }
+                "telegram" => {
+                    if let Some(token) = &credentials.telegram_token {
+                        platform_table["token"] = toml_edit::value(token.as_str());
+                    }
+                }
+                "twitch" => {
+                    if let Some(username) = &credentials.twitch_username {
+                        platform_table["username"] = toml_edit::value(username.as_str());
+                    }
+                    if let Some(token) = &credentials.twitch_oauth_token {
+                        platform_table["oauth_token"] = toml_edit::value(token.as_str());
+                    }
+                    if let Some(client_id) = &credentials.twitch_client_id {
+                        platform_table["client_id"] = toml_edit::value(client_id.as_str());
+                    }
+                    if let Some(client_secret) = &credentials.twitch_client_secret {
+                        platform_table["client_secret"] = toml_edit::value(client_secret.as_str());
+                    }
+                    if let Some(refresh) = &credentials.twitch_refresh_token {
+                        platform_table["refresh_token"] = toml_edit::value(refresh.as_str());
+                    }
+                }
+                "email" => {
+                    if let Some(host) = &credentials.email_imap_host {
+                        platform_table["imap_host"] = toml_edit::value(host.as_str());
+                    }
+                    if let Some(port) = credentials.email_imap_port {
+                        platform_table["imap_port"] = toml_edit::value(i64::from(port));
+                    }
+                    if let Some(username) = &credentials.email_imap_username {
+                        platform_table["imap_username"] = toml_edit::value(username.as_str());
+                    }
+                    if let Some(password) = &credentials.email_imap_password {
+                        platform_table["imap_password"] = toml_edit::value(password.as_str());
+                    }
+                    if let Some(host) = &credentials.email_smtp_host {
+                        platform_table["smtp_host"] = toml_edit::value(host.as_str());
+                    }
+                    if let Some(port) = credentials.email_smtp_port {
+                        platform_table["smtp_port"] = toml_edit::value(i64::from(port));
+                    }
+                    if let Some(username) = &credentials.email_smtp_username {
+                        platform_table["smtp_username"] = toml_edit::value(username.as_str());
+                    }
+                    if let Some(password) = &credentials.email_smtp_password {
+                        platform_table["smtp_password"] = toml_edit::value(password.as_str());
+                    }
+                    if let Some(from) = &credentials.email_from_address {
+                        platform_table["from_address"] = toml_edit::value(from.as_str());
+                    }
+                }
+                "webhook" => {
+                    if let Some(port) = credentials.webhook_port {
+                        platform_table["port"] = toml_edit::value(i64::from(port));
+                    }
+                    if let Some(bind) = &credentials.webhook_bind {
+                        platform_table["bind"] = toml_edit::value(bind.as_str());
+                    }
+                    if let Some(token) = &credentials.webhook_auth_token {
+                        platform_table["auth_token"] = toml_edit::value(token.as_str());
+                    }
+                }
+                _ => {}
+            }
+            platform_table["enabled"] = toml_edit::value(enabled);
+        }
+        Some(ref name) => {
+            // Named instance — add to [[messaging.<platform>.instances]]
+            let instance_name = name.trim().to_string();
+
+            // Check for duplicates
+            if let Some(existing_instances) = platform_table
+                .get("instances")
+                .and_then(|item| item.as_array_of_tables())
+            {
+                for existing in existing_instances {
+                    if existing
+                        .get("name")
+                        .and_then(|value| value.as_str())
+                        .is_some_and(|name| name == instance_name)
+                    {
+                        return Ok(Json(MessagingInstanceActionResponse {
+                            success: false,
+                            message: format!(
+                                "instance '{instance_name}' already exists for {platform}"
+                            ),
+                        }));
+                    }
+                }
+            }
+
+            let mut instance_table = toml_edit::Table::new();
+            instance_table["name"] = toml_edit::value(&instance_name);
+            instance_table["enabled"] = toml_edit::value(enabled);
+
+            match platform.as_str() {
+                "discord" => {
+                    if let Some(token) = &credentials.discord_token {
+                        instance_table["token"] = toml_edit::value(token.as_str());
+                    }
+                }
+                "slack" => {
+                    if let Some(token) = &credentials.slack_bot_token {
+                        instance_table["bot_token"] = toml_edit::value(token.as_str());
+                    }
+                    if let Some(token) = &credentials.slack_app_token {
+                        instance_table["app_token"] = toml_edit::value(token.as_str());
+                    }
+                }
+                "telegram" => {
+                    if let Some(token) = &credentials.telegram_token {
+                        instance_table["token"] = toml_edit::value(token.as_str());
+                    }
+                }
+                "twitch" => {
+                    if let Some(username) = &credentials.twitch_username {
+                        instance_table["username"] = toml_edit::value(username.as_str());
+                    }
+                    if let Some(token) = &credentials.twitch_oauth_token {
+                        instance_table["oauth_token"] = toml_edit::value(token.as_str());
+                    }
+                    if let Some(client_id) = &credentials.twitch_client_id {
+                        instance_table["client_id"] = toml_edit::value(client_id.as_str());
+                    }
+                    if let Some(client_secret) = &credentials.twitch_client_secret {
+                        instance_table["client_secret"] = toml_edit::value(client_secret.as_str());
+                    }
+                    if let Some(refresh) = &credentials.twitch_refresh_token {
+                        instance_table["refresh_token"] = toml_edit::value(refresh.as_str());
+                    }
+                }
+                "email" => {
+                    if let Some(host) = &credentials.email_imap_host {
+                        instance_table["imap_host"] = toml_edit::value(host.as_str());
+                    }
+                    if let Some(port) = credentials.email_imap_port {
+                        instance_table["imap_port"] = toml_edit::value(i64::from(port));
+                    }
+                    if let Some(username) = &credentials.email_imap_username {
+                        instance_table["imap_username"] = toml_edit::value(username.as_str());
+                    }
+                    if let Some(password) = &credentials.email_imap_password {
+                        instance_table["imap_password"] = toml_edit::value(password.as_str());
+                    }
+                    if let Some(host) = &credentials.email_smtp_host {
+                        instance_table["smtp_host"] = toml_edit::value(host.as_str());
+                    }
+                    if let Some(port) = credentials.email_smtp_port {
+                        instance_table["smtp_port"] = toml_edit::value(i64::from(port));
+                    }
+                    if let Some(username) = &credentials.email_smtp_username {
+                        instance_table["smtp_username"] = toml_edit::value(username.as_str());
+                    }
+                    if let Some(password) = &credentials.email_smtp_password {
+                        instance_table["smtp_password"] = toml_edit::value(password.as_str());
+                    }
+                    if let Some(from) = &credentials.email_from_address {
+                        instance_table["from_address"] = toml_edit::value(from.as_str());
+                    }
+                }
+                "webhook" => {
+                    if let Some(port) = credentials.webhook_port {
+                        instance_table["port"] = toml_edit::value(i64::from(port));
+                    }
+                    if let Some(bind) = &credentials.webhook_bind {
+                        instance_table["bind"] = toml_edit::value(bind.as_str());
+                    }
+                    if let Some(token) = &credentials.webhook_auth_token {
+                        instance_table["auth_token"] = toml_edit::value(token.as_str());
+                    }
+                }
+                _ => {}
+            }
+
+            // Append the new instance table
+            if platform_table.get("instances").is_none() {
+                platform_table.insert(
+                    "instances",
+                    toml_edit::Item::ArrayOfTables(toml_edit::ArrayOfTables::new()),
+                );
+            }
+            if let Some(instances) = platform_table
+                .get_mut("instances")
+                .and_then(|item| item.as_array_of_tables_mut())
+            {
+                instances.push(instance_table);
+            }
+        }
+    }
+
+    // Write updated config
+    tokio::fs::write(&config_path, doc.to_string())
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, "failed to write config.toml");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+
+    // Reload config and hot-start the new adapter
+    if let Ok(new_config) = crate::config::Config::load_from_path(&config_path) {
+        let bindings_guard = state.bindings.read().await;
+        if let Some(bindings_swap) = bindings_guard.as_ref() {
+            bindings_swap.store(std::sync::Arc::new(new_config.bindings.clone()));
+        }
+    }
+
+    // The file watcher will pick up the change and start the adapter.
+    // We don't duplicate the adapter-start logic here — the hot-reload
+    // path in config.rs handles creating and registering all adapters.
+
+    let label = if let Some(name) = &request.name {
+        format!("{platform}:{}", name.trim())
+    } else {
+        format!("{platform} (default)")
+    };
+    tracing::info!(platform = %platform, instance = %label, "messaging instance created via API");
+
+    Ok(Json(MessagingInstanceActionResponse {
+        success: true,
+        message: format!("{label} instance created"),
+    }))
+}
+
+/// Delete a named adapter instance (or the default instance) for a platform.
+///
+/// Removes the instance entry from config.toml, removes bindings targeting
+/// that adapter, and shuts down the runtime adapter.
+pub(super) async fn delete_messaging_instance(
+    State(state): State<Arc<ApiState>>,
+    Json(request): Json<DeleteMessagingInstanceRequest>,
+) -> Result<Json<MessagingInstanceActionResponse>, StatusCode> {
+    let platform = &request.platform;
+    let adapter_name = request.name.as_deref().map(str::trim);
+
+    if !matches!(
+        platform.as_str(),
+        "discord" | "slack" | "telegram" | "twitch" | "email" | "webhook"
+    ) {
+        return Ok(Json(MessagingInstanceActionResponse {
+            success: false,
+            message: format!("instances are not supported for '{platform}'"),
+        }));
+    }
+
+    let config_path = state.config_path.read().await.clone();
+    let content = tokio::fs::read_to_string(&config_path)
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, "failed to read config.toml");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+    let mut doc: toml_edit::DocumentMut = content.parse().map_err(|error| {
+        tracing::warn!(%error, "failed to parse config.toml");
+        StatusCode::INTERNAL_SERVER_ERROR
+    })?;
+
+    let runtime_key = crate::config::binding_runtime_adapter_key(platform, adapter_name);
+
+    if let Some(adapter_name) = adapter_name {
+        // Remove a named instance from [[messaging.<platform>.instances]]
+        let removed = if let Some(instances) = doc
+            .get_mut("messaging")
+            .and_then(|m| m.get_mut(platform.as_str()))
+            .and_then(|p| p.get_mut("instances"))
+            .and_then(|item| item.as_array_of_tables_mut())
+        {
+            let mut found = false;
+            let mut index = 0;
+            while index < instances.len() {
+                let matches = instances
+                    .get(index)
+                    .and_then(|t| t.get("name"))
+                    .and_then(|v| v.as_str())
+                    .is_some_and(|name| name == adapter_name);
+                if matches {
+                    instances.remove(index);
+                    found = true;
+                    break;
+                }
+                index += 1;
+            }
+            found
+        } else {
+            false
+        };
+
+        if !removed {
+            return Ok(Json(MessagingInstanceActionResponse {
+                success: false,
+                message: format!("instance '{adapter_name}' not found for {platform}"),
+            }));
+        }
+    } else {
+        // Remove default instance — clear root-level credentials
+        if let Some(table) = doc
+            .get_mut("messaging")
+            .and_then(|m| m.get_mut(platform.as_str()))
+            .and_then(|p| p.as_table_mut())
+        {
+            match platform.as_str() {
+                "discord" => {
+                    table.remove("token");
+                }
+                "slack" => {
+                    table.remove("bot_token");
+                    table.remove("app_token");
+                }
+                "telegram" => {
+                    table.remove("token");
+                }
+                "twitch" => {
+                    table.remove("username");
+                    table.remove("oauth_token");
+                    table.remove("client_id");
+                    table.remove("client_secret");
+                    table.remove("refresh_token");
+                }
+                "email" => {
+                    table.remove("imap_host");
+                    table.remove("imap_port");
+                    table.remove("imap_username");
+                    table.remove("imap_password");
+                    table.remove("smtp_host");
+                    table.remove("smtp_port");
+                    table.remove("smtp_username");
+                    table.remove("smtp_password");
+                    table.remove("from_address");
+                }
+                "webhook" => {
+                    table.remove("port");
+                    table.remove("bind");
+                    table.remove("auth_token");
+                }
+                _ => {}
+            }
+        }
+    }
+
+    // Remove bindings targeting this adapter
+    if let Some(bindings) = doc
+        .get_mut("bindings")
+        .and_then(|b| b.as_array_of_tables_mut())
+    {
+        let mut index = 0;
+        while index < bindings.len() {
+            let binding_channel = bindings
+                .get(index)
+                .and_then(|t| t.get("channel"))
+                .and_then(|v| v.as_str());
+            let binding_adapter = bindings
+                .get(index)
+                .and_then(|t| t.get("adapter"))
+                .and_then(|v| v.as_str());
+
+            let matches_platform = binding_channel.is_some_and(|ch| ch == platform);
+            let matches_adapter = match (binding_adapter, adapter_name) {
+                (None, None) => true,
+                (Some(ba), Some(an)) => ba == an,
+                _ => false,
+            };
+
+            if matches_platform && matches_adapter {
+                bindings.remove(index);
+            } else {
+                index += 1;
+            }
+        }
+    }
+
+    tokio::fs::write(&config_path, doc.to_string())
+        .await
+        .map_err(|error| {
+            tracing::warn!(%error, "failed to write config.toml");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+
+    // Reload bindings
+    if let Ok(new_config) = crate::config::Config::load_from_path(&config_path) {
+        let bindings_guard = state.bindings.read().await;
+        if let Some(bindings_swap) = bindings_guard.as_ref() {
+            bindings_swap.store(std::sync::Arc::new(new_config.bindings.clone()));
+        }
+    }
+
+    // Shut down the runtime adapter
+    let manager_guard = state.messaging_manager.read().await;
+    if let Some(manager) = manager_guard.as_ref()
+        && let Err(error) = manager.remove_adapter(&runtime_key).await
+    {
+        tracing::warn!(%error, adapter = %runtime_key, "failed to shut down adapter during instance delete");
+    }
+
+    // Clean up twitch token file if applicable
+    if platform == "twitch" {
+        let instance_dir = state.instance_dir.load();
+        let token_path = if let Some(name) = adapter_name {
+            let safe_name: String = name
+                .chars()
+                .map(|ch| if ch.is_ascii_alphanumeric() { ch } else { '_' })
+                .collect();
+            instance_dir.join(format!("twitch_token_{safe_name}.json"))
+        } else {
+            instance_dir.join("twitch_token.json")
+        };
+        match tokio::fs::remove_file(&token_path).await {
+            Ok(()) => {
+                tracing::info!(path = %token_path.display(), "twitch token file deleted");
+            }
+            Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
+            Err(error) => {
+                tracing::warn!(
+                    %error,
+                    path = %token_path.display(),
+                    "failed to delete twitch token file"
+                );
+            }
+        }
+    }
+
+    tracing::info!(platform = %platform, adapter = %runtime_key, "messaging instance deleted via API");
+
+    Ok(Json(MessagingInstanceActionResponse {
+        success: true,
+        message: format!("{runtime_key} instance deleted"),
+    }))
+}
diff --git a/src/api/server.rs b/src/api/server.rs
index 669dff17d..2dc8402a8 100644
--- a/src/api/server.rs
+++ b/src/api/server.rs
@@ -163,6 +163,10 @@ pub async fn start_http_server(
             post(messaging::disconnect_platform),
         )
         .route("/messaging/toggle", post(messaging::toggle_platform))
+        .route(
+            "/messaging/instances",
+            post(messaging::create_messaging_instance).delete(messaging::delete_messaging_instance),
+        )
         .route(
             "/bindings",
             get(bindings::list_bindings)
diff --git a/src/api/webchat.rs b/src/api/webchat.rs
index 352d6d487..761a3b13d 100644
--- a/src/api/webchat.rs
+++ b/src/api/webchat.rs
@@ -59,6 +59,7 @@ pub(super) async fn webchat_send(
     let inbound = InboundMessage {
         id: uuid::Uuid::new_v4().to_string(),
         source: "webchat".into(),
+        adapter: Some("webchat".into()),
         conversation_id: conversation_id.clone(),
         sender_id: request.sender_name.clone(),
         agent_id: Some(request.agent_id.into()),
diff --git a/src/config.rs b/src/config.rs
index 69abfce80..0273238ea 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -1149,11 +1149,22 @@ impl ResolvedAgentConfig {
     }
 }
 
+/// Normalize an adapter selector: trim whitespace, return `None` if empty.
+fn normalize_adapter(adapter: Option<String>) -> Option<String> {
+    adapter
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+}
+
 /// Routes a messaging platform conversation to a specific agent.
 #[derive(Debug, Clone)]
 pub struct Binding {
     pub agent_id: String,
     pub channel: String,
+    /// Optional named adapter selector (platform-scoped).
+    ///
+    /// `None` targets the default adapter for this platform.
+    pub adapter: Option<String>,
     pub guild_id: Option<String>,
     pub workspace_id: Option<String>, // Slack workspace (team) ID
     pub chat_id: Option<String>,
@@ -1166,12 +1177,26 @@ pub struct Binding {
 }
 
 impl Binding {
+    /// Runtime adapter key for this binding.
+    pub fn runtime_adapter_key(&self) -> String {
+        binding_runtime_adapter_key(self.channel.as_str(), self.adapter.as_deref())
+    }
+
+    /// Whether this binding targets the default adapter for its platform.
+    pub fn uses_default_adapter(&self) -> bool {
+        self.adapter.is_none()
+    }
+
     /// Check if this binding matches an inbound message.
     fn matches(&self, message: &crate::InboundMessage) -> bool {
         if self.channel != message.source {
             return false;
         }
 
+        if !binding_adapter_matches(self, message) {
+            return false;
+        }
+
         // For webchat messages, match based on agent_id in the message
         if message.source == "webchat"
             && let Some(message_agent_id) = &message.agent_id
@@ -1278,6 +1303,274 @@ impl Binding {
     }
 }
 
+/// Build a runtime adapter key from platform and optional named selector.
+pub fn binding_runtime_adapter_key(platform: &str, adapter: Option<&str>) -> String {
+    if let Some(name) = adapter
+        && !name.is_empty()
+    {
+        return format!("{platform}:{name}");
+    }
+    platform.to_string()
+}
+
+/// Match a binding's adapter selector against an inbound message adapter.
+fn binding_adapter_matches(binding: &Binding, message: &crate::InboundMessage) -> bool {
+    match (&binding.adapter, message.adapter_selector()) {
+        (None, None) => true,
+        (Some(expected), Some(actual)) => expected == actual,
+        _ => false,
+    }
+}
+
+#[derive(Debug, Clone)]
+struct AdapterValidationState {
+    default_present: bool,
+    named_instances: std::collections::HashSet<String>,
+}
+
+fn is_named_adapter_platform(platform: &str) -> bool {
+    matches!(
+        platform,
+        "discord" | "slack" | "telegram" | "twitch" | "email"
+    )
+}
+
+fn validate_named_messaging_adapters(
+    messaging: &MessagingConfig,
+    bindings: &[Binding],
+) -> Result<()> {
+    let adapter_states = build_adapter_validation_states(messaging)?;
+
+    for binding in bindings {
+        if !is_named_adapter_platform(binding.channel.as_str()) {
+            if binding.adapter.is_some() {
+                return Err(ConfigError::Invalid(format!(
+                    "binding for channel '{}' can't set adapter: this platform does not support named adapters",
+                    binding.channel
+                ))
+                .into());
+            }
+            continue;
+        }
+
+        let state = adapter_states.get(binding.channel.as_str()).ok_or_else(|| {
+            ConfigError::Invalid(format!(
+                "binding for channel '{}' can't be resolved: no messaging config exists for that platform",
+                binding.channel
+            ))
+        })?;
+
+        // adapter is already normalized at ingest time via normalize_adapter().
+        match binding.adapter.as_deref() {
+            Some(adapter_name) => {
+                if !state.named_instances.contains(adapter_name) {
+                    return Err(ConfigError::Invalid(format!(
+                        "binding for channel '{}' references missing adapter '{}'",
+                        binding.channel, adapter_name
+                    ))
+                    .into());
+                }
+            }
+            None => {
+                if !state.default_present {
+                    return Err(ConfigError::Invalid(format!(
+                        "binding for channel '{}' requires the default adapter, but no default credentials are configured",
+                        binding.channel
+                    ))
+                    .into());
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn build_adapter_validation_states(
+    messaging: &MessagingConfig,
+) -> Result<std::collections::HashMap<&'static str, AdapterValidationState>> {
+    let mut states = std::collections::HashMap::new();
+
+    if let Some(discord) = &messaging.discord {
+        let named_instances = validate_instance_names(
+            "discord",
+            discord
+                .instances
+                .iter()
+                .map(|instance| instance.name.as_str()),
+        )?;
+        validate_runtime_keys(
+            "discord",
+            !discord.token.trim().is_empty(),
+            &named_instances,
+        )?;
+        states.insert(
+            "discord",
+            AdapterValidationState {
+                default_present: !discord.token.trim().is_empty(),
+                named_instances,
+            },
+        );
+    }
+
+    if let Some(slack) = &messaging.slack {
+        let named_instances = validate_instance_names(
+            "slack",
+            slack
+                .instances
+                .iter()
+                .map(|instance| instance.name.as_str()),
+        )?;
+        let default_present =
+            !slack.bot_token.trim().is_empty() && !slack.app_token.trim().is_empty();
+        validate_runtime_keys("slack", default_present, &named_instances)?;
+        states.insert(
+            "slack",
+            AdapterValidationState {
+                default_present,
+                named_instances,
+            },
+        );
+    }
+
+    if let Some(telegram) = &messaging.telegram {
+        let named_instances = validate_instance_names(
+            "telegram",
+            telegram
+                .instances
+                .iter()
+                .map(|instance| instance.name.as_str()),
+        )?;
+        let default_present = !telegram.token.trim().is_empty();
+        validate_runtime_keys("telegram", default_present, &named_instances)?;
+        states.insert(
+            "telegram",
+            AdapterValidationState {
+                default_present,
+                named_instances,
+            },
+        );
+    }
+
+    if let Some(twitch) = &messaging.twitch {
+        let named_instances = validate_instance_names(
+            "twitch",
+            twitch
+                .instances
+                .iter()
+                .map(|instance| instance.name.as_str()),
+        )?;
+        let default_present =
+            !twitch.username.trim().is_empty() && !twitch.oauth_token.trim().is_empty();
+        validate_runtime_keys("twitch", default_present, &named_instances)?;
+        states.insert(
+            "twitch",
+            AdapterValidationState {
+                default_present,
+                named_instances,
+            },
+        );
+    }
+
+    if let Some(email) = &messaging.email {
+        let named_instances = validate_instance_names(
+            "email",
+            email
+                .instances
+                .iter()
+                .map(|instance| instance.name.as_str()),
+        )?;
+        let default_present = !email.imap_host.trim().is_empty()
+            && !email.imap_username.trim().is_empty()
+            && !email.imap_password.trim().is_empty()
+            && !email.smtp_host.trim().is_empty();
+        validate_runtime_keys("email", default_present, &named_instances)?;
+        states.insert(
+            "email",
+            AdapterValidationState {
+                default_present,
+                named_instances,
+            },
+        );
+    }
+
+    Ok(states)
+}
+
+fn validate_instance_names<'a>(
+    platform: &str,
+    names: impl Iterator<Item = &'a str>,
+) -> Result<std::collections::HashSet<String>> {
+    let mut seen = std::collections::HashSet::new();
+
+    for name in names {
+        let trimmed = name.trim();
+        if trimmed.is_empty() {
+            return Err(ConfigError::Invalid(format!(
+                "messaging.{platform}.instances name can't be empty"
+            ))
+            .into());
+        }
+        if trimmed != name {
+            return Err(ConfigError::Invalid(format!(
+                "messaging.{platform}.instances name '{}' can't contain leading or trailing whitespace",
+                name
+            ))
+            .into());
+        }
+        if trimmed.eq_ignore_ascii_case("default") {
+            return Err(ConfigError::Invalid(format!(
+                "messaging.{platform}.instances name '{}' is reserved",
+                name
+            ))
+            .into());
+        }
+        if trimmed.contains(':') {
+            return Err(ConfigError::Invalid(format!(
+                "messaging.{platform}.instances name '{}' can't contain ':'",
+                name
+            ))
+            .into());
+        }
+        if !seen.insert(trimmed.to_string()) {
+            return Err(ConfigError::Invalid(format!(
+                "messaging.{platform}.instances has duplicate name '{}'",
+                name
+            ))
+            .into());
+        }
+    }
+
+    Ok(seen)
+}
+
+fn validate_runtime_keys(
+    platform: &str,
+    default_present: bool,
+    named_instances: &std::collections::HashSet<String>,
+) -> Result<()> {
+    let mut runtime_keys = std::collections::HashSet::new();
+
+    if default_present && !runtime_keys.insert(platform.to_string()) {
+        return Err(ConfigError::Invalid(format!(
+            "messaging.{platform} has duplicate runtime adapter key '{platform}'"
+        ))
+        .into());
+    }
+
+    for instance_name in named_instances {
+        let runtime_key = format!("{platform}:{instance_name}");
+        if !runtime_keys.insert(runtime_key.clone()) {
+            return Err(ConfigError::Invalid(format!(
+                "messaging.{platform} has duplicate runtime adapter key '{runtime_key}'"
+            ))
+            .into());
+        }
+    }
+
+    Ok(())
+}
+
 /// Resolve which agent should handle an inbound message.
 ///
 /// Checks bindings in order. First match wins. Falls back to the default
@@ -1310,17 +1603,43 @@ pub struct MessagingConfig {
 pub struct DiscordConfig {
     pub enabled: bool,
     pub token: String,
+    /// Additional named Discord bot instances for this platform.
+    pub instances: Vec<DiscordInstanceConfig>,
     /// User IDs allowed to DM the bot. If empty, DMs are ignored entirely.
     pub dm_allowed_users: Vec<String>,
     /// Whether to process messages from other bots (self-messages are always ignored).
     pub allow_bot_messages: bool,
 }
 
+#[derive(Clone)]
+pub struct DiscordInstanceConfig {
+    pub name: String,
+    pub enabled: bool,
+    pub token: String,
+    /// User IDs allowed to DM this bot instance.
+    pub dm_allowed_users: Vec<String>,
+    /// Whether this bot instance processes messages from other bots.
+    pub allow_bot_messages: bool,
+}
+
+impl std::fmt::Debug for DiscordInstanceConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("DiscordInstanceConfig")
+            .field("name", &self.name)
+            .field("enabled", &self.enabled)
+            .field("token", &"[REDACTED]")
+            .field("dm_allowed_users", &self.dm_allowed_users)
+            .field("allow_bot_messages", &self.allow_bot_messages)
+            .finish()
+    }
+}
+
 impl std::fmt::Debug for DiscordConfig {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("DiscordConfig")
             .field("enabled", &self.enabled)
             .field("token", &"[REDACTED]")
+            .field("instances", &self.instances)
             .field("dm_allowed_users", &self.dm_allowed_users)
             .field("allow_bot_messages", &self.allow_bot_messages)
             .finish()
@@ -1346,18 +1665,46 @@ pub struct SlackConfig {
     pub enabled: bool,
     pub bot_token: String,
     pub app_token: String,
+    /// Additional named Slack app instances for this platform.
+    pub instances: Vec<SlackInstanceConfig>,
     /// User IDs allowed to DM the bot. If empty, DMs are ignored entirely.
     pub dm_allowed_users: Vec<String>,
     /// Slash command definitions. If empty, all slash commands are ignored.
     pub commands: Vec<SlackCommandConfig>,
 }
 
+#[derive(Clone)]
+pub struct SlackInstanceConfig {
+    pub name: String,
+    pub enabled: bool,
+    pub bot_token: String,
+    pub app_token: String,
+    /// User IDs allowed to DM this app instance.
+    pub dm_allowed_users: Vec<String>,
+    /// Slash command definitions for this app instance.
+    pub commands: Vec<SlackCommandConfig>,
+}
+
+impl std::fmt::Debug for SlackInstanceConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SlackInstanceConfig")
+            .field("name", &self.name)
+            .field("enabled", &self.enabled)
+            .field("bot_token", &"[REDACTED]")
+            .field("app_token", &"[REDACTED]")
+            .field("dm_allowed_users", &self.dm_allowed_users)
+            .field("commands", &self.commands)
+            .finish()
+    }
+}
+
 impl std::fmt::Debug for SlackConfig {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("SlackConfig")
             .field("enabled", &self.enabled)
             .field("bot_token", &"[REDACTED]")
             .field("app_token", &"[REDACTED]")
+            .field("instances", &self.instances)
             .field("dm_allowed_users", &self.dm_allowed_users)
             .field("commands", &self.commands)
             .finish()
@@ -1390,8 +1737,30 @@ pub struct SlackPermissions {
 impl SlackPermissions {
     /// Build from the current config's slack settings and bindings.
     pub fn from_config(slack: &SlackConfig, bindings: &[Binding]) -> Self {
-        let slack_bindings: Vec<&Binding> =
-            bindings.iter().filter(|b| b.channel == "slack").collect();
+        Self::from_bindings_for_adapter(slack.dm_allowed_users.clone(), bindings, None)
+    }
+
+    /// Build permissions for a named Slack adapter instance.
+    pub fn from_instance_config(instance: &SlackInstanceConfig, bindings: &[Binding]) -> Self {
+        Self::from_bindings_for_adapter(
+            instance.dm_allowed_users.clone(),
+            bindings,
+            Some(instance.name.as_str()),
+        )
+    }
+
+    fn from_bindings_for_adapter(
+        seed_dm_allowed_users: Vec<String>,
+        bindings: &[Binding],
+        adapter_selector: Option<&str>,
+    ) -> Self {
+        let slack_bindings: Vec<&Binding> = bindings
+            .iter()
+            .filter(|binding| {
+                binding.channel == "slack"
+                    && binding_adapter_selector_matches(binding, adapter_selector)
+            })
+            .collect();
 
         let workspace_filter = {
             let workspace_ids: Vec<String> = slack_bindings
@@ -1421,7 +1790,7 @@ impl SlackPermissions {
             filter
         };
 
-        let mut dm_allowed_users = slack.dm_allowed_users.clone();
+        let mut dm_allowed_users = seed_dm_allowed_users;
 
         for binding in &slack_bindings {
             for id in &binding.dm_allowed_users {
@@ -1442,8 +1811,37 @@ impl SlackPermissions {
 impl DiscordPermissions {
     /// Build from the current config's discord settings and bindings.
     pub fn from_config(discord: &DiscordConfig, bindings: &[Binding]) -> Self {
-        let discord_bindings: Vec<&Binding> =
-            bindings.iter().filter(|b| b.channel == "discord").collect();
+        Self::from_bindings_for_adapter(
+            discord.dm_allowed_users.clone(),
+            discord.allow_bot_messages,
+            bindings,
+            None,
+        )
+    }
+
+    /// Build permissions for a named Discord adapter instance.
+    pub fn from_instance_config(instance: &DiscordInstanceConfig, bindings: &[Binding]) -> Self {
+        Self::from_bindings_for_adapter(
+            instance.dm_allowed_users.clone(),
+            instance.allow_bot_messages,
+            bindings,
+            Some(instance.name.as_str()),
+        )
+    }
+
+    fn from_bindings_for_adapter(
+        seed_dm_allowed_users: Vec<String>,
+        allow_bot_messages: bool,
+        bindings: &[Binding],
+        adapter_selector: Option<&str>,
+    ) -> Self {
+        let discord_bindings: Vec<&Binding> = bindings
+            .iter()
+            .filter(|binding| {
+                binding.channel == "discord"
+                    && binding_adapter_selector_matches(binding, adapter_selector)
+            })
+            .collect();
 
         let guild_filter = {
             let guild_ids: Vec<u64> = discord_bindings
@@ -1478,8 +1876,7 @@ impl DiscordPermissions {
             filter
         };
 
-        let mut dm_allowed_users: Vec<u64> = discord
-            .dm_allowed_users
+        let mut dm_allowed_users: Vec<u64> = seed_dm_allowed_users
             .iter()
             .filter_map(|id| id.parse::<u64>().ok())
             .collect();
@@ -1499,7 +1896,7 @@ impl DiscordPermissions {
             guild_filter,
             channel_filter,
             dm_allowed_users,
-            allow_bot_messages: discord.allow_bot_messages,
+            allow_bot_messages,
         }
     }
 }
@@ -1508,15 +1905,38 @@ impl DiscordPermissions {
 pub struct TelegramConfig {
     pub enabled: bool,
     pub token: String,
+    /// Additional named Telegram bot instances for this platform.
+    pub instances: Vec<TelegramInstanceConfig>,
     /// User IDs allowed to DM the bot. If empty, DMs are ignored entirely.
     pub dm_allowed_users: Vec<String>,
 }
 
+#[derive(Clone)]
+pub struct TelegramInstanceConfig {
+    pub name: String,
+    pub enabled: bool,
+    pub token: String,
+    /// User IDs allowed to DM this bot instance.
+    pub dm_allowed_users: Vec<String>,
+}
+
+impl std::fmt::Debug for TelegramInstanceConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("TelegramInstanceConfig")
+            .field("name", &self.name)
+            .field("enabled", &self.enabled)
+            .field("token", &"[REDACTED]")
+            .field("dm_allowed_users", &self.dm_allowed_users)
+            .finish()
+    }
+}
+
 impl std::fmt::Debug for TelegramConfig {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("TelegramConfig")
             .field("enabled", &self.enabled)
             .field("token", &"[REDACTED]")
+            .field("instances", &self.instances)
             .field("dm_allowed_users", &self.dm_allowed_users)
             .finish()
     }
@@ -1542,6 +1962,57 @@ pub struct EmailConfig {
     pub allowed_senders: Vec<String>,
     pub max_body_bytes: usize,
     pub max_attachment_bytes: usize,
+    pub instances: Vec<EmailInstanceConfig>,
+}
+
+/// Per-instance config for a named email adapter.
+#[derive(Clone)]
+pub struct EmailInstanceConfig {
+    pub name: String,
+    pub enabled: bool,
+    pub imap_host: String,
+    pub imap_port: u16,
+    pub imap_username: String,
+    pub imap_password: String,
+    pub imap_use_tls: bool,
+    pub smtp_host: String,
+    pub smtp_port: u16,
+    pub smtp_username: String,
+    pub smtp_password: String,
+    pub smtp_use_starttls: bool,
+    pub from_address: String,
+    pub from_name: Option<String>,
+    pub poll_interval_secs: u64,
+    pub folders: Vec<String>,
+    pub allowed_senders: Vec<String>,
+    pub max_body_bytes: usize,
+    pub max_attachment_bytes: usize,
+}
+
+impl std::fmt::Debug for EmailInstanceConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("EmailInstanceConfig")
+            .field("name", &self.name)
+            .field("enabled", &self.enabled)
+            .field("imap_host", &self.imap_host)
+            .field("imap_port", &self.imap_port)
+            .field("imap_username", &"[REDACTED]")
+            .field("imap_password", &"[REDACTED]")
+            .field("imap_use_tls", &self.imap_use_tls)
+            .field("smtp_host", &self.smtp_host)
+            .field("smtp_port", &self.smtp_port)
+            .field("smtp_username", &"[REDACTED]")
+            .field("smtp_password", &"[REDACTED]")
+            .field("smtp_use_starttls", &self.smtp_use_starttls)
+            .field("from_address", &"[REDACTED]")
+            .field("from_name", &self.from_name)
+            .field("poll_interval_secs", &self.poll_interval_secs)
+            .field("folders", &self.folders)
+            .field("allowed_senders", &"[REDACTED]")
+            .field("max_body_bytes", &self.max_body_bytes)
+            .field("max_attachment_bytes", &self.max_attachment_bytes)
+            .finish()
+    }
 }
 
 impl std::fmt::Debug for EmailConfig {
@@ -1583,9 +2054,29 @@ pub struct TelegramPermissions {
 impl TelegramPermissions {
     /// Build from the current config's telegram settings and bindings.
     pub fn from_config(telegram: &TelegramConfig, bindings: &[Binding]) -> Self {
+        Self::from_bindings_for_adapter(telegram.dm_allowed_users.clone(), bindings, None)
+    }
+
+    /// Build permissions for a named Telegram adapter instance.
+    pub fn from_instance_config(instance: &TelegramInstanceConfig, bindings: &[Binding]) -> Self {
+        Self::from_bindings_for_adapter(
+            instance.dm_allowed_users.clone(),
+            bindings,
+            Some(instance.name.as_str()),
+        )
+    }
+
+    fn from_bindings_for_adapter(
+        seed_dm_allowed_users: Vec<String>,
+        bindings: &[Binding],
+        adapter_selector: Option<&str>,
+    ) -> Self {
         let telegram_bindings: Vec<&Binding> = bindings
             .iter()
-            .filter(|b| b.channel == "telegram")
+            .filter(|binding| {
+                binding.channel == "telegram"
+                    && binding_adapter_selector_matches(binding, adapter_selector)
+            })
             .collect();
 
         let chat_filter = {
@@ -1600,8 +2091,7 @@ impl TelegramPermissions {
             }
         };
 
-        let mut dm_allowed_users: Vec<i64> = telegram
-            .dm_allowed_users
+        let mut dm_allowed_users: Vec<i64> = seed_dm_allowed_users
             .iter()
             .filter_map(|id| id.parse::<i64>().ok())
             .collect();
@@ -1631,18 +2121,58 @@ pub struct TwitchConfig {
     pub client_id: Option<String>,
     pub client_secret: Option<String>,
     pub refresh_token: Option<String>,
+    /// Additional named Twitch bot instances for this platform.
+    pub instances: Vec<TwitchInstanceConfig>,
     /// Channels to join (without the # prefix).
     pub channels: Vec<String>,
     /// Optional prefix that triggers the bot (e.g. "!ask"). If empty, all messages are processed.
     pub trigger_prefix: Option<String>,
 }
 
+#[derive(Clone)]
+pub struct TwitchInstanceConfig {
+    pub name: String,
+    pub enabled: bool,
+    pub username: String,
+    pub oauth_token: String,
+    pub client_id: Option<String>,
+    pub client_secret: Option<String>,
+    pub refresh_token: Option<String>,
+    /// Channels to join (without the # prefix).
+    pub channels: Vec<String>,
+    /// Optional prefix that triggers the bot for this instance.
+    pub trigger_prefix: Option<String>,
+}
+
+impl std::fmt::Debug for TwitchInstanceConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("TwitchInstanceConfig")
+            .field("name", &self.name)
+            .field("enabled", &self.enabled)
+            .field("username", &self.username)
+            .field("oauth_token", &"[REDACTED]")
+            .field("client_id", &self.client_id)
+            .field(
+                "client_secret",
+                &self.client_secret.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field(
+                "refresh_token",
+                &self.refresh_token.as_ref().map(|_| "[REDACTED]"),
+            )
+            .field("channels", &self.channels)
+            .field("trigger_prefix", &self.trigger_prefix)
+            .finish()
+    }
+}
+
 impl std::fmt::Debug for TwitchConfig {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("TwitchConfig")
             .field("enabled", &self.enabled)
             .field("username", &self.username)
             .field("oauth_token", &"[REDACTED]")
+            .field("instances", &self.instances)
             .field("channels", &self.channels)
             .field("trigger_prefix", &self.trigger_prefix)
             .finish()
@@ -1663,8 +2193,22 @@ pub struct TwitchPermissions {
 impl TwitchPermissions {
     /// Build from the current config's twitch settings and bindings.
     pub fn from_config(_twitch: &TwitchConfig, bindings: &[Binding]) -> Self {
-        let twitch_bindings: Vec<&Binding> =
-            bindings.iter().filter(|b| b.channel == "twitch").collect();
+        Self::from_bindings_for_adapter(bindings, None)
+    }
+
+    /// Build permissions for a named Twitch adapter instance.
+    pub fn from_instance_config(instance: &TwitchInstanceConfig, bindings: &[Binding]) -> Self {
+        Self::from_bindings_for_adapter(bindings, Some(instance.name.as_str()))
+    }
+
+    fn from_bindings_for_adapter(bindings: &[Binding], adapter_selector: Option<&str>) -> Self {
+        let twitch_bindings: Vec<&Binding> = bindings
+            .iter()
+            .filter(|binding| {
+                binding.channel == "twitch"
+                    && binding_adapter_selector_matches(binding, adapter_selector)
+            })
+            .collect();
 
         let channel_filter = {
             let channel_ids: Vec<String> = twitch_bindings
@@ -1694,6 +2238,16 @@ impl TwitchPermissions {
     }
 }
 
+fn binding_adapter_selector_matches(binding: &Binding, adapter_selector: Option<&str>) -> bool {
+    match (binding.adapter.as_deref(), adapter_selector) {
+        (None, None) => true,
+        (Some(binding_selector), Some(requested_selector)) => {
+            binding_selector == requested_selector
+        }
+        _ => false,
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct WebhookConfig {
     pub enabled: bool,
@@ -2166,6 +2720,20 @@ struct TomlMessagingConfig {
 
 #[derive(Deserialize)]
 struct TomlDiscordConfig {
+    #[serde(default)]
+    enabled: bool,
+    token: Option<String>,
+    #[serde(default)]
+    instances: Vec<TomlDiscordInstanceConfig>,
+    #[serde(default)]
+    dm_allowed_users: Vec<String>,
+    #[serde(default)]
+    allow_bot_messages: bool,
+}
+
+#[derive(Deserialize)]
+struct TomlDiscordInstanceConfig {
+    name: String,
     #[serde(default)]
     enabled: bool,
     token: Option<String>,
@@ -2177,6 +2745,21 @@ struct TomlDiscordConfig {
 
 #[derive(Deserialize)]
 struct TomlSlackConfig {
+    #[serde(default)]
+    enabled: bool,
+    bot_token: Option<String>,
+    app_token: Option<String>,
+    #[serde(default)]
+    instances: Vec<TomlSlackInstanceConfig>,
+    #[serde(default)]
+    dm_allowed_users: Vec<String>,
+    #[serde(default)]
+    commands: Vec<TomlSlackCommandConfig>,
+}
+
+#[derive(Deserialize)]
+struct TomlSlackInstanceConfig {
+    name: String,
     #[serde(default)]
     enabled: bool,
     bot_token: Option<String>,
@@ -2196,6 +2779,18 @@ struct TomlSlackCommandConfig {
 
 #[derive(Deserialize)]
 struct TomlTelegramConfig {
+    #[serde(default)]
+    enabled: bool,
+    token: Option<String>,
+    #[serde(default)]
+    instances: Vec<TomlTelegramInstanceConfig>,
+    #[serde(default)]
+    dm_allowed_users: Vec<String>,
+}
+
+#[derive(Deserialize)]
+struct TomlTelegramInstanceConfig {
+    name: String,
     #[serde(default)]
     enabled: bool,
     token: Option<String>,
@@ -2233,6 +2828,41 @@ struct TomlEmailConfig {
     max_body_bytes: usize,
     #[serde(default = "default_email_max_attachment_bytes")]
     max_attachment_bytes: usize,
+    #[serde(default)]
+    instances: Vec<TomlEmailInstanceConfig>,
+}
+
+#[derive(Deserialize)]
+struct TomlEmailInstanceConfig {
+    name: String,
+    #[serde(default)]
+    enabled: bool,
+    imap_host: Option<String>,
+    #[serde(default = "default_email_imap_port")]
+    imap_port: u16,
+    imap_username: Option<String>,
+    imap_password: Option<String>,
+    #[serde(default = "default_email_imap_use_tls")]
+    imap_use_tls: bool,
+    smtp_host: Option<String>,
+    #[serde(default = "default_email_smtp_port")]
+    smtp_port: u16,
+    smtp_username: Option<String>,
+    smtp_password: Option<String>,
+    #[serde(default = "default_email_smtp_use_starttls")]
+    smtp_use_starttls: bool,
+    from_address: Option<String>,
+    from_name: Option<String>,
+    #[serde(default = "default_email_poll_interval_secs")]
+    poll_interval_secs: u64,
+    #[serde(default = "default_email_folders")]
+    folders: Vec<String>,
+    #[serde(default)]
+    allowed_senders: Vec<String>,
+    #[serde(default = "default_email_max_body_bytes")]
+    max_body_bytes: usize,
+    #[serde(default = "default_email_max_attachment_bytes")]
+    max_attachment_bytes: usize,
 }
 
 #[derive(Deserialize)]
@@ -2248,6 +2878,23 @@ struct TomlWebhookConfig {
 
 #[derive(Deserialize)]
 struct TomlTwitchConfig {
+    #[serde(default)]
+    enabled: bool,
+    username: Option<String>,
+    oauth_token: Option<String>,
+    client_id: Option<String>,
+    client_secret: Option<String>,
+    refresh_token: Option<String>,
+    #[serde(default)]
+    instances: Vec<TomlTwitchInstanceConfig>,
+    #[serde(default)]
+    channels: Vec<String>,
+    trigger_prefix: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct TomlTwitchInstanceConfig {
+    name: String,
     #[serde(default)]
     enabled: bool,
     username: Option<String>,
@@ -2303,6 +2950,8 @@ fn default_email_max_attachment_bytes() -> usize {
 struct TomlBinding {
     agent_id: String,
     channel: String,
+    #[serde(default)]
+    adapter: Option<String>,
     guild_id: Option<String>,
     workspace_id: Option<String>,
     chat_id: Option<String>,
@@ -3930,35 +4579,96 @@ impl Config {
             first.default = true;
         }
 
-        let messaging = MessagingConfig {
-            discord: toml.messaging.discord.and_then(|d| {
-                let token = d
-                    .token
-                    .as_deref()
-                    .and_then(resolve_env_value)
-                    .or_else(|| std::env::var("DISCORD_BOT_TOKEN").ok())?;
+        let messaging = MessagingConfig {
+            discord: toml.messaging.discord.and_then(|d| {
+                let instances = d
+                    .instances
+                    .into_iter()
+                    .map(|instance| {
+                        let token = instance.token.as_deref().and_then(resolve_env_value);
+                        if instance.enabled && token.is_none() {
+                            tracing::warn!(
+                                adapter = %instance.name,
+                                "discord instance is enabled but token is missing/unresolvable — disabling"
+                            );
+                        }
+                        DiscordInstanceConfig {
+                            name: instance.name,
+                            enabled: instance.enabled && token.is_some(),
+                            token: token.unwrap_or_default(),
+                            dm_allowed_users: instance.dm_allowed_users,
+                            allow_bot_messages: instance.allow_bot_messages,
+                        }
+                    })
+                    .collect::<Vec<_>>();
+
+                let token = std::env::var("DISCORD_BOT_TOKEN")
+                    .ok()
+                    .or_else(|| d.token.as_deref().and_then(resolve_env_value));
+
+                if token.is_none() && instances.is_empty() {
+                    return None;
+                }
+
                 Some(DiscordConfig {
                     enabled: d.enabled,
-                    token,
+                    token: token.unwrap_or_default(),
+                    instances,
                     dm_allowed_users: d.dm_allowed_users,
                     allow_bot_messages: d.allow_bot_messages,
                 })
             }),
             slack: toml.messaging.slack.and_then(|s| {
-                let bot_token = s
-                    .bot_token
-                    .as_deref()
-                    .and_then(resolve_env_value)
-                    .or_else(|| std::env::var("SLACK_BOT_TOKEN").ok())?;
-                let app_token = s
-                    .app_token
-                    .as_deref()
-                    .and_then(resolve_env_value)
-                    .or_else(|| std::env::var("SLACK_APP_TOKEN").ok())?;
+                let instances = s
+                    .instances
+                    .into_iter()
+                    .map(|instance| {
+                        let bot_token =
+                            instance.bot_token.as_deref().and_then(resolve_env_value);
+                        let app_token =
+                            instance.app_token.as_deref().and_then(resolve_env_value);
+                        if instance.enabled && (bot_token.is_none() || app_token.is_none()) {
+                            tracing::warn!(
+                                adapter = %instance.name,
+                                "slack instance is enabled but tokens are missing/unresolvable — disabling"
+                            );
+                        }
+                        let has_credentials = bot_token.is_some() && app_token.is_some();
+                        SlackInstanceConfig {
+                            name: instance.name,
+                            enabled: instance.enabled && has_credentials,
+                            bot_token: bot_token.unwrap_or_default(),
+                            app_token: app_token.unwrap_or_default(),
+                            dm_allowed_users: instance.dm_allowed_users,
+                            commands: instance
+                                .commands
+                                .into_iter()
+                                .map(|command| SlackCommandConfig {
+                                    command: command.command,
+                                    agent_id: command.agent_id,
+                                    description: command.description,
+                                })
+                                .collect(),
+                        }
+                    })
+                    .collect::<Vec<_>>();
+
+                let bot_token = std::env::var("SLACK_BOT_TOKEN")
+                    .ok()
+                    .or_else(|| s.bot_token.as_deref().and_then(resolve_env_value));
+                let app_token = std::env::var("SLACK_APP_TOKEN")
+                    .ok()
+                    .or_else(|| s.app_token.as_deref().and_then(resolve_env_value));
+
+                if (bot_token.is_none() || app_token.is_none()) && instances.is_empty() {
+                    return None;
+                }
+
                 Some(SlackConfig {
                     enabled: s.enabled,
-                    bot_token,
-                    app_token,
+                    bot_token: bot_token.unwrap_or_default(),
+                    app_token: app_token.unwrap_or_default(),
+                    instances,
                     dm_allowed_users: s.dm_allowed_users,
                     commands: s
                         .commands
@@ -3972,31 +4682,141 @@ impl Config {
                 })
             }),
             telegram: toml.messaging.telegram.and_then(|t| {
-                let token = t
-                    .token
-                    .as_deref()
-                    .and_then(resolve_env_value)
-                    .or_else(|| std::env::var("TELEGRAM_BOT_TOKEN").ok())?;
+                let instances = t
+                    .instances
+                    .into_iter()
+                    .map(|instance| {
+                        let token = instance.token.as_deref().and_then(resolve_env_value);
+                        if instance.enabled && token.is_none() {
+                            tracing::warn!(
+                                adapter = %instance.name,
+                                "telegram instance is enabled but token is missing/unresolvable — disabling"
+                            );
+                        }
+                        TelegramInstanceConfig {
+                            name: instance.name,
+                            enabled: instance.enabled && token.is_some(),
+                            token: token.unwrap_or_default(),
+                            dm_allowed_users: instance.dm_allowed_users,
+                        }
+                    })
+                    .collect::<Vec<_>>();
+
+                let token = std::env::var("TELEGRAM_BOT_TOKEN")
+                    .ok()
+                    .or_else(|| t.token.as_deref().and_then(resolve_env_value));
+
+                if token.is_none() && instances.is_empty() {
+                    return None;
+                }
+
                 Some(TelegramConfig {
                     enabled: t.enabled,
-                    token,
+                    token: token.unwrap_or_default(),
+                    instances,
                     dm_allowed_users: t.dm_allowed_users,
                 })
             }),
             email: toml.messaging.email.and_then(|email| {
+                let instances = email
+                    .instances
+                    .into_iter()
+                    .map(|instance| {
+                        let imap_host =
+                            instance.imap_host.as_deref().and_then(resolve_env_value);
+                        let imap_username =
+                            instance.imap_username.as_deref().and_then(resolve_env_value);
+                        let imap_password =
+                            instance.imap_password.as_deref().and_then(resolve_env_value);
+                        let smtp_host =
+                            instance.smtp_host.as_deref().and_then(resolve_env_value);
+
+                        let has_credentials = imap_host.is_some()
+                            && imap_username.is_some()
+                            && imap_password.is_some()
+                            && smtp_host.is_some();
+
+                        if instance.enabled && !has_credentials {
+                            tracing::warn!(
+                                adapter = %instance.name,
+                                "email instance is enabled but credentials are missing/unresolvable — disabling"
+                            );
+                        }
+
+                        let imap_username_val = imap_username.unwrap_or_default();
+                        let imap_password_val = imap_password.unwrap_or_default();
+                        let smtp_username = instance
+                            .smtp_username
+                            .as_deref()
+                            .and_then(resolve_env_value)
+                            .unwrap_or_else(|| imap_username_val.clone());
+                        let smtp_password = instance
+                            .smtp_password
+                            .as_deref()
+                            .and_then(resolve_env_value)
+                            .unwrap_or_else(|| imap_password_val.clone());
+                        let from_address = instance
+                            .from_address
+                            .as_deref()
+                            .and_then(resolve_env_value)
+                            .unwrap_or_else(|| smtp_username.clone());
+                        let from_name =
+                            instance.from_name.as_deref().and_then(resolve_env_value);
+
+                        EmailInstanceConfig {
+                            name: instance.name,
+                            enabled: instance.enabled && has_credentials,
+                            imap_host: imap_host.unwrap_or_default(),
+                            imap_port: instance.imap_port,
+                            imap_username: imap_username_val,
+                            imap_password: imap_password_val,
+                            imap_use_tls: instance.imap_use_tls,
+                            smtp_host: smtp_host.unwrap_or_default(),
+                            smtp_port: instance.smtp_port,
+                            smtp_username,
+                            smtp_password,
+                            smtp_use_starttls: instance.smtp_use_starttls,
+                            from_address,
+                            from_name,
+                            poll_interval_secs: instance.poll_interval_secs,
+                            folders: if instance.folders.is_empty() {
+                                vec!["INBOX".to_string()]
+                            } else {
+                                instance.folders
+                            },
+                            allowed_senders: instance.allowed_senders,
+                            max_body_bytes: instance.max_body_bytes,
+                            max_attachment_bytes: instance.max_attachment_bytes,
+                        }
+                    })
+                    .collect::<Vec<_>>();
+
                 let imap_host = std::env::var("EMAIL_IMAP_HOST")
                     .ok()
-                    .or_else(|| email.imap_host.as_deref().and_then(resolve_env_value))?;
+                    .or_else(|| email.imap_host.as_deref().and_then(resolve_env_value));
                 let imap_username = std::env::var("EMAIL_IMAP_USERNAME")
                     .ok()
-                    .or_else(|| email.imap_username.as_deref().and_then(resolve_env_value))?;
+                    .or_else(|| email.imap_username.as_deref().and_then(resolve_env_value));
                 let imap_password = std::env::var("EMAIL_IMAP_PASSWORD")
                     .ok()
-                    .or_else(|| email.imap_password.as_deref().and_then(resolve_env_value))?;
-
+                    .or_else(|| email.imap_password.as_deref().and_then(resolve_env_value));
                 let smtp_host = std::env::var("EMAIL_SMTP_HOST")
                     .ok()
-                    .or_else(|| email.smtp_host.as_deref().and_then(resolve_env_value))?;
+                    .or_else(|| email.smtp_host.as_deref().and_then(resolve_env_value));
+
+                let has_default = imap_host.is_some()
+                    && imap_username.is_some()
+                    && imap_password.is_some()
+                    && smtp_host.is_some();
+
+                if !has_default && instances.is_empty() {
+                    return None;
+                }
+
+                let imap_host = imap_host.unwrap_or_default();
+                let imap_username = imap_username.unwrap_or_default();
+                let imap_password = imap_password.unwrap_or_default();
+                let smtp_host = smtp_host.unwrap_or_default();
                 let smtp_username = std::env::var("EMAIL_SMTP_USERNAME")
                     .ok()
                     .or_else(|| email.smtp_username.as_deref().and_then(resolve_env_value))
@@ -4037,6 +4857,7 @@ impl Config {
                     allowed_senders: email.allowed_senders,
                     max_body_bytes: email.max_body_bytes,
                     max_attachment_bytes: email.max_attachment_bytes,
+                    instances,
                 })
             }),
             webhook: toml.messaging.webhook.map(|w| WebhookConfig {
@@ -4046,16 +4867,56 @@ impl Config {
                 auth_token: w.auth_token.as_deref().and_then(resolve_env_value),
             }),
             twitch: toml.messaging.twitch.and_then(|t| {
-                let username = t
-                    .username
-                    .as_deref()
-                    .and_then(resolve_env_value)
-                    .or_else(|| std::env::var("TWITCH_BOT_USERNAME").ok())?;
-                let oauth_token = t
-                    .oauth_token
-                    .as_deref()
-                    .and_then(resolve_env_value)
-                    .or_else(|| std::env::var("TWITCH_OAUTH_TOKEN").ok())?;
+                let instances = t
+                    .instances
+                    .into_iter()
+                    .map(|instance| {
+                        let username = instance.username.as_deref().and_then(resolve_env_value);
+                        let oauth_token = instance
+                            .oauth_token
+                            .as_deref()
+                            .and_then(resolve_env_value);
+                        if instance.enabled && (username.is_none() || oauth_token.is_none()) {
+                            tracing::warn!(
+                                adapter = %instance.name,
+                                "twitch instance is enabled but credentials are missing/unresolvable — disabling"
+                            );
+                        }
+                        let has_credentials = username.is_some() && oauth_token.is_some();
+                        let client_id = instance.client_id.as_deref().and_then(resolve_env_value);
+                        let client_secret = instance
+                            .client_secret
+                            .as_deref()
+                            .and_then(resolve_env_value);
+                        let refresh_token = instance
+                            .refresh_token
+                            .as_deref()
+                            .and_then(resolve_env_value);
+                        TwitchInstanceConfig {
+                            name: instance.name,
+                            enabled: instance.enabled && has_credentials,
+                            username: username.unwrap_or_default(),
+                            oauth_token: oauth_token.unwrap_or_default(),
+                            client_id,
+                            client_secret,
+                            refresh_token,
+                            channels: instance.channels,
+                            trigger_prefix: instance.trigger_prefix,
+                        }
+                    })
+                    .collect::<Vec<_>>();
+
+                let username = std::env::var("TWITCH_BOT_USERNAME")
+                    .ok()
+                    .or_else(|| t.username.as_deref().and_then(resolve_env_value));
+                let oauth_token = std::env::var("TWITCH_OAUTH_TOKEN")
+                    .ok()
+                    .or_else(|| t.oauth_token.as_deref().and_then(resolve_env_value));
+
+                if (username.is_none() || oauth_token.is_none()) && instances.is_empty() {
+                    return None;
+                }
+
                 let client_id = t
                     .client_id
                     .as_deref()
@@ -4073,23 +4934,25 @@ impl Config {
                     .or_else(|| std::env::var("TWITCH_REFRESH_TOKEN").ok());
                 Some(TwitchConfig {
                     enabled: t.enabled,
-                    username,
-                    oauth_token,
+                    username: username.unwrap_or_default(),
+                    oauth_token: oauth_token.unwrap_or_default(),
                     client_id,
                     client_secret,
                     refresh_token,
+                    instances,
                     channels: t.channels,
                     trigger_prefix: t.trigger_prefix,
                 })
             }),
         };
 
-        let bindings = toml
+        let bindings: Vec<Binding> = toml
             .bindings
             .into_iter()
             .map(|b| Binding {
                 agent_id: b.agent_id,
                 channel: b.channel,
+                adapter: normalize_adapter(b.adapter),
                 guild_id: b.guild_id,
                 workspace_id: b.workspace_id,
                 chat_id: b.chat_id,
@@ -4099,6 +4962,8 @@ impl Config {
             })
             .collect();
 
+        validate_named_messaging_adapters(&messaging, &bindings)?;
+
         let api = ApiConfig {
             enabled: toml.api.enabled,
             port: toml.api.port,
@@ -4664,110 +5529,283 @@ pub fn spawn_file_watcher(
                     let instance_dir = instance_dir.clone();
 
                     rt.spawn(async move {
-                        // Discord: start if enabled and not already running
+                        // Discord: start default + named instances that are enabled and not already running.
                         if let Some(discord_config) = &config.messaging.discord
-                            && discord_config.enabled && !manager.has_adapter("discord").await {
-                                let perms = match discord_permissions {
-                                    Some(ref existing) => existing.clone(),
-                                    None => {
-                                        let perms = DiscordPermissions::from_config(discord_config, &config.bindings);
-                                        Arc::new(arc_swap::ArcSwap::from_pointee(perms))
+                            && discord_config.enabled {
+                                if !discord_config.token.is_empty() && !manager.has_adapter("discord").await {
+                                    let permissions = match discord_permissions {
+                                        Some(ref existing) => existing.clone(),
+                                        None => {
+                                            let permissions = DiscordPermissions::from_config(discord_config, &config.bindings);
+                                            Arc::new(arc_swap::ArcSwap::from_pointee(permissions))
+                                        }
+                                    };
+                                    let adapter = crate::messaging::discord::DiscordAdapter::new(
+                                        "discord",
+                                        &discord_config.token,
+                                        permissions,
+                                    );
+                                    if let Err(error) = manager.register_and_start(adapter).await {
+                                        tracing::error!(%error, "failed to hot-start discord adapter from config change");
+                                    }
+                                }
+
+                                for instance in discord_config.instances.iter().filter(|instance| instance.enabled) {
+                                    let runtime_key = binding_runtime_adapter_key(
+                                        "discord",
+                                        Some(instance.name.as_str()),
+                                    );
+                                    if manager.has_adapter(runtime_key.as_str()).await {
+                                        // TODO: named instance permissions are not hot-updated on
+                                        // config reload because each instance owns its own
+                                        // Arc<ArcSwap> with no external handle. Fixing this
+                                        // requires either a permission-update method on the
+                                        // Messaging trait or a shared handle registry. Permissions
+                                        // will be correct after a full restart.
+                                        continue;
+                                    }
+
+                                    let permissions = Arc::new(arc_swap::ArcSwap::from_pointee(
+                                        DiscordPermissions::from_instance_config(instance, &config.bindings),
+                                    ));
+                                    let adapter = crate::messaging::discord::DiscordAdapter::new(
+                                        runtime_key,
+                                        &instance.token,
+                                        permissions,
+                                    );
+                                    if let Err(error) = manager.register_and_start(adapter).await {
+                                        tracing::error!(%error, adapter = %instance.name, "failed to hot-start named discord adapter from config change");
                                     }
-                                };
-                                let adapter = crate::messaging::discord::DiscordAdapter::new(
-                                    &discord_config.token,
-                                    perms,
-                                );
-                                if let Err(error) = manager.register_and_start(adapter).await {
-                                    tracing::error!(%error, "failed to hot-start discord adapter from config change");
                                 }
                             }
 
-                        // Slack: start if enabled and not already running
+                        // Slack: start default + named instances that are enabled and not already running.
                         if let Some(slack_config) = &config.messaging.slack
-                            && slack_config.enabled && !manager.has_adapter("slack").await {
-                                let perms = match slack_permissions {
-                                    Some(ref existing) => existing.clone(),
-                                    None => {
-                                        let perms = SlackPermissions::from_config(slack_config, &config.bindings);
-                                        Arc::new(arc_swap::ArcSwap::from_pointee(perms))
-                                    }
-                                };
-                                match crate::messaging::slack::SlackAdapter::new(
-                                    &slack_config.bot_token,
-                                    &slack_config.app_token,
-                                    perms,
-                                    slack_config.commands.clone(),
-                                ) {
-                                    Ok(adapter) => {
-                                        if let Err(error) = manager.register_and_start(adapter).await {
-                                            tracing::error!(%error, "failed to hot-start slack adapter from config change");
+                            && slack_config.enabled {
+                                if !slack_config.bot_token.is_empty()
+                                    && !slack_config.app_token.is_empty()
+                                    && !manager.has_adapter("slack").await
+                                {
+                                    let permissions = match slack_permissions {
+                                        Some(ref existing) => existing.clone(),
+                                        None => {
+                                            let permissions = SlackPermissions::from_config(slack_config, &config.bindings);
+                                            Arc::new(arc_swap::ArcSwap::from_pointee(permissions))
                                         }
+                                    };
+                                    match crate::messaging::slack::SlackAdapter::new(
+                                        "slack",
+                                        &slack_config.bot_token,
+                                        &slack_config.app_token,
+                                        permissions,
+                                        slack_config.commands.clone(),
+                                    ) {
+                                        Ok(adapter) => {
+                                            if let Err(error) = manager.register_and_start(adapter).await {
+                                                tracing::error!(%error, "failed to hot-start slack adapter from config change");
+                                            }
+                                        }
+                                        Err(error) => {
+                                            tracing::error!(%error, "failed to build slack adapter from config change");
+                                        }
+                                    }
+                                }
+
+                                for instance in slack_config.instances.iter().filter(|instance| instance.enabled) {
+                                    let runtime_key = binding_runtime_adapter_key(
+                                        "slack",
+                                        Some(instance.name.as_str()),
+                                    );
+                                    if manager.has_adapter(runtime_key.as_str()).await {
+                                        // TODO: named instance permissions not hot-updated (see discord block comment)
+                                        continue;
                                     }
-                                    Err(error) => {
-                                        tracing::error!(%error, "failed to build slack adapter from config change");
+
+                                    let permissions = Arc::new(arc_swap::ArcSwap::from_pointee(
+                                        SlackPermissions::from_instance_config(instance, &config.bindings),
+                                    ));
+                                    match crate::messaging::slack::SlackAdapter::new(
+                                        runtime_key,
+                                        &instance.bot_token,
+                                        &instance.app_token,
+                                        permissions,
+                                        instance.commands.clone(),
+                                    ) {
+                                        Ok(adapter) => {
+                                            if let Err(error) = manager.register_and_start(adapter).await {
+                                                tracing::error!(%error, adapter = %instance.name, "failed to hot-start named slack adapter from config change");
+                                            }
+                                        }
+                                        Err(error) => {
+                                            tracing::error!(%error, adapter = %instance.name, "failed to build named slack adapter from config change");
+                                        }
                                     }
                                 }
                             }
 
-                        // Telegram: start if enabled and not already running
+                        // Telegram: start default + named instances that are enabled and not already running.
                         if let Some(telegram_config) = &config.messaging.telegram
-                            && telegram_config.enabled && !manager.has_adapter("telegram").await {
-                                let perms = match telegram_permissions {
-                                    Some(ref existing) => existing.clone(),
-                                    None => {
-                                        let perms = TelegramPermissions::from_config(telegram_config, &config.bindings);
-                                        Arc::new(arc_swap::ArcSwap::from_pointee(perms))
+                            && telegram_config.enabled {
+                                if !telegram_config.token.is_empty()
+                                    && !manager.has_adapter("telegram").await
+                                {
+                                    let permissions = match telegram_permissions {
+                                        Some(ref existing) => existing.clone(),
+                                        None => {
+                                            let permissions = TelegramPermissions::from_config(telegram_config, &config.bindings);
+                                            Arc::new(arc_swap::ArcSwap::from_pointee(permissions))
+                                        }
+                                    };
+                                    let adapter = crate::messaging::telegram::TelegramAdapter::new(
+                                        "telegram",
+                                        &telegram_config.token,
+                                        permissions,
+                                    );
+                                    if let Err(error) = manager.register_and_start(adapter).await {
+                                        tracing::error!(%error, "failed to hot-start telegram adapter from config change");
+                                    }
+                                }
+
+                                for instance in telegram_config.instances.iter().filter(|instance| instance.enabled) {
+                                    let runtime_key = binding_runtime_adapter_key(
+                                        "telegram",
+                                        Some(instance.name.as_str()),
+                                    );
+                                    if manager.has_adapter(runtime_key.as_str()).await {
+                                        // TODO: named instance permissions not hot-updated (see discord block comment)
+                                        continue;
+                                    }
+
+                                    let permissions = Arc::new(arc_swap::ArcSwap::from_pointee(
+                                        TelegramPermissions::from_instance_config(instance, &config.bindings),
+                                    ));
+                                    let adapter = crate::messaging::telegram::TelegramAdapter::new(
+                                        runtime_key,
+                                        &instance.token,
+                                        permissions,
+                                    );
+                                    if let Err(error) = manager.register_and_start(adapter).await {
+                                        tracing::error!(%error, adapter = %instance.name, "failed to hot-start named telegram adapter from config change");
                                     }
-                                };
-                                let adapter = crate::messaging::telegram::TelegramAdapter::new(
-                                    &telegram_config.token,
-                                    perms,
-                                );
-                                if let Err(error) = manager.register_and_start(adapter).await {
-                                    tracing::error!(%error, "failed to hot-start telegram adapter from config change");
                                 }
                             }
 
-                        // Email: start if enabled and not already running
+                        // Email: start default + named instances that are enabled and not already running.
                         if let Some(email_config) = &config.messaging.email
-                            && email_config.enabled && !manager.has_adapter("email").await {
-                                match crate::messaging::email::EmailAdapter::from_config(email_config) {
-                                    Ok(adapter) => {
-                                        if let Err(error) = manager.register_and_start(adapter).await {
-                                            tracing::error!(%error, "failed to hot-start email adapter from config change");
+                            && email_config.enabled {
+                                if !email_config.imap_host.is_empty() && !manager.has_adapter("email").await {
+                                    match crate::messaging::email::EmailAdapter::from_config(email_config) {
+                                        Ok(adapter) => {
+                                            if let Err(error) = manager.register_and_start(adapter).await {
+                                                tracing::error!(%error, "failed to hot-start email adapter from config change");
+                                            }
                                         }
+                                        Err(error) => {
+                                            tracing::error!(%error, "failed to build email adapter from config change");
+                                        }
+                                    }
+                                }
+
+                                for instance in email_config.instances.iter().filter(|instance| instance.enabled) {
+                                    let runtime_key = binding_runtime_adapter_key(
+                                        "email",
+                                        Some(instance.name.as_str()),
+                                    );
+                                    if manager.has_adapter(runtime_key.as_str()).await {
+                                        continue;
                                     }
-                                    Err(error) => {
-                                        tracing::error!(%error, "failed to build email adapter from config change");
+
+                                    match crate::messaging::email::EmailAdapter::from_instance_config(
+                                        runtime_key.as_str(),
+                                        instance,
+                                    ) {
+                                        Ok(adapter) => {
+                                            if let Err(error) = manager.register_and_start(adapter).await {
+                                                tracing::error!(%error, adapter = %instance.name, "failed to hot-start named email adapter from config change");
+                                            }
+                                        }
+                                        Err(error) => {
+                                            tracing::error!(%error, adapter = %instance.name, "failed to build named email adapter from config change");
+                                        }
                                     }
                                 }
                             }
 
-                        // Twitch: start if enabled and not already running
+                        // Twitch: start default + named instances that are enabled and not already running.
                         if let Some(twitch_config) = &config.messaging.twitch
-                            && twitch_config.enabled && !manager.has_adapter("twitch").await {
-                                let perms = match twitch_permissions {
-                                    Some(ref existing) => existing.clone(),
-                                    None => {
-                                        let perms = TwitchPermissions::from_config(twitch_config, &config.bindings);
-                                        Arc::new(arc_swap::ArcSwap::from_pointee(perms))
+                            && twitch_config.enabled {
+                                if !twitch_config.username.is_empty()
+                                    && !twitch_config.oauth_token.is_empty()
+                                    && !manager.has_adapter("twitch").await
+                                {
+                                    let permissions = match twitch_permissions {
+                                        Some(ref existing) => existing.clone(),
+                                        None => {
+                                            let permissions = TwitchPermissions::from_config(twitch_config, &config.bindings);
+                                            Arc::new(arc_swap::ArcSwap::from_pointee(permissions))
+                                        }
+                                    };
+                                    let token_path = instance_dir.join("twitch_token.json");
+                                    let adapter = crate::messaging::twitch::TwitchAdapter::new(
+                                        "twitch",
+                                        &twitch_config.username,
+                                        &twitch_config.oauth_token,
+                                        twitch_config.client_id.clone(),
+                                        twitch_config.client_secret.clone(),
+                                        twitch_config.refresh_token.clone(),
+                                        Some(token_path),
+                                        twitch_config.channels.clone(),
+                                        twitch_config.trigger_prefix.clone(),
+                                        permissions,
+                                    );
+                                    if let Err(error) = manager.register_and_start(adapter).await {
+                                        tracing::error!(%error, "failed to hot-start twitch adapter from config change");
+                                    }
+                                }
+
+                                for instance in twitch_config.instances.iter().filter(|instance| instance.enabled) {
+                                    let runtime_key = binding_runtime_adapter_key(
+                                        "twitch",
+                                        Some(instance.name.as_str()),
+                                    );
+                                    if manager.has_adapter(runtime_key.as_str()).await {
+                                        // TODO: named instance permissions not hot-updated (see discord block comment)
+                                        continue;
+                                    }
+
+                                    let token_file_name = {
+                                        use std::hash::{Hash, Hasher};
+                                        let mut hasher = std::collections::hash_map::DefaultHasher::new();
+                                        instance.name.hash(&mut hasher);
+                                        let name_hash = hasher.finish();
+                                        format!(
+                                            "twitch_token_{}_{name_hash:016x}.json",
+                                            instance
+                                                .name
+                                                .chars()
+                                                .map(|ch| if ch.is_ascii_alphanumeric() { ch } else { '_' })
+                                                .collect::<String>()
+                                        )
+                                    };
+                                    let token_path = instance_dir.join(token_file_name);
+                                    let permissions = Arc::new(arc_swap::ArcSwap::from_pointee(
+                                        TwitchPermissions::from_instance_config(instance, &config.bindings),
+                                    ));
+                                    let adapter = crate::messaging::twitch::TwitchAdapter::new(
+                                        runtime_key,
+                                        &instance.username,
+                                        &instance.oauth_token,
+                                        instance.client_id.clone(),
+                                        instance.client_secret.clone(),
+                                        instance.refresh_token.clone(),
+                                        Some(token_path),
+                                        instance.channels.clone(),
+                                        instance.trigger_prefix.clone(),
+                                        permissions,
+                                    );
+                                    if let Err(error) = manager.register_and_start(adapter).await {
+                                        tracing::error!(%error, adapter = %instance.name, "failed to hot-start named twitch adapter from config change");
                                     }
-                                };
-                                let token_path = instance_dir.join("twitch_token.json");
-                                let adapter = crate::messaging::twitch::TwitchAdapter::new(
-                                    &twitch_config.username,
-                                    &twitch_config.oauth_token,
-                                    twitch_config.client_id.clone(),
-                                    twitch_config.client_secret.clone(),
-                                    twitch_config.refresh_token.clone(),
-                                    Some(token_path),
-                                    twitch_config.channels.clone(),
-                                    twitch_config.trigger_prefix.clone(),
-                                    perms,
-                                );
-                                if let Err(error) = manager.register_and_start(adapter).await {
-                                    tracing::error!(%error, "failed to hot-start twitch adapter from config change");
                                 }
                             }
                     });
@@ -5543,6 +6581,7 @@ bind = "127.0.0.1"
             enabled: true,
             bot_token: "xoxb-test".into(),
             app_token: "xapp-test".into(),
+            instances: vec![],
             dm_allowed_users,
             commands: vec![],
         }
@@ -5553,6 +6592,7 @@ bind = "127.0.0.1"
         Binding {
             agent_id: "test-agent".into(),
             channel: "slack".into(),
+            adapter: None,
             guild_id: None,
             workspace_id: workspace_id.map(String::from),
             chat_id: None,
@@ -6263,4 +7303,429 @@ startup_delay_secs = 2
             );
         }
     }
+
+    // --- Named Messaging Adapter Tests ---
+
+    #[test]
+    fn runtime_adapter_key_default() {
+        assert_eq!(binding_runtime_adapter_key("telegram", None), "telegram");
+    }
+
+    #[test]
+    fn runtime_adapter_key_named() {
+        assert_eq!(
+            binding_runtime_adapter_key("telegram", Some("support")),
+            "telegram:support"
+        );
+    }
+
+    #[test]
+    fn runtime_adapter_key_empty_name_is_default() {
+        assert_eq!(binding_runtime_adapter_key("discord", Some("")), "discord");
+    }
+
+    #[test]
+    fn binding_runtime_adapter_key_method() {
+        let binding = Binding {
+            agent_id: "main".into(),
+            channel: "telegram".into(),
+            adapter: Some("sales".into()),
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        };
+        assert_eq!(binding.runtime_adapter_key(), "telegram:sales");
+    }
+
+    #[test]
+    fn binding_uses_default_adapter() {
+        let binding = Binding {
+            agent_id: "main".into(),
+            channel: "discord".into(),
+            adapter: None,
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        };
+        assert!(binding.uses_default_adapter());
+    }
+
+    fn test_inbound_message(source: &str, adapter: Option<&str>) -> crate::InboundMessage {
+        crate::InboundMessage {
+            id: "test".into(),
+            source: source.into(),
+            adapter: adapter.map(String::from),
+            conversation_id: "conv".into(),
+            sender_id: "user1".into(),
+            agent_id: None,
+            content: crate::MessageContent::Text("hello".into()),
+            timestamp: chrono::Utc::now(),
+            metadata: Default::default(),
+            formatted_author: None,
+        }
+    }
+
+    #[test]
+    fn adapter_matches_default_binding_default_message() {
+        let binding = Binding {
+            agent_id: "main".into(),
+            channel: "telegram".into(),
+            adapter: None,
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        };
+        let message = test_inbound_message("telegram", None);
+        assert!(binding_adapter_matches(&binding, &message));
+    }
+
+    #[test]
+    fn adapter_matches_named_binding_named_message() {
+        let binding = Binding {
+            agent_id: "main".into(),
+            channel: "telegram".into(),
+            adapter: Some("support".into()),
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        };
+        let message = test_inbound_message("telegram", Some("telegram:support"));
+        assert!(binding_adapter_matches(&binding, &message));
+    }
+
+    #[test]
+    fn adapter_mismatch_named_vs_default() {
+        let binding = Binding {
+            agent_id: "main".into(),
+            channel: "telegram".into(),
+            adapter: Some("support".into()),
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        };
+        let message = test_inbound_message("telegram", None);
+        assert!(!binding_adapter_matches(&binding, &message));
+    }
+
+    #[test]
+    fn adapter_mismatch_default_vs_named() {
+        let binding = Binding {
+            agent_id: "main".into(),
+            channel: "telegram".into(),
+            adapter: None,
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        };
+        let message = test_inbound_message("telegram", Some("telegram:support"));
+        assert!(!binding_adapter_matches(&binding, &message));
+    }
+
+    #[test]
+    fn adapter_mismatch_different_names() {
+        let binding = Binding {
+            agent_id: "main".into(),
+            channel: "telegram".into(),
+            adapter: Some("support".into()),
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        };
+        let message = test_inbound_message("telegram", Some("telegram:sales"));
+        assert!(!binding_adapter_matches(&binding, &message));
+    }
+
+    #[test]
+    fn validate_named_adapters_valid_config() {
+        let messaging = MessagingConfig {
+            discord: None,
+            slack: None,
+            telegram: Some(TelegramConfig {
+                enabled: true,
+                token: "tok".into(),
+                instances: vec![TelegramInstanceConfig {
+                    name: "support".into(),
+                    enabled: true,
+                    token: "tok2".into(),
+                    dm_allowed_users: vec![],
+                }],
+                dm_allowed_users: vec![],
+            }),
+            email: None,
+            webhook: None,
+            twitch: None,
+        };
+        let bindings = vec![
+            Binding {
+                agent_id: "main".into(),
+                channel: "telegram".into(),
+                adapter: None,
+                guild_id: None,
+                workspace_id: None,
+                chat_id: None,
+                channel_ids: vec![],
+                require_mention: false,
+                dm_allowed_users: vec![],
+            },
+            Binding {
+                agent_id: "support-agent".into(),
+                channel: "telegram".into(),
+                adapter: Some("support".into()),
+                guild_id: None,
+                workspace_id: None,
+                chat_id: None,
+                channel_ids: vec![],
+                require_mention: false,
+                dm_allowed_users: vec![],
+            },
+        ];
+        assert!(validate_named_messaging_adapters(&messaging, &bindings).is_ok());
+    }
+
+    #[test]
+    fn validate_named_adapters_missing_instance() {
+        let messaging = MessagingConfig {
+            discord: None,
+            slack: None,
+            telegram: Some(TelegramConfig {
+                enabled: true,
+                token: "tok".into(),
+                instances: vec![],
+                dm_allowed_users: vec![],
+            }),
+            email: None,
+            webhook: None,
+            twitch: None,
+        };
+        let bindings = vec![Binding {
+            agent_id: "main".into(),
+            channel: "telegram".into(),
+            adapter: Some("nonexistent".into()),
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        }];
+        assert!(validate_named_messaging_adapters(&messaging, &bindings).is_err());
+    }
+
+    #[test]
+    fn validate_named_adapters_duplicate_names_rejected() {
+        let result = validate_instance_names("telegram", ["support", "support"].into_iter());
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn validate_named_adapters_empty_name_rejected() {
+        let result = validate_instance_names("telegram", [""].into_iter());
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn validate_named_adapters_default_name_rejected() {
+        let result = validate_instance_names("telegram", ["default"].into_iter());
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn validate_adapter_on_unsupported_platform_rejected() {
+        let messaging = MessagingConfig {
+            discord: None,
+            slack: None,
+            telegram: None,
+            email: Some(EmailConfig {
+                enabled: true,
+                imap_host: "imap.test.com".into(),
+                imap_port: 993,
+                imap_username: "user".into(),
+                imap_password: "pass".into(),
+                imap_use_tls: true,
+                smtp_host: "smtp.test.com".into(),
+                smtp_port: 587,
+                smtp_username: "user".into(),
+                smtp_password: "pass".into(),
+                smtp_use_starttls: true,
+                from_address: "bot@test.com".into(),
+                from_name: None,
+                poll_interval_secs: 60,
+                folders: vec![],
+                allowed_senders: vec![],
+                max_body_bytes: 1_000_000,
+                max_attachment_bytes: 10_000_000,
+                instances: vec![],
+            }),
+            webhook: None,
+            twitch: None,
+        };
+        let bindings = vec![Binding {
+            agent_id: "main".into(),
+            channel: "email".into(),
+            adapter: Some("named".into()),
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        }];
+        assert!(validate_named_messaging_adapters(&messaging, &bindings).is_err());
+    }
+
+    #[test]
+    fn validate_binding_without_default_adapter_rejected() {
+        let messaging = MessagingConfig {
+            discord: None,
+            slack: None,
+            telegram: Some(TelegramConfig {
+                enabled: true,
+                token: "".into(), // no default credential
+                instances: vec![TelegramInstanceConfig {
+                    name: "support".into(),
+                    enabled: true,
+                    token: "tok".into(),
+                    dm_allowed_users: vec![],
+                }],
+                dm_allowed_users: vec![],
+            }),
+            email: None,
+            webhook: None,
+            twitch: None,
+        };
+        // Binding targets default adapter, but no default credentials exist
+        let bindings = vec![Binding {
+            agent_id: "main".into(),
+            channel: "telegram".into(),
+            adapter: None,
+            guild_id: None,
+            workspace_id: None,
+            chat_id: None,
+            channel_ids: vec![],
+            require_mention: false,
+            dm_allowed_users: vec![],
+        }];
+        assert!(validate_named_messaging_adapters(&messaging, &bindings).is_err());
+    }
+
+    #[test]
+    fn inbound_message_adapter_selector_default() {
+        let message = test_inbound_message("telegram", None);
+        assert_eq!(message.adapter_selector(), None);
+    }
+
+    #[test]
+    fn inbound_message_adapter_selector_named() {
+        let message = test_inbound_message("telegram", Some("telegram:support"));
+        assert_eq!(message.adapter_selector(), Some("support"));
+    }
+
+    #[test]
+    fn inbound_message_adapter_key_default() {
+        let message = test_inbound_message("telegram", None);
+        assert_eq!(message.adapter_key(), "telegram");
+    }
+
+    #[test]
+    fn inbound_message_adapter_key_named() {
+        let message = test_inbound_message("telegram", Some("telegram:support"));
+        assert_eq!(message.adapter_key(), "telegram:support");
+    }
+
+    #[test]
+    fn toml_round_trip_with_named_instances() {
+        let _guard = env_test_lock().lock().unwrap();
+        let guard = EnvGuard::new();
+
+        let toml_content = r#"
+[messaging.telegram]
+enabled = true
+token = "default-token"
+
+[[messaging.telegram.instances]]
+name = "support"
+enabled = true
+token = "support-token"
+
+[[bindings]]
+agent_id = "main"
+channel = "telegram"
+
+[[bindings]]
+agent_id = "support-bot"
+channel = "telegram"
+adapter = "support"
+chat_id = "-100111"
+"#;
+        let config_path = guard.test_dir.join("config.toml");
+        std::fs::write(&config_path, toml_content).unwrap();
+
+        let config = Config::load_from_path(&config_path).unwrap();
+        let telegram = config.messaging.telegram.as_ref().unwrap();
+        assert_eq!(telegram.token, "default-token");
+        assert_eq!(telegram.instances.len(), 1);
+        assert_eq!(telegram.instances[0].name, "support");
+        assert_eq!(telegram.instances[0].token, "support-token");
+
+        assert_eq!(config.bindings.len(), 2);
+        assert!(config.bindings[0].adapter.is_none());
+        assert_eq!(config.bindings[1].adapter.as_deref(), Some("support"));
+        assert_eq!(config.bindings[1].chat_id.as_deref(), Some("-100111"));
+    }
+
+    #[test]
+    fn toml_backward_compat_no_adapter_field() {
+        let _guard = env_test_lock().lock().unwrap();
+        let guard = EnvGuard::new();
+
+        let toml_content = r#"
+[messaging.discord]
+enabled = true
+token = "my-discord-token"
+
+[[bindings]]
+agent_id = "main"
+channel = "discord"
+guild_id = "123456"
+"#;
+        let config_path = guard.test_dir.join("config.toml");
+        std::fs::write(&config_path, toml_content).unwrap();
+
+        let config = Config::load_from_path(&config_path).unwrap();
+        assert!(config.bindings[0].adapter.is_none());
+        assert_eq!(config.bindings[0].guild_id.as_deref(), Some("123456"));
+    }
+
+    #[test]
+    fn normalize_adapter_trims_and_clears_empty() {
+        assert_eq!(normalize_adapter(None), None);
+        assert_eq!(normalize_adapter(Some("".into())), None);
+        assert_eq!(normalize_adapter(Some("   ".into())), None);
+        assert_eq!(
+            normalize_adapter(Some(" support ".into())),
+            Some("support".into())
+        );
+        assert_eq!(normalize_adapter(Some("ops".into())), Some("ops".into()));
+    }
 }
diff --git a/src/cron/scheduler.rs b/src/cron/scheduler.rs
index 36493bcb6..3aaf32384 100644
--- a/src/cron/scheduler.rs
+++ b/src/cron/scheduler.rs
@@ -760,6 +760,7 @@ async fn run_cron_job(job: &CronJob, context: &CronContext) -> Result<()> {
     let message = InboundMessage {
         id: uuid::Uuid::new_v4().to_string(),
         source: "cron".into(),
+        adapter: None,
         conversation_id: format!("cron:{}", job.id),
         sender_id: "system".into(),
         agent_id: Some(context.deps.agent_id.clone()),
diff --git a/src/lib.rs b/src/lib.rs
index 4a8dffc79..161680e99 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -244,6 +244,12 @@ pub struct Agent {
 pub struct InboundMessage {
     pub id: String,
     pub source: String,
+    /// Runtime adapter key that received this message.
+    ///
+    /// Defaults to the platform source (`source`) when omitted so older payloads
+    /// and synthetic messages remain compatible.
+    #[serde(default)]
+    pub adapter: Option<String>,
     pub conversation_id: String,
     pub sender_id: String,
     /// Set by the router after binding resolution. None until routed.
@@ -256,6 +262,35 @@ pub struct InboundMessage {
     pub formatted_author: Option<String>,
 }
 
+impl InboundMessage {
+    /// Runtime adapter key for routing outbound operations.
+    ///
+    /// Falls back to the platform source for backward compatibility.
+    pub fn adapter_key(&self) -> &str {
+        self.adapter
+            .as_deref()
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .unwrap_or(&self.source)
+    }
+
+    /// Platform-scoped adapter selector used by bindings.
+    ///
+    /// Returns `None` for the default adapter and `Some(name)` for named
+    /// adapters (e.g. `telegram:support` -> `Some("support")`).
+    pub fn adapter_selector(&self) -> Option<&str> {
+        let adapter_key = self.adapter_key();
+        if adapter_key == self.source {
+            return None;
+        }
+
+        adapter_key
+            .strip_prefix(&self.source)
+            .and_then(|suffix| suffix.strip_prefix(':'))
+            .filter(|name| !name.is_empty())
+    }
+}
+
 /// Message content variants.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
diff --git a/src/main.rs b/src/main.rs
index 76a3390d1..f2a928904 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1452,13 +1452,43 @@ async fn initialize_agents(
     if let Some(discord_config) = &config.messaging.discord
         && discord_config.enabled
     {
-        let adapter = spacebot::messaging::discord::DiscordAdapter::new(
-            &discord_config.token,
-            discord_permissions.clone().ok_or_else(|| {
-                anyhow::anyhow!("discord permissions not initialized when discord is enabled")
-            })?,
-        );
-        new_messaging_manager.register(adapter).await;
+        if !discord_config.token.is_empty() {
+            let adapter = spacebot::messaging::discord::DiscordAdapter::new(
+                "discord",
+                &discord_config.token,
+                discord_permissions.clone().ok_or_else(|| {
+                    anyhow::anyhow!("discord permissions not initialized when discord is enabled")
+                })?,
+            );
+            new_messaging_manager.register(adapter).await;
+        }
+
+        for instance in discord_config
+            .instances
+            .iter()
+            .filter(|instance| instance.enabled)
+        {
+            if instance.token.is_empty() {
+                tracing::warn!(adapter = %instance.name, "skipping enabled discord instance with empty token");
+                continue;
+            }
+            let runtime_key = spacebot::config::binding_runtime_adapter_key(
+                "discord",
+                Some(instance.name.as_str()),
+            );
+            let perms = Arc::new(ArcSwap::from_pointee(
+                spacebot::config::DiscordPermissions::from_instance_config(
+                    instance,
+                    &config.bindings,
+                ),
+            ));
+            let adapter = spacebot::messaging::discord::DiscordAdapter::new(
+                runtime_key,
+                &instance.token,
+                perms,
+            );
+            new_messaging_manager.register(adapter).await;
+        }
     }
 
     // Shared Slack permissions (hot-reloadable via file watcher)
@@ -1473,19 +1503,57 @@ async fn initialize_agents(
     if let Some(slack_config) = &config.messaging.slack
         && slack_config.enabled
     {
-        match spacebot::messaging::slack::SlackAdapter::new(
-            &slack_config.bot_token,
-            &slack_config.app_token,
-            slack_permissions.clone().ok_or_else(|| {
-                anyhow::anyhow!("slack permissions not initialized when slack is enabled")
-            })?,
-            slack_config.commands.clone(),
-        ) {
-            Ok(adapter) => {
-                new_messaging_manager.register(adapter).await;
+        if !slack_config.bot_token.is_empty() && !slack_config.app_token.is_empty() {
+            match spacebot::messaging::slack::SlackAdapter::new(
+                "slack",
+                &slack_config.bot_token,
+                &slack_config.app_token,
+                slack_permissions.clone().ok_or_else(|| {
+                    anyhow::anyhow!("slack permissions not initialized when slack is enabled")
+                })?,
+                slack_config.commands.clone(),
+            ) {
+                Ok(adapter) => {
+                    new_messaging_manager.register(adapter).await;
+                }
+                Err(error) => {
+                    tracing::error!(%error, "failed to build slack adapter");
+                }
             }
-            Err(error) => {
-                tracing::error!(%error, "failed to build slack adapter");
+        }
+
+        for instance in slack_config
+            .instances
+            .iter()
+            .filter(|instance| instance.enabled)
+        {
+            if instance.bot_token.is_empty() || instance.app_token.is_empty() {
+                tracing::warn!(adapter = %instance.name, "skipping enabled slack instance with missing tokens");
+                continue;
+            }
+            let runtime_key = spacebot::config::binding_runtime_adapter_key(
+                "slack",
+                Some(instance.name.as_str()),
+            );
+            let perms = Arc::new(ArcSwap::from_pointee(
+                spacebot::config::SlackPermissions::from_instance_config(
+                    instance,
+                    &config.bindings,
+                ),
+            ));
+            match spacebot::messaging::slack::SlackAdapter::new(
+                runtime_key,
+                &instance.bot_token,
+                &instance.app_token,
+                perms,
+                instance.commands.clone(),
+            ) {
+                Ok(adapter) => {
+                    new_messaging_manager.register(adapter).await;
+                }
+                Err(error) => {
+                    tracing::error!(%error, adapter = %instance.name, "failed to build named slack adapter");
+                }
             }
         }
     }
@@ -1500,24 +1568,82 @@ async fn initialize_agents(
     if let Some(telegram_config) = &config.messaging.telegram
         && telegram_config.enabled
     {
-        let adapter = spacebot::messaging::telegram::TelegramAdapter::new(
-            &telegram_config.token,
-            telegram_permissions.clone().ok_or_else(|| {
-                anyhow::anyhow!("telegram permissions not initialized when telegram is enabled")
-            })?,
-        );
-        new_messaging_manager.register(adapter).await;
+        if !telegram_config.token.is_empty() {
+            let adapter = spacebot::messaging::telegram::TelegramAdapter::new(
+                "telegram",
+                &telegram_config.token,
+                telegram_permissions.clone().ok_or_else(|| {
+                    anyhow::anyhow!("telegram permissions not initialized when telegram is enabled")
+                })?,
+            );
+            new_messaging_manager.register(adapter).await;
+        }
+
+        for instance in telegram_config
+            .instances
+            .iter()
+            .filter(|instance| instance.enabled)
+        {
+            if instance.token.is_empty() {
+                tracing::warn!(adapter = %instance.name, "skipping enabled telegram instance with empty token");
+                continue;
+            }
+            let runtime_key = spacebot::config::binding_runtime_adapter_key(
+                "telegram",
+                Some(instance.name.as_str()),
+            );
+            let perms = Arc::new(ArcSwap::from_pointee(
+                spacebot::config::TelegramPermissions::from_instance_config(
+                    instance,
+                    &config.bindings,
+                ),
+            ));
+            let adapter = spacebot::messaging::telegram::TelegramAdapter::new(
+                runtime_key,
+                &instance.token,
+                perms,
+            );
+            new_messaging_manager.register(adapter).await;
+        }
     }
 
     if let Some(email_config) = &config.messaging.email
         && email_config.enabled
     {
-        match spacebot::messaging::email::EmailAdapter::from_config(email_config) {
-            Ok(adapter) => {
-                new_messaging_manager.register(adapter).await;
+        if !email_config.imap_host.is_empty() {
+            match spacebot::messaging::email::EmailAdapter::from_config(email_config) {
+                Ok(adapter) => {
+                    new_messaging_manager.register(adapter).await;
+                }
+                Err(error) => {
+                    tracing::error!(%error, "failed to build email adapter");
+                }
             }
-            Err(error) => {
-                tracing::error!(%error, "failed to build email adapter");
+        }
+
+        for instance in email_config
+            .instances
+            .iter()
+            .filter(|instance| instance.enabled)
+        {
+            if instance.imap_host.is_empty() {
+                tracing::warn!(adapter = %instance.name, "skipping enabled email instance with empty credentials");
+                continue;
+            }
+            let runtime_key = spacebot::config::binding_runtime_adapter_key(
+                "email",
+                Some(instance.name.as_str()),
+            );
+            match spacebot::messaging::email::EmailAdapter::from_instance_config(
+                runtime_key,
+                instance,
+            ) {
+                Ok(adapter) => {
+                    new_messaging_manager.register(adapter).await;
+                }
+                Err(error) => {
+                    tracing::error!(%error, adapter = %instance.name, "failed to build named email adapter");
+                }
             }
         }
     }
@@ -1544,20 +1670,72 @@ async fn initialize_agents(
         && twitch_config.enabled
     {
         let twitch_token_path = config.instance_dir.join("twitch_token.json");
-        let adapter = spacebot::messaging::twitch::TwitchAdapter::new(
-            &twitch_config.username,
-            &twitch_config.oauth_token,
-            twitch_config.client_id.clone(),
-            twitch_config.client_secret.clone(),
-            twitch_config.refresh_token.clone(),
-            Some(twitch_token_path),
-            twitch_config.channels.clone(),
-            twitch_config.trigger_prefix.clone(),
-            twitch_permissions.clone().ok_or_else(|| {
-                anyhow::anyhow!("twitch permissions not initialized when twitch is enabled")
-            })?,
-        );
-        new_messaging_manager.register(adapter).await;
+        if !twitch_config.username.is_empty() && !twitch_config.oauth_token.is_empty() {
+            let adapter = spacebot::messaging::twitch::TwitchAdapter::new(
+                "twitch",
+                &twitch_config.username,
+                &twitch_config.oauth_token,
+                twitch_config.client_id.clone(),
+                twitch_config.client_secret.clone(),
+                twitch_config.refresh_token.clone(),
+                Some(twitch_token_path),
+                twitch_config.channels.clone(),
+                twitch_config.trigger_prefix.clone(),
+                twitch_permissions.clone().ok_or_else(|| {
+                    anyhow::anyhow!("twitch permissions not initialized when twitch is enabled")
+                })?,
+            );
+            new_messaging_manager.register(adapter).await;
+        }
+
+        for instance in twitch_config
+            .instances
+            .iter()
+            .filter(|instance| instance.enabled)
+        {
+            if instance.username.is_empty() || instance.oauth_token.is_empty() {
+                tracing::warn!(adapter = %instance.name, "skipping enabled twitch instance with missing credentials");
+                continue;
+            }
+            let runtime_key = spacebot::config::binding_runtime_adapter_key(
+                "twitch",
+                Some(instance.name.as_str()),
+            );
+            let token_file_name = {
+                use std::hash::{Hash, Hasher};
+                let mut hasher = std::collections::hash_map::DefaultHasher::new();
+                instance.name.hash(&mut hasher);
+                let name_hash = hasher.finish();
+                format!(
+                    "twitch_token_{}_{name_hash:016x}.json",
+                    instance
+                        .name
+                        .chars()
+                        .map(|ch| if ch.is_ascii_alphanumeric() { ch } else { '_' })
+                        .collect::<String>()
+                )
+            };
+            let token_path = config.instance_dir.join(token_file_name);
+            let perms = Arc::new(ArcSwap::from_pointee(
+                spacebot::config::TwitchPermissions::from_instance_config(
+                    instance,
+                    &config.bindings,
+                ),
+            ));
+            let adapter = spacebot::messaging::twitch::TwitchAdapter::new(
+                runtime_key,
+                &instance.username,
+                &instance.oauth_token,
+                instance.client_id.clone(),
+                instance.client_secret.clone(),
+                instance.refresh_token.clone(),
+                Some(token_path),
+                instance.channels.clone(),
+                instance.trigger_prefix.clone(),
+                perms,
+            );
+            new_messaging_manager.register(adapter).await;
+        }
     }
 
     let webchat_adapter = Arc::new(spacebot::messaging::webchat::WebChatAdapter::new());
diff --git a/src/messaging.rs b/src/messaging.rs
index 63d2eea6d..f57d5d68a 100644
--- a/src/messaging.rs
+++ b/src/messaging.rs
@@ -13,3 +13,4 @@ pub mod webhook;
 
 pub use manager::MessagingManager;
 pub use traits::Messaging;
+pub use traits::apply_runtime_adapter_to_conversation_id;
diff --git a/src/messaging/discord.rs b/src/messaging/discord.rs
index ab433dd3a..01ad151d6 100644
--- a/src/messaging/discord.rs
+++ b/src/messaging/discord.rs
@@ -1,6 +1,7 @@
 //! Discord messaging adapter using serenity.
 
 use crate::config::DiscordPermissions;
+use crate::messaging::apply_runtime_adapter_to_conversation_id;
 use crate::messaging::traits::{HistoryMessage, InboundStream, Messaging};
 use crate::{InboundMessage, MessageContent, OutboundResponse, StatusUpdate};
 
@@ -20,6 +21,7 @@ use tokio::sync::{RwLock, mpsc};
 
 /// Discord adapter state.
 pub struct DiscordAdapter {
+    runtime_key: String,
     token: String,
     permissions: Arc<ArcSwap<DiscordPermissions>>,
     http: Arc<RwLock<Option<Arc<Http>>>>,
@@ -32,8 +34,13 @@ pub struct DiscordAdapter {
 }
 
 impl DiscordAdapter {
-    pub fn new(token: impl Into<String>, permissions: Arc<ArcSwap<DiscordPermissions>>) -> Self {
+    pub fn new(
+        runtime_key: impl Into<String>,
+        token: impl Into<String>,
+        permissions: Arc<ArcSwap<DiscordPermissions>>,
+    ) -> Self {
         Self {
+            runtime_key: runtime_key.into(),
             token: token.into(),
             permissions,
             http: Arc::new(RwLock::new(None)),
@@ -89,7 +96,7 @@ impl DiscordAdapter {
 
 impl Messaging for DiscordAdapter {
     fn name(&self) -> &str {
-        "discord"
+        &self.runtime_key
     }
 
     async fn start(&self) -> crate::Result<InboundStream> {
@@ -97,6 +104,7 @@ impl Messaging for DiscordAdapter {
 
         let handler = Handler {
             inbound_tx,
+            runtime_key: self.runtime_key.clone(),
             permissions: self.permissions.clone(),
             http_slot: self.http.clone(),
             bot_user_id_slot: self.bot_user_id.clone(),
@@ -556,6 +564,7 @@ impl Messaging for DiscordAdapter {
 
 struct Handler {
     inbound_tx: mpsc::Sender<InboundMessage>,
+    runtime_key: String,
     permissions: Arc<ArcSwap<DiscordPermissions>>,
     http_slot: Arc<RwLock<Option<Arc<Http>>>>,
     bot_user_id_slot: Arc<RwLock<Option<UserId>>>,
@@ -603,7 +612,7 @@ impl EventHandler for Handler {
             return;
         }
 
-        let conversation_id = build_conversation_id(&message);
+        let conversation_id = build_conversation_id(&self.runtime_key, &message);
         let content = extract_content(&message);
         let (metadata, formatted_author) = build_metadata(&ctx, &message, bot_user_id).await;
 
@@ -627,6 +636,7 @@ impl EventHandler for Handler {
         let inbound = InboundMessage {
             id: message.id.to_string(),
             source: "discord".into(),
+            adapter: Some(self.runtime_key.clone()),
             conversation_id,
             sender_id: message.author.id.to_string(),
             agent_id: None,
@@ -679,10 +689,12 @@ impl EventHandler for Handler {
             return;
         }
 
-        let conversation_id = match component.guild_id {
+        let base_conversation_id = match component.guild_id {
             Some(guild_id) => format!("discord:{}:{}", guild_id, component.channel_id),
             None => format!("discord:dm:{}", user.id),
         };
+        let conversation_id =
+            apply_runtime_adapter_to_conversation_id(&self.runtime_key, base_conversation_id);
 
         let values = match &component.data.kind {
             serenity::all::ComponentInteractionDataKind::StringSelect { values } => values.clone(),
@@ -730,6 +742,7 @@ impl EventHandler for Handler {
         let inbound = InboundMessage {
             id: component.id.to_string(), // Use interaction ID to ensure uniqueness
             source: "discord".into(),
+            adapter: Some(self.runtime_key.clone()),
             conversation_id,
             sender_id: user.id.to_string(),
             agent_id: None,
@@ -766,11 +779,13 @@ fn is_mention_or_reply_to_bot(message: &Message, bot_user_id: Option<UserId>) ->
 
 // -- Helper functions --
 
-fn build_conversation_id(message: &Message) -> String {
-    match message.guild_id {
+fn build_conversation_id(runtime_key: &str, message: &Message) -> String {
+    let base_conversation_id = match message.guild_id {
         Some(guild_id) => format!("discord:{}:{}", guild_id, message.channel_id),
         None => format!("discord:dm:{}", message.author.id),
-    }
+    };
+
+    apply_runtime_adapter_to_conversation_id(runtime_key, base_conversation_id)
 }
 
 fn extract_content(message: &Message) -> MessageContent {
diff --git a/src/messaging/email.rs b/src/messaging/email.rs
index ae73e9d19..aceff2c18 100644
--- a/src/messaging/email.rs
+++ b/src/messaging/email.rs
@@ -36,6 +36,7 @@ struct EmailPollConfig {
     poll_interval: Duration,
     allowed_senders: Vec<String>,
     max_body_bytes: usize,
+    runtime_key: String,
 }
 
 struct HistoryEntry {
@@ -70,6 +71,7 @@ pub struct EmailSearchHit {
 
 /// Email adapter state.
 pub struct EmailAdapter {
+    runtime_key: String,
     imap_host: String,
     imap_port: u16,
     imap_username: String,
@@ -116,6 +118,39 @@ impl std::fmt::Debug for EmailAdapter {
 
 impl EmailAdapter {
     pub fn from_config(config: &EmailConfig) -> crate::Result<Self> {
+        Self::build("email".to_string(), config)
+    }
+
+    pub fn from_instance_config(
+        runtime_key: impl Into<String>,
+        config: &crate::config::EmailInstanceConfig,
+    ) -> crate::Result<Self> {
+        // Build a temporary EmailConfig to reuse build_smtp_transport and shared logic.
+        let email_config = EmailConfig {
+            enabled: config.enabled,
+            imap_host: config.imap_host.clone(),
+            imap_port: config.imap_port,
+            imap_username: config.imap_username.clone(),
+            imap_password: config.imap_password.clone(),
+            imap_use_tls: config.imap_use_tls,
+            smtp_host: config.smtp_host.clone(),
+            smtp_port: config.smtp_port,
+            smtp_username: config.smtp_username.clone(),
+            smtp_password: config.smtp_password.clone(),
+            smtp_use_starttls: config.smtp_use_starttls,
+            from_address: config.from_address.clone(),
+            from_name: config.from_name.clone(),
+            poll_interval_secs: config.poll_interval_secs,
+            folders: config.folders.clone(),
+            allowed_senders: config.allowed_senders.clone(),
+            max_body_bytes: config.max_body_bytes,
+            max_attachment_bytes: config.max_attachment_bytes,
+            instances: Vec::new(),
+        };
+        Self::build(runtime_key.into(), &email_config)
+    }
+
+    fn build(runtime_key: String, config: &EmailConfig) -> crate::Result<Self> {
         let folders = config
             .folders
             .iter()
@@ -132,6 +167,7 @@ impl EmailAdapter {
         let smtp_transport = build_smtp_transport(config)?;
 
         Ok(Self {
+            runtime_key,
             imap_host: config.imap_host.clone(),
             imap_port: config.imap_port,
             imap_username: config.imap_username.clone(),
@@ -167,6 +203,7 @@ impl EmailAdapter {
             poll_interval: self.poll_interval,
             allowed_senders: self.allowed_senders.clone(),
             max_body_bytes: self.max_body_bytes,
+            runtime_key: self.runtime_key.clone(),
         }
     }
 
@@ -242,7 +279,7 @@ impl EmailAdapter {
 
 impl Messaging for EmailAdapter {
     fn name(&self) -> &str {
-        "email"
+        &self.runtime_key
     }
 
     async fn start(&self) -> crate::Result<InboundStream> {
@@ -837,6 +874,7 @@ fn parse_inbound_email(
     Ok(Some(InboundMessage {
         id: message_id,
         source: "email".into(),
+        adapter: Some(config.runtime_key.clone()),
         conversation_id,
         sender_id: sender_email,
         agent_id: None,
@@ -1031,6 +1069,7 @@ pub fn search_mailbox(
         poll_interval: Duration::from_secs(config.poll_interval_secs.max(5)),
         allowed_senders: config.allowed_senders.clone(),
         max_body_bytes: config.max_body_bytes.max(1024),
+        runtime_key: "email".to_string(),
     })?;
 
     let limit = query.limit.clamp(1, 50);
diff --git a/src/messaging/manager.rs b/src/messaging/manager.rs
index c08014676..a55a6e293 100644
--- a/src/messaging/manager.rs
+++ b/src/messaging/manager.rs
@@ -125,6 +125,21 @@ impl MessagingManager {
         self.adapters.read().await.contains_key(name)
     }
 
+    /// Returns true if any adapter exists for the given platform.
+    pub async fn has_platform_adapters(&self, platform: &str) -> bool {
+        let prefix = format!("{platform}:");
+        self.adapters
+            .read()
+            .await
+            .keys()
+            .any(|name| name == platform || name.starts_with(&prefix))
+    }
+
+    /// List registered adapter runtime keys.
+    pub async fn adapter_names(&self) -> Vec<String> {
+        self.adapters.read().await.keys().cloned().collect()
+    }
+
     /// Spawn a background task that retries starting a failed adapter with exponential backoff.
     ///
     /// Once the adapter starts successfully, its stream is forwarded into the
@@ -206,9 +221,10 @@ impl MessagingManager {
         response: OutboundResponse,
     ) -> crate::Result<()> {
         let adapters = self.adapters.read().await;
+        let adapter_key = message.adapter_key();
         let adapter = adapters
-            .get(&message.source)
-            .with_context(|| format!("no messaging adapter named '{}'", message.source))?;
+            .get(adapter_key)
+            .with_context(|| format!("no messaging adapter named '{}'", adapter_key))?;
         adapter.respond(message, response).await
     }
 
@@ -219,9 +235,10 @@ impl MessagingManager {
         status: StatusUpdate,
     ) -> crate::Result<()> {
         let adapters = self.adapters.read().await;
+        let adapter_key = message.adapter_key();
         let adapter = adapters
-            .get(&message.source)
-            .with_context(|| format!("no messaging adapter named '{}'", message.source))?;
+            .get(adapter_key)
+            .with_context(|| format!("no messaging adapter named '{}'", adapter_key))?;
         adapter.send_status(message, status).await
     }
 
@@ -246,9 +263,10 @@ impl MessagingManager {
         limit: usize,
     ) -> crate::Result<Vec<HistoryMessage>> {
         let adapters = self.adapters.read().await;
+        let adapter_key = message.adapter_key();
         let adapter = adapters
-            .get(&message.source)
-            .with_context(|| format!("no messaging adapter named '{}'", message.source))?;
+            .get(adapter_key)
+            .with_context(|| format!("no messaging adapter named '{}'", adapter_key))?;
         adapter.fetch_history(message, limit).await
     }
 
@@ -262,6 +280,26 @@ impl MessagingManager {
         Ok(())
     }
 
+    /// Remove and shut down all adapters for a platform (default + named).
+    pub async fn remove_platform_adapters(&self, platform: &str) -> crate::Result<()> {
+        let mut names = Vec::new();
+        {
+            let adapters = self.adapters.read().await;
+            let prefix = format!("{platform}:");
+            for name in adapters.keys() {
+                if name == platform || name.starts_with(&prefix) {
+                    names.push(name.clone());
+                }
+            }
+        }
+
+        for name in names {
+            self.remove_adapter(&name).await?;
+        }
+
+        Ok(())
+    }
+
     /// Shut down all adapters gracefully.
     pub async fn shutdown(&self) {
         let adapters = self.adapters.read().await;
diff --git a/src/messaging/slack.rs b/src/messaging/slack.rs
index 2aa1e3cbf..0402b3011 100644
--- a/src/messaging/slack.rs
+++ b/src/messaging/slack.rs
@@ -22,6 +22,7 @@
 //! - DM broadcast via `conversations.open`
 
 use crate::config::{SlackCommandConfig, SlackPermissions};
+use crate::messaging::apply_runtime_adapter_to_conversation_id;
 use crate::messaging::traits::{HistoryMessage, InboundStream, Messaging};
 use crate::{InboundMessage, MessageContent, OutboundResponse, StatusUpdate};
 
@@ -35,6 +36,7 @@ use tokio::sync::{RwLock, mpsc};
 /// State shared with socket mode callbacks via `SlackClientEventsUserState`.
 struct SlackAdapterState {
     inbound_tx: mpsc::Sender<InboundMessage>,
+    runtime_key: String,
     permissions: Arc<ArcSwap<SlackPermissions>>,
     bot_token: String,
     bot_user_id: String,
@@ -55,6 +57,7 @@ struct SlackUserIdentity {
 
 /// Slack adapter.
 pub struct SlackAdapter {
+    runtime_key: String,
     bot_token: String,
     app_token: String,
     permissions: Arc<ArcSwap<SlackPermissions>>,
@@ -73,11 +76,13 @@ pub struct SlackAdapter {
 
 impl SlackAdapter {
     pub fn new(
+        runtime_key: impl Into<String>,
         bot_token: impl Into<String>,
         app_token: impl Into<String>,
         permissions: Arc<ArcSwap<SlackPermissions>>,
         commands: Vec<SlackCommandConfig>,
     ) -> anyhow::Result<Self> {
+        let runtime_key = runtime_key.into();
         let bot_token = bot_token.into();
         let client = Arc::new(SlackClient::new(
             SlackClientHyperConnector::new().context("failed to create slack HTTP connector")?,
@@ -88,6 +93,7 @@ impl SlackAdapter {
             .map(|c| (c.command, c.agent_id))
             .collect();
         Ok(Self {
+            runtime_key,
             bot_token,
             app_token: app_token.into(),
             permissions,
@@ -225,11 +231,13 @@ async fn handle_message_event(
         }
     }
 
-    let conversation_id = if let Some(ref thread_ts) = msg_event.origin.thread_ts {
+    let base_conversation_id = if let Some(ref thread_ts) = msg_event.origin.thread_ts {
         format!("slack:{}:{}:{}", team_id_str, channel_id, thread_ts.0)
     } else {
         format!("slack:{}:{}", team_id_str, channel_id)
     };
+    let conversation_id =
+        apply_runtime_adapter_to_conversation_id(&adapter_state.runtime_key, base_conversation_id);
 
     let content = extract_message_content(&msg_event.content);
 
@@ -249,6 +257,7 @@ async fn handle_message_event(
 
     send_inbound(
         &adapter_state.inbound_tx,
+        &adapter_state.runtime_key,
         ts,
         conversation_id,
         user_id.unwrap_or_default(),
@@ -308,11 +317,13 @@ async fn handle_app_mention_event(
         return Ok(());
     }
 
-    let conversation_id = if let Some(ref thread_ts) = mention.origin.thread_ts {
+    let base_conversation_id = if let Some(ref thread_ts) = mention.origin.thread_ts {
         format!("slack:{}:{}:{}", team_id_str, channel_id, thread_ts.0)
     } else {
         format!("slack:{}:{}", team_id_str, channel_id)
     };
+    let conversation_id =
+        apply_runtime_adapter_to_conversation_id(&adapter_state.runtime_key, base_conversation_id);
 
     // Strip the leading @-mention from the text so the agent sees clean input
     let raw_text = mention.content.text.clone().unwrap_or_default();
@@ -336,6 +347,7 @@ async fn handle_app_mention_event(
 
     send_inbound(
         &adapter_state.inbound_tx,
+        &adapter_state.runtime_key,
         ts,
         conversation_id,
         user_id,
@@ -444,7 +456,9 @@ async fn handle_command_event(
 
     let agent_id = adapter_state.commands[&command_str].clone();
 
-    let conversation_id = format!("slack:{}:{}", team_id, channel_id);
+    let base_conversation_id = format!("slack:{}:{}", team_id, channel_id);
+    let conversation_id =
+        apply_runtime_adapter_to_conversation_id(&adapter_state.runtime_key, base_conversation_id);
 
     let mut metadata = HashMap::new();
     metadata.insert(
@@ -483,6 +497,7 @@ async fn handle_command_event(
     let inbound = InboundMessage {
         id: msg_id,
         source: "slack".into(),
+        adapter: Some(adapter_state.runtime_key.clone()),
         conversation_id,
         sender_id: user_id.clone(),
         agent_id: None,
@@ -579,11 +594,13 @@ async fn handle_interaction_event(
     // Use trigger_id as the unique message id for this interaction turn.
     let msg_id = block_actions.trigger_id.0.clone();
 
-    let conversation_id = if let Some(ref ts) = message_ts {
+    let base_conversation_id = if let Some(ref ts) = message_ts {
         format!("slack:{}:{}:{}", team_id, channel_id, ts)
     } else {
         format!("slack:{}:{}", team_id, channel_id)
     };
+    let conversation_id =
+        apply_runtime_adapter_to_conversation_id(&adapter_state.runtime_key, base_conversation_id);
 
     // Process each action in the payload as a separate inbound message.
     // In practice Slack sends one action per interaction, but the API allows many.
@@ -663,6 +680,7 @@ async fn handle_interaction_event(
         let inbound = InboundMessage {
             id,
             source: "slack".into(),
+            adapter: Some(adapter_state.runtime_key.clone()),
             conversation_id: conversation_id.clone(),
             sender_id: user_id.clone(),
             agent_id: None,
@@ -686,7 +704,7 @@ async fn handle_interaction_event(
 
 impl Messaging for SlackAdapter {
     fn name(&self) -> &str {
-        "slack"
+        &self.runtime_key
     }
 
     async fn start(&self) -> crate::Result<InboundStream> {
@@ -706,6 +724,7 @@ impl Messaging for SlackAdapter {
 
         let adapter_state = Arc::new(SlackAdapterState {
             inbound_tx,
+            runtime_key: self.runtime_key.clone(),
             permissions: self.permissions.clone(),
             bot_token: self.bot_token.clone(),
             bot_user_id,
@@ -1426,8 +1445,10 @@ async fn build_metadata_and_author(
 }
 
 /// Dispatch a fully-constructed `InboundMessage` to the inbound channel.
+#[allow(clippy::too_many_arguments)]
 async fn send_inbound(
     tx: &mpsc::Sender<InboundMessage>,
+    runtime_key: &str,
     ts: String,
     conversation_id: String,
     sender_id: String,
@@ -1438,6 +1459,7 @@ async fn send_inbound(
     let inbound = InboundMessage {
         id: ts,
         source: "slack".into(),
+        adapter: Some(runtime_key.to_string()),
         conversation_id,
         sender_id,
         agent_id: None,
diff --git a/src/messaging/telegram.rs b/src/messaging/telegram.rs
index eab7994c2..8ab5130b6 100644
--- a/src/messaging/telegram.rs
+++ b/src/messaging/telegram.rs
@@ -1,6 +1,7 @@
 //! Telegram messaging adapter using teloxide.
 
 use crate::config::TelegramPermissions;
+use crate::messaging::apply_runtime_adapter_to_conversation_id;
 use crate::messaging::traits::{InboundStream, Messaging};
 use crate::{Attachment, InboundMessage, MessageContent, OutboundResponse, StatusUpdate};
 
@@ -26,6 +27,7 @@ const REJECTED_USERS_CAPACITY: usize = 50;
 
 /// Telegram adapter state.
 pub struct TelegramAdapter {
+    runtime_key: String,
     permissions: Arc<ArcSwap<TelegramPermissions>>,
     bot: Bot,
     bot_user_id: Arc<RwLock<Option<UserId>>>,
@@ -55,10 +57,16 @@ const FORMATTED_SPLIT_LENGTH: usize = MAX_MESSAGE_LENGTH / 2;
 const STREAM_EDIT_INTERVAL: std::time::Duration = std::time::Duration::from_millis(1000);
 
 impl TelegramAdapter {
-    pub fn new(token: impl Into<String>, permissions: Arc<ArcSwap<TelegramPermissions>>) -> Self {
+    pub fn new(
+        runtime_key: impl Into<String>,
+        token: impl Into<String>,
+        permissions: Arc<ArcSwap<TelegramPermissions>>,
+    ) -> Self {
+        let runtime_key = runtime_key.into();
         let token = token.into();
         let bot = Bot::new(&token);
         Self {
+            runtime_key,
             permissions,
             bot,
             bot_user_id: Arc::new(RwLock::new(None)),
@@ -97,7 +105,7 @@ impl TelegramAdapter {
 
 impl Messaging for TelegramAdapter {
     fn name(&self) -> &str {
-        "telegram"
+        &self.runtime_key
     }
 
     async fn start(&self) -> crate::Result<InboundStream> {
@@ -122,6 +130,7 @@ impl Messaging for TelegramAdapter {
         );
 
         let bot = self.bot.clone();
+        let runtime_key = self.runtime_key.clone();
         let permissions = self.permissions.clone();
         let bot_user_id = self.bot_user_id.clone();
         let bot_username = self.bot_username.clone();
@@ -238,7 +247,11 @@ impl Messaging for TelegramAdapter {
                             }
 
                             let content = build_content(&bot, message, &text).await;
-                            let conversation_id = format!("telegram:{chat_id}");
+                            let base_conversation_id = format!("telegram:{chat_id}");
+                            let conversation_id = apply_runtime_adapter_to_conversation_id(
+                                &runtime_key,
+                                base_conversation_id,
+                            );
                             let sender_id = message
                                 .from
                                 .as_ref()
@@ -253,6 +266,7 @@ impl Messaging for TelegramAdapter {
                             let inbound = InboundMessage {
                                 id: message.id.0.to_string(),
                                 source: "telegram".into(),
+                                adapter: Some(runtime_key.clone()),
                                 conversation_id,
                                 sender_id,
                                 agent_id: None,
diff --git a/src/messaging/traits.rs b/src/messaging/traits.rs
index 1f5e10f00..060c060c4 100644
--- a/src/messaging/traits.rs
+++ b/src/messaging/traits.rs
@@ -168,3 +168,24 @@ impl<T: Messaging> MessagingDyn for T {
         Box::pin(Messaging::shutdown(self))
     }
 }
+
+/// Rewrite a conversation ID's platform prefix to use a named adapter's runtime key.
+///
+/// Given a `runtime_key` like `"discord:ops"` and a `base_conversation_id` like
+/// `"discord:12345"`, returns `"discord:ops:12345"`. If the runtime key matches
+/// the existing platform prefix (i.e. the default adapter), the ID is returned
+/// unchanged.
+pub fn apply_runtime_adapter_to_conversation_id(
+    runtime_key: &str,
+    base_conversation_id: String,
+) -> String {
+    let Some((platform, remainder)) = base_conversation_id.split_once(':') else {
+        return base_conversation_id;
+    };
+
+    if runtime_key == platform {
+        base_conversation_id
+    } else {
+        format!("{runtime_key}:{remainder}")
+    }
+}
diff --git a/src/messaging/twitch.rs b/src/messaging/twitch.rs
index d716bf795..e80d79010 100644
--- a/src/messaging/twitch.rs
+++ b/src/messaging/twitch.rs
@@ -1,6 +1,7 @@
 //! Twitch chat messaging adapter using twitch-irc.
 
 use crate::config::TwitchPermissions;
+use crate::messaging::apply_runtime_adapter_to_conversation_id;
 use crate::messaging::traits::{InboundStream, Messaging};
 use crate::{InboundMessage, MessageContent, OutboundResponse};
 
@@ -40,38 +41,30 @@ impl TokenStorage for TwitchTokenStorage {
 
     async fn load_token(&mut self) -> Result<UserAccessToken, Self::LoadError> {
         let mut created_at = Utc::now();
-        let mut expires_at = None;
 
-        if let Some(path) = &self.token_path {
-            if let Ok(data) = std::fs::read_to_string(path)
-                && let Ok(file) = serde_json::from_str::<TwitchTokenFile>(&data)
-            {
-                self.access_token = file.access_token;
-                self.refresh_token = file.refresh_token;
-                if let Some(stored_created) = file.created_at {
-                    created_at = stored_created;
-                }
-                expires_at = file.expires_at;
-            }
-            if !self.refresh_token.is_empty() && expires_at.is_none() {
-                expires_at = Some(created_at + chrono::Duration::hours(1));
-            }
-            let file = TwitchTokenFile {
-                access_token: self.access_token.clone(),
-                refresh_token: self.refresh_token.clone(),
-                created_at: Some(created_at),
-                expires_at,
-            };
-            if let Ok(data) = serde_json::to_string_pretty(&file) {
-                let _ = std::fs::write(path, data);
+        if let Some(path) = &self.token_path
+            && let Ok(data) = std::fs::read_to_string(path)
+            && let Ok(file) = serde_json::from_str::<TwitchTokenFile>(&data)
+        {
+            self.access_token = file.access_token;
+            self.refresh_token = file.refresh_token;
+            if let Some(stored_created) = file.created_at {
+                created_at = stored_created;
             }
         }
 
+        // Never return expires_at from load_token. The twitch-irc library's
+        // RefreshingLoginCredentials will attempt an OAuth token refresh
+        // whenever it sees an expired/near-expired token, and if the refresh
+        // credentials are invalid it spin-loops with no backoff. By always
+        // returning expires_at = None here, we treat the access token as
+        // non-expiring on load. Real expiry data is only set via
+        // update_token() after a *successful* library-driven refresh.
         Ok(UserAccessToken {
             access_token: self.access_token.clone(),
             refresh_token: self.refresh_token.clone(),
             created_at,
-            expires_at,
+            expires_at: None,
         })
     }
 
@@ -100,6 +93,7 @@ type IrcClient = TwitchIRCClient<SecureTCPTransport, TwitchCredentials>;
 
 /// Twitch chat adapter state.
 pub struct TwitchAdapter {
+    runtime_key: String,
     username: String,
     oauth_token: String,
     client_id: Option<String>,
@@ -119,6 +113,7 @@ const MAX_MESSAGE_LENGTH: usize = 500;
 impl TwitchAdapter {
     #[allow(clippy::too_many_arguments)]
     pub fn new(
+        runtime_key: impl Into<String>,
         username: impl Into<String>,
         oauth_token: impl Into<String>,
         client_id: Option<String>,
@@ -130,6 +125,7 @@ impl TwitchAdapter {
         permissions: Arc<ArcSwap<TwitchPermissions>>,
     ) -> Self {
         Self {
+            runtime_key: runtime_key.into(),
             username: username.into(),
             oauth_token: oauth_token.into(),
             client_id,
@@ -147,7 +143,7 @@ impl TwitchAdapter {
 
 impl Messaging for TwitchAdapter {
     fn name(&self) -> &str {
-        "twitch"
+        &self.runtime_key
     }
 
     async fn start(&self) -> crate::Result<InboundStream> {
@@ -163,15 +159,26 @@ impl Messaging for TwitchAdapter {
             .unwrap_or(&self.oauth_token)
             .to_string();
 
+        let refresh_token = self.refresh_token.clone().unwrap_or_default();
+        let client_id = self.client_id.clone().unwrap_or_default();
+        let client_secret = self.client_secret.clone().unwrap_or_default();
+
+        if refresh_token.is_empty() || client_id.is_empty() || client_secret.is_empty() {
+            tracing::info!(
+                adapter = %self.runtime_key,
+                "twitch token refresh disabled (missing client_id, client_secret, or refresh_token)"
+            );
+        }
+
         let storage = TwitchTokenStorage {
             access_token: token,
-            refresh_token: self.refresh_token.clone().unwrap_or_default(),
+            refresh_token,
             token_path: self.token_path.clone(),
         };
         let credentials = TwitchCredentials::init_with_username(
             Some(self.username.clone()),
-            self.client_id.clone().unwrap_or_default(),
-            self.client_secret.clone().unwrap_or_default(),
+            client_id,
+            client_secret,
             storage,
         );
         let config = ClientConfig::new_simple(credentials);
@@ -198,6 +205,7 @@ impl Messaging for TwitchAdapter {
         let permissions = self.permissions.clone();
         let bot_username = self.username.to_lowercase();
         let trigger_prefix = self.trigger_prefix.clone();
+        let runtime_key = self.runtime_key.clone();
 
         tokio::spawn(async move {
             loop {
@@ -249,7 +257,11 @@ impl Messaging for TwitchAdapter {
                         }
 
                         let channel_login = privmsg.channel_login.clone();
-                        let conversation_id = format!("twitch:{channel_login}");
+                        let base_conversation_id = format!("twitch:{channel_login}");
+                        let conversation_id = apply_runtime_adapter_to_conversation_id(
+                            &runtime_key,
+                            base_conversation_id,
+                        );
 
                         let mut metadata = HashMap::new();
                         metadata.insert(
@@ -282,6 +294,7 @@ impl Messaging for TwitchAdapter {
                         let inbound = InboundMessage {
                             id: privmsg.message_id.clone(),
                             source: "twitch".into(),
+                            adapter: Some(runtime_key.clone()),
                             conversation_id,
                             sender_id: privmsg.sender.id.clone(),
                             agent_id: None,
diff --git a/src/messaging/webhook.rs b/src/messaging/webhook.rs
index e43f742ef..65565fad6 100644
--- a/src/messaging/webhook.rs
+++ b/src/messaging/webhook.rs
@@ -37,6 +37,7 @@ struct AppState {
     inbound_tx: Arc<RwLock<Option<mpsc::Sender<InboundMessage>>>>,
     response_buffers: Arc<RwLock<HashMap<String, Vec<WebhookResponse>>>>,
     auth_token: Option<String>,
+    runtime_key: String,
 }
 
 /// Inbound webhook request body.
@@ -103,6 +104,7 @@ impl Messaging for WebhookAdapter {
             inbound_tx: self.inbound_tx.clone(),
             response_buffers: self.response_buffers.clone(),
             auth_token: self.auth_token.clone(),
+            runtime_key: self.name().to_string(),
         };
 
         if self.auth_token.is_none() {
@@ -268,6 +270,7 @@ async fn handle_send(
     let inbound = InboundMessage {
         id: uuid::Uuid::new_v4().to_string(),
         source: "webhook".into(),
+        adapter: Some(state.runtime_key.clone()),
         conversation_id,
         sender_id: request.sender_id.clone(),
         agent_id: request.agent_id.map(Into::into),