diff --git a/apps/desktop/src/settings/DesktopClientSettings.test.ts b/apps/desktop/src/settings/DesktopClientSettings.test.ts
index b74bb7439f87..dd3aaac15b4d 100644
--- a/apps/desktop/src/settings/DesktopClientSettings.test.ts
+++ b/apps/desktop/src/settings/DesktopClientSettings.test.ts
@@ -39,6 +39,7 @@ const clientSettings: ClientSettings = {
   // T3-CUSTOM(expbkt3): plan mode is available by default in the fork.
   planModeAvailable: true,
   nativePlanReviewEnabled: true,
+  agentUiSurfacesEnabled: true,
   showSkillsInSlashMenu: false,
   providerModelPreferences: {},
   providerRateLimitsEnabled: true,
diff --git a/apps/server/src/agentui/AgentUiService.test.ts b/apps/server/src/agentui/AgentUiService.test.ts
new file mode 100644
index 000000000000..bdef5421c796
--- /dev/null
+++ b/apps/server/src/agentui/AgentUiService.test.ts
@@ -0,0 +1,138 @@
+/**
+ * T3-CUSTOM(expbkt3): coverage for agent-rendered UI surfaces.
+ *
+ * The validation here is the security boundary an agent's input crosses, so the
+ * tests pin the rejections as tightly as the happy path: an agent that can
+ * choose the framed URL scheme, or push an unbounded document into the database,
+ * is a different feature from the one we shipped.
+ */
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { AGENT_UI_MAX_HTML_CHARS, ThreadId } from "@t3tools/contracts";
+import { describe, expect, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import { MigrationsLive } from "../persistence/Migrations.ts";
+import { SqlitePersistenceMemory } from "../persistence/Layers/Sqlite.ts";
+import * as AgentUiRenders from "../persistence/AgentUiRenders.ts";
+import * as AgentUiServiceModule from "./AgentUiService.ts";
+import { AgentUiService } from "./AgentUiService.ts";
+
+const threadId = ThreadId.make("thread-agent-ui");
+const otherThreadId = ThreadId.make("thread-agent-ui-other");
+
+const layer = AgentUiServiceModule.layer.pipe(
+  Layer.provide(AgentUiRenders.layer),
+  Layer.provide(MigrationsLive),
+  Layer.provide(SqlitePersistenceMemory),
+  Layer.provide(NodeServices.layer),
+);
+
+const withService = <A, E>(
+  body: (service: AgentUiService["Service"]) => Effect.Effect<A, E, never>,
+) =>
+  Effect.gen(function* () {
+    const service = yield* AgentUiService;
+    return yield* body(service);
+  }).pipe(Effect.provide(layer));
+
+describe("AgentUiService", () => {
+  it.effect("stores an inline document and reads it back by handle", () =>
+    withService((service) =>
+      Effect.gen(function* () {
+        const handle = yield* service.show({
+          threadId,
+          title: "  Latency  ",
+          html: "<p>hello</p>",
+        });
+        expect(handle.kind).toBe("html");
+        expect(handle.renderId.startsWith("aui_")).toBe(true);
+
+        const render = yield* service.getRender({ threadId, renderId: handle.renderId });
+        expect(render?.html).toBe("<p>hello</p>");
+        expect(render?.title).toBe("Latency");
+        expect(render?.url).toBeNull();
+      }),
+    ),
+  );
+
+  it.effect("scopes a render to its own thread", () =>
+    withService((service) =>
+      Effect.gen(function* () {
+        const handle = yield* service.show({ threadId, title: "Chart", html: "<b>x</b>" });
+        const leaked = yield* service.getRender({
+          threadId: otherThreadId,
+          renderId: handle.renderId,
+        });
+        expect(leaked).toBeNull();
+      }),
+    ),
+  );
+
+  it.effect("clamps the height into the embeddable range", () =>
+    withService((service) =>
+      Effect.gen(function* () {
+        const tall = yield* service.show({ threadId, title: "t", html: "<p/>", height: 5_000 });
+        const short = yield* service.show({ threadId, title: "t", html: "<p/>", height: 1 });
+        const absent = yield* service.show({ threadId, title: "t", html: "<p/>" });
+        expect(tall.height).toBe(900);
+        expect(short.height).toBe(120);
+        expect(absent.height).toBe(360);
+      }),
+    ),
+  );
+
+  it.effect("accepts an https URL and rejects every other scheme", () =>
+    withService((service) =>
+      Effect.gen(function* () {
+        const ok = yield* service.show({ threadId, title: "Docs", url: "https://example.com/a" });
+        expect(ok.kind).toBe("url");
+
+        for (const url of [
+          "http://example.com",
+          "javascript:alert(1)",
+          "file:///etc/passwd",
+          "data:text/html,<script>alert(1)</script>",
+          "not a url",
+        ]) {
+          const failure = yield* service.show({ threadId, title: "x", url }).pipe(Effect.flip);
+          expect(failure.message).toContain("https://");
+        }
+      }),
+    ),
+  );
+
+  it.effect("requires exactly one of html or url", () =>
+    withService((service) =>
+      Effect.gen(function* () {
+        const neither = yield* service.show({ threadId, title: "x" }).pipe(Effect.flip);
+        expect(neither.message).toContain("Provide either");
+
+        const both = yield* service
+          .show({ threadId, title: "x", html: "<p/>", url: "https://example.com" })
+          .pipe(Effect.flip);
+        expect(both.message).toContain("only one");
+      }),
+    ),
+  );
+
+  it.effect("refuses a document past the size cap", () =>
+    withService((service) =>
+      Effect.gen(function* () {
+        const failure = yield* service
+          .show({ threadId, title: "x", html: "a".repeat(AGENT_UI_MAX_HTML_CHARS + 1) })
+          .pipe(Effect.flip);
+        expect(failure.message).toContain("the limit is");
+      }),
+    ),
+  );
+
+  it.effect("returns null for a render that was never stored", () =>
+    withService((service) =>
+      Effect.gen(function* () {
+        const missing = yield* service.getRender({ threadId, renderId: "aui_nope" });
+        expect(missing).toBeNull();
+      }),
+    ),
+  );
+});
diff --git a/apps/server/src/agentui/AgentUiService.ts b/apps/server/src/agentui/AgentUiService.ts
new file mode 100644
index 000000000000..e203fd5f4334
--- /dev/null
+++ b/apps/server/src/agentui/AgentUiService.ts
@@ -0,0 +1,153 @@
+/**
+ * T3-CUSTOM(expbkt3): agent-rendered UI surfaces shown inline in the chat.
+ *
+ * The `t3_show_ui` MCP tool records a render here and gets back a short handle;
+ * the chat later fetches the body by that handle. Keeping the two halves in one
+ * fork-owned service means the validation an agent's input goes through — size
+ * caps, height clamping, URL scheme — is the same validation the reader relies
+ * on, and none of it lives in an upstream file.
+ */
+import {
+  AGENT_UI_DEFAULT_HEIGHT,
+  AGENT_UI_MAX_HEIGHT,
+  AGENT_UI_MAX_HTML_CHARS,
+  AGENT_UI_MIN_HEIGHT,
+  AgentUiError,
+  type AgentUiRenderHandle,
+  type AgentUiRenderRecord,
+  type ThreadId,
+} from "@t3tools/contracts";
+import * as Context from "effect/Context";
+import * as Crypto from "effect/Crypto";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+
+import { AgentUiRepository } from "../persistence/AgentUiRenders.ts";
+
+export interface ShowUiInput {
+  readonly threadId: ThreadId;
+  readonly title: string;
+  readonly html?: string | undefined;
+  readonly url?: string | undefined;
+  readonly height?: number | undefined;
+}
+
+export interface AgentUiServiceShape {
+  readonly show: (input: ShowUiInput) => Effect.Effect<AgentUiRenderHandle, AgentUiError>;
+  readonly getRender: (input: {
+    readonly threadId: ThreadId;
+    readonly renderId: string;
+  }) => Effect.Effect<AgentUiRenderRecord | null, AgentUiError>;
+}
+
+export class AgentUiService extends Context.Service<AgentUiService, AgentUiServiceShape>()(
+  "t3/agentui/AgentUiService",
+) {}
+
+function clampHeight(height: number | undefined): number {
+  if (height === undefined || !Number.isFinite(height)) return AGENT_UI_DEFAULT_HEIGHT;
+  return Math.max(AGENT_UI_MIN_HEIGHT, Math.min(Math.round(height), AGENT_UI_MAX_HEIGHT));
+}
+
+/**
+ * Only https is embeddable. http would be blocked as mixed content on every
+ * hosted deployment, and the non-network schemes are how a framed document
+ * would reach back at the app.
+ */
+function normalizeUrl(raw: string): string | null {
+  let parsed: URL;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    return null;
+  }
+  return parsed.protocol === "https:" ? parsed.toString() : null;
+}
+
+export const make = Effect.gen(function* () {
+  const repository = yield* AgentUiRepository;
+  const crypto = yield* Crypto.Crypto;
+
+  // A failing CSPRNG is a defect, not something a caller can recover from.
+  const uuid = crypto.randomUUIDv4.pipe(Effect.orDie);
+
+  const show: AgentUiServiceShape["show"] = (input) =>
+    Effect.gen(function* () {
+      const title = input.title.trim() || "Agent view";
+      const html = input.html?.trim() ?? "";
+      const rawUrl = input.url?.trim() ?? "";
+
+      if (html.length === 0 && rawUrl.length === 0) {
+        return yield* new AgentUiError({
+          operation: "show",
+          message: "Provide either `html` or `url`.",
+        });
+      }
+      if (html.length > 0 && rawUrl.length > 0) {
+        return yield* new AgentUiError({
+          operation: "show",
+          message: "Provide only one of `html` or `url`, not both.",
+        });
+      }
+      if (html.length > AGENT_UI_MAX_HTML_CHARS) {
+        return yield* new AgentUiError({
+          operation: "show",
+          message: `The document is ${html.length} characters; the limit is ${AGENT_UI_MAX_HTML_CHARS}. Render a smaller view, or link to a URL.`,
+        });
+      }
+
+      const url = rawUrl.length > 0 ? normalizeUrl(rawUrl) : null;
+      if (rawUrl.length > 0 && url === null) {
+        return yield* new AgentUiError({
+          operation: "show",
+          message: "`url` must be an absolute https:// URL.",
+        });
+      }
+
+      const kind = url === null ? ("html" as const) : ("url" as const);
+      const height = clampHeight(input.height);
+      const renderId = `aui_${(yield* uuid).replaceAll("-", "").slice(0, 20)}`;
+      const createdAt = yield* Effect.map(DateTime.now, DateTime.formatIso);
+
+      yield* repository
+        .insertRender({
+          renderId,
+          threadId: input.threadId,
+          title,
+          kind,
+          html: kind === "html" ? html : null,
+          url,
+          height,
+          createdAt,
+        })
+        .pipe(
+          Effect.mapError(
+            (cause) =>
+              new AgentUiError({
+                operation: "show",
+                message: `Could not store the view: ${String(cause)}`,
+              }),
+          ),
+        );
+
+      return { renderId, kind, height, title } satisfies AgentUiRenderHandle;
+    });
+
+  const getRender: AgentUiServiceShape["getRender"] = (input) =>
+    repository.getRender(input).pipe(
+      Effect.map(Option.getOrNull),
+      Effect.mapError(
+        (cause) =>
+          new AgentUiError({
+            operation: "get-render",
+            message: `Could not read the view: ${String(cause)}`,
+          }),
+      ),
+    );
+
+  return AgentUiService.of({ show, getRender });
+});
+
+export const layer = Layer.effect(AgentUiService, make);
diff --git a/apps/server/src/auth/rpcForkScopes.ts b/apps/server/src/auth/rpcForkScopes.ts
index 42f4fc587f1f..5862e2256e58 100644
--- a/apps/server/src/auth/rpcForkScopes.ts
+++ b/apps/server/src/auth/rpcForkScopes.ts
@@ -52,4 +52,7 @@ export const FORK_RPC_REQUIRED_SCOPES = {
   [WS_FORK_METHODS.sessionArchiveBackfill]: AuthOrchestrationOperateScope,
   // T3-CUSTOM(expbkt3): context handoff renders a string and writes nothing.
   [WS_FORK_METHODS.threadContextExport]: AuthOrchestrationReadScope,
+  // T3-CUSTOM(expbkt3): agent-rendered UI surfaces. A read of thread content,
+  // and the handler additionally gates on per-thread access.
+  [WS_FORK_METHODS.agentUiGetRender]: AuthOrchestrationReadScope,
 } as const;
diff --git a/apps/server/src/mcp/toolkits/control/handlers.ts b/apps/server/src/mcp/toolkits/control/handlers.ts
index 7e16a017d37e..245f08050c80 100644
--- a/apps/server/src/mcp/toolkits/control/handlers.ts
+++ b/apps/server/src/mcp/toolkits/control/handlers.ts
@@ -33,6 +33,8 @@ import { ProjectionSnapshotQuery } from "../../../orchestration/Services/Project
 // T3-CUSTOM(expbkt3): bounded catch-up detail for t3_list_sessions.
 import type { ProjectionSessionListDetail } from "../../../orchestration/Services/ProjectionSnapshotQuery.ts";
 import { PlannotatorManager } from "../../../plannotator/PlannotatorManager.ts";
+// T3-CUSTOM(expbkt3): agent-rendered UI surfaces in chat.
+import { AgentUiService } from "../../../agentui/AgentUiService.ts";
 import { ProviderRegistry } from "../../../provider/Services/ProviderRegistry.ts";
 import { redactServerSettingsForClient, ServerSettingsService } from "../../../serverSettings.ts";
 import * as WorkspacePaths from "../../../workspace/WorkspacePaths.ts";
@@ -1363,6 +1365,35 @@ const handlers = {
     },
   ),
 
+  // T3-CUSTOM(expbkt3): BEGIN — agent-rendered UI surfaces in chat.
+  //
+  // Always renders into the caller's own session: the box appears where the tool
+  // call appears, so there is no cross-session target to authorize.
+  t3_show_ui: Effect.fn("T3ControlToolkit.showUi")(function* (input) {
+    const operation = "show-ui";
+    const scope = yield* requireCapability(operation, "t3.read");
+    const agentUi = yield* AgentUiService;
+    const handle = yield* agentUi
+      .show({
+        threadId: scope.threadId,
+        title: input.title,
+        html: input.html,
+        url: input.url,
+        height: input.height,
+      })
+      .pipe(mapControlError(operation));
+    // Small and single-line on purpose: activity projection summarizes an MCP
+    // result to one short line, and this handle has to survive that trip to
+    // reach the chat client.
+    return {
+      t3UiRender: true,
+      renderId: handle.renderId,
+      kind: handle.kind,
+      height: handle.height,
+    };
+  }),
+  // T3-CUSTOM(expbkt3): END
+
   t3_dispatch_command: Effect.fn("T3ControlToolkit.dispatchCommand")(function* (input) {
     const operation = "dispatch-command";
     yield* requireExternalOperator(operation);
diff --git a/apps/server/src/mcp/toolkits/control/tools.ts b/apps/server/src/mcp/toolkits/control/tools.ts
index 64c314658b8c..fffda16430ab 100644
--- a/apps/server/src/mcp/toolkits/control/tools.ts
+++ b/apps/server/src/mcp/toolkits/control/tools.ts
@@ -30,6 +30,8 @@ import {
   PlannotatorManager,
   PlannotatorPlanFormat,
 } from "../../../plannotator/PlannotatorManager.ts";
+// T3-CUSTOM(expbkt3): agent-rendered UI surfaces in chat.
+import { AgentUiService } from "../../../agentui/AgentUiService.ts";
 import { ProviderRegistry } from "../../../provider/Services/ProviderRegistry.ts";
 import { ServerSettingsService } from "../../../serverSettings.ts";
 import * as WorkspacePaths from "../../../workspace/WorkspacePaths.ts";
@@ -52,6 +54,7 @@ const dependencies = [
   Crypto.Crypto,
 ];
 const plannotatorDependencies = [...dependencies, PlannotatorManager];
+const agentUiDependencies = [...dependencies, AgentUiService];
 const configurationDependencies = [...dependencies, ProviderRegistry, ServerSettingsService];
 const ownershipDependencies = [ClerkDirectory, ServerConfig];
 const projectDependencies = [
@@ -612,6 +615,43 @@ export const T3UnlinkSessionTool = mutatingTool(
 );
 // T3-CUSTOM(expbkt3): END
 
+// T3-CUSTOM(expbkt3): BEGIN — agent-rendered UI surfaces in chat.
+//
+// Named to stay clear of the provider adapters' substring classifier: anything
+// containing "create", "file", "agent" or "command" would be tagged as a file
+// change or subagent row instead of an MCP tool call.
+export const T3ShowUiTool = readonlyTool(
+  Tool.make("t3_show_ui", {
+    description:
+      "Render an interactive view inside the chat transcript: a sandboxed box the user sees inline, right where the tool call happened. Pass a self-contained HTML document in `html` (inline <style> and <script> both run, no network access as the app) or an absolute https URL in `url` to embed a page. Use it for charts, diagrams, tables, dashboards, forms, canvases, and previews — anything clearer seen than described. Each call renders one new box; call it again to show an updated view. Scripts run in a sandbox with an opaque origin, so the document cannot reach T3 Code, its cookies, or the network as the user.",
+    parameters: Schema.Struct({
+      title: described(
+        Schema.String,
+        "Short label shown on the box, e.g. 'Latency by endpoint' or 'Migration plan'.",
+      ),
+      html: Schema.optional(
+        described(
+          Schema.String,
+          "A self-contained HTML document or fragment. Inline CSS and JS are allowed and run sandboxed; external assets are not fetched. Mutually exclusive with `url`.",
+        ),
+      ),
+      url: Schema.optional(
+        described(
+          Schema.String,
+          "Absolute https:// URL to embed instead of inline HTML. Mutually exclusive with `html`.",
+        ),
+      ),
+      height: Schema.optional(
+        described(Schema.Int, "Box height in pixels, from 120 through 900. Defaults to 360."),
+      ),
+    }),
+    success: Schema.Unknown,
+    failure: T3ControlToolError,
+    dependencies: agentUiDependencies,
+  }).annotate(Tool.Title, "Show a view in chat"),
+);
+// T3-CUSTOM(expbkt3): END
+
 export const T3ControlToolkit = Toolkit.make(
   T3ListSessionsTool,
   T3GetSessionTool,
@@ -632,4 +672,6 @@ export const T3ControlToolkit = Toolkit.make(
   T3SubmitPlanTool,
   T3ListPlannotatorReviewsTool,
   T3DispatchCommandTool,
+  // T3-CUSTOM(expbkt3): agent-rendered UI surfaces in chat.
+  T3ShowUiTool,
 );
diff --git a/apps/server/src/mcp/toolkits/webUi/catalog.test.ts b/apps/server/src/mcp/toolkits/webUi/catalog.test.ts
index 49c3dbd10c66..b5673cbb1019 100644
--- a/apps/server/src/mcp/toolkits/webUi/catalog.test.ts
+++ b/apps/server/src/mcp/toolkits/webUi/catalog.test.ts
@@ -37,7 +37,7 @@ const invocation = (
 });
 
 it("generates one unique virtual tool and complete schemas for every web RPC", () => {
-  expect(WEB_UI_VIRTUAL_TOOL_COUNT).toBe(137);
+  expect(WEB_UI_VIRTUAL_TOOL_COUNT).toBe(138);
   expect(WEB_UI_STREAM_TOOL_COUNT).toBe(20);
   expect(WEB_UI_VIRTUAL_TOOL_COUNT).toBe(WsRpcGroup.requests.size);
   expect(new Set(WEB_UI_VIRTUAL_TOOLS.map((tool) => tool.name)).size).toBe(
diff --git a/apps/server/src/mcp/toolkits/webUi/registration.test.ts b/apps/server/src/mcp/toolkits/webUi/registration.test.ts
index 0aaee6003693..b0e49b2ccd3a 100644
--- a/apps/server/src/mcp/toolkits/webUi/registration.test.ts
+++ b/apps/server/src/mcp/toolkits/webUi/registration.test.ts
@@ -66,9 +66,9 @@ it.effect("registers four compact tools while listing the complete virtual surfa
       expect(listed.isError).toBe(false);
       expect(listed.structuredContent).toMatchObject({
         ok: true,
-        rpcCount: 137,
+        rpcCount: 138,
         streamCount: 20,
-        matchedCount: 137,
+        matchedCount: 138,
       });
 
       const schema = yield* withInvocation(
diff --git a/apps/server/src/orchestration/ActivityPayloadProjection.agentUi.test.ts b/apps/server/src/orchestration/ActivityPayloadProjection.agentUi.test.ts
new file mode 100644
index 000000000000..07ca80201911
--- /dev/null
+++ b/apps/server/src/orchestration/ActivityPayloadProjection.agentUi.test.ts
@@ -0,0 +1,132 @@
+/**
+ * T3-CUSTOM(expbkt3): wire-survival coverage for agent-rendered UI surfaces.
+ *
+ * The projection summarizes an MCP result down to one short line, so the render
+ * handle only reaches the chat because this file carves it out first. Both
+ * provider nestings are pinned here — Codex puts the result under `item`, Claude
+ * leaves it flat — because losing either one silently turns every agent view
+ * back into an ordinary collapsed tool row.
+ */
+import { describe, expect, it } from "vite-plus/test";
+import type { OrchestrationThreadActivity } from "@t3tools/contracts";
+import { projectActivityPayload } from "./ActivityPayloadProjection.ts";
+
+const RESULT_JSON = JSON.stringify({
+  t3UiRender: true,
+  renderId: "aui_abc123",
+  kind: "html",
+  height: 420,
+});
+
+function activity(payload: Record<string, unknown>): OrchestrationThreadActivity {
+  return {
+    id: "activity-1",
+    tone: "tool",
+    kind: "tool.completed",
+    summary: "Tool",
+    payload,
+    turnId: null,
+    createdAt: "2026-08-01T10:00:00.000Z",
+  } as unknown as OrchestrationThreadActivity;
+}
+
+function projectedData(payload: Record<string, unknown>): Record<string, unknown> {
+  const projected = projectActivityPayload(activity(payload));
+  return (projected.payload as Record<string, unknown>).data as Record<string, unknown>;
+}
+
+describe("agent UI render handle projection", () => {
+  it("keeps the handle from a Codex-shaped result nested under item", () => {
+    const data = projectedData({
+      itemType: "mcp_tool_call",
+      data: {
+        item: {
+          type: "mcpToolCall",
+          tool: "t3_show_ui",
+          server: "t3-code",
+          result: { content: [{ type: "text", text: RESULT_JSON }] },
+        },
+      },
+    });
+
+    expect(data.t3Ui).toEqual({ renderId: "aui_abc123", height: 420, kind: "html" });
+  });
+
+  it("keeps the handle from a flat Claude-shaped tool result", () => {
+    const data = projectedData({
+      itemType: "mcp_tool_call",
+      data: {
+        toolName: "mcp__t3-code__t3_show_ui",
+        input: { title: "Chart" },
+        result: { type: "tool_result", content: RESULT_JSON },
+      },
+    });
+
+    expect(data.t3Ui).toEqual({ renderId: "aui_abc123", height: 420, kind: "html" });
+  });
+
+  it("keeps the handle when a provider sends structuredContent instead of text", () => {
+    const data = projectedData({
+      itemType: "mcp_tool_call",
+      data: {
+        toolName: "mcp__t3-code__t3_show_ui",
+        result: {
+          content: [],
+          structuredContent: {
+            t3UiRender: true,
+            renderId: "aui_abc123",
+            kind: "html",
+            height: 420,
+          },
+        },
+      },
+    });
+
+    expect(data.t3Ui).toEqual({ renderId: "aui_abc123", height: 420, kind: "html" });
+  });
+
+  it("keeps the handle when the result object is the handle itself", () => {
+    const data = projectedData({
+      itemType: "mcp_tool_call",
+      data: {
+        result: { t3UiRender: true, renderId: "aui_abc123", kind: "url", height: 200 },
+      },
+    });
+
+    expect(data.t3Ui).toEqual({ renderId: "aui_abc123", height: 200, kind: "url" });
+  });
+
+  it("leaves ordinary MCP results alone", () => {
+    const data = projectedData({
+      itemType: "mcp_tool_call",
+      data: {
+        toolName: "mcp__t3-code__t3_list_sessions",
+        result: { content: [{ type: "text", text: '{"sessions":[]}' }] },
+      },
+    });
+
+    expect(data.t3Ui).toBeUndefined();
+  });
+
+  it("ignores a result that claims the marker without a usable render id", () => {
+    const data = projectedData({
+      itemType: "mcp_tool_call",
+      data: {
+        result: { content: JSON.stringify({ t3UiRender: true, renderId: "" }) },
+      },
+    });
+
+    expect(data.t3Ui).toBeUndefined();
+  });
+
+  it("still summarizes the result body it carved the handle out of", () => {
+    const data = projectedData({
+      itemType: "mcp_tool_call",
+      data: { result: { content: RESULT_JSON } },
+    });
+
+    expect(data.t3Ui).toBeDefined();
+    // The bulky result is still summarized, not passed through wholesale.
+    expect(typeof (data.result as Record<string, unknown>).content).toBe("string");
+  });
+});
diff --git a/apps/server/src/orchestration/ActivityPayloadProjection.ts b/apps/server/src/orchestration/ActivityPayloadProjection.ts
index 32f249c251d5..e7d47443a35a 100644
--- a/apps/server/src/orchestration/ActivityPayloadProjection.ts
+++ b/apps/server/src/orchestration/ActivityPayloadProjection.ts
@@ -208,6 +208,65 @@ function extractMcpResultText(result: unknown): string | null {
   return null;
 }
 
+// T3-CUSTOM(expbkt3): BEGIN — agent-rendered UI surfaces.
+/** Narrows a decoded value to a `t3_show_ui` handle, or nothing. */
+function readAgentUiHandle(value: unknown): Record<string, unknown> | undefined {
+  const record = asRecord(value);
+  if (!record || record.t3UiRender !== true) {
+    return undefined;
+  }
+  const renderId = record.renderId;
+  if (typeof renderId !== "string" || renderId.length === 0) {
+    return undefined;
+  }
+  const handle: Record<string, unknown> = { renderId };
+  if (typeof record.height === "number") {
+    handle.height = record.height;
+  }
+  if (record.kind === "html" || record.kind === "url") {
+    handle.kind = record.kind;
+  }
+  return handle;
+}
+
+/**
+ * The `t3_show_ui` handle, pulled out of an MCP result before the rest of it is
+ * summarized away.
+ *
+ * The tool stores the document server-side and returns only this handle, so the
+ * chat can mount the sandboxed box and fetch the body on demand. Bounded by
+ * construction — four short scalar fields — so it costs nothing on the wire.
+ *
+ * Three shapes are accepted because providers disagree about where a tool result
+ * lands: the text content array, `structuredContent` (which Claude Code has
+ * shipped in place of the content array), and the bare result object. Missing a
+ * shape does not fail loudly — it silently turns every agent view back into an
+ * ordinary tool row — so this reads all three rather than betting on one.
+ */
+function extractAgentUiHandle(result: unknown): Record<string, unknown> | undefined {
+  const direct = readAgentUiHandle(result);
+  if (direct) {
+    return direct;
+  }
+
+  const record = asRecord(result);
+  const structured = record ? readAgentUiHandle(record.structuredContent) : undefined;
+  if (structured) {
+    return structured;
+  }
+
+  const text = extractMcpResultText(result);
+  if (text === null || !text.includes("t3UiRender")) {
+    return undefined;
+  }
+  try {
+    return readAgentUiHandle(JSON.parse(text));
+  } catch {
+    return undefined;
+  }
+}
+// T3-CUSTOM(expbkt3): END
+
 function summarizeMcpResult(result: unknown): Record<string, unknown> | undefined {
   if (result === undefined || result === null) {
     return undefined;
@@ -254,6 +313,13 @@ function projectMcpToolCallData(data: Record<string, unknown>): Record<string, u
     }
   }
 
+  // T3-CUSTOM(expbkt3): keep the agent UI render handle. Both nestings are
+  // possible here — Codex puts the result under `item`, Claude leaves it flat.
+  const agentUiHandle = extractAgentUiHandle(item?.result) ?? extractAgentUiHandle(data.result);
+  if (agentUiHandle) {
+    projectedData.t3Ui = agentUiHandle;
+  }
+
   if ("toolCallId" in data) {
     projectedData.toolCallId = data.toolCallId;
   }
diff --git a/apps/server/src/persistence/AgentUiRenders.ts b/apps/server/src/persistence/AgentUiRenders.ts
new file mode 100644
index 000000000000..badcb9027c09
--- /dev/null
+++ b/apps/server/src/persistence/AgentUiRenders.ts
@@ -0,0 +1,119 @@
+/**
+ * T3-CUSTOM(expbkt3): persistence for agent-rendered UI surfaces.
+ *
+ * Insert-only. A render is the exact document an agent produced for one
+ * `t3_show_ui` call, so nothing ever rewrites one; re-running the tool appends a
+ * new row. Bodies live here rather than on the activity payload because that
+ * path caps strings at 32 KiB and summarizes tool results to a single line.
+ */
+import { AgentUiRenderRecord, ThreadId } from "@t3tools/contracts";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+import * as SqlSchema from "effect/unstable/sql/SqlSchema";
+
+import {
+  type ProjectionRepositoryError,
+  PersistenceDecodeError,
+  PersistenceSqlError,
+} from "./Errors.ts";
+
+export type AgentUiRepositoryError = ProjectionRepositoryError;
+
+const AgentUiRenderRawRow = Schema.Struct({
+  renderId: Schema.Unknown,
+  threadId: Schema.Unknown,
+  title: Schema.Unknown,
+  kind: Schema.Unknown,
+  html: Schema.Unknown,
+  url: Schema.Unknown,
+  height: Schema.Unknown,
+  createdAt: Schema.Unknown,
+});
+
+export class AgentUiRepository extends Context.Service<
+  AgentUiRepository,
+  {
+    readonly insertRender: (
+      input: AgentUiRenderRecord,
+    ) => Effect.Effect<void, AgentUiRepositoryError>;
+    readonly getRender: (input: {
+      readonly threadId: ThreadId;
+      readonly renderId: string;
+    }) => Effect.Effect<Option.Option<AgentUiRenderRecord>, AgentUiRepositoryError>;
+  }
+>()("t3/persistence/AgentUiRenders/AgentUiRepository") {}
+
+function mapError(operation: string) {
+  return (cause: unknown): AgentUiRepositoryError =>
+    Schema.isSchemaError(cause)
+      ? PersistenceDecodeError.fromSchemaError(`${operation}:decode`, cause)
+      : new PersistenceSqlError({ operation: `${operation}:query`, cause });
+}
+
+const decodeRender = Schema.decodeUnknownEffect(AgentUiRenderRecord);
+
+export const make = Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+
+  const renderColumns = sql`
+    render_id AS "renderId",
+    thread_id AS "threadId",
+    title AS "title",
+    kind AS "kind",
+    html AS "html",
+    url AS "url",
+    height AS "height",
+    created_at AS "createdAt"
+  `;
+
+  const insertRenderRow = SqlSchema.void({
+    Request: AgentUiRenderRecord,
+    execute: (input) => sql`
+      INSERT INTO agent_ui_renders (
+        render_id, thread_id, title, kind, html, url, height, created_at
+      ) VALUES (
+        ${input.renderId}, ${input.threadId}, ${input.title}, ${input.kind},
+        ${input.html}, ${input.url}, ${input.height}, ${input.createdAt}
+      )
+      ON CONFLICT(render_id) DO NOTHING
+    `,
+  });
+
+  // Thread id is part of the lookup, not just the row: it is what lets the
+  // websocket handler authorize the read against the caller's thread access
+  // before it ever touches the body.
+  const getRenderRow = SqlSchema.findOneOption({
+    Request: Schema.Struct({ threadId: ThreadId, renderId: Schema.String }),
+    Result: AgentUiRenderRawRow,
+    execute: ({ threadId, renderId }) => sql`
+      SELECT ${renderColumns} FROM agent_ui_renders
+      WHERE render_id = ${renderId} AND thread_id = ${threadId}
+    `,
+  });
+
+  return AgentUiRepository.of({
+    insertRender: (input) =>
+      insertRenderRow(input).pipe(Effect.mapError(mapError("AgentUi.insertRender"))),
+
+    getRender: (input) =>
+      getRenderRow(input).pipe(
+        Effect.mapError(mapError("AgentUi.getRender")),
+        Effect.flatMap(
+          Option.match({
+            onNone: () => Effect.succeed(Option.none()),
+            onSome: (row) =>
+              decodeRender(row).pipe(
+                Effect.map(Option.some),
+                Effect.mapError(mapError("AgentUi.getRender")),
+              ),
+          }),
+        ),
+      ),
+  });
+});
+
+export const layer = Layer.effect(AgentUiRepository, make);
diff --git a/apps/server/src/persistence/Migrations.ts b/apps/server/src/persistence/Migrations.ts
index fecf5d30e648..d3b737f6d263 100644
--- a/apps/server/src/persistence/Migrations.ts
+++ b/apps/server/src/persistence/Migrations.ts
@@ -66,6 +66,7 @@ import Migration0045 from "./Migrations/045_EnvironmentUsers.ts";
 import Migration1005 from "./Migrations/036_ProjectionThreadsPinned.ts";
 // T3-CUSTOM(expbkt3): fork migrations, numbered 1000+.
 import Migration1000 from "./Migrations/1000_ProjectionThreadsPriority.ts";
+import Migration1022 from "./Migrations/1022_AgentUiRenders.ts";
 import Migration1001 from "./Migrations/1001_SessionRecoveryState.ts";
 import Migration1002 from "./Migrations/1002_ThreadBootstrapAndCreationDefaults.ts";
 // T3-CUSTOM(expbkt3): exact durable work items and guarded recovery audit.
@@ -223,6 +224,8 @@ const migrationEntries = [
   [1019, "AuthSessionClientConnection", Migration1019],
   [1020, "ProjectionThreadLinkedPullRequest", Migration1020],
   [1021, "ProjectionThreadsUnsettledAt", Migration1021],
+  // T3-CUSTOM(expbkt3): agent-rendered UI surfaces in chat.
+  [1022, "AgentUiRenders", Migration1022],
 ] as const;
 
 export const migrationManifest = migrationEntries.map(([id, name]) => [id, name] as const);
diff --git a/apps/server/src/persistence/Migrations/1022_AgentUiRenders.ts b/apps/server/src/persistence/Migrations/1022_AgentUiRenders.ts
new file mode 100644
index 000000000000..1102fbf21a35
--- /dev/null
+++ b/apps/server/src/persistence/Migrations/1022_AgentUiRenders.ts
@@ -0,0 +1,32 @@
+// T3-CUSTOM(expbkt3): agent-rendered UI surfaces shown inline in chat.
+//
+// One row per `t3_show_ui` call. Rows are insert-only: an agent re-running the
+// tool produces a new render rather than mutating an old one, so a timeline row
+// keeps showing what the agent actually produced at that point in the thread.
+// Bodies live here instead of on the activity payload, which is capped.
+import * as Effect from "effect/Effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+
+export default Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+
+  yield* sql`
+    CREATE TABLE IF NOT EXISTS agent_ui_renders (
+      render_id TEXT PRIMARY KEY,
+      thread_id TEXT NOT NULL,
+      title TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      html TEXT,
+      url TEXT,
+      height INTEGER NOT NULL,
+      created_at TEXT NOT NULL
+    )
+  `;
+
+  // Thread-scoped reads back the fetch-on-demand RPC, and the archive sweep
+  // deletes by thread.
+  yield* sql`
+    CREATE INDEX IF NOT EXISTS idx_agent_ui_renders_thread
+      ON agent_ui_renders(thread_id, created_at)
+  `;
+});
diff --git a/apps/server/src/server.test.ts b/apps/server/src/server.test.ts
index 2c1512f23e30..9389a7eb77ed 100644
--- a/apps/server/src/server.test.ts
+++ b/apps/server/src/server.test.ts
@@ -146,6 +146,9 @@ import * as PlannotatorManager from "./plannotator/PlannotatorManager.ts";
 // T3-CUSTOM(expbkt3): native plan review.
 import * as PlanReviewDocuments from "./persistence/PlanReviewDocuments.ts";
 import * as PlanReviewServiceLayer from "./planreview/PlanReviewService.ts";
+// T3-CUSTOM(expbkt3): agent-rendered UI surfaces in chat.
+import * as AgentUiRenders from "./persistence/AgentUiRenders.ts";
+import * as AgentUiServiceLayer from "./agentui/AgentUiService.ts";
 import * as BrowserTraceCollector from "./observability/BrowserTraceCollector.ts";
 import * as ProjectFaviconResolver from "./project/ProjectFaviconResolver.ts";
 import * as T3ProjectFileLoader from "./project/T3ProjectFileLoader.ts";
@@ -706,6 +709,12 @@ const buildAppUnderTest = (options?: {
           Layer.provide(PlanReviewDocuments.layer.pipe(Layer.provide(SqlitePersistenceMemory))),
         ),
       ),
+      // T3-CUSTOM(expbkt3): agent UI surfaces service for the fork RPC handlers.
+      Layer.provide(
+        AgentUiServiceLayer.layer.pipe(
+          Layer.provide(AgentUiRenders.layer.pipe(Layer.provide(SqlitePersistenceMemory))),
+        ),
+      ),
       Layer.provide(
         OrchestrationCommandDispatcher.layerWithBootstrapRepository.pipe(
           Layer.provide(
diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
index f4fb94b6654d..9aed3e9cc69f 100644
--- a/apps/server/src/server.ts
+++ b/apps/server/src/server.ts
@@ -59,7 +59,10 @@ import * as PlannotatorManager from "./plannotator/PlannotatorManager.ts";
 // T3-CUSTOM(expbkt3): native plan review.
 import * as PlanIngestListener from "./planreview/PlanIngestListener.ts";
 import * as PlanReviewServiceLayer from "./planreview/PlanReviewService.ts";
+// T3-CUSTOM(expbkt3): agent-rendered UI surfaces in chat.
+import * as AgentUiServiceLayer from "./agentui/AgentUiService.ts";
 import * as PlanReviewDocuments from "./persistence/PlanReviewDocuments.ts";
+import * as AgentUiRenders from "./persistence/AgentUiRenders.ts";
 import { plannotatorProxyRouteLayer } from "./plannotator/http.ts";
 // T3-CUSTOM(expbkt3): END
 import * as PreviewManager from "./preview/Manager.ts";
@@ -871,10 +874,17 @@ export const makeServerLayer = Layer.unwrap(
       Layer.provide(PlanReviewDocuments.layer),
       Layer.provideMerge(runtimeServicesWithoutPlannotatorLive),
     );
+    // T3-CUSTOM(expbkt3): agent-rendered UI surfaces. Only needs the sqlite
+    // client, so it composes beside plan review rather than under it.
+    const agentUiServicesLive = AgentUiServiceLayer.layer.pipe(
+      Layer.provide(AgentUiRenders.layer),
+      Layer.provideMerge(runtimeServicesWithoutPlannotatorLive),
+    );
     const runtimeServicesLive = Layer.mergeAll(
       PlannotatorManager.layer.pipe(Layer.provideMerge(runtimeServicesWithoutPlannotatorLive)),
       PlanIngestListener.layer.pipe(Layer.provideMerge(planReviewServicesLive)),
       planReviewServicesLive,
+      agentUiServicesLive,
     );
 
     const routesLayer = HttpRouter.serve(makeRoutesLayer.pipe(Layer.provide(launcherLayer)), {
diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.ts
index 4291905a84c7..87e5700665c9 100644
--- a/apps/server/src/ws.ts
+++ b/apps/server/src/ws.ts
@@ -122,6 +122,8 @@ import * as PreviewAutomationBroker from "./mcp/PreviewAutomationBroker.ts";
 import * as UserMcpProfileStore from "./mcp/UserMcpProfileStore.ts";
 // T3-CUSTOM(expbkt3): native plan review service.
 import { PlanReviewService } from "./planreview/PlanReviewService.ts";
+// T3-CUSTOM(expbkt3): agent-rendered UI surfaces in chat.
+import { AgentUiService } from "./agentui/AgentUiService.ts";
 import * as PreviewManager from "./preview/Manager.ts";
 import { issueAssetUrl } from "./assets/AssetAccess.ts";
 import { deletePendingAttachment, issueAttachmentUploadUrl } from "./assets/AttachmentUpload.ts";
@@ -544,6 +546,8 @@ const makeWsRpcLayer = (
       const environmentUsers = yield* EnvironmentUserService.EnvironmentUserService;
       // T3-CUSTOM(expbkt3): BEGIN native plan review connection state.
       const planReview = yield* PlanReviewService;
+      // T3-CUSTOM(expbkt3): agent-rendered UI surfaces in chat.
+      const agentUi = yield* AgentUiService;
       // Resolved once per connection: it only labels this actor's own comments.
       const actorLabel =
         actorUserId === null
@@ -1280,6 +1284,7 @@ const makeWsRpcLayer = (
         sourceControlProfiles,
         environmentUsers,
         planReview,
+        agentUi,
         actorLabel,
         systemResourceMonitor,
         providerRateLimits,
diff --git a/apps/server/src/wsForkHandlers.ts b/apps/server/src/wsForkHandlers.ts
index 1dd68cb76802..9682b7f20b8c 100644
--- a/apps/server/src/wsForkHandlers.ts
+++ b/apps/server/src/wsForkHandlers.ts
@@ -17,6 +17,8 @@ import {
   WS_METHODS,
   WsRpcGroup,
   EnvironmentAuthorizationError,
+  // T3-CUSTOM(expbkt3): agent-rendered UI surfaces in chat.
+  AgentUiError,
   OrchestrationGetSnapshotError,
   PlanReviewError,
   SessionArchiveError,
@@ -36,6 +38,8 @@ import type * as GitVcsDriver from "./vcs/GitVcsDriver.ts";
 import type * as UserMcpProfileStore from "./mcp/UserMcpProfileStore.ts";
 import type * as OrchestrationEngine from "./orchestration/Services/OrchestrationEngine.ts";
 import type * as PlanReviewService from "./planreview/PlanReviewService.ts";
+// T3-CUSTOM(expbkt3): agent-rendered UI surfaces in chat.
+import type * as AgentUiService from "./agentui/AgentUiService.ts";
 import type * as ProjectionSnapshotQuery from "./orchestration/Services/ProjectionSnapshotQuery.ts";
 import type * as SystemResourceMonitor from "./observability/SystemResourceMonitor.ts";
 import type { ProviderRateLimitsShape } from "./provider/ProviderRateLimits.ts";
@@ -64,6 +68,8 @@ export interface ForkWsHandlerDeps {
   readonly environmentUsers: EnvironmentUserService.EnvironmentUserService["Service"];
   // T3-CUSTOM(expbkt3): native plan review.
   readonly planReview: PlanReviewService.PlanReviewService["Service"];
+  // T3-CUSTOM(expbkt3): agent-rendered UI surfaces in chat.
+  readonly agentUi: AgentUiService.AgentUiServiceShape;
   /** Display name for the acting user, stamped onto their review comments. */
   readonly actorLabel: string | null;
   readonly systemResourceMonitor: SystemResourceMonitor.SystemResourceMonitor["Service"];
@@ -114,6 +120,7 @@ export const makeForkWsHandlers = ({
   sourceControlProfiles,
   environmentUsers,
   planReview,
+  agentUi,
   actorLabel,
   systemResourceMonitor,
   providerRateLimits,
@@ -237,6 +244,20 @@ export const makeForkWsHandlers = ({
         ),
         { "rpc.aggregate": "session-archive" },
       ),
+    // T3-CUSTOM(expbkt3): agent-rendered UI surfaces. Thread-scoped: the render
+    // body only goes out to someone who can already read that thread.
+    [WS_METHODS.agentUiGetRender]: (input) =>
+      observeRpcEffect(
+        WS_METHODS.agentUiGetRender,
+        requireThreadAccess(input.threadId).pipe(
+          Effect.mapError(
+            (cause) => new AgentUiError({ operation: "get-render", message: cause.message }),
+          ),
+          Effect.andThen(agentUi.getRender({ threadId: input.threadId, renderId: input.renderId })),
+          Effect.map((render) => ({ render })),
+        ),
+        { "rpc.aggregate": "agent-ui" },
+      ),
     // T3-CUSTOM(expbkt3): END
     [WS_METHODS.sourceControlProfilesList]: (_input) =>
       observeRpcEffect(WS_METHODS.sourceControlProfilesList, sourceControlProfiles.list, {
diff --git a/apps/web/src/agentUiExpandedStore.test.ts b/apps/web/src/agentUiExpandedStore.test.ts
new file mode 100644
index 000000000000..0b3b6a6aabae
--- /dev/null
+++ b/apps/web/src/agentUiExpandedStore.test.ts
@@ -0,0 +1,51 @@
+/**
+ * T3-CUSTOM(expbkt3): expanded agent view state.
+ *
+ * Only one view may own the transcript at a time — expanding a second must
+ * replace the first rather than stack, because the overlay is a single mount
+ * point and a stack would strand the older one underneath it.
+ */
+import { describe, expect, it, beforeEach } from "vite-plus/test";
+import type { ScopedThreadRef } from "@t3tools/contracts";
+
+import { useAgentUiExpandedStore } from "./agentUiExpandedStore";
+
+const threadRef = { environmentId: "env-1", threadId: "thread-1" } as unknown as ScopedThreadRef;
+const otherThreadRef = {
+  environmentId: "env-2",
+  threadId: "thread-2",
+} as unknown as ScopedThreadRef;
+
+describe("useAgentUiExpandedStore", () => {
+  beforeEach(() => {
+    useAgentUiExpandedStore.getState().collapse();
+  });
+
+  it("starts with nothing expanded", () => {
+    expect(useAgentUiExpandedStore.getState().expanded).toBeNull();
+  });
+
+  it("expands a view and collapses it again", () => {
+    useAgentUiExpandedStore.getState().expand({ threadRef, renderId: "aui_1" });
+    expect(useAgentUiExpandedStore.getState().expanded).toEqual({ threadRef, renderId: "aui_1" });
+
+    useAgentUiExpandedStore.getState().collapse();
+    expect(useAgentUiExpandedStore.getState().expanded).toBeNull();
+  });
+
+  it("replaces the expanded view rather than stacking a second one", () => {
+    const store = useAgentUiExpandedStore.getState();
+    store.expand({ threadRef, renderId: "aui_1" });
+    store.expand({ threadRef: otherThreadRef, renderId: "aui_2" });
+
+    expect(useAgentUiExpandedStore.getState().expanded).toEqual({
+      threadRef: otherThreadRef,
+      renderId: "aui_2",
+    });
+  });
+
+  it("is a no-op to collapse when nothing is expanded", () => {
+    useAgentUiExpandedStore.getState().collapse();
+    expect(useAgentUiExpandedStore.getState().expanded).toBeNull();
+  });
+});
diff --git a/apps/web/src/agentUiExpandedStore.ts b/apps/web/src/agentUiExpandedStore.ts
new file mode 100644
index 000000000000..f70e1a6dcbcb
--- /dev/null
+++ b/apps/web/src/agentUiExpandedStore.ts
@@ -0,0 +1,29 @@
+/**
+ * T3-CUSTOM(expbkt3): which agent view, if any, is expanded over the transcript.
+ *
+ * Deliberately not persisted and deliberately global-but-single: expanding a
+ * view is a transient reading posture, and only one can own the transcript at a
+ * time. Keeping it in a store rather than in the timeline row is what lets the
+ * overlay mount beside the message list — outside the virtualized rows, which
+ * clip and recycle — while the card that opened it stays a plain row.
+ */
+import { create } from "zustand";
+
+import type { ScopedThreadRef } from "@t3tools/contracts";
+
+export interface ExpandedAgentUiView {
+  readonly threadRef: ScopedThreadRef;
+  readonly renderId: string;
+}
+
+interface AgentUiExpandedStoreState {
+  readonly expanded: ExpandedAgentUiView | null;
+  expand: (view: ExpandedAgentUiView) => void;
+  collapse: () => void;
+}
+
+export const useAgentUiExpandedStore = create<AgentUiExpandedStoreState>((set) => ({
+  expanded: null,
+  expand: (view) => set({ expanded: view }),
+  collapse: () => set({ expanded: null }),
+}));
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index 2f445afe50ee..0c82af019ad3 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -164,6 +164,8 @@ import {
 } from "../rightPanelStore";
 // T3-CUSTOM(expbkt3): native plan review surface.
 import { PlanReviewPanel, useOpenPlanReviewDocumentId } from "../fork/planReviewSurface";
+// T3-CUSTOM(expbkt3): agent-rendered UI surfaces in chat.
+import { AgentUiExpandedSurface } from "../fork/agentUiSurface";
 import {
   isPreviewSupportedInRuntime,
   setActivePreviewTab,
@@ -7854,6 +7856,8 @@ function ChatViewContent(props: ChatViewProps) {
                 </div>
               ) : null}
               {/* T3-CUSTOM(expbkt3): END */}
+              {/* T3-CUSTOM(expbkt3): an expanded agent view covers the transcript, not the composer. */}
+              <AgentUiExpandedSurface />
             </div>
 
             {/* Input bar — centered hero while a draft has no messages, docked at the bottom otherwise */}
diff --git a/apps/web/src/components/chat/MessagesTimeline.agentUi.logic.test.ts b/apps/web/src/components/chat/MessagesTimeline.agentUi.logic.test.ts
new file mode 100644
index 000000000000..0a163f2171ca
--- /dev/null
+++ b/apps/web/src/components/chat/MessagesTimeline.agentUi.logic.test.ts
@@ -0,0 +1,118 @@
+/**
+ * T3-CUSTOM(expbkt3): agent views must survive work-log grouping.
+ *
+ * Tool rows collapse into a "+N tool calls" toggle once several land in a row,
+ * which is right for a record that work happened and wrong for an agent view:
+ * the view *is* the answer, so collapsing it hides the thing the user asked
+ * for. These tests pin that a `t3_show_ui` row is always rendered on its own,
+ * without the reader expanding anything.
+ */
+import { describe, expect, it } from "vite-plus/test";
+
+import { deriveMessagesTimelineRows, workEntryStaysVisible } from "./MessagesTimeline.logic";
+
+function toolEntry(id: string, at: string) {
+  return {
+    id: `entry-${id}`,
+    kind: "work" as const,
+    createdAt: at,
+    entry: {
+      id,
+      createdAt: at,
+      turnId: "turn-1" as never,
+      label: "Ran a tool",
+      tone: "tool" as const,
+      itemType: "mcp_tool_call" as const,
+      toolLifecycleStatus: "completed" as const,
+    },
+  };
+}
+
+function agentUiEntry(id: string, at: string) {
+  const base = toolEntry(id, at);
+  return {
+    ...base,
+    entry: { ...base.entry, label: "Showed a view", agentUi: { renderId: `aui_${id}` } },
+  };
+}
+
+const derive = (timelineEntries: ReadonlyArray<ReturnType<typeof toolEntry>>) =>
+  deriveMessagesTimelineRows({
+    timelineEntries,
+    isWorking: false,
+    activeTurnStartedAt: null,
+    turnDiffSummaryByAssistantMessageId: new Map(),
+    revertTurnCountByUserMessageId: new Map(),
+  });
+
+/** Every work entry the reader can see without expanding a toggle. */
+function visibleWorkEntryIds(rows: ReturnType<typeof derive>): ReadonlyArray<string> {
+  const ids: string[] = [];
+  for (const row of rows) {
+    if (row.kind === "work") {
+      for (const entry of row.groupedEntries) ids.push(entry.id);
+    }
+  }
+  return ids;
+}
+
+describe("workEntryStaysVisible", () => {
+  it("covers agent views as well as spawn rows", () => {
+    expect(workEntryStaysVisible({ agentUi: { renderId: "aui_1" } } as never)).toBe(true);
+    expect(
+      workEntryStaysVisible({ agentSpawn: { workflowId: null, agentTaskIds: [] } } as never),
+    ).toBe(true);
+  });
+
+  it("leaves an ordinary tool row collapsible", () => {
+    expect(workEntryStaysVisible({ label: "Ran a tool" } as never)).toBe(false);
+    expect(workEntryStaysVisible({ agentUi: undefined } as never)).toBe(false);
+  });
+});
+
+describe("agent views in the work log", () => {
+  it("renders the view without the reader expanding anything", () => {
+    const rows = derive([
+      toolEntry("tool-1", "2026-01-01T00:00:01Z"),
+      toolEntry("tool-2", "2026-01-01T00:00:02Z"),
+      agentUiEntry("view-1", "2026-01-01T00:00:03Z"),
+      toolEntry("tool-3", "2026-01-01T00:00:04Z"),
+    ]);
+
+    expect(visibleWorkEntryIds(rows)).toContain("view-1");
+  });
+
+  it("still folds the same run away when none of them is a view", () => {
+    // The control. Without a view the whole settled turn folds and no work row
+    // survives — which is exactly what was swallowing the box before, and what
+    // must keep happening for ordinary tool calls.
+    const rows = derive([
+      toolEntry("tool-1", "2026-01-01T00:00:01Z"),
+      toolEntry("tool-2", "2026-01-01T00:00:02Z"),
+      toolEntry("tool-3", "2026-01-01T00:00:03Z"),
+      toolEntry("tool-4", "2026-01-01T00:00:04Z"),
+    ]);
+
+    expect(visibleWorkEntryIds(rows)).toEqual([]);
+    expect(rows.some((row) => row.kind === "turn-fold")).toBe(true);
+  });
+
+  it("keeps every view visible when several land in one run", () => {
+    const rows = derive([
+      toolEntry("tool-1", "2026-01-01T00:00:01Z"),
+      agentUiEntry("view-1", "2026-01-01T00:00:02Z"),
+      toolEntry("tool-2", "2026-01-01T00:00:03Z"),
+      agentUiEntry("view-2", "2026-01-01T00:00:04Z"),
+      toolEntry("tool-3", "2026-01-01T00:00:05Z"),
+    ]);
+
+    const visible = visibleWorkEntryIds(rows);
+    expect(visible).toContain("view-1");
+    expect(visible).toContain("view-2");
+  });
+
+  it("renders a lone view on its own", () => {
+    const rows = derive([agentUiEntry("view-1", "2026-01-01T00:00:01Z")]);
+    expect(visibleWorkEntryIds(rows)).toEqual(["view-1"]);
+  });
+});
diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.ts b/apps/web/src/components/chat/MessagesTimeline.logic.ts
index a78a9af1eb0b..3afb95f1c085 100644
--- a/apps/web/src/components/chat/MessagesTimeline.logic.ts
+++ b/apps/web/src/components/chat/MessagesTimeline.logic.ts
@@ -23,6 +23,16 @@ export const TIMELINE_MINIMAP_MAX_HEIGHT_CSS = "calc(100vh - 18rem)";
 export const TIMELINE_CONTENT_MAX_WIDTH = 768;
 export const TIMELINE_MINIMAP_PERSISTENT_GUTTER = 48;
 
+// T3-CUSTOM(expbkt3): rows that must never collapse into a "+N tool calls"
+// toggle, and never fold away with their turn.
+//
+// A spawn CTA hides a still-running fleet when folded; an agent view is worse,
+// because the view *is* the answer the agent produced, not a record that work
+// happened. Behind a toggle it may as well not have been drawn.
+export function workEntryStaysVisible(entry: WorkLogEntry): boolean {
+  return entry.agentSpawn !== undefined || entry.agentUi !== undefined;
+}
+
 export function workEntryIsVisibleInGroup(
   entry: WorkLogEntry,
   expandedToolGroupEntry = false,
@@ -615,7 +625,7 @@ function deriveTurnFolds(input: {
       // Agent-spawn CTA rows never fold: workflows outlive their launching
       // turn (dynamic spawns, background execution), and folding the CTA
       // when the turn settles makes a still-running fleet invisible.
-      if (entry.kind === "work" && entry.entry.agentSpawn !== undefined) {
+      if (entry.kind === "work" && workEntryStaysVisible(entry.entry)) {
         continue;
       }
       hiddenEntryIds.add(entry.id);
@@ -742,7 +752,7 @@ export function deriveMessagesTimelineRows(input: {
     }
     if (entry.kind === "work") {
       return (
-        entry.entry.agentSpawn === undefined &&
+        !workEntryStaysVisible(entry.entry) &&
         workLogEntryIsToolLike(entry.entry) &&
         entry.entry.toolLifecycleStatus === "inProgress"
       );
@@ -757,7 +767,7 @@ export function deriveMessagesTimelineRows(input: {
     if (
       !entryBelongsToActiveTurn(entry, index) ||
       entry.kind !== "work" ||
-      entry.entry.agentSpawn !== undefined ||
+      workEntryStaysVisible(entry.entry) ||
       entry.entry.tone === "error" ||
       !workLogEntryIsToolLike(entry.entry)
     ) {
@@ -875,7 +885,7 @@ export function deriveMessagesTimelineRows(input: {
         const onlyToolEntries = visibleGroupedEntries.every(
           (entry) =>
             workLogEntryIsToolLike(entry) &&
-            entry.agentSpawn === undefined &&
+            !workEntryStaysVisible(entry) &&
             entry.tone !== "error",
         );
         const activeInProgressToolEntries = visibleGroupedEntries.filter(workEntryIsInActiveRun);
@@ -951,12 +961,12 @@ export function deriveMessagesTimelineRows(input: {
           // (review finding: concatenating two filtered lists moved a
           // mid-group spawn row above earlier tool rows).
           const overflowCandidates = visibleGroupedEntries.filter(
-            (entry) => entry.agentSpawn === undefined,
+            (entry) => !workEntryStaysVisible(entry),
           );
           const hiddenEntries = overflowCandidates.slice(0, -MAX_VISIBLE_WORK_LOG_ENTRIES);
           const hiddenIds = new Set(hiddenEntries.map((entry) => entry.id));
           const visibleEntries = visibleGroupedEntries.filter(
-            (entry) => entry.agentSpawn !== undefined || !hiddenIds.has(entry.id),
+            (entry) => workEntryStaysVisible(entry) || !hiddenIds.has(entry.id),
           );
           const renderedEntries = expanded ? visibleGroupedEntries : visibleEntries;
 
diff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsx
index 93e7876b283e..04ad55a864a9 100644
--- a/apps/web/src/components/chat/MessagesTimeline.tsx
+++ b/apps/web/src/components/chat/MessagesTimeline.tsx
@@ -73,6 +73,8 @@ import {
   XIcon,
   ZapIcon,
 } from "lucide-react";
+// T3-CUSTOM(expbkt3): agent-rendered UI surfaces in chat.
+import { AgentUiSurfaceRow, resolveAgentUiSurface } from "../../fork/agentUiSurface";
 import { Button } from "../ui/button";
 import { buildExpandedImagePreview, ExpandedImagePreview } from "./ExpandedImagePreview";
 import { ProposedPlanCard } from "./ProposedPlanCard";
@@ -2868,17 +2870,30 @@ const SimpleWorkEntryRow = memo(function SimpleWorkEntryRow(props: {
   isExpandedToolGroupEntry: boolean;
 }) {
   const { workEntry, workspaceRoot, isExpandedToolGroupEntry } = props;
-  // Before any hooks: spawn CTA rows render their own component.
+  // T3-CUSTOM(expbkt3): agent-rendered UI surfaces need the thread they belong
+  // to, so the context read moves above the spawn early return.
+  const { threadRef } = use(TimelineRowCtx);
   if (workEntry.agentSpawn) {
     return <AgentSpawnCtaRow workEntry={workEntry} />;
   }
-  return (
+  const plainRow = (
     <PlainWorkEntryRow
       workEntry={workEntry}
       workspaceRoot={workspaceRoot}
       isExpandedToolGroupEntry={isExpandedToolGroupEntry}
     />
   );
+  // T3-CUSTOM(expbkt3): a `t3_show_ui` call keeps its ordinary row and mounts
+  // its sandboxed box underneath it.
+  const agentUiSurface = resolveAgentUiSurface(workEntry);
+  if (agentUiSurface) {
+    return (
+      <AgentUiSurfaceRow threadRef={threadRef} surface={agentUiSurface}>
+        {plainRow}
+      </AgentUiSurfaceRow>
+    );
+  }
+  return plainRow;
 });
 
 const PlainWorkEntryRow = memo(function PlainWorkEntryRow(props: {
diff --git a/apps/web/src/components/settings/ExperimentsSettingsPanel.tsx b/apps/web/src/components/settings/ExperimentsSettingsPanel.tsx
index 06f5918d0a7e..541838b7126c 100644
--- a/apps/web/src/components/settings/ExperimentsSettingsPanel.tsx
+++ b/apps/web/src/components/settings/ExperimentsSettingsPanel.tsx
@@ -31,6 +31,8 @@ export function ExperimentsSettingsPanel() {
   const updateSettings = useUpdateClientSettings();
   // T3-CUSTOM(expbkt3): native plan review (moved here from the removed Beta panel).
   const nativePlanReviewEnabled = useClientSettings((settings) => settings.nativePlanReviewEnabled);
+  // T3-CUSTOM(expbkt3): agent-rendered UI surfaces in chat.
+  const agentUiSurfacesEnabled = useClientSettings((settings) => settings.agentUiSurfacesEnabled);
 
   return (
     <SettingsPageContainer>
@@ -50,6 +52,21 @@ export function ExperimentsSettingsPanel() {
           }
         />
         {/* T3-CUSTOM(expbkt3): END */}
+        {/* T3-CUSTOM(expbkt3): BEGIN — agent-rendered UI surfaces in chat. */}
+        <SettingsRow
+          {...searchableSetting("agent-ui-surfaces")}
+          description="Let agents render interactive views inline in the chat: charts, diagrams, tables, forms and other small HTML documents, shown in a sandboxed box where the tool call happened. Agents reach this through the t3_show_ui tool. While off, those calls stay ordinary collapsed tool rows."
+          control={
+            <Switch
+              checked={agentUiSurfacesEnabled}
+              onCheckedChange={(checked) =>
+                updateSettings({ agentUiSurfacesEnabled: Boolean(checked) })
+              }
+              aria-label="Agent views in chat"
+            />
+          }
+        />
+        {/* T3-CUSTOM(expbkt3): END */}
         <SettingsRow
           title="Phase-grouped sidebar"
           description="Group threads by lifecycle phase instead of repository. Repository, branch, and provider stay visible as row labels, and the original sidebar remains available when this is off."
diff --git a/apps/web/src/components/settings/settingsSearch.ts b/apps/web/src/components/settings/settingsSearch.ts
index 0861fc3e6ade..8d74b618413f 100644
--- a/apps/web/src/components/settings/settingsSearch.ts
+++ b/apps/web/src/components/settings/settingsSearch.ts
@@ -272,6 +272,12 @@ export const SETTINGS_SEARCH_ITEMS = [
     title: "Native plan review",
     to: "/settings/experiments",
   },
+  // T3-CUSTOM(expbkt3): agent-rendered UI surfaces in chat.
+  {
+    id: "agent-ui-surfaces",
+    title: "Agent views in chat",
+    to: "/settings/experiments",
+  },
   {
     id: "archive",
     title: "Archived threads",
diff --git a/apps/web/src/fork/agentUiSurface.test.ts b/apps/web/src/fork/agentUiSurface.test.ts
new file mode 100644
index 000000000000..9114da206390
--- /dev/null
+++ b/apps/web/src/fork/agentUiSurface.test.ts
@@ -0,0 +1,73 @@
+/**
+ * T3-CUSTOM(expbkt3): the pure half of agent-rendered UI surfaces.
+ *
+ * `resolveAgentUiSurface` runs on every work-log row in the timeline, before any
+ * hooks, so it has to stay total: an unexpected payload shape must fall back to
+ * the ordinary tool row rather than throw inside the list renderer.
+ */
+import { describe, expect, it } from "vite-plus/test";
+
+import { resolveAgentUiSurface, resolveEmbedSandbox } from "./agentUiSurface";
+
+describe("resolveAgentUiSurface", () => {
+  it("reads a well-formed handle", () => {
+    expect(
+      resolveAgentUiSurface({ agentUi: { renderId: "aui_1", kind: "html", height: 400 } }),
+    ).toEqual({ renderId: "aui_1", kind: "html", height: 400 });
+  });
+
+  it("returns null for an ordinary work entry", () => {
+    expect(resolveAgentUiSurface({})).toBeNull();
+    expect(resolveAgentUiSurface({ agentUi: undefined })).toBeNull();
+  });
+
+  it("survives payload shapes it was not built for", () => {
+    for (const agentUi of [null, "aui_1", 42, [], { renderId: 7 }, { renderId: "" }]) {
+      expect(resolveAgentUiSurface({ agentUi })).toBeNull();
+    }
+  });
+
+  it("defaults the kind to html and only accepts url as the alternative", () => {
+    expect(resolveAgentUiSurface({ agentUi: { renderId: "a" } })?.kind).toBe("html");
+    expect(resolveAgentUiSurface({ agentUi: { renderId: "a", kind: "url" } })?.kind).toBe("url");
+    expect(resolveAgentUiSurface({ agentUi: { renderId: "a", kind: "nonsense" } })?.kind).toBe(
+      "html",
+    );
+  });
+
+  it("clamps a height an agent could otherwise use to take over the transcript", () => {
+    expect(resolveAgentUiSurface({ agentUi: { renderId: "a", height: 99_999 } })?.height).toBe(900);
+    expect(resolveAgentUiSurface({ agentUi: { renderId: "a", height: -10 } })?.height).toBe(120);
+    expect(resolveAgentUiSurface({ agentUi: { renderId: "a", height: "tall" } })?.height).toBe(360);
+    expect(resolveAgentUiSurface({ agentUi: { renderId: "a" } })?.height).toBe(360);
+  });
+});
+
+describe("resolveEmbedSandbox", () => {
+  const page = "https://bkt3.dev.beknown.live";
+
+  it("gives a cross-origin app its own origin back so storage works", () => {
+    const sandbox = resolveEmbedSandbox("https://draw-canvas.dev.beknown.live/", page);
+    // Without this, localStorage and IndexedDB throw and real apps never boot.
+    expect(sandbox).toContain("allow-same-origin");
+    expect(sandbox).toContain("allow-scripts");
+  });
+
+  it("withholds allow-same-origin from a self-referential embed", () => {
+    // allow-scripts + allow-same-origin on our OWN origin is a sandbox escape:
+    // the frame could reach the signed-in session directly.
+    for (const url of [page, `${page}/settings`, `${page}/?x=1#y`]) {
+      expect(resolveEmbedSandbox(url, page)).not.toContain("allow-same-origin");
+    }
+  });
+
+  it("treats a different port or scheme on the same host as cross-origin", () => {
+    expect(resolveEmbedSandbox("https://bkt3.dev.beknown.live:8443/", page)).toContain(
+      "allow-same-origin",
+    );
+  });
+
+  it("falls back to the locked-down sandbox for an unparseable url", () => {
+    expect(resolveEmbedSandbox("not a url", page)).not.toContain("allow-same-origin");
+  });
+});
diff --git a/apps/web/src/fork/agentUiSurface.tsx b/apps/web/src/fork/agentUiSurface.tsx
new file mode 100644
index 000000000000..7186fb396812
--- /dev/null
+++ b/apps/web/src/fork/agentUiSurface.tsx
@@ -0,0 +1,306 @@
+/**
+ * T3-CUSTOM(expbkt3): single entry point for agent-rendered UI surfaces.
+ *
+ * Everything the chat timeline needs lives here, so `MessagesTimeline` takes one
+ * import and one early return rather than growing surface logic inline. That
+ * keeps the next upstream merge cheap.
+ *
+ * A surface is one `t3_show_ui` tool call: the agent stored a document
+ * server-side and the work-log row carries only a short render handle. The card
+ * fetches the body on demand and mounts it in a sandboxed iframe, the way MCP
+ * Apps hosts render a `ui://` resource.
+ */
+import {
+  AGENT_UI_DEFAULT_HEIGHT,
+  AGENT_UI_MAX_HEIGHT,
+  AGENT_UI_MIN_HEIGHT,
+  type ScopedThreadRef,
+} from "@t3tools/contracts";
+import { Maximize2Icon, XIcon } from "lucide-react";
+import { memo, useEffect, useMemo, useState, type ReactNode } from "react";
+
+import { useClientSettings } from "../hooks/useSettings";
+import { agentUiEnvironment } from "../state/agentUi";
+import { useAgentUiExpandedStore } from "../agentUiExpandedStore";
+import { useEnvironmentQuery } from "../state/query";
+import { cn } from "../lib/utils";
+
+/** The handle `ActivityPayloadProjection` keeps on an MCP tool-call payload. */
+export interface AgentUiSurfaceHandle {
+  readonly renderId: string;
+  readonly kind: "html" | "url";
+  readonly height: number;
+}
+
+function clampHeight(height: unknown): number {
+  if (typeof height !== "number" || !Number.isFinite(height)) return AGENT_UI_DEFAULT_HEIGHT;
+  return Math.max(AGENT_UI_MIN_HEIGHT, Math.min(Math.round(height), AGENT_UI_MAX_HEIGHT));
+}
+
+/**
+ * Reads the render handle off a work-log entry, or null when the row is an
+ * ordinary tool call. Pure, so the timeline can call it before any hooks.
+ */
+export function resolveAgentUiSurface(entry: {
+  readonly agentUi?: unknown;
+}): AgentUiSurfaceHandle | null {
+  const handle = entry.agentUi;
+  if (typeof handle !== "object" || handle === null) return null;
+  const record = handle as Record<string, unknown>;
+  const renderId = record.renderId;
+  if (typeof renderId !== "string" || renderId.length === 0) return null;
+  return {
+    renderId,
+    kind: record.kind === "url" ? "url" : "html",
+    height: clampHeight(record.height),
+  };
+}
+
+/** Wraps a bare fragment so an agent can pass markup without a document shell. */
+function toSrcDoc(html: string): string {
+  if (/<html[\s>]/i.test(html)) return html;
+  return [
+    "<!doctype html>",
+    '<html><head><meta charset="utf-8">',
+    '<meta name="viewport" content="width=device-width, initial-scale=1">',
+    "<style>body{margin:0;padding:12px;font-family:system-ui,sans-serif}</style>",
+    "</head><body>",
+    html,
+    "</body></html>",
+  ].join("");
+}
+
+const EMBED_SANDBOX_BASE = "allow-scripts allow-forms allow-popups allow-downloads";
+
+/**
+ * Sandbox for a framed URL.
+ *
+ * A real app needs its own origin back: without `allow-same-origin` the document
+ * is opaque, so `localStorage`, IndexedDB and cookies all throw. Excalidraw and
+ * anything else that persists state simply fails to boot without it.
+ *
+ * Pairing `allow-same-origin` with `allow-scripts` is only an escape when the
+ * framed document is same-origin with *this* page — then it can reach our DOM,
+ * our storage and the user's session directly. So it is withheld exactly there,
+ * which leaves a self-referential embed opaque and harmless instead of handing
+ * an agent arbitrary script in the signed-in app.
+ */
+export function resolveEmbedSandbox(url: string, pageOrigin: string): string {
+  let origin: string;
+  try {
+    origin = new URL(url).origin;
+  } catch {
+    return EMBED_SANDBOX_BASE;
+  }
+  return origin === pageOrigin ? EMBED_SANDBOX_BASE : `${EMBED_SANDBOX_BASE} allow-same-origin`;
+}
+
+/**
+ * Fetches one render and mounts it. Shared by the inline card and the expanded
+ * overlay so both agree on sandboxing, loading and failure states — the sandbox
+ * rules in particular must never drift between the two.
+ */
+const AgentUiRenderFrame = memo(function AgentUiRenderFrame(props: {
+  readonly threadRef: ScopedThreadRef;
+  readonly renderId: string;
+  readonly onTitle?: ((title: string) => void) | undefined;
+}) {
+  const { environmentId, threadId } = props.threadRef;
+  const query = useEnvironmentQuery(
+    agentUiEnvironment.render({
+      environmentId,
+      input: { threadId, renderId: props.renderId },
+    }),
+  );
+  const render = query.data?.render ?? null;
+
+  // An unmodified sandbox gives the document an opaque origin: its scripts run,
+  // so charts and interactions work, but it cannot reach this page, our cookies,
+  // or the network as the signed-in user.
+  const srcDoc = useMemo(
+    () => (render?.kind === "html" && render.html ? toSrcDoc(render.html) : null),
+    [render?.kind, render?.html],
+  );
+
+  const onTitle = props.onTitle;
+  const title = render?.title;
+  useEffect(() => {
+    if (onTitle && title) onTitle(title);
+  }, [onTitle, title]);
+
+  if (query.isPending && render === null) {
+    return (
+      <div className="flex h-full items-center justify-center text-secondary-label text-xs">
+        Loading view…
+      </div>
+    );
+  }
+  if (render === null) {
+    return (
+      <div className="flex h-full items-center justify-center px-4 text-center text-secondary-label text-xs">
+        {query.error ?? "This view is no longer available."}
+      </div>
+    );
+  }
+  if (srcDoc !== null) {
+    return (
+      <iframe
+        // Keying on the render makes the browser build a fresh document; an
+        // iframe does not re-run scripts on a srcDoc mutation alone.
+        key={render.renderId}
+        title={render.title}
+        srcDoc={srcDoc}
+        className={cn("size-full border-0 bg-white")}
+        sandbox="allow-scripts"
+        referrerPolicy="no-referrer"
+      />
+    );
+  }
+  if (render.url) {
+    return (
+      <iframe
+        key={render.renderId}
+        title={render.title}
+        src={render.url}
+        className="size-full border-0 bg-white"
+        sandbox={resolveEmbedSandbox(render.url, window.location.origin)}
+        referrerPolicy="no-referrer"
+      />
+    );
+  }
+  return null;
+});
+
+interface AgentUiSurfaceCardProps {
+  readonly threadRef: ScopedThreadRef;
+  readonly surface: AgentUiSurfaceHandle;
+}
+
+function AgentUiSurfaceCardImpl({ threadRef, surface }: AgentUiSurfaceCardProps) {
+  const [collapsed, setCollapsed] = useState(false);
+  const [title, setTitle] = useState("Agent view");
+  const expand = useAgentUiExpandedStore((state) => state.expand);
+
+  return (
+    <div className="mt-1 ms-7 overflow-hidden rounded-lg border border-border/60 bg-card">
+      <div className="flex items-center gap-1 px-1.5 py-1">
+        <button
+          type="button"
+          className="flex min-w-0 flex-1 items-center gap-1.5 rounded px-1.5 py-0.5 text-left hover:bg-accent/20"
+          onClick={() => expand({ threadRef, renderId: surface.renderId })}
+          aria-label={`Expand ${title}`}
+        >
+          <span className="min-w-0 flex-1 truncate font-medium text-secondary-label text-xs">
+            {title}
+          </span>
+          <Maximize2Icon className="size-3 shrink-0 text-icon-muted opacity-70" aria-hidden />
+        </button>
+        <button
+          type="button"
+          className="shrink-0 rounded px-1.5 py-0.5 text-[0.6875rem] text-secondary-label/70 hover:bg-accent/20 hover:text-secondary-label"
+          onClick={() => setCollapsed((value) => !value)}
+          aria-expanded={!collapsed}
+        >
+          {collapsed ? "Show" : "Hide"}
+        </button>
+      </div>
+      {collapsed ? null : (
+        <div className="border-border/60 border-t" style={{ height: surface.height }}>
+          <AgentUiRenderFrame
+            threadRef={threadRef}
+            renderId={surface.renderId}
+            onTitle={setTitle}
+          />
+        </div>
+      )}
+    </div>
+  );
+}
+
+const AgentUiSurfaceCard = memo(AgentUiSurfaceCardImpl);
+
+/**
+ * Wraps the timeline's ordinary tool row with the surface it produced.
+ *
+ * Composition rather than modification: the upstream row renders unchanged as
+ * `children`, and turning the setting off leaves exactly that row behind.
+ */
+export const AgentUiSurfaceRow = memo(function AgentUiSurfaceRow(props: {
+  readonly threadRef: ScopedThreadRef | null;
+  readonly surface: AgentUiSurfaceHandle;
+  readonly children: ReactNode;
+}) {
+  const enabled = useClientSettings((settings) => settings.agentUiSurfacesEnabled);
+  if (!enabled || props.threadRef === null) {
+    return props.children;
+  }
+  return (
+    <div className="flex flex-col">
+      {props.children}
+      <AgentUiSurfaceCard threadRef={props.threadRef} surface={props.surface} />
+    </div>
+  );
+});
+
+/**
+ * The expanded view, filling the message area and leaving the composer usable.
+ *
+ * Mounted as the last child of the messages wrapper in `ChatView`, which is
+ * already `relative` and already excludes the input bar — so `absolute inset-0`
+ * covers exactly the transcript and nothing else. It cannot live inside the
+ * timeline row that opened it: those rows are virtualized, so they clip and get
+ * recycled out from under an overlay.
+ */
+export const AgentUiExpandedSurface = memo(function AgentUiExpandedSurface() {
+  const enabled = useClientSettings((settings) => settings.agentUiSurfacesEnabled);
+  const expanded = useAgentUiExpandedStore((state) => state.expanded);
+  const collapse = useAgentUiExpandedStore((state) => state.collapse);
+  const [title, setTitle] = useState("Agent view");
+
+  const open = enabled && expanded !== null;
+  useEffect(() => {
+    if (!open) return;
+    const onKeyDown = (event: KeyboardEvent) => {
+      if (event.key === "Escape") {
+        event.stopPropagation();
+        collapse();
+      }
+    };
+    // Capture phase: the composer and the timeline both handle Escape, and the
+    // expanded view is the frontmost surface, so it answers first.
+    window.addEventListener("keydown", onKeyDown, true);
+    return () => window.removeEventListener("keydown", onKeyDown, true);
+  }, [open, collapse]);
+
+  if (!open || expanded === null) return null;
+
+  return (
+    <div
+      className="absolute inset-0 z-40 flex flex-col bg-background"
+      role="dialog"
+      aria-label={title}
+    >
+      <div className="flex items-center gap-2 border-border/60 border-b px-3 py-1.5">
+        <span className="min-w-0 flex-1 truncate font-medium text-secondary-label text-xs">
+          {title}
+        </span>
+        <button
+          type="button"
+          className="flex shrink-0 items-center gap-1 rounded px-1.5 py-0.5 text-[0.6875rem] text-secondary-label/70 hover:bg-accent/20 hover:text-secondary-label"
+          onClick={collapse}
+          aria-label="Close the expanded view"
+        >
+          <XIcon className="size-3" aria-hidden />
+          Close
+        </button>
+      </div>
+      <div className="min-h-0 flex-1">
+        <AgentUiRenderFrame
+          threadRef={expanded.threadRef}
+          renderId={expanded.renderId}
+          onTitle={setTitle}
+        />
+      </div>
+    </div>
+  );
+});
diff --git a/apps/web/src/session-logic.ts b/apps/web/src/session-logic.ts
index 217c2f6cb4fa..d282d99a3b7e 100644
--- a/apps/web/src/session-logic.ts
+++ b/apps/web/src/session-logic.ts
@@ -93,6 +93,11 @@ export interface WorkLogEntry {
     workflowId: string | null;
     agentTaskIds: ReadonlyArray<string>;
   };
+  /**
+   * T3-CUSTOM(expbkt3): render handle left by a `t3_show_ui` call. The document
+   * itself is fetched on demand; this is only the key to it.
+   */
+  agentUi?: unknown;
 }
 
 const workLogCollapseKey = Symbol();
@@ -989,6 +994,11 @@ function toDerivedWorkLogEntry(activity: OrchestrationThreadActivity): DerivedWo
     if (data?.item !== undefined) {
       entry.toolData = data.item;
     }
+    // T3-CUSTOM(expbkt3): agent-rendered UI surfaces. Read straight off `data`,
+    // which every adapter populates, rather than the Codex-only `data.item`.
+    if (data?.t3Ui !== undefined) {
+      entry.agentUi = data.t3Ui;
+    }
   }
   if (itemType) {
     entry.itemType = itemType;
diff --git a/apps/web/src/state/agentUi.ts b/apps/web/src/state/agentUi.ts
new file mode 100644
index 000000000000..a36248484d69
--- /dev/null
+++ b/apps/web/src/state/agentUi.ts
@@ -0,0 +1,6 @@
+// T3-CUSTOM(expbkt3): agent UI surface atoms bound to the web connection.
+import { createAgentUiEnvironmentAtoms } from "@t3tools/client-runtime/state/agentUi";
+
+import { connectionAtomRuntime } from "../connection/runtime";
+
+export const agentUiEnvironment = createAgentUiEnvironmentAtoms(connectionAtomRuntime);
diff --git a/docs/README.md b/docs/README.md
index e98649505c68..689c9544b2ec 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -15,6 +15,7 @@
 - [Source control integrations](./user/source-control.md)
 - [Worktree setup and new-thread defaults](./user/worktree-setup.md)
 - [T3 Code MCP control center](./user/t3-mcp-control.md)
+- [Agent views in chat](./user/agent-views.md)
 - [Background service (Linux)](./user/background-service.md)
 - [Provider usage limits](./user/provider-limits.md)
 - Providers: [Codex](./user/providers-codex.md) · [Claude](./user/providers-claude.md)
diff --git a/docs/operations/expbkt3-customizations.md b/docs/operations/expbkt3-customizations.md
index b25aec3e53e6..5538ec955012 100644
--- a/docs/operations/expbkt3-customizations.md
+++ b/docs/operations/expbkt3-customizations.md
@@ -109,6 +109,7 @@ turn-settlement rewrite in `state/threadReducer.ts`, the restart predicate in
 | Execution resume resync   | none — two marked seams only                                                                                                                                                                                                                       | `ws.ts` shell/thread resume, `client-runtime/state/shellReducer.ts` overlay merge                                                                                                                                                                                                                                                         |
 | Native plan review        | `apps/server/src/planreview/`, `persistence/PlanReviewDocuments.ts`, migration 1009, `packages/shared/src/planReview.ts`, `packages/contracts/src/planReview.ts`, `apps/web/src/components/planreview/`, `apps/web/src/fork/planReviewSurface.tsx` | fork RPC group + scopes + handlers, one `ws.ts` dep, right-panel store/tabs, `ChatView.tsx` branch, `ProposedPlanCard.tsx` button, Beta settings toggle, nullable comment range in `reviewCommentContext.ts` + `reviewCommentSelection.ts` + `nativeReviewDiffAdapter.ts`, plan-comment card in `MessagesTimeline.tsx` + `ThreadFeed.tsx` |
 | Session identity          | `apps/server/src/identity/SessionIdentityEnvironment.ts`, `apps/server/src/provider/claudeSessionIdentity.expbkt3.ts`                                                                                                                              | `ProviderCommandReactor.ts` execution-options seam, `ProviderService.ts` adapter-spawn seam, `identityEnvironment` on `ProviderSessionExecutionOptions`, conditional scrub in `SourceControlExecutionEnvironment.ts`, `server.ts` layer, `ClaudeAdapter.ts` system-prompt append + `UserPromptSubmit` hook seams                          |
+| Agent views in chat       | `apps/server/src/agentui/`, `persistence/AgentUiRenders.ts`, migration 1022, `packages/contracts/src/agentUi.ts`, `packages/client-runtime/src/state/agentUi.ts`, `apps/web/src/fork/agentUiSurface.tsx`, `apps/web/src/state/agentUi.ts`          | `t3_show_ui` in the MCP control toolkit, fork RPC group + scopes + handlers, one `ws.ts` dep, one `server.ts` layer, marked handle passthrough in `ActivityPayloadProjection.ts`, `agentUi` field + read in `session-logic.ts`, one import and early return in `MessagesTimeline.tsx`, Experiments toggle + `settingsSearch.ts` entry     |
 | Experimental deployment   | `.github/workflows/deploy-expbkt3.yml`, `deploy/expbkt3/`                                                                                                                                                                                          | none                                                                                                                                                                                                                                                                                                                                      |
 
 Generated files such as `apps/web/src/routeTree.gen.ts` do not receive hand-written
diff --git a/docs/user/agent-views.md b/docs/user/agent-views.md
new file mode 100644
index 000000000000..b0299d243955
--- /dev/null
+++ b/docs/user/agent-views.md
@@ -0,0 +1,45 @@
+# Agent views in chat
+
+> **T3-CUSTOM(expbkt3):** This feature is maintained as an experimental,
+> upstream-isolated extension. See the
+> [customization boundary registry](../operations/expbkt3-customizations.md).
+
+An agent can render a small interactive view directly in the conversation: a
+chart, a diagram, a table, a form, a preview. The view appears inline, in the
+place where the agent produced it, rather than as a file you have to open.
+
+Ask for something visual — "chart the request latency by endpoint", "show me the
+migration order as a diagram", "lay these options out side by side" — and the
+agent decides whether a view says it better than text.
+
+## What a view is
+
+Each view is a box in the transcript with a title bar you can collapse. Inside
+is a document the agent wrote, rendered in a sandbox:
+
+- Its styles and scripts run, so charts, tabs and hover states work.
+- It cannot reach T3 Code, your session, your cookies, or the network as you.
+- It cannot navigate the app or read anything outside its own box.
+
+Views are a snapshot, not a live surface. When an agent shows you an updated
+version it appears as a new box further down the conversation, so scrolling back
+still shows what it produced at that point in the work.
+
+An agent can also embed a page by its `https` address instead of writing the
+document itself. Some sites refuse to be embedded and will show an empty box;
+that is the site's decision, not a fault in T3.
+
+## Turning it off
+
+**Settings → Experiments → Agent views in chat.** While it is off, an agent that
+tries to show a view leaves an ordinary collapsed tool row instead, and nothing
+is rendered. The setting is per client, so turning it off on your laptop does not
+change what you see on your phone.
+
+## Limits
+
+- One view is capped at roughly 256,000 characters. An agent that needs more is
+  told to render something smaller.
+- Height is capped, so a view cannot take over the transcript.
+- Views are stored with the session and are removed when the session's data is
+  reclaimed.
diff --git a/packages/client-runtime/package.json b/packages/client-runtime/package.json
index 91bf92b129ce..201407bd95cc 100644
--- a/packages/client-runtime/package.json
+++ b/packages/client-runtime/package.json
@@ -143,6 +143,10 @@
       "types": "./src/state/planReview.ts",
       "default": "./src/state/planReview.ts"
     },
+    "./state/agentUi": {
+      "types": "./src/state/agentUi.ts",
+      "default": "./src/state/agentUi.ts"
+    },
     "./state/terminal": {
       "types": "./src/state/terminal.ts",
       "default": "./src/state/terminal.ts"
diff --git a/packages/client-runtime/src/state/agentUi.ts b/packages/client-runtime/src/state/agentUi.ts
new file mode 100644
index 000000000000..af9b26096508
--- /dev/null
+++ b/packages/client-runtime/src/state/agentUi.ts
@@ -0,0 +1,24 @@
+/**
+ * T3-CUSTOM(expbkt3): client atoms for agent-rendered UI surfaces.
+ *
+ * Renders are immutable, so this is a plain keyed query with no subscription:
+ * once a box has its document it never changes, and an agent showing something
+ * new produces a new render with its own key.
+ */
+import { WS_METHODS } from "@t3tools/contracts";
+import { Atom } from "effect/unstable/reactivity";
+
+import { createEnvironmentRpcQueryAtomFamily } from "./runtime.ts";
+import type { EnvironmentRegistry } from "../connection/registry.ts";
+import { EnvironmentCacheStore } from "../platform/persistence.ts";
+
+export function createAgentUiEnvironmentAtoms<R, E>(
+  runtime: Atom.AtomRuntime<EnvironmentRegistry | EnvironmentCacheStore | R, E>,
+) {
+  return {
+    render: createEnvironmentRpcQueryAtomFamily(runtime, {
+      label: "environment-data:agent-ui:get-render",
+      tag: WS_METHODS.agentUiGetRender,
+    }),
+  };
+}
diff --git a/packages/contracts/src/agentUi.ts b/packages/contracts/src/agentUi.ts
new file mode 100644
index 000000000000..2ae5fbad0c2d
--- /dev/null
+++ b/packages/contracts/src/agentUi.ts
@@ -0,0 +1,69 @@
+/**
+ * T3-CUSTOM(expbkt3): agent-rendered UI surfaces in the chat transcript.
+ *
+ * An agent calls the `t3_show_ui` MCP tool with a small HTML document (or a URL)
+ * and the chat mounts it as a sandboxed box inline, the way MCP Apps hosts render
+ * `ui://` resources. Each call is one immutable render: re-running the tool makes
+ * a new box rather than mutating an existing one, so a timeline row always shows
+ * exactly what the agent produced at that moment.
+ *
+ * The HTML never travels on an activity payload — only the short render handle
+ * does. Clients fetch the body through `agentUi.getRender`, which keeps the
+ * websocket cheap and sidesteps the activity payload string cap.
+ */
+import * as Schema from "effect/Schema";
+
+import { ThreadId, TrimmedNonEmptyString } from "./baseSchemas.ts";
+
+/** How the box gets its content: an inline document, or a framed URL. */
+export const AgentUiRenderKind = Schema.Literals(["html", "url"]);
+export type AgentUiRenderKind = typeof AgentUiRenderKind.Type;
+
+export const AGENT_UI_MIN_HEIGHT = 120;
+export const AGENT_UI_MAX_HEIGHT = 900;
+export const AGENT_UI_DEFAULT_HEIGHT = 360;
+/** Largest inline document accepted from a tool call. */
+export const AGENT_UI_MAX_HTML_CHARS = 262_144;
+
+export const AgentUiRenderRecord = Schema.Struct({
+  renderId: TrimmedNonEmptyString,
+  threadId: ThreadId,
+  title: Schema.String,
+  kind: AgentUiRenderKind,
+  html: Schema.NullOr(Schema.String),
+  url: Schema.NullOr(Schema.String),
+  height: Schema.Number,
+  createdAt: Schema.String,
+});
+export type AgentUiRenderRecord = typeof AgentUiRenderRecord.Type;
+
+export const AgentUiGetRenderInput = Schema.Struct({
+  threadId: ThreadId,
+  renderId: TrimmedNonEmptyString,
+});
+export type AgentUiGetRenderInput = typeof AgentUiGetRenderInput.Type;
+
+export const AgentUiGetRenderResult = Schema.Struct({
+  render: Schema.NullOr(AgentUiRenderRecord),
+});
+export type AgentUiGetRenderResult = typeof AgentUiGetRenderResult.Type;
+
+export class AgentUiError extends Schema.TaggedErrorClass<AgentUiError>()("AgentUiError", {
+  operation: TrimmedNonEmptyString,
+  message: TrimmedNonEmptyString,
+}) {}
+
+/**
+ * The handle the tool result carries back through the provider stream.
+ *
+ * Deliberately tiny and single-line: activity projection summarizes MCP results
+ * to one short line, so anything larger would not survive to the client.
+ */
+export const AGENT_UI_RESULT_MARKER = "t3UiRender";
+
+export interface AgentUiRenderHandle {
+  readonly renderId: string;
+  readonly kind: AgentUiRenderKind;
+  readonly height: number;
+  readonly title: string;
+}
diff --git a/packages/contracts/src/index.ts b/packages/contracts/src/index.ts
index aaee2afcf62d..b7b5d73556e0 100644
--- a/packages/contracts/src/index.ts
+++ b/packages/contracts/src/index.ts
@@ -22,6 +22,8 @@ export * from "./personalMcp.ts";
 export * from "./linearIssue.ts";
 // T3-CUSTOM(expbkt3): native plan review contracts.
 export * from "./planReview.ts";
+// T3-CUSTOM(expbkt3): agent-rendered UI surfaces in chat.
+export * from "./agentUi.ts";
 export * from "./git.ts";
 export * from "./vcs.ts";
 export * from "./sourceControl.ts";
diff --git a/packages/contracts/src/rpcFork.ts b/packages/contracts/src/rpcFork.ts
index 64a474cf3eca..2596f1d0b899 100644
--- a/packages/contracts/src/rpcFork.ts
+++ b/packages/contracts/src/rpcFork.ts
@@ -25,6 +25,8 @@ import {
   PersonalMcpTokenResult,
 } from "./personalMcp.ts";
 import { LinearIssueStatusInput, LinearIssueStatusResult } from "./linearIssue.ts";
+// T3-CUSTOM(expbkt3): agent-rendered UI surfaces in chat.
+import { AgentUiError, AgentUiGetRenderInput, AgentUiGetRenderResult } from "./agentUi.ts";
 import {
   PlanReviewCutVersionInput,
   PlanReviewDocumentIdInput,
@@ -110,6 +112,8 @@ export const WS_FORK_METHODS = {
   sessionArchiveReclaim: "sessionArchive.reclaim",
   sessionArchiveBackfill: "sessionArchive.backfill",
   threadContextExport: "threadContext.export",
+  // T3-CUSTOM(expbkt3): agent-rendered UI surfaces in chat.
+  agentUiGetRender: "agentUi.getRender",
 } as const;
 
 export const WsPersonalMcpGetProfileRpc = Rpc.make(WS_FORK_METHODS.personalMcpGetProfile, {
@@ -304,6 +308,15 @@ export const WsThreadContextExportRpc = Rpc.make(WS_FORK_METHODS.threadContextEx
   error: Schema.Union([SessionArchiveError, EnvironmentAuthorizationError]),
 });
 
+// T3-CUSTOM(expbkt3): agent-rendered UI surfaces. The render body is fetched on
+// demand rather than pushed through activity payloads, which keeps oversized
+// documents off the websocket and out of the activity string cap.
+export const WsAgentUiGetRenderRpc = Rpc.make(WS_FORK_METHODS.agentUiGetRender, {
+  payload: AgentUiGetRenderInput,
+  success: AgentUiGetRenderResult,
+  error: Schema.Union([AgentUiError, EnvironmentAuthorizationError]),
+});
+
 export const WsOrchestrationStopExecutionRpc = Rpc.make(ORCHESTRATION_WS_METHODS.stopExecution, {
   payload: OrchestrationRpcSchemas.stopExecution.input,
   success: OrchestrationRpcSchemas.stopExecution.output,
@@ -413,6 +426,7 @@ export const FORK_WS_RPCS = [
   WsSessionArchiveReclaimRpc,
   WsSessionArchiveBackfillRpc,
   WsThreadContextExportRpc,
+  WsAgentUiGetRenderRpc,
   WsOrchestrationStopExecutionRpc,
   WsOrchestrationReplayEventsRpc,
 ] as const;
diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.ts
index 1684a943e664..866f9a447bcf 100644
--- a/packages/contracts/src/settings.ts
+++ b/packages/contracts/src/settings.ts
@@ -257,6 +257,9 @@ export const ClientSettingsSchema = Schema.Struct({
   // T3-CUSTOM(expbkt3): native plan review. On by default; turning it off hides
   // the Preview entry points and leaves Plannotator as the only review path.
   nativePlanReviewEnabled: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(true))),
+  // T3-CUSTOM(expbkt3): agent-rendered UI surfaces in the chat transcript. While
+  // off, a `t3_show_ui` call stays an ordinary collapsed tool row.
+  agentUiSurfacesEnabled: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(true))),
   sidebarAutoSettleAfterDays: Schema.NullOr(SidebarAutoSettleAfterDays).pipe(
     Schema.withDecodingDefault(Effect.succeed(DEFAULT_SIDEBAR_AUTO_SETTLE_AFTER_DAYS)),
   ),
@@ -1241,6 +1244,8 @@ export const ClientSettingsPatch = Schema.Struct({
   legacySidebarEnabled: Schema.optionalKey(Schema.Boolean),
   // T3-CUSTOM(expbkt3): native plan review.
   nativePlanReviewEnabled: Schema.optionalKey(Schema.Boolean),
+  // T3-CUSTOM(expbkt3): agent-rendered UI surfaces in chat.
+  agentUiSurfacesEnabled: Schema.optionalKey(Schema.Boolean),
   sidebarAutoSettleAfterDays: Schema.optionalKey(Schema.NullOr(SidebarAutoSettleAfterDays)),
   sidebarAutoSettleOnMerge: Schema.optionalKey(Schema.Boolean),
   sidebarProjectGroupingMode: Schema.optionalKey(SidebarProjectGroupingMode),