diff --git a/bun.lock b/bun.lock
index 3fab909..047092b 100644
--- a/bun.lock
+++ b/bun.lock
@@ -6,7 +6,7 @@
       "name": "contextvm-site",
       "dependencies": {
         "@contextvm/mcp-sdk": "^1.30.0",
-        "@contextvm/sdk": "^0.13.6",
+        "@contextvm/sdk": "^0.13.7",
         "@sjsf/ajv8-validator": "^3.3.2",
         "@sjsf/form": "^3.3.2",
         "@sjsf/shadcn4-theme": "^3.3.2",
@@ -102,7 +102,7 @@
 
     "@contextvm/mcp-sdk": ["@contextvm/mcp-sdk@1.30.0", "", { "dependencies": { "ajv": "^8.17.1", "ajv-formats": "^3.0.1", "cross-spawn": "^7.0.5", "zod": "^3.25 || ^4.0", "zod-to-json-schema": "^3.25.1" } }, "sha512-Z4xyxxxtKnczEgVzLagaUdT1EtoVzc1bjr6kpIfTlw7mP5ESAzXeDUAMO9leIwituphz2ELE6ad9BjW7blDjjw=="],
 
-    "@contextvm/sdk": ["@contextvm/sdk@0.13.6", "", { "dependencies": { "@contextvm/mcp-sdk": "^1.30.0", "@noble/hashes": "^2.2.0", "applesauce-relay": "^6.2.1", "canonicalize": "^2.1.0", "nostr-tools": "^2.23.9", "pino": "^10.3.1", "rxjs": "^7.8.2", "ws": "^8.20.0", "zod": "^4.4.3" }, "peerDependencies": { "typescript": "^5.9.3" } }, "sha512-m67xpauk6w2YD4R/wDBdNBqNcPbXPgtbKx/gUS3/90UBJEyT9/Mt4/hGh9B/nX9y07HT+LUAfS9BC/0wYJWdhg=="],
+    "@contextvm/sdk": ["@contextvm/sdk@0.13.7", "", { "dependencies": { "@contextvm/mcp-sdk": "^1.30.0", "@noble/hashes": "^2.2.0", "applesauce-relay": "^6.2.1", "canonicalize": "^2.1.0", "nostr-tools": "^2.23.9", "pino": "^10.3.1", "rxjs": "^7.8.2", "ws": "^8.20.0", "zod": "^4.4.3" }, "peerDependencies": { "typescript": "^5.9.3" } }, "sha512-Y4fKGVYJzOTHM0bNuLE9+HzDWvr+pCmQgrsn4Wh2pT73ThwNIhvLOWw/GJygNPOZnQSQ3h3v46efwYto/g/oBQ=="],
 
     "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.27.7", "", { "os": "aix", "cpu": "ppc64" }, "sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg=="],
 
diff --git a/package.json b/package.json
index a581dca..ada4ba3 100644
--- a/package.json
+++ b/package.json
@@ -49,7 +49,7 @@
 	},
 	"dependencies": {
 		"@contextvm/mcp-sdk": "^1.30.0",
-		"@contextvm/sdk": "^0.13.6",
+		"@contextvm/sdk": "^0.13.7",
 		"@sjsf/ajv8-validator": "^3.3.2",
 		"@sjsf/form": "^3.3.2",
 		"@sjsf/shadcn4-theme": "^3.3.2",
diff --git a/src/lib/components/PromptGetForm.svelte b/src/lib/components/PromptGetForm.svelte
index 547e808..a1f2aa6 100644
--- a/src/lib/components/PromptGetForm.svelte
+++ b/src/lib/components/PromptGetForm.svelte
@@ -19,6 +19,11 @@
 	import { activeAccount } from '$lib/services/accountManager.svelte';
 	import * as Alert from '$lib/components/ui/alert/index.js';
 	import PaymentStatusPanel from '$lib/components/PaymentStatusPanel.svelte';
+	import PaymentErrorCard from '$lib/components/chat/PaymentErrorCard.svelte';
+	import {
+		extractExplicitGatingError,
+		type ExplicitGatingError
+	} from '$lib/services/payments/payment-errors';
 	import { paymentNotificationsService } from '$lib/services/payments/payment-notifications.svelte';
 	import {
 		findCapTagForPrompt,
@@ -43,6 +48,7 @@
 	// Form state
 	let formResult = $state<GetPromptResult | null>(null);
 	let formError = $state<string | null>(null);
+	let gatingError = $state<ExplicitGatingError | null>(null);
 	let showResult = $state(false);
 
 	// Collapsible state
@@ -98,6 +104,7 @@
 			// Ensure payment panel is visible for subsequent calls.
 			paymentOpen = true;
 			paymentNotificationsService.clearServer(serverPubkey);
+			gatingError = null;
 			open = true;
 			try {
 				if (!connectionState.connected) {
@@ -111,6 +118,12 @@
 				formResult = result;
 				showResult = true;
 			} catch (error) {
+				const explicitGatingError = extractExplicitGatingError(error);
+				if (explicitGatingError) {
+					gatingError = explicitGatingError;
+					return;
+				}
+
 				formError = error instanceof Error ? error.message : 'Failed to get prompt';
 			} finally {
 				loading = false;
@@ -123,6 +136,7 @@
 		form.reset(new Event('reset'));
 		formResult = null;
 		formError = null;
+		gatingError = null;
 		showResult = false;
 		paymentNotificationsService.clearServer(serverPubkey);
 		paymentOpen = true;
@@ -160,6 +174,11 @@
 		class="data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:animate-in data-[state=open]:fade-in-0 overflow-hidden"
 	>
 		<div class="border-t bg-muted/50 p-4">
+			{#if gatingError}
+				<div class="mb-4">
+					<PaymentErrorCard error={gatingError} />
+				</div>
+			{/if}
 			{#if paymentState}
 				<div class="mb-4">
 					<PaymentStatusPanel payment={paymentState} open={paymentOpen} />
diff --git a/src/lib/components/ResourceReadForm.svelte b/src/lib/components/ResourceReadForm.svelte
index 2892381..90b678f 100644
--- a/src/lib/components/ResourceReadForm.svelte
+++ b/src/lib/components/ResourceReadForm.svelte
@@ -12,6 +12,11 @@
 	import { activeAccount } from '$lib/services/accountManager.svelte';
 	import * as Alert from '$lib/components/ui/alert/index.js';
 	import PaymentStatusPanel from '$lib/components/PaymentStatusPanel.svelte';
+	import PaymentErrorCard from '$lib/components/chat/PaymentErrorCard.svelte';
+	import {
+		extractExplicitGatingError,
+		type ExplicitGatingError
+	} from '$lib/services/payments/payment-errors';
 	import { paymentNotificationsService } from '$lib/services/payments/payment-notifications.svelte';
 	import {
 		findCapTagForResource,
@@ -36,6 +41,7 @@
 	// Form state
 	let formResult = $state<ReadResourceResult | null>(null);
 	let formError = $state<string | null>(null);
+	let gatingError = $state<ExplicitGatingError | null>(null);
 	let showResult = $state(false);
 
 	// Collapsible state
@@ -80,6 +86,7 @@
 				// Ensure payment panel is visible for subsequent reads.
 				paymentOpen = true;
 				paymentNotificationsService.clearServer(serverPubkey);
+				gatingError = null;
 				open = true;
 				try {
 					if (!connectionState.connected) {
@@ -93,6 +100,12 @@
 					formResult = result;
 					showResult = true;
 				} catch (error) {
+					const explicitGatingError = extractExplicitGatingError(error);
+					if (explicitGatingError) {
+						gatingError = explicitGatingError;
+						return;
+					}
+
 					formError = error instanceof Error ? error.message : 'Failed to read resource';
 				} finally {
 					loading = false;
@@ -106,6 +119,7 @@
 		form.reset(new Event('reset'));
 		formResult = null;
 		formError = null;
+		gatingError = null;
 		showResult = false;
 		paymentNotificationsService.clearServer(serverPubkey);
 		paymentOpen = true;
@@ -140,6 +154,11 @@
 		class="data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:animate-in data-[state=open]:fade-in-0 overflow-hidden"
 	>
 		<div class="border-t bg-muted/50 p-4">
+			{#if gatingError}
+				<div class="mb-4">
+					<PaymentErrorCard error={gatingError} />
+				</div>
+			{/if}
 			{#if paymentState}
 				<div class="mb-4">
 					<PaymentStatusPanel payment={paymentState} open={paymentOpen} />
diff --git a/src/lib/components/ToolCallForm.svelte b/src/lib/components/ToolCallForm.svelte
index ec7c5eb..601ff10 100644
--- a/src/lib/components/ToolCallForm.svelte
+++ b/src/lib/components/ToolCallForm.svelte
@@ -13,6 +13,11 @@
 	import { activeAccount } from '$lib/services/accountManager.svelte';
 	import * as Alert from '$lib/components/ui/alert/index.js';
 	import PaymentStatusPanel from '$lib/components/PaymentStatusPanel.svelte';
+	import PaymentErrorCard from '$lib/components/chat/PaymentErrorCard.svelte';
+	import {
+		extractExplicitGatingError,
+		type ExplicitGatingError
+	} from '$lib/services/payments/payment-errors';
 	import { paymentNotificationsService } from '$lib/services/payments/payment-notifications.svelte';
 	import {
 		findCapTagForTool,
@@ -36,6 +41,7 @@
 	// Form state
 	let formResult = $state<CallToolResult | null>(null);
 	let formError = $state<string | null>(null);
+	let gatingError = $state<ExplicitGatingError | null>(null);
 	let showResult = $state(false);
 	let paymentState = $derived.by(() =>
 		paymentNotificationsService.getLatestForServer(serverPubkey)
@@ -73,6 +79,7 @@
 				// Ensure the payment UI is visible for subsequent calls.
 				paymentOpen = true;
 				paymentNotificationsService.clearServer(serverPubkey);
+				gatingError = null;
 				try {
 					if (!connectionState.connected) {
 						await mcpClientService.getClient(serverPubkey);
@@ -92,6 +99,14 @@
 					showResult = true;
 					loading = false;
 				} catch (error) {
+					const explicitGatingError = extractExplicitGatingError(error);
+					if (explicitGatingError) {
+						gatingError = explicitGatingError;
+						open = true;
+						loading = false;
+						return;
+					}
+
 					formError = error instanceof Error ? error.message : 'Failed to call tool';
 					loading = false;
 				}
@@ -104,6 +119,7 @@
 		form.reset(new Event('reset'));
 		formResult = null;
 		formError = null;
+		gatingError = null;
 		showResult = false;
 		paymentNotificationsService.clearServer(serverPubkey);
 		// Keep payment panel visible for the next invocation.
@@ -165,6 +181,11 @@
 		class="data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:animate-in data-[state=open]:fade-in-0 overflow-hidden"
 	>
 		<div class="border-t bg-muted/50 p-4">
+			{#if gatingError}
+				<div class="mb-4">
+					<PaymentErrorCard error={gatingError} />
+				</div>
+			{/if}
 			{#if paymentState}
 				<div class="mb-4">
 					<PaymentStatusPanel payment={paymentState} open={paymentOpen} />
diff --git a/src/lib/components/chat/PaymentErrorCard.svelte b/src/lib/components/chat/PaymentErrorCard.svelte
new file mode 100644
index 0000000..845c1a7
--- /dev/null
+++ b/src/lib/components/chat/PaymentErrorCard.svelte
@@ -0,0 +1,113 @@
+<script lang="ts">
+	import QrCode from '$lib/components/QrCode.svelte';
+	import * as Tabs from '$lib/components/ui/tabs/index.js';
+	import {
+		PAYMENT_PENDING_ERROR_CODE,
+		PAYMENT_REQUIRED_ERROR_CODE,
+		isPaymentRequiredError,
+		type ExplicitGatingError
+	} from '$lib/services/payments/payment-errors';
+	import { copyToClipboard } from '$lib/utils';
+	import CopyIcon from '@lucide/svelte/icons/copy';
+
+	let { error }: { error: ExplicitGatingError } = $props();
+
+	const paymentOptions = $derived.by(() => {
+		if (!isPaymentRequiredError(error) || !Array.isArray(error.data.payment_options)) {
+			return [];
+		}
+
+		return error.data.payment_options.filter(
+			(option): option is Record<string, unknown> => typeof option === 'object' && option !== null
+		);
+	});
+	const instructions = $derived(
+		typeof error.data.instructions === 'string' ? error.data.instructions : null
+	);
+	const retryAfter = $derived(
+		typeof error.data.retry_after === 'number' ? error.data.retry_after : null
+	);
+	const title = $derived(
+		error.code === PAYMENT_REQUIRED_ERROR_CODE ? 'Payment required' : 'Payment pending'
+	);
+</script>
+
+<div
+	class="rounded-lg border border-amber-500/30 bg-amber-50/70 p-3 text-amber-950 shadow-sm dark:bg-amber-950/20 dark:text-amber-50"
+>
+	<div class="mb-2 flex flex-wrap items-center gap-2">
+		<span
+			class="rounded-full bg-amber-500/15 px-2 py-0.5 text-[10px] font-medium text-amber-800 dark:text-amber-200"
+		>
+			{title}
+		</span>
+		<span class="font-mono text-[10px] text-amber-800/70 dark:text-amber-200/70">
+			{error.code === PAYMENT_REQUIRED_ERROR_CODE
+				? PAYMENT_REQUIRED_ERROR_CODE
+				: PAYMENT_PENDING_ERROR_CODE}
+		</span>
+		{#if retryAfter !== null}
+			<span class="font-mono text-[10px] text-amber-800/70 dark:text-amber-200/70">
+				Retry after {retryAfter}s
+			</span>
+		{/if}
+	</div>
+
+	{#if instructions}
+		<p class="mb-2 text-sm leading-5">{instructions}</p>
+	{:else if error.message}
+		<p class="mb-2 text-sm leading-5">{error.message}</p>
+	{/if}
+
+	{#if paymentOptions.length > 0}
+		<div class="rounded-md bg-background/70 px-3 py-2 text-foreground">
+			{#each paymentOptions as option, i (i)}
+				{@const amount = option.amount}
+				{@const pmi = typeof option.pmi === 'string' ? option.pmi : null}
+				{@const payReq = typeof option.pay_req === 'string' ? option.pay_req : null}
+
+				<div class={i > 0 ? 'mt-3 border-t border-border/50 pt-3' : ''}>
+					<div class="flex flex-wrap items-center gap-x-3 gap-y-1">
+						{#if amount !== undefined}
+							<span class="text-xs text-muted-foreground">Amount</span>
+							<span class="font-mono text-xs">{amount}</span>
+						{/if}
+						{#if pmi}
+							<span class="text-xs text-muted-foreground">PMI</span>
+							<span class="min-w-0 font-mono text-xs break-all">{pmi}</span>
+						{/if}
+					</div>
+
+					{#if payReq}
+						<Tabs.Root value="invoice" class="mt-3 w-full">
+							<Tabs.List class="grid w-full grid-cols-2">
+								<Tabs.Trigger value="invoice">Payment Request</Tabs.Trigger>
+								<Tabs.Trigger value="qr">QR</Tabs.Trigger>
+							</Tabs.List>
+
+							<Tabs.Content value="invoice" class="mt-2">
+								<div class="relative rounded-md bg-muted p-2">
+									<pre class="max-h-44 overflow-auto pr-8 text-xs whitespace-pre-wrap">{payReq}</pre>
+									<button
+										type="button"
+										onclick={() => copyToClipboard(payReq)}
+										class="absolute top-1.5 right-1.5 rounded p-1 text-muted-foreground transition-colors hover:bg-background hover:text-primary"
+										aria-label="Copy payment request"
+									>
+										<CopyIcon class="h-3.5 w-3.5" />
+									</button>
+								</div>
+							</Tabs.Content>
+
+							<Tabs.Content value="qr" class="mt-2">
+								<div class="flex justify-center">
+									<QrCode data={payReq} size={180} />
+								</div>
+							</Tabs.Content>
+						</Tabs.Root>
+					{/if}
+				</div>
+			{/each}
+		</div>
+	{/if}
+</div>
diff --git a/src/lib/components/chat/ToolCallCard.svelte b/src/lib/components/chat/ToolCallCard.svelte
index 9f5aebc..be04456 100644
--- a/src/lib/components/chat/ToolCallCard.svelte
+++ b/src/lib/components/chat/ToolCallCard.svelte
@@ -1,5 +1,8 @@
 <script lang="ts">
 	import Button from '$lib/components/ui/button/button.svelte';
+	import PaymentErrorCard from '$lib/components/chat/PaymentErrorCard.svelte';
+	import PaymentStatusPanel from '$lib/components/PaymentStatusPanel.svelte';
+	import { paymentNotificationsService } from '$lib/services/payments/payment-notifications.svelte';
 	import * as Collapsible from '$lib/components/ui/collapsible/index.js';
 	import type { ToolCallData } from '$lib/types/chat-types';
 	import { cn, copyToClipboard } from '$lib/utils.js';
@@ -9,6 +12,7 @@
 	import CopyIcon from '@lucide/svelte/icons/copy';
 	import LoaderCircleIcon from '@lucide/svelte/icons/loader-circle';
 	import ShieldCheckIcon from '@lucide/svelte/icons/shield-check';
+	import WalletIcon from '@lucide/svelte/icons/wallet';
 	import XCircleIcon from '@lucide/svelte/icons/x-circle';
 
 	let {
@@ -26,6 +30,10 @@
 	let formattedArguments = $state('{}');
 	let lastArguments = $state('');
 
+	// Transparent-mode payment for this tool's server (explicit gating uses paymentError below).
+	const transparentPayment = $derived(
+		toolCall.serverPubkey ? paymentNotificationsService.getLatestForServer(toolCall.serverPubkey) : undefined
+	);
 	const title = $derived(toolCall.name.replace(/_/g, ' '));
 	const statusLabel = $derived.by(() => {
 		switch (toolCall.status) {
@@ -39,6 +47,8 @@
 				return 'Rejected';
 			case 'error':
 				return 'Error';
+			case 'payment_required':
+				return 'Payment required';
 			default:
 				return 'Approval needed';
 		}
@@ -85,13 +95,15 @@
 					'inline-flex items-center gap-1.5 rounded-full px-2 py-0.5 text-[10px] font-medium',
 					toolCall.status === 'completed'
 						? 'bg-emerald-500/10 text-emerald-600 dark:text-emerald-400'
-						: toolCall.status === 'error'
-							? 'bg-destructive/10 text-destructive'
-							: toolCall.status === 'rejected'
-								? 'bg-slate-500/10 text-slate-600 dark:text-slate-300'
-								: toolCall.status === 'running'
-									? 'bg-primary/10 text-primary'
-									: 'bg-amber-500/10 text-amber-700 dark:text-amber-300'
+						: toolCall.status === 'payment_required'
+							? 'bg-amber-500/10 text-amber-700 dark:text-amber-300'
+							: toolCall.status === 'error'
+								? 'bg-destructive/10 text-destructive'
+								: toolCall.status === 'rejected'
+									? 'bg-slate-500/10 text-slate-600 dark:text-slate-300'
+									: toolCall.status === 'running'
+										? 'bg-primary/10 text-primary'
+										: 'bg-amber-500/10 text-amber-700 dark:text-amber-300'
 				)}
 				role="status"
 				aria-live="polite"
@@ -99,6 +111,8 @@
 			>
 				{#if toolCall.status === 'completed'}
 					<CheckCircleIcon class="h-3 w-3" />
+				{:else if toolCall.status === 'payment_required'}
+					<WalletIcon class="h-3 w-3" />
 				{:else if toolCall.status === 'error'}
 					<XCircleIcon class="h-3 w-3" />
 				{:else if toolCall.status === 'rejected'}
@@ -174,5 +188,12 @@
 				</Collapsible.Content>
 			</Collapsible.Root>
 		{/if}
+
+		{#if toolCall.paymentError}
+			<PaymentErrorCard error={toolCall.paymentError} />
+		{:else if transparentPayment &&
+			(toolCall.status === 'running' || toolCall.status === 'pending' || toolCall.status === 'approved')}
+			<PaymentStatusPanel payment={transparentPayment} />
+		{/if}
 	</div>
 </div>
diff --git a/src/lib/services/agent-orchestrator.test.ts b/src/lib/services/agent-orchestrator.test.ts
new file mode 100644
index 0000000..49e658f
--- /dev/null
+++ b/src/lib/services/agent-orchestrator.test.ts
@@ -0,0 +1,245 @@
+import { describe, expect, it, mock } from 'bun:test';
+import { AgentOrchestrator } from './agent-orchestrator';
+import {
+	PAYMENT_PENDING_ERROR_CODE,
+	PAYMENT_REQUIRED_ERROR_CODE
+} from './payments/payment-errors';
+import type { LLMService, SendMessageResult } from './llm';
+import type { McpClientService } from './mcpClient.svelte';
+import type { ChatMessage } from '$lib/types/chat-types';
+
+describe('AgentOrchestrator explicit gating', () => {
+	it('handles -32042 payment_required by setting status and serializing losslessly', async () => {
+		const mockData = {
+			instructions: 'Pay to continue',
+			payment_options: [{ pmi: 'bitcoin-lightning-bolt11', amount: 21, pay_req: 'lnbc...' }]
+		};
+		const mockError = Object.assign(new Error('Payment Required'), {
+			code: PAYMENT_REQUIRED_ERROR_CODE,
+			data: mockData
+		});
+
+		const mcpClientService = {
+			clients: new Map([['test_server', { 
+				getServerVersion: () => ({ name: 'test', version: '1' }),
+				listTools: async () => ({ tools: [{ name: 'test_tool', inputSchema: { type: 'object', properties: {} } }] })
+			}]]),
+			listTools: mock(async () => ({
+				tools: [
+					{
+						name: 'test_tool',
+						inputSchema: { type: 'object', properties: {} }
+					}
+				]
+			})),
+			callTool: mock(async () => {
+				throw mockError;
+			})
+		} as unknown as McpClientService;
+
+		const llmService: LLMService = {
+			sendMessage: mock(async (messages: ChatMessage[]) => {
+				// If we have a tool result, return stop
+				const hasToolResult = messages.some((m) => m.role === 'tool');
+				if (hasToolResult) {
+					return { content: 'Acknowledged', finishReason: 'stop' } as SendMessageResult;
+				}
+
+				return {
+					content: '',
+					finishReason: 'tool_calls',
+					model: 'test',
+					toolCalls: [
+						{
+							id: 'call_1',
+							functionName: 'test_test_tool',
+							arguments: '{}'
+						}
+					]
+				} as SendMessageResult;
+			})
+		} as unknown as LLMService;
+
+		const orchestrator = new AgentOrchestrator({ llmService, mcpClientService });
+
+		const initialMessages: ChatMessage[] = [{ id: 'msg1', role: 'user', content: 'Do it', timestamp: new Date() }];
+
+		const runPromise = orchestrator.run({
+			messages: initialMessages,
+			signal: new AbortController().signal
+		});
+
+		for (let i = 0; i < 200 && !(orchestrator as any).pendingApprovals?.has('call_1'); i += 1) {
+			await new Promise((resolve) => setTimeout(resolve, 1));
+		}
+		if (!(orchestrator as any).pendingApprovals?.has('call_1')) throw new Error('Tool call approval not registered');
+		orchestrator.approveToolCall('call_1');
+
+		await runPromise;
+
+		// We should have: User -> Assistant (tool_calls) -> Tool (payment_required result) -> Assistant (Acknowledged)
+		expect(initialMessages.length).toBe(4);
+
+		const assistantMessage = initialMessages[1];
+		expect(assistantMessage.role).toBe('assistant');
+		expect(assistantMessage.toolCalls).toBeDefined();
+
+		const toolCall = assistantMessage.toolCalls![0];
+		expect(toolCall.status).toBe('payment_required');
+		expect(toolCall.paymentError).toEqual({
+			code: PAYMENT_REQUIRED_ERROR_CODE,
+			message: 'Payment Required',
+			data: mockData
+		});
+
+		const toolMessage = initialMessages[2];
+		expect(toolMessage.role).toBe('tool');
+		expect(toolMessage.content).toBe(
+			JSON.stringify({
+				code: PAYMENT_REQUIRED_ERROR_CODE,
+				message: 'Payment Required',
+				data: mockData
+			})
+		);
+	});
+
+	it('handles -32043 payment_pending by setting status and serializing losslessly', async () => {
+		const mockData = { retry_after: 2 };
+		const mockError = Object.assign(new Error('Payment Pending'), {
+			code: PAYMENT_PENDING_ERROR_CODE,
+			data: mockData
+		});
+
+		const mcpClientService = {
+			clients: new Map([['test_server', { 
+				getServerVersion: () => ({ name: 'test', version: '1' }),
+				listTools: async () => ({ tools: [{ name: 'test_tool', inputSchema: { type: 'object', properties: {} } }] })
+			}]]),
+			listTools: mock(async () => ({
+				tools: [
+					{
+						name: 'test_tool',
+						inputSchema: { type: 'object', properties: {} }
+					}
+				]
+			})),
+			callTool: mock(async () => {
+				throw mockError;
+			})
+		} as unknown as McpClientService;
+
+		const llmService: LLMService = {
+			sendMessage: mock(async (messages: ChatMessage[]) => {
+				const hasToolResult = messages.some((m) => m.role === 'tool');
+				if (hasToolResult) {
+					return { content: 'Acknowledged', finishReason: 'stop' } as SendMessageResult;
+				}
+
+				return {
+					content: '',
+					finishReason: 'tool_calls',
+					model: 'test',
+					toolCalls: [
+						{
+							id: 'call_1',
+							functionName: 'test_test_tool',
+							arguments: '{}'
+						}
+					]
+				} as SendMessageResult;
+			})
+		} as unknown as LLMService;
+
+		const orchestrator = new AgentOrchestrator({ llmService, mcpClientService });
+		const initialMessages: ChatMessage[] = [{ id: 'msg1', role: 'user', content: 'Do it', timestamp: new Date() }];
+		
+		const runPromise = orchestrator.run({
+			messages: initialMessages,
+			signal: new AbortController().signal
+		});
+
+		for (let i = 0; i < 200 && !(orchestrator as any).pendingApprovals?.has('call_1'); i += 1) {
+			await new Promise((resolve) => setTimeout(resolve, 1));
+		}
+		if (!(orchestrator as any).pendingApprovals?.has('call_1')) throw new Error('Tool call approval not registered');
+		orchestrator.approveToolCall('call_1');
+
+		await runPromise;
+
+		const assistantMessage = initialMessages[1];
+		const toolCall = assistantMessage.toolCalls![0];
+		
+		expect(toolCall.status).toBe('payment_required');
+		expect(toolCall.paymentError).toEqual({
+			code: PAYMENT_PENDING_ERROR_CODE,
+			message: 'Payment Pending',
+			data: mockData
+		});
+	});
+
+	it('leaves status as error for non-payment errors', async () => {
+		const mockError = new Error('Network timeout');
+
+		const mcpClientService = {
+			clients: new Map([['test_server', { 
+				getServerVersion: () => ({ name: 'test', version: '1' }),
+				listTools: async () => ({ tools: [{ name: 'test_tool', inputSchema: { type: 'object', properties: {} } }] })
+			}]]),
+			listTools: mock(async () => ({
+				tools: [
+					{
+						name: 'test_tool',
+						inputSchema: { type: 'object', properties: {} }
+					}
+				]
+			})),
+			callTool: mock(async () => {
+				throw mockError;
+			})
+		} as unknown as McpClientService;
+
+		const llmService: LLMService = {
+			sendMessage: mock(async (messages: ChatMessage[]) => {
+				const hasToolResult = messages.some((m) => m.role === 'tool');
+				if (hasToolResult) {
+					return { content: 'Acknowledged', finishReason: 'stop' } as SendMessageResult;
+				}
+
+				return {
+					content: '',
+					finishReason: 'tool_calls',
+					model: 'test',
+					toolCalls: [
+						{
+							id: 'call_1',
+							functionName: 'test_test_tool',
+							arguments: '{}'
+						}
+					]
+				} as SendMessageResult;
+			})
+		} as unknown as LLMService;
+
+		const orchestrator = new AgentOrchestrator({ llmService, mcpClientService });
+		const initialMessages: ChatMessage[] = [{ id: 'msg1', role: 'user', content: 'Do it', timestamp: new Date() }];
+		
+		const runPromise = orchestrator.run({
+			messages: initialMessages,
+			signal: new AbortController().signal
+		});
+
+		for (let i = 0; i < 200 && !(orchestrator as any).pendingApprovals?.has('call_1'); i += 1) {
+			await new Promise((resolve) => setTimeout(resolve, 1));
+		}
+		if (!(orchestrator as any).pendingApprovals?.has('call_1')) throw new Error('Tool call approval not registered');
+		orchestrator.approveToolCall('call_1');
+
+		await runPromise;
+
+		const assistantMessage = initialMessages[1];
+		const toolCall = assistantMessage.toolCalls![0];
+		
+		expect(toolCall.status).toBe('error');
+		expect(toolCall.paymentError).toBeUndefined();
+	});
+});
diff --git a/src/lib/services/agent-orchestrator.ts b/src/lib/services/agent-orchestrator.ts
index a47fb88..1fa8c3e 100644
--- a/src/lib/services/agent-orchestrator.ts
+++ b/src/lib/services/agent-orchestrator.ts
@@ -3,8 +3,11 @@ import type { ChatMessage, ToolCallData } from '$lib/types/chat-types';
 import type { LLMService, SendMessageResult } from '$lib/services/llm';
 import type { McpClientService } from '$lib/services/mcpClient.svelte';
 import { ToolRegistry, type ToolResolveResult } from '$lib/services/mcp-openai-bridge';
+import {
+	extractExplicitGatingError,
+	serializeExplicitGatingError
+} from '$lib/services/payments/payment-errors';
 
-const DEFAULT_MAX_TOOL_ROUNDS = 5;
 const DEFAULT_TOOL_APPROVAL_TIMEOUT_MS = 120_000;
 const DEFAULT_REGISTRY_CACHE_MS = 60_000;
 const DEFAULT_TOOL_CONCURRENCY = 4;
@@ -36,12 +39,10 @@ export type AgentOrchestratorRunOptions = {
 
 export type AgentOrchestratorResult = {
 	lastModel: string | null;
-	stoppedByMaxRounds: boolean;
 	error?: string;
 };
 
 export class AgentOrchestrator {
-	private maxToolRounds: number;
 	private toolApprovalTimeoutMs: number;
 	private registryCacheMs: number;
 	private toolConcurrency: number;
@@ -53,14 +54,12 @@ export class AgentOrchestrator {
 	constructor(options: {
 		llmService: LLMService;
 		mcpClientService: McpClientService;
-		maxToolRounds?: number;
 		toolApprovalTimeoutMs?: number;
 		registryCacheMs?: number;
 		toolConcurrency?: number;
 	}) {
 		this.llmService = options.llmService;
 		this.mcpClientService = options.mcpClientService;
-		this.maxToolRounds = options.maxToolRounds ?? DEFAULT_MAX_TOOL_ROUNDS;
 		this.toolApprovalTimeoutMs = options.toolApprovalTimeoutMs ?? DEFAULT_TOOL_APPROVAL_TIMEOUT_MS;
 		this.registryCacheMs = options.registryCacheMs ?? DEFAULT_REGISTRY_CACHE_MS;
 		this.toolConcurrency = Math.max(1, options.toolConcurrency ?? DEFAULT_TOOL_CONCURRENCY);
@@ -100,11 +99,8 @@ export class AgentOrchestrator {
 				: null;
 			let outgoingMessages = this.withToolSystemContext(messages, systemMessage);
 			let done = false;
-			let round = 0;
-
-			while (!done && round < this.maxToolRounds) {
-				round += 1;
 
+			while (!done && !signal.aborted) {
 				const rawAssistant: ChatMessage = {
 					id: crypto.randomUUID(),
 					content: '',
@@ -134,7 +130,7 @@ export class AgentOrchestrator {
 					if (!assistant.content && !assistant.toolCalls?.length) {
 						this.removeMessage(messages, assistant.id, callbacks);
 					}
-					return { lastModel, stoppedByMaxRounds: false };
+					return { lastModel };
 				}
 
 				if (result.content && result.content !== assistant.content) {
@@ -173,7 +169,7 @@ export class AgentOrchestrator {
 						}
 					);
 					if (signal.aborted) {
-						return { lastModel, stoppedByMaxRounds: false };
+						return { lastModel };
 					}
 
 					for (const toolResultMessage of toolResultMessages) {
@@ -191,19 +187,7 @@ export class AgentOrchestrator {
 				done = true;
 			}
 
-			if (!done && !signal.aborted) {
-				const warningMessage: ChatMessage = {
-					id: crypto.randomUUID(),
-					content: `Stopped after ${this.maxToolRounds} tool rounds to avoid a runaway loop.`,
-					role: 'assistant',
-					timestamp: new Date()
-				};
-				messages.push(warningMessage);
-				callbacks?.onMessageAdded?.(warningMessage);
-				return { lastModel, stoppedByMaxRounds: true };
-			}
-
-			return { lastModel, stoppedByMaxRounds: false };
+			return { lastModel };
 		} catch (error) {
 			const latestAssistant = [...messages]
 				.reverse()
@@ -213,7 +197,7 @@ export class AgentOrchestrator {
 				if (latestAssistant && !latestAssistant.content && !latestAssistant.toolCalls?.length) {
 					this.removeMessage(messages, latestAssistant.id, callbacks);
 				}
-				return { lastModel, stoppedByMaxRounds: false };
+				return { lastModel };
 			}
 
 			const errorText = error instanceof Error ? error.message : 'Something went wrong.';
@@ -222,7 +206,7 @@ export class AgentOrchestrator {
 				callbacks?.onAssistantUpdated?.(latestAssistant);
 			}
 			callbacks?.onError?.(errorText);
-			return { lastModel, stoppedByMaxRounds: false, error: errorText };
+			return { lastModel, error: errorText };
 		} finally {
 			this.rejectPendingApprovals(new Error('Tool approval cancelled'));
 		}
@@ -316,7 +300,8 @@ export class AgentOrchestrator {
 		message: ChatMessage,
 		toolCallId: string,
 		status: ToolCallData['status'],
-		result?: string
+		result?: string,
+		paymentError?: ToolCallData['paymentError']
 	): void {
 		const toolCall = message.toolCalls?.find((candidate) => candidate.id === toolCallId);
 		if (!toolCall) {
@@ -327,6 +312,9 @@ export class AgentOrchestrator {
 		if (result !== undefined) {
 			toolCall.result = result;
 		}
+		if (paymentError !== undefined) {
+			toolCall.paymentError = paymentError;
+		}
 	}
 
 	private serializeToolResult(result: CallToolResult): string {
@@ -385,7 +373,8 @@ export class AgentOrchestrator {
 				name: toolCall.functionName,
 				arguments: toolCall.arguments,
 				status: resolved.value.tier === 'auto' ? 'running' : 'pending',
-				serverName: resolved.value.serverName
+				serverName: resolved.value.serverName,
+				serverPubkey: resolved.value.serverPubkey
 			};
 		});
 
@@ -403,8 +392,13 @@ export class AgentOrchestrator {
 		} = {}
 	): Promise<ChatMessage[]> {
 		const { signal, onStatusUpdate, approvalTimeoutMs = this.toolApprovalTimeoutMs } = options;
-		const markStatus = (toolCallId: string, status: ToolCallData['status'], result?: string) => {
-			this.updateToolCallStatus(assistantMessage, toolCallId, status, result);
+		const markStatus = (
+			toolCallId: string,
+			status: ToolCallData['status'],
+			result?: string,
+			paymentError?: ToolCallData['paymentError']
+		) => {
+			this.updateToolCallStatus(assistantMessage, toolCallId, status, result, paymentError);
 			onStatusUpdate?.(toolCallId);
 		};
 		const throwIfAborted = () => {
@@ -443,6 +437,13 @@ export class AgentOrchestrator {
 				markStatus(toolCall.id, 'completed', serialized);
 				return this.makeToolResultMessage(toolCall.id, toolCall.functionName, serialized);
 			} catch (error) {
+				const gatingError = extractExplicitGatingError(error);
+				if (gatingError) {
+					const serialized = serializeExplicitGatingError(gatingError);
+					markStatus(toolCall.id, 'payment_required', serialized, gatingError);
+					return this.makeToolResultMessage(toolCall.id, toolCall.functionName, serialized);
+				}
+
 				const errorText = error instanceof Error ? error.message : 'Tool call failed';
 				const serialized = `Error: ${errorText}`;
 				const status = errorText === 'User rejected tool call' ? 'rejected' : 'error';
diff --git a/src/lib/services/mcpClient.svelte.ts b/src/lib/services/mcpClient.svelte.ts
index f9d9fed..f25c08c 100644
--- a/src/lib/services/mcpClient.svelte.ts
+++ b/src/lib/services/mcpClient.svelte.ts
@@ -2,7 +2,8 @@ import { activeAccount } from '$lib/services/accountManager.svelte';
 import { NostrClientTransport } from '@contextvm/sdk';
 import {
 	PAYMENT_ACCEPTED_METHOD,
-	PAYMENT_REJECTED_METHOD
+	PAYMENT_REJECTED_METHOD,
+	PAYMENT_REQUIRED_METHOD
 } from '@contextvm/sdk/payments/constants';
 import { Client } from '@contextvm/mcp-sdk/client/index.js';
 import {
@@ -16,14 +17,18 @@ import {
 } from '@contextvm/mcp-sdk/types.js';
 import { SvelteMap } from 'svelte/reactivity';
 import { paymentNotificationsService } from '$lib/services/payments/payment-notifications.svelte';
-import { withClientPayments, PMI_BITCOIN_LIGHTNING_BOLT11 } from '@contextvm/sdk';
-import { UiOnlyPaymentHandler } from '$lib/services/payments/ui-payment-handler';
+import { withClientPayments } from '@contextvm/sdk';
 import type { Transport } from '@contextvm/mcp-sdk/shared/transport.js';
 import type { ProgressCallback } from '@contextvm/mcp-sdk/shared/protocol.js';
 import { decodeServerIdentifier } from '$lib/utils';
-import type { PaymentAcceptedNotification, PaymentRejectedNotification } from '@contextvm/sdk';
+import type { PaymentAcceptedNotification, PaymentRejectedNotification, PaymentRequiredNotification } from '@contextvm/sdk';
 import { z } from 'zod';
 
+export type PaymentInteractionMode = 'transparent' | 'explicit_gating';
+type PaymentNegotiatingTransport = NostrClientTransport & {
+	getEffectivePaymentInteraction?: () => PaymentInteractionMode | undefined;
+};
+
 const PaymentAcceptedNotificationSchema = z.object({
 	jsonrpc: z.literal('2.0').optional(),
 	method: z.literal(PAYMENT_ACCEPTED_METHOD),
@@ -36,6 +41,12 @@ const PaymentRejectedNotificationSchema = z.object({
 	params: z.record(z.string(), z.unknown()).optional()
 });
 
+const PaymentRequiredNotificationSchema = z.object({
+	jsonrpc: z.literal('2.0').optional(),
+	method: z.literal(PAYMENT_REQUIRED_METHOD),
+	params: z.record(z.string(), z.unknown()).optional()
+});
+
 function getRequestEventIdFromNotification(notification: {
 	params?: Record<string, unknown>;
 }): string | undefined {
@@ -58,6 +69,7 @@ export class McpClientService {
 	private clientTransports = new SvelteMap<string, NostrClientTransport>();
 	private connectionStates = new SvelteMap<string, McpConnectionState>();
 	private serverIdentifiers = new SvelteMap<string, string>();
+	private connectionModes = new SvelteMap<string, PaymentInteractionMode>();
 	private static readonly clientConfig = {
 		name: 'ContextVM Web Client',
 		version: '1.0.0'
@@ -129,6 +141,22 @@ export class McpClientService {
 				timestamp: Date.now()
 			});
 		});
+
+		client.setNotificationHandler(PaymentRequiredNotificationSchema, async (notification) => {
+			const requestEventId = getRequestEventIdFromNotification(notification);
+			if (!requestEventId) return;
+
+			paymentNotificationsService.set({
+				serverPubkey: serverIdentifier,
+				requestEventId,
+				status: 'payment_required',
+				notification: {
+					type: 'payment_required',
+					...(notification as PaymentRequiredNotification)
+				},
+				timestamp: Date.now()
+			});
+		});
 	}
 
 	private clearServerState(serverIdentifier: string): void {
@@ -137,8 +165,10 @@ export class McpClientService {
 		paymentNotificationsService.clearServer(this.getServerKey(serverIdentifier));
 	}
 
-	// Helper method to create a new transport for a client
-	private createTransport(serverIdentifier: string): Transport {
+	private createTransport(
+		serverIdentifier: string,
+		paymentInteraction?: PaymentInteractionMode
+	): Transport {
 		// Check if user is logged in
 		const currentAccount = activeAccount.getValue();
 		if (!currentAccount) {
@@ -159,15 +189,7 @@ export class McpClientService {
 		});
 		this.clientTransports.set(serverKey, baseTransport);
 
-		// UI-only payments integration using the SDK middleware.
-		// - advertises PMIs via `pmi` tags
-		// - captures payment_required in our handler
-		// - does not attempt to pay
-		const uiHandler = new UiOnlyPaymentHandler({
-			pmi: PMI_BITCOIN_LIGHTNING_BOLT11,
-			serverPubkey: preferredIdentifier
-		});
-		return withClientPayments(baseTransport, { handlers: [uiHandler] });
+		return withClientPayments(baseTransport, { paymentInteraction });
 	}
 
 	/**
@@ -206,6 +228,31 @@ export class McpClientService {
 			?.getServerPromptsListEvent();
 	}
 
+	public setConnectionMode(serverIdentifier: string, mode: PaymentInteractionMode): void {
+		this.connectionModes.set(this.getServerKey(serverIdentifier), mode);
+	}
+
+	public getConnectionMode(serverIdentifier: string): PaymentInteractionMode {
+		return this.connectionModes.get(this.getServerKey(serverIdentifier)) ?? 'transparent';
+	}
+
+	public getEffectivePaymentMode(serverIdentifier: string): PaymentInteractionMode | undefined {
+		return (
+			this.clientTransports.get(this.getServerKey(serverIdentifier)) as
+				| PaymentNegotiatingTransport
+				| undefined
+		)?.getEffectivePaymentInteraction?.();
+	}
+
+	public async reconnectWithMode(
+		serverIdentifier: string,
+		mode: PaymentInteractionMode
+	): Promise<void> {
+		this.setConnectionMode(serverIdentifier, mode);
+		await this.disconnect(serverIdentifier, { keepMode: true });
+		await this.getClient(serverIdentifier);
+	}
+
 	// Reconnect all existing clients using their preferred server identifier.
 	public async reconnectAllClients(): Promise<void> {
 		for (const [serverPubkey, client] of this.clients) {
@@ -218,7 +265,10 @@ export class McpClientService {
 
 				await client.close();
 
-				const transport = this.createTransport(this.getPreferredServerIdentifier(serverPubkey));
+				const transport = this.createTransport(
+					this.getPreferredServerIdentifier(serverPubkey),
+					this.connectionModes.get(serverPubkey)
+				);
 
 				await client.connect(transport);
 
@@ -255,11 +305,10 @@ export class McpClientService {
 				error: null
 			});
 
-			const transport = this.createTransport(serverIdentifier);
+			const transport = this.createTransport(serverIdentifier, this.connectionModes.get(serverKey));
 			const client = new Client(McpClientService.clientConfig);
 			await client.connect(transport);
 
-			// CEP-8 `payment_required` is captured by the payments middleware handler.
 			this.registerPaymentNotificationHandlers(client, serverIdentifier);
 
 			this.clients.set(serverKey, client);
@@ -283,15 +332,21 @@ export class McpClientService {
 	}
 
 	// Disconnect from a server
-	async disconnect(serverIdentifier: string): Promise<void> {
+	async disconnect(serverIdentifier: string, options: { keepMode?: boolean } = {}): Promise<void> {
 		const serverKey = this.getServerKey(serverIdentifier);
 		const client = this.clients.get(serverKey);
+		if (!client && !options.keepMode) {
+			this.connectionModes.delete(serverKey);
+		}
 		if (client) {
 			await client.close();
 			this.clients.delete(serverKey);
 			this.clientTransports.delete(serverKey);
 			this.clearServerState(serverIdentifier);
 			this.serverIdentifiers.delete(serverKey);
+			if (!options.keepMode) {
+				this.connectionModes.delete(serverKey);
+			}
 			this.setConnectionState(serverKey, { ...McpClientService.defaultConnectionState });
 		}
 	}
@@ -397,6 +452,7 @@ export class McpClientService {
 		this.clientTransports.clear();
 		this.connectionStates.clear();
 		this.serverIdentifiers.clear();
+		this.connectionModes.clear();
 	}
 }
 
diff --git a/src/lib/services/payments/payment-errors.test.ts b/src/lib/services/payments/payment-errors.test.ts
new file mode 100644
index 0000000..ddf0bb5
--- /dev/null
+++ b/src/lib/services/payments/payment-errors.test.ts
@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'bun:test';
+import {
+	PAYMENT_PENDING_ERROR_CODE,
+	PAYMENT_REQUIRED_ERROR_CODE,
+	extractExplicitGatingError,
+	isPaymentPendingError,
+	isPaymentRequiredError,
+	serializeExplicitGatingError
+} from './payment-errors';
+
+describe('explicit gating payment errors', () => {
+	it('extracts and serializes payment-required errors without changing data', () => {
+		const data = {
+			instructions: 'Pay before retrying',
+			payment_options: [{ pmi: 'bitcoin-lightning-bolt11', amount: 21, pay_req: 'lnbc...' }]
+		};
+		const error = Object.assign(new Error('Payment required'), {
+			code: PAYMENT_REQUIRED_ERROR_CODE,
+			data
+		});
+
+		const extracted = extractExplicitGatingError(error);
+
+		expect(extracted).toEqual({
+			code: PAYMENT_REQUIRED_ERROR_CODE,
+			message: 'Payment required',
+			data
+		});
+		expect(extracted?.data).toBe(data);
+		expect(extracted && isPaymentRequiredError(extracted)).toBe(true);
+		expect(extracted && serializeExplicitGatingError(extracted)).toBe(
+			JSON.stringify({ code: PAYMENT_REQUIRED_ERROR_CODE, message: 'Payment required', data })
+		);
+	});
+
+	it('extracts payment-pending errors', () => {
+		const extracted = extractExplicitGatingError({
+			code: PAYMENT_PENDING_ERROR_CODE,
+			message: 'Payment pending',
+			data: { retry_after: 2 }
+		});
+
+		expect(extracted && isPaymentPendingError(extracted)).toBe(true);
+		expect(extracted?.data).toEqual({ retry_after: 2 });
+	});
+
+	it('ignores unrelated errors', () => {
+		expect(extractExplicitGatingError(new Error('No payment'))).toBeNull();
+		expect(extractExplicitGatingError({ code: -32000, message: 'Generic error' })).toBeNull();
+	});
+});
diff --git a/src/lib/services/payments/payment-errors.ts b/src/lib/services/payments/payment-errors.ts
new file mode 100644
index 0000000..8877eb5
--- /dev/null
+++ b/src/lib/services/payments/payment-errors.ts
@@ -0,0 +1,63 @@
+export const PAYMENT_REQUIRED_ERROR_CODE = -32042;
+export const PAYMENT_PENDING_ERROR_CODE = -32043;
+
+export interface PaymentRequiredError {
+	code: typeof PAYMENT_REQUIRED_ERROR_CODE;
+	message: string;
+	data: Record<string, unknown>;
+}
+
+export interface PaymentPendingError {
+	code: typeof PAYMENT_PENDING_ERROR_CODE;
+	message: string;
+	data: Record<string, unknown>;
+}
+
+export type ExplicitGatingError = PaymentRequiredError | PaymentPendingError;
+
+type ErrorCandidate = {
+	code?: unknown;
+	message?: unknown;
+	data?: unknown;
+};
+
+function isErrorCandidate(error: unknown): error is ErrorCandidate {
+	return typeof error === 'object' && error !== null;
+}
+
+function isExplicitGatingCode(
+	code: unknown
+): code is typeof PAYMENT_REQUIRED_ERROR_CODE | typeof PAYMENT_PENDING_ERROR_CODE {
+	return code === PAYMENT_REQUIRED_ERROR_CODE || code === PAYMENT_PENDING_ERROR_CODE;
+}
+
+export function extractExplicitGatingError(error: unknown): ExplicitGatingError | null {
+	if (!isErrorCandidate(error) || !isExplicitGatingCode(error.code)) {
+		return null;
+	}
+
+	return {
+		code: error.code,
+		message: typeof error.message === 'string' ? error.message : 'Payment required',
+		data:
+			typeof error.data === 'object' && error.data !== null
+				? (error.data as Record<string, unknown>)
+				: {}
+	};
+}
+
+export function serializeExplicitGatingError(error: ExplicitGatingError): string {
+	return JSON.stringify({
+		code: error.code,
+		message: error.message,
+		data: error.data
+	});
+}
+
+export function isPaymentRequiredError(error: ExplicitGatingError): error is PaymentRequiredError {
+	return error.code === PAYMENT_REQUIRED_ERROR_CODE;
+}
+
+export function isPaymentPendingError(error: ExplicitGatingError): error is PaymentPendingError {
+	return error.code === PAYMENT_PENDING_ERROR_CODE;
+}
diff --git a/src/lib/services/payments/ui-payment-handler.ts b/src/lib/services/payments/ui-payment-handler.ts
deleted file mode 100644
index ed082e8..0000000
--- a/src/lib/services/payments/ui-payment-handler.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-import type {
-	PaymentHandler,
-	PaymentHandlerRequest,
-	PaymentRequiredNotification
-} from '@contextvm/sdk';
-import { paymentNotificationsService } from './payment-notifications.svelte';
-
-/**
- * UI-only payment handler.
- *
- * - Lets the SDK advertise a PMI via `pmi` tags (CEP-8 discovery)
- * - Captures `payment_required` (via `handle`) so the UI can render `pay_req`
- * - Does NOT attempt to pay.
- */
-export class UiOnlyPaymentHandler implements PaymentHandler {
-	public readonly pmi: string;
-	private readonly serverPubkey: string;
-
-	constructor(options: { pmi: string; serverPubkey: string }) {
-		this.pmi = options.pmi;
-		this.serverPubkey = options.serverPubkey;
-	}
-
-	canHandle(_req: PaymentHandlerRequest): boolean {
-		// We always want to surface the notification in the UI.
-		return true;
-	}
-
-	async handle(req: PaymentHandlerRequest): Promise<void> {
-		// Record a UI state entry. Correlation is available via requestEventId.
-		const notification: PaymentRequiredNotification = {
-			jsonrpc: '2.0',
-			method: 'notifications/payment_required',
-			params: {
-				amount: req.amount,
-				pay_req: req.pay_req,
-				pmi: req.pmi,
-				description: req.description,
-				ttl: req.ttl,
-				_meta: req._meta
-			}
-		};
-
-		paymentNotificationsService.set({
-			serverPubkey: this.serverPubkey,
-			requestEventId: req.requestEventId,
-			status: 'payment_required',
-			notification: { type: 'payment_required', ...notification },
-			timestamp: Date.now()
-		});
-	}
-}
diff --git a/src/lib/types/chat-types.ts b/src/lib/types/chat-types.ts
index 1486795..6b3d5f2 100644
--- a/src/lib/types/chat-types.ts
+++ b/src/lib/types/chat-types.ts
@@ -1,12 +1,23 @@
+import type { ExplicitGatingError } from '$lib/services/payments/payment-errors';
+
 export type ToolApprovalTier = 'auto' | 'prompt';
 
 export interface ToolCallData {
 	id: string;
 	name: string;
 	arguments: string;
-	status: 'pending' | 'running' | 'approved' | 'completed' | 'rejected' | 'error';
+	status:
+		| 'pending'
+		| 'running'
+		| 'approved'
+		| 'completed'
+		| 'rejected'
+		| 'error'
+		| 'payment_required';
 	result?: string;
 	serverName?: string;
+	serverPubkey?: string;
+	paymentError?: ExplicitGatingError;
 }
 
 export interface ChatMessage {
diff --git a/src/routes/s/[pubkey]/+page.svelte b/src/routes/s/[pubkey]/+page.svelte
index 22cd88e..07c49ce 100644
--- a/src/routes/s/[pubkey]/+page.svelte
+++ b/src/routes/s/[pubkey]/+page.svelte
@@ -16,7 +16,12 @@
 	import * as Tabs from '$lib/components/ui/tabs/index.js';
 	import * as Card from '$lib/components/ui/card/index.js';
 	import Button from '$lib/components/ui/button/button.svelte';
-	import { mcpClientService, type McpConnectionState } from '$lib/services/mcpClient.svelte';
+	import { Switch } from '$lib/components/ui/switch/index.js';
+	import {
+		mcpClientService,
+		type McpConnectionState,
+		type PaymentInteractionMode
+	} from '$lib/services/mcpClient.svelte';
 	import { activeAccount } from '$lib/services/accountManager.svelte';
 	import { eventStore } from '$lib/services/eventStore';
 	import { createServerNotesLoader } from '$lib/services/loaders.svelte';
@@ -161,6 +166,24 @@
 
 	// Connection state
 	const connectionState = $derived<McpConnectionState>(mcpClientService.getConnectionState(pubkey));
+	const requestedPaymentMode = $derived(mcpClientService.getConnectionMode(connectionIdentifier));
+	const effectivePaymentMode = $derived(
+		// Re-evaluate after the handshake completes: connectionState.connected flips true
+		// only once client.connect() resolves, by which point the effective mode is set.
+		connectionState.connected ? mcpClientService.getEffectivePaymentMode(connectionIdentifier) : undefined
+	);
+	const paymentModeCaption = $derived(
+		connectionState.connected
+			? `Effective: ${effectivePaymentMode ?? 'transparent'}`
+			: requestedPaymentMode
+	);
+	const explicitGatingEnabled = $derived(requestedPaymentMode === 'explicit_gating');
+	const modeMismatch = $derived(
+		connectionState.connected &&
+			requestedPaymentMode === 'explicit_gating' &&
+			effectivePaymentMode !== 'explicit_gating'
+	);
+	let paymentModeChanging = $state(false);
 
 	// Server capabilities data
 	const serverData = $derived({
@@ -225,6 +248,21 @@
 			console.error('Disconnection error:', err);
 		}
 	}
+
+	async function handlePaymentModeChange(checked: boolean) {
+		const mode: PaymentInteractionMode = checked ? 'explicit_gating' : 'transparent';
+		paymentModeChanging = true;
+
+		try {
+			if (connectionState.connected) {
+				await mcpClientService.reconnectWithMode(connectionIdentifier, mode);
+			} else {
+				mcpClientService.setConnectionMode(connectionIdentifier, mode);
+			}
+		} finally {
+			paymentModeChanging = false;
+		}
+	}
 </script>
 
 <Seo title={seoTitle} description={seoDescription} image={seoImage} url={seoUrl} type={seoType} />
@@ -295,7 +333,34 @@
 							</a>
 						{/if}
 					</div>
-					<div class="w-full">
+					<div class="w-full space-y-3">
+						<div
+							class="flex items-center justify-between gap-3 rounded-lg border border-border/70 bg-muted/40 px-3 py-2"
+						>
+							<div class="min-w-0">
+								<p class="text-xs font-medium text-foreground">Payment mode</p>
+								<p class="text-[11px] text-muted-foreground">
+									{paymentModeCaption}
+								</p>
+								{#if modeMismatch}
+									<p class="mt-0.5 text-[11px] text-amber-600 dark:text-amber-400">
+										Server does not support explicit gating &mdash; fell back to transparent.
+									</p>
+								{/if}
+							</div>
+							<div class="flex shrink-0 items-center gap-2">
+								<span class="text-xs text-muted-foreground">
+									{explicitGatingEnabled ? 'Explicit gating' : 'Transparent'}
+								</span>
+								<Switch
+									checked={explicitGatingEnabled}
+									onCheckedChange={handlePaymentModeChange}
+									disabled={paymentModeChanging || connectionState.loading}
+									size="sm"
+									aria-label="Use explicit gating payment mode"
+								/>
+							</div>
+						</div>
 						{#if connectionState.connected}
 							<div class="flex flex-col items-center gap-3">
 								<div