diff --git a/apps/server/src/index.ts b/apps/server/src/index.ts
index 9726f63..4a79eae 100644
--- a/apps/server/src/index.ts
+++ b/apps/server/src/index.ts
@@ -19,11 +19,13 @@ import { RemoteEnvironmentGateway } from "./remote/remoteEnvironmentGateway.ts";
 import { createAgentBundlesRouter } from "./routes/agentBundles.ts";
 import { createGlobalMemoryRouter } from "./routes/globalMemory.ts";
 import { createInternalAgentsRouter } from "./routes/internalAgents.ts";
+import { createInternalCsomRouter } from "./routes/internalCsom.ts";
 import { createInternalEgressRouter } from "./routes/internalEgress.ts";
 import { createInternalMemoryRouter } from "./routes/internalMemory.ts";
 import { createInternalSessionRouter } from "./routes/internalSession.ts";
 import { createInternalTriggersRouter } from "./routes/internalTriggers.ts";
 import { createMeRouter } from "./routes/me.ts";
+import { createRemoteEnvRouter } from "./routes/remoteEnv.ts";
 import { createSessionsRouter } from "./routes/sessions/index.ts";
 import {
   createAgentEventHandler,
@@ -120,6 +122,9 @@ app.use("/api/agent-bundles", createAgentBundlesRouter(agentBundleStore));
 app.use("/api/global-memory", createGlobalMemoryRouter(memory));
 // Returns the current user, derived from the Oktasso JWT cookie.
 app.use("/api/me", createMeRouter());
+// Hands the SPA the `/remote-env` token so the Pipeline Editor tab can connect
+// as its session's CSOM executor (only when remote hosting is enabled).
+app.use("/api/remote-env", createRemoteEnvRouter());
 // Internal API for the orchestrator extension running inside each Pi process.
 app.use(
   "/internal/agents",
@@ -127,6 +132,9 @@ app.use(
 );
 // Internal egress proxy for bundle tool extensions (e.g. the Tangle API tool).
 app.use("/internal/egress", createInternalEgressRouter());
+// Internal CSOM relay: Prime's pipeline-editor tools drive the browser's
+// embedded Tangle editor through the remote-environment gateway.
+app.use("/internal/csom", createInternalCsomRouter(remoteGateway));
 // Internal API for the triggers extension running inside each Pi process.
 app.use(
   "/internal/triggers",
diff --git a/apps/server/src/remote/remoteEnvironmentGateway.ts b/apps/server/src/remote/remoteEnvironmentGateway.ts
index 5c8031c..69399c6 100644
--- a/apps/server/src/remote/remoteEnvironmentGateway.ts
+++ b/apps/server/src/remote/remoteEnvironmentGateway.ts
@@ -11,6 +11,8 @@ import {
   type RemoteAgentEvent,
   type RemoteAgentEventPayload,
   type RemoteAgentMessagePayload,
+  type RemoteCsomCallRequest,
+  type RemoteCsomCallResponse,
   RemoteEnvEvents,
   type RemoteEnvHandshake,
   type RemoteKillCommand,
@@ -35,6 +37,9 @@ import type { SessionStore } from "../store/sessionStore.ts";
 const DEFAULT_ROOM_LIMIT = 30;
 const MAX_ROOM_LIMIT = 200;
 
+/** How long a CSOM invocation waits for the environment's ack before failing. */
+const CSOM_CALL_TIMEOUT_MS = 20_000;
+
 /**
  * Relays a remote sub-agent's reply/report into the session's Prime process.
  * Wired in `index.ts` to `pi.sendToAgent(sessionId, PRIME_AGENT_ID, text)`, so
@@ -46,6 +51,8 @@ export type DeliverToPrime = (sessionId: string, text: string) => void;
 interface RemoteEnvConnection {
   environmentId: string;
   socket: Socket;
+  /** Session this environment is bound to as the CSOM executor, if any. */
+  sessionId?: string;
 }
 
 /** A sub-agent hosted in a remote environment, tracked in the gateway roster. */
@@ -107,6 +114,8 @@ export class RemoteEnvironmentGateway {
   private readonly environments = new Map<string, RemoteEnvConnection>();
   /** Per-session remote sub-agent rosters, keyed by sessionId then agentId. */
   private readonly sessions = new Map<string, Map<string, RemoteSubagent>>();
+  /** CSOM executor binding: sessionId -> environmentId (e.g. a browser tab). */
+  private readonly csomBindings = new Map<string, string>();
 
   constructor(
     io: SocketIOServer,
@@ -138,6 +147,54 @@ export class RemoteEnvironmentGateway {
     return [...roster.values()].map(toInfo);
   }
 
+  /** True when a session has a connected CSOM executor (pipeline editor). */
+  hasCsomEditor(sessionId: string): boolean {
+    const environmentId = this.csomBindings.get(sessionId);
+    return environmentId !== undefined && this.environments.has(environmentId);
+  }
+
+  /**
+   * Invokes a CSOM editing method on the session's bound editor environment and
+   * resolves with its ack. Returns a structured `{ ok: false, error }` when no
+   * editor is connected or the environment times out, so callers (Prime's CSOM
+   * tools) can surface a helpful message rather than throw.
+   */
+  invokeCsom(
+    sessionId: string,
+    method: string,
+    args: unknown[],
+  ): Promise<RemoteCsomCallResponse> {
+    const environmentId = this.csomBindings.get(sessionId);
+    const environment = environmentId
+      ? this.environments.get(environmentId)
+      : undefined;
+    if (!environment) {
+      return Promise.resolve({
+        ok: false,
+        error:
+          "No pipeline editor is connected for this session. Ask the user to " +
+          "open the Pipeline Editor tab first.",
+      });
+    }
+
+    const request: RemoteCsomCallRequest = { sessionId, method, args };
+    return new Promise<RemoteCsomCallResponse>((resolve) => {
+      environment.socket
+        .timeout(CSOM_CALL_TIMEOUT_MS)
+        .emit(
+          RemoteEnvEvents.CsomCall,
+          request,
+          (err: Error | null, response: RemoteCsomCallResponse) => {
+            if (err) {
+              resolve({ ok: false, error: `CSOM call timed out: ${method}` });
+              return;
+            }
+            resolve(response);
+          },
+        );
+    });
+  }
+
   /**
    * Spawns a sub-agent on a connected remote environment. Resolves the
    * effective config from the global templates/defaults (remote environments
@@ -300,8 +357,10 @@ export class RemoteEnvironmentGateway {
 
   /** Registers a connected environment and wires its inbound listeners. */
   private onConnection(_namespace: Namespace, socket: Socket): void {
-    const { environmentId } = socket.handshake.auth as RemoteEnvHandshake;
-    this.environments.set(environmentId, { environmentId, socket });
+    const { environmentId, sessionId } = socket.handshake
+      .auth as RemoteEnvHandshake;
+    this.environments.set(environmentId, { environmentId, socket, sessionId });
+    if (sessionId) this.csomBindings.set(sessionId, environmentId);
     console.log(`[remote-env] connected: ${environmentId}`);
 
     socket.on(RemoteEnvEvents.AgentEvent, (payload: RemoteAgentEventPayload) =>
@@ -398,6 +457,9 @@ export class RemoteEnvironmentGateway {
   /** Drops a disconnected environment and fails its still-live sub-agents. */
   private onDisconnect(environmentId: string): void {
     this.environments.delete(environmentId);
+    for (const [sessionId, boundId] of this.csomBindings) {
+      if (boundId === environmentId) this.csomBindings.delete(sessionId);
+    }
     for (const [sessionId, roster] of this.sessions) {
       this.failEnvironmentAgents(sessionId, roster, environmentId);
     }
diff --git a/apps/server/src/routes/internalCsom.ts b/apps/server/src/routes/internalCsom.ts
new file mode 100644
index 0000000..a361660
--- /dev/null
+++ b/apps/server/src/routes/internalCsom.ts
@@ -0,0 +1,55 @@
+import { type Response, Router } from "express";
+import { z } from "zod";
+
+import { requireInternalToken } from "../middleware/requireInternalToken.ts";
+import { getValidated, validate } from "../middleware/validate.ts";
+import type { RemoteEnvironmentGateway } from "../remote/remoteEnvironmentGateway.ts";
+
+/**
+ * A CSOM invocation: the camelCase editor method (e.g. `addTask`,
+ * `connectNodes`, `getSpecYaml`) and its positional args, scoped to a session.
+ * `args` is permissive — it is forwarded verbatim to the editor bridge.
+ */
+const csomInvokeSchema = z.object({
+  sessionId: z.string().min(1),
+  method: z.string().min(1),
+  args: z.array(z.unknown()).optional(),
+});
+type CsomInvokeBody = z.infer<typeof csomInvokeSchema>;
+
+/** Forwards a CSOM call to the session's bound editor and returns its ack. */
+async function handleInvoke(
+  remoteGateway: RemoteEnvironmentGateway,
+  body: CsomInvokeBody,
+  res: Response,
+): Promise<void> {
+  const result = await remoteGateway.invokeCsom(
+    body.sessionId,
+    body.method,
+    body.args ?? [],
+  );
+  res.json(result);
+}
+
+/**
+ * Internal API used by the CSOM tool extension running inside each Pi process.
+ * It lets Prime drive the embedded Tangle pipeline editor: each tool call is
+ * relayed to the browser tab that opened the editor (the session's bound remote
+ * environment) and the CSOM result is returned.
+ *
+ * Guarded by the same `INTERNAL_TOKEN` the other internal APIs use, so only the
+ * spawned Pi processes (not arbitrary local callers) can drive the editor.
+ */
+export function createInternalCsomRouter(
+  remoteGateway: RemoteEnvironmentGateway,
+): Router {
+  const router = Router();
+
+  router.use(requireInternalToken);
+
+  router.post("/invoke", validate({ body: csomInvokeSchema }), (req, res) =>
+    handleInvoke(remoteGateway, getValidated<CsomInvokeBody>(req).body, res),
+  );
+
+  return router;
+}
diff --git a/apps/server/src/routes/remoteEnv.ts b/apps/server/src/routes/remoteEnv.ts
new file mode 100644
index 0000000..a04095a
--- /dev/null
+++ b/apps/server/src/routes/remoteEnv.ts
@@ -0,0 +1,30 @@
+import { type Request, type Response, Router } from "express";
+
+import { REMOTE_ENV_TOKEN } from "../config.ts";
+
+/**
+ * Tells the SPA whether remote CSOM hosting is enabled and, if so, hands it the
+ * shared `/remote-env` token so the Pipeline Editor tab can connect as its
+ * session's CSOM executor.
+ *
+ * The token is the same shared secret external remote environments use. Remote
+ * hosting is opt-in (empty by default), so this only exposes a token an operator
+ * has explicitly configured. It is a same-origin dev convenience; production
+ * deployments that gate the app behind auth should front this route with it.
+ */
+function handleGetToken(_req: Request, res: Response): void {
+  if (!REMOTE_ENV_TOKEN) {
+    res.json({ enabled: false });
+    return;
+  }
+  res.json({ enabled: true, token: REMOTE_ENV_TOKEN });
+}
+
+/** Public REST router exposing the remote-env connection token to the SPA. */
+export function createRemoteEnvRouter(): Router {
+  const router = Router();
+  router.get("/token", (req: Request, res: Response) =>
+    handleGetToken(req, res),
+  );
+  return router;
+}
diff --git a/apps/web/package.json b/apps/web/package.json
index 7e98840..3bbba80 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -21,6 +21,7 @@
     "@remote-dom/core": "^1.11.1",
     "@remote-dom/polyfill": "^1.5.1",
     "@remote-dom/react": "^1.2.2",
+    "@tangent/remote-subagent": "workspace:*",
     "@tangent/shared": "workspace:*",
     "@tangent/ui-extensions-sdk": "workspace:*",
     "@tangent/ui-primitives": "workspace:*",
diff --git a/apps/web/src/features/bundle-ui/BundleUiHost.tsx b/apps/web/src/features/bundle-ui/BundleUiHost.tsx
index 605129a..b587438 100644
--- a/apps/web/src/features/bundle-ui/BundleUiHost.tsx
+++ b/apps/web/src/features/bundle-ui/BundleUiHost.tsx
@@ -101,6 +101,8 @@ interface BundleUiHostProps {
   stateNamespace?: string;
   /** Collapses the message this component is rendered in (message surface). */
   onCollapse?: () => void;
+  /** Opens a full-screen in-app tab requested via `execUICommand({ type: "openTab" })`. */
+  onOpenTab?: (command: Extract<UICommand, { type: "openTab" }>) => void;
 }
 
 function Placeholder() {
@@ -118,6 +120,7 @@ export function BundleUiHost({
   onSendPrompt,
   stateNamespace,
   onCollapse,
+  onOpenTab,
 }: BundleUiHostProps) {
   const receiver = useMemo(() => new RemoteReceiver(), []);
   const [failed, setFailed] = useState(false);
@@ -128,11 +131,15 @@ export function BundleUiHost({
   const sendPromptRef = useRef<((text: string) => void) | undefined>(undefined);
   const stateNamespaceRef = useRef<string | undefined>(undefined);
   const collapseRef = useRef<(() => void) | undefined>(undefined);
+  const openTabRef = useRef<
+    ((command: Extract<UICommand, { type: "openTab" }>) => void) | undefined
+  >(undefined);
   useEffect(() => {
     propsRef.current = props ?? {};
     sendPromptRef.current = onSendPrompt;
     stateNamespaceRef.current = stateNamespace;
     collapseRef.current = onCollapse;
+    openTabRef.current = onOpenTab;
   });
 
   useEffect(() => {
@@ -169,6 +176,10 @@ export function BundleUiHost({
           openExternalUrl(command.url);
           return;
         }
+        if (command.type === "openTab") {
+          openTabRef.current?.(command);
+          return;
+        }
         await openTargetUrl(command);
       },
     });
diff --git a/apps/web/src/features/chat/components/PrimeChatPanel.tsx b/apps/web/src/features/chat/components/PrimeChatPanel.tsx
index 417b410..cf92cc7 100644
--- a/apps/web/src/features/chat/components/PrimeChatPanel.tsx
+++ b/apps/web/src/features/chat/components/PrimeChatPanel.tsx
@@ -7,6 +7,7 @@ import {
   type SubagentInfo,
   type Trigger,
 } from "@tangent/shared/contracts";
+import type { UICommand } from "@tangent/ui-extensions-sdk/types";
 import { Box } from "@tangent/ui-primitives/box";
 import { BlockStack, InlineStack } from "@tangent/ui-primitives/layout";
 
@@ -55,6 +56,7 @@ interface PrimeChatPanelProps {
   openArtifactTab: (url: string, title: string) => void;
   pinnedPaths: Set<string>;
   togglePinArtifact: (path: string, title: string) => void;
+  onOpenTab: (command: Extract<UICommand, { type: "openTab" }>) => void;
 }
 
 export function PrimeChatPanel({
@@ -82,6 +84,7 @@ export function PrimeChatPanel({
   openArtifactTab,
   pinnedPaths,
   togglePinArtifact,
+  onOpenTab,
 }: PrimeChatPanelProps) {
   return (
     <BlockStack grow>
@@ -95,6 +98,7 @@ export function PrimeChatPanel({
         onOpenArtifact={openArtifactTab}
         pinnedPaths={pinnedPaths}
         onTogglePinArtifact={togglePinArtifact}
+        onOpenTab={onOpenTab}
         isMessageStreaming={isMessageStreaming}
       />
       {memorySuggestions.length > 0 && (
@@ -112,7 +116,11 @@ export function PrimeChatPanel({
         </Box>
       )}
       {bundleId && (
-        <BundlePanelLauncher bundleId={bundleId} onSendPrompt={send} />
+        <BundlePanelLauncher
+          bundleId={bundleId}
+          onSendPrompt={send}
+          onOpenTab={onOpenTab}
+        />
       )}
       <PrimeComposerFooter
         sessionId={sessionId}
diff --git a/apps/web/src/features/chat/components/SessionChat.tsx b/apps/web/src/features/chat/components/SessionChat.tsx
index 6b6b20b..f63b656 100644
--- a/apps/web/src/features/chat/components/SessionChat.tsx
+++ b/apps/web/src/features/chat/components/SessionChat.tsx
@@ -70,8 +70,15 @@ export function SessionChat({ sessionId }: SessionChatProps) {
 
   // Opened tabs (assets and sub-agent threads), each shown beside the chat in
   // its own closeable tab.
-  const { tabs, activeTab, setActiveTab, openAsset, openAgent, closeAsset } =
-    useAssetTabs();
+  const {
+    tabs,
+    activeTab,
+    setActiveTab,
+    openAsset,
+    openAgent,
+    openPipelineEditor,
+    closeAsset,
+  } = useAssetTabs();
 
   // The session's pages, files, and triggers as one uniform list of cards.
   const assets = buildAssets({ sessionId, artifacts, triggers });
@@ -117,6 +124,16 @@ export function SessionChat({ sessionId }: SessionChatProps) {
     });
   };
 
+  // A bundle message/panel component can ask the host to open a full-screen
+  // in-app tab via `host.execUICommand({ type: "openTab" })`. Only the
+  // pipeline-editor tab exists today.
+  const handleOpenTab = (command: {
+    tab: "pipeline-editor";
+    title?: string;
+  }) => {
+    if (command.tab === "pipeline-editor") openPipelineEditor(command.title);
+  };
+
   // Pin an artifact if it isn't already pinned, else unpin it. The chip's
   // pinned state and the sidebar list both update via the `artifacts.update`
   // directive once the server confirms.
@@ -227,6 +244,7 @@ export function SessionChat({ sessionId }: SessionChatProps) {
                   openArtifactTab={openArtifactTab}
                   pinnedPaths={pinnedPaths}
                   togglePinArtifact={togglePinArtifact}
+                  onOpenTab={handleOpenTab}
                 />
               </TabsContent>
 
diff --git a/apps/web/src/features/chat/components/composer/BundlePanelLauncher.tsx b/apps/web/src/features/chat/components/composer/BundlePanelLauncher.tsx
index 12a12d1..b0debb0 100644
--- a/apps/web/src/features/chat/components/composer/BundlePanelLauncher.tsx
+++ b/apps/web/src/features/chat/components/composer/BundlePanelLauncher.tsx
@@ -1,3 +1,4 @@
+import type { UICommand } from "@tangent/ui-extensions-sdk/types";
 import { Box } from "@tangent/ui-primitives/box";
 import { Button } from "@tangent/ui-primitives/button";
 import { BlockStack, InlineStack } from "@tangent/ui-primitives/layout";
@@ -14,6 +15,8 @@ interface BundlePanelLauncherProps {
   bundleId: string;
   /** Composes the panel's prompt and sends it to Prime. */
   onSendPrompt: (text: string) => void;
+  /** Opens a full-screen in-app tab requested by a panel via `execUICommand`. */
+  onOpenTab?: (command: Extract<UICommand, { type: "openTab" }>) => void;
 }
 
 /**
@@ -24,6 +27,7 @@ interface BundlePanelLauncherProps {
 export function BundlePanelLauncher({
   bundleId,
   onSendPrompt,
+  onOpenTab,
 }: BundlePanelLauncherProps) {
   const { data: bundle } = useAgentBundle(bundleId);
   const [selected, setSelected] = useState<string | null>(null);
@@ -81,6 +85,7 @@ export function BundlePanelLauncher({
                   onSendPrompt(text);
                   setSelected(null);
                 }}
+                onOpenTab={onOpenTab}
               />
             </BlockStack>
           </Box>
diff --git a/apps/web/src/features/chat/components/message/ChatMessage.tsx b/apps/web/src/features/chat/components/message/ChatMessage.tsx
index e0d0185..b415fc2 100644
--- a/apps/web/src/features/chat/components/message/ChatMessage.tsx
+++ b/apps/web/src/features/chat/components/message/ChatMessage.tsx
@@ -1,3 +1,4 @@
+import type { UICommand } from "@tangent/ui-extensions-sdk/types";
 import { BlockStack } from "@tangent/ui-primitives/layout";
 import { Paragraph } from "@tangent/ui-primitives/typography";
 import { useState } from "react";
@@ -39,6 +40,8 @@ interface ChatMessageProps {
   onTogglePinArtifact?: (path: string, title: string) => void;
   /** Collapses this message into the hidden state; omitted disables collapse. */
   onCollapse?: () => void;
+  /** Opens a full-screen in-app tab requested by a `tangent-ui:` component. */
+  onOpenTab?: (command: Extract<UICommand, { type: "openTab" }>) => void;
 }
 
 function ChatMessageContent({
@@ -52,6 +55,7 @@ function ChatMessageContent({
   pinnedPaths,
   onTogglePinArtifact,
   onCollapse,
+  onOpenTab,
 }: ChatMessageProps) {
   if (message.memory)
     return (
@@ -121,6 +125,7 @@ function ChatMessageContent({
             sessionId={sessionId}
             messageId={message.id}
             onCollapse={onCollapse}
+            onOpenTab={onOpenTab}
           >
             {message.content}
           </Markdown>
diff --git a/apps/web/src/features/chat/components/message/ChatMessageList.tsx b/apps/web/src/features/chat/components/message/ChatMessageList.tsx
index 022274f..9743d9d 100644
--- a/apps/web/src/features/chat/components/message/ChatMessageList.tsx
+++ b/apps/web/src/features/chat/components/message/ChatMessageList.tsx
@@ -1,4 +1,5 @@
 import type { AgentActivity } from "@tangent/shared/contracts";
+import type { UICommand } from "@tangent/ui-extensions-sdk/types";
 import { Box } from "@tangent/ui-primitives/box";
 import { BlockStack } from "@tangent/ui-primitives/layout";
 import { Paragraph } from "@tangent/ui-primitives/typography";
@@ -31,6 +32,8 @@ interface ChatMessageListProps {
   pinnedPaths?: Set<string>;
   /** Toggles an artifact's pinned state from its chip. */
   onTogglePinArtifact?: (path: string, title: string) => void;
+  /** Opens a full-screen in-app tab requested by a `tangent-ui:` component. */
+  onOpenTab?: (command: Extract<UICommand, { type: "openTab" }>) => void;
   /** Whether a given message id is still receiving streamed deltas. */
   isMessageStreaming: (messageId: string) => boolean;
 }
@@ -54,6 +57,7 @@ interface RowContentProps {
   onOpenArtifact?: (url: string, title: string) => void;
   pinnedPaths?: Set<string>;
   onTogglePinArtifact?: (path: string, title: string) => void;
+  onOpenTab?: (command: Extract<UICommand, { type: "openTab" }>) => void;
   isMessageStreaming: (messageId: string) => boolean;
   onCollapse: (id: string) => void;
   onExpand: (ids: string[]) => void;
@@ -68,6 +72,7 @@ function RowContent({
   onOpenArtifact,
   pinnedPaths,
   onTogglePinArtifact,
+  onOpenTab,
   isMessageStreaming,
   onCollapse,
   onExpand,
@@ -84,6 +89,7 @@ function RowContent({
           onOpenArtifact={onOpenArtifact}
           pinnedPaths={pinnedPaths}
           onTogglePinArtifact={onTogglePinArtifact}
+          onOpenTab={onOpenTab}
           isStreaming={isMessageStreaming(row.message.id)}
           onCollapse={() => onCollapse(row.message.id)}
         />
@@ -110,6 +116,7 @@ export function ChatMessageList({
   onOpenArtifact,
   pinnedPaths,
   onTogglePinArtifact,
+  onOpenTab,
   isMessageStreaming,
 }: ChatMessageListProps) {
   // Collapse state is ephemeral per view (not URL or server). Thinking-only
@@ -214,6 +221,7 @@ export function ChatMessageList({
                       onOpenArtifact={onOpenArtifact}
                       pinnedPaths={pinnedPaths}
                       onTogglePinArtifact={onTogglePinArtifact}
+                      onOpenTab={onOpenTab}
                       isMessageStreaming={isMessageStreaming}
                       onCollapse={collapse}
                       onExpand={expand}
diff --git a/apps/web/src/features/chat/components/tabs/AssetTabContent.tsx b/apps/web/src/features/chat/components/tabs/AssetTabContent.tsx
index 951ec37..1794cd8 100644
--- a/apps/web/src/features/chat/components/tabs/AssetTabContent.tsx
+++ b/apps/web/src/features/chat/components/tabs/AssetTabContent.tsx
@@ -11,6 +11,7 @@ import type { AgentModelSelection } from "@/features/chat/hooks/useSessionChat";
 import type { ChatMessage } from "@/features/chat/model/types";
 
 import { ArtifactTabView } from "./ArtifactTabView";
+import { PipelineEditorTabView } from "./PipelineEditorTabView";
 import { SubagentTabView } from "./SubagentTabView";
 import { TriggerTabPanel } from "./TriggerTabPanel";
 
@@ -118,6 +119,8 @@ export function AssetTabContent({
           onClose={() => closeAsset(tab.id)}
         />
       );
+    case "pipeline-editor":
+      return <PipelineEditorTabView sessionId={sessionId} title={tab.title} />;
     default:
       return (
         <ArtifactTabView
diff --git a/apps/web/src/features/chat/components/tabs/PipelineEditorTabView.tsx b/apps/web/src/features/chat/components/tabs/PipelineEditorTabView.tsx
new file mode 100644
index 0000000..c0cf529
--- /dev/null
+++ b/apps/web/src/features/chat/components/tabs/PipelineEditorTabView.tsx
@@ -0,0 +1,163 @@
+import {
+  connectRemoteEnvironment,
+  type RemoteEnvironmentClient,
+} from "@tangent/remote-subagent";
+import { Box } from "@tangent/ui-primitives/box";
+import { Icon } from "@tangent/ui-primitives/icon";
+import { BlockStack, InlineStack } from "@tangent/ui-primitives/layout";
+import { Text } from "@tangent/ui-primitives/typography";
+import { useEffect, useRef, useState } from "react";
+
+import { env } from "@/shared/config/env";
+import { apiUrl } from "@/shared/lib/basePath";
+import { EmptyState } from "@/shared/ui/patterns/empty-state";
+import { Toolbar } from "@/shared/ui/patterns/toolbar";
+
+import { TangleEmbedClient } from "../../lib/tangleEmbedClient";
+
+interface PipelineEditorTabViewProps {
+  /** Session that owns this editor; binds the CSOM executor to it. */
+  sessionId: string;
+  /** Tab title (unused for now; the editor supplies its own pipeline name). */
+  title: string;
+}
+
+/** Whether the browser tab is connected to the server as the CSOM executor. */
+type RemoteStatus = "disabled" | "connecting" | "connected" | "error";
+
+interface RemoteEnvConfig {
+  enabled: boolean;
+  token?: string;
+}
+
+/** Reads the `/remote-env` token the SPA uses to connect as a CSOM executor. */
+async function fetchRemoteEnvConfig(): Promise<RemoteEnvConfig> {
+  try {
+    const res = await fetch(apiUrl("/api/remote-env/token"));
+    if (!res.ok) return { enabled: false };
+    return (await res.json()) as RemoteEnvConfig;
+  } catch {
+    return { enabled: false };
+  }
+}
+
+/** Builds the embed URL with the origin gate and (optional) backend base. */
+function buildEmbedUrl(base: string): string {
+  const url = new URL("/embed/editor", base);
+  url.searchParams.set("parentOrigin", window.location.origin);
+  if (env.tangleBackendUrl) {
+    url.searchParams.set("backendUrl", env.tangleBackendUrl);
+  }
+  return url.toString();
+}
+
+const STATUS_LABEL: Record<RemoteStatus, string> = {
+  disabled: "Prime control off",
+  connecting: "Connecting Prime...",
+  connected: "Prime can edit live",
+  error: "Prime control unavailable",
+};
+
+const STATUS_TONE: Record<RemoteStatus, "subdued" | "success" | "critical"> = {
+  disabled: "subdued",
+  connecting: "subdued",
+  connected: "success",
+  error: "critical",
+};
+
+/**
+ * Full-screen tab that embeds the Tangle pipeline editor and lets Prime drive
+ * it live. The iframe speaks the CSOM postMessage bridge; this tab also connects
+ * to the server's `/remote-env` gateway as the session's CSOM executor, so each
+ * CSOM tool Prime calls is relayed here and run against the editor.
+ *
+ * The parent is the source of truth for the embed, but here Prime edits the
+ * in-memory spec directly through CSOM, so the graph updates in real time.
+ */
+export function PipelineEditorTabView({
+  sessionId,
+}: PipelineEditorTabViewProps) {
+  const iframeRef = useRef<HTMLIFrameElement>(null);
+  const [remoteStatus, setRemoteStatus] = useState<RemoteStatus>("connecting");
+
+  const embedBase = env.tangleEmbedUrl;
+
+  useEffect(() => {
+    const iframe = iframeRef.current;
+    if (!iframe || !embedBase) return undefined;
+
+    const embedOrigin = new URL(embedBase).origin;
+    const client = new TangleEmbedClient(iframe, embedOrigin);
+    client.init({
+      parentOrigin: window.location.origin,
+      backendUrl: env.tangleBackendUrl || undefined,
+    });
+
+    let remote: RemoteEnvironmentClient | undefined;
+    let cancelled = false;
+
+    void fetchRemoteEnvConfig().then((config) => {
+      if (cancelled) return;
+      if (!config.enabled || !config.token) {
+        setRemoteStatus("disabled");
+        return;
+      }
+      remote = connectRemoteEnvironment({
+        url: window.location.origin,
+        token: config.token,
+        environmentId: `browser-csom:${sessionId}`,
+        sessionId,
+        handlers: {
+          onCsomCall: (request) => client.call(request.method, ...request.args),
+        },
+      });
+      remote.socket.on("connect", () => setRemoteStatus("connected"));
+      remote.socket.on("disconnect", () => setRemoteStatus("connecting"));
+      remote.socket.on("connect_error", () => setRemoteStatus("error"));
+    });
+
+    return () => {
+      cancelled = true;
+      remote?.disconnect();
+      client.dispose();
+    };
+  }, [embedBase, sessionId]);
+
+  if (!embedBase) {
+    return (
+      <Box padding="base">
+        <EmptyState
+          icon="Workflow"
+          title="Pipeline editor not configured"
+          description="Set VITE_TANGLE_EMBED_URL to the Tangle UI host that serves /embed/editor to enable this tab."
+        />
+      </Box>
+    );
+  }
+
+  return (
+    <BlockStack grow>
+      <Toolbar chrome="light" align="end" aria-label="Pipeline editor status">
+        <InlineStack gap="1" blockAlign="center" wrap="nowrap">
+          <Icon
+            name={remoteStatus === "connected" ? "Zap" : "ZapOff"}
+            size="xs"
+            tone={STATUS_TONE[remoteStatus]}
+          />
+          <Text size="xs" tone={STATUS_TONE[remoteStatus]}>
+            {STATUS_LABEL[remoteStatus]}
+          </Text>
+        </InlineStack>
+      </Toolbar>
+      <div className="relative flex min-h-0 w-full flex-1">
+        <iframe
+          ref={iframeRef}
+          src={buildEmbedUrl(embedBase)}
+          title="Tangle pipeline editor"
+          allow="clipboard-read; clipboard-write"
+          className="absolute inset-0 h-full w-full border-0 bg-white"
+        />
+      </div>
+    </BlockStack>
+  );
+}
diff --git a/apps/web/src/features/chat/hooks/useAssetTabs.ts b/apps/web/src/features/chat/hooks/useAssetTabs.ts
index e718bbf..b81fce5 100644
--- a/apps/web/src/features/chat/hooks/useAssetTabs.ts
+++ b/apps/web/src/features/chat/hooks/useAssetTabs.ts
@@ -14,11 +14,18 @@ import type { Asset } from "@/features/chat/model/assets";
 export type AssetTab =
   | { id: string; kind: "page" | "file"; title: string; url: string }
   | { id: string; kind: "trigger"; title: string; triggerId: string }
-  | { id: string; kind: "agent"; title: string; agentId: string };
+  | { id: string; kind: "agent"; title: string; agentId: string }
+  | { id: string; kind: "pipeline-editor"; title: string };
 
 /** The fixed, non-closeable chat tab's value (Prime's main thread). */
 export const CHAT_TAB_VALUE = "chat";
 
+/**
+ * Fixed id for the singleton pipeline-editor tab. One editor tab is shared per
+ * session, so opening it again just focuses the existing tab.
+ */
+export const PIPELINE_EDITOR_TAB_ID = "pipeline-editor";
+
 /** Maps an {@link Asset} to the tab payload SessionChat keeps open for it. */
 function toTab(asset: Asset): AssetTab {
   if (asset.kind === "trigger") {
@@ -66,10 +73,30 @@ export function useAssetTabs() {
     });
   }
 
+  /**
+   * Opens (or focuses) the session's singleton pipeline-editor tab — a
+   * full-screen surface embedding the Tangle editor that Prime drives over CSOM.
+   */
+  function openPipelineEditor(title?: string) {
+    openTab({
+      id: PIPELINE_EDITOR_TAB_ID,
+      kind: "pipeline-editor",
+      title: title?.trim() || "Pipeline Editor",
+    });
+  }
+
   function closeAsset(id: string) {
     setTabs((prev) => prev.filter((tab) => tab.id !== id));
     setActiveTab((prev) => (prev === id ? CHAT_TAB_VALUE : prev));
   }
 
-  return { tabs, activeTab, setActiveTab, openAsset, openAgent, closeAsset };
+  return {
+    tabs,
+    activeTab,
+    setActiveTab,
+    openAsset,
+    openAgent,
+    openPipelineEditor,
+    closeAsset,
+  };
 }
diff --git a/apps/web/src/features/chat/lib/tangleEmbedClient.ts b/apps/web/src/features/chat/lib/tangleEmbedClient.ts
new file mode 100644
index 0000000..cdd55aa
--- /dev/null
+++ b/apps/web/src/features/chat/lib/tangleEmbedClient.ts
@@ -0,0 +1,149 @@
+/**
+ * Promise-based RPC client for the Tangle embedded editor's CSOM postMessage
+ * bridge (see the embed's `csomBridgeProtocol.ts`). The parent (this app) waits
+ * for `tangle-csom:ready`, pushes `init` config, and issues `call`s whose
+ * results resolve on the matching `tangle-csom:result`. `event`s (e.g.
+ * `specChanged`) are surfaced through `onEvent`.
+ *
+ * Messages before `ready` are queued and flushed on ready, except `init`, which
+ * may be sent immediately so the embed has its config as early as possible.
+ */
+
+const CSOM_MESSAGE = {
+  ready: "tangle-csom:ready",
+  init: "tangle-csom:init",
+  call: "tangle-csom:call",
+  result: "tangle-csom:result",
+  event: "tangle-csom:event",
+} as const;
+
+/** Config pushed to the embed's `init` handshake. */
+export interface TangleEmbedInit {
+  parentOrigin?: string;
+  backendUrl?: string;
+  authToken?: string;
+  spec?: string;
+  pipeline?: { name: string; fileId?: string };
+}
+
+type Pending = {
+  resolve: (value: unknown) => void;
+  reject: (error: Error) => void;
+};
+
+interface CsomResultMessage {
+  type: typeof CSOM_MESSAGE.result;
+  id: string;
+  ok: boolean;
+  value?: unknown;
+  error?: string;
+}
+
+interface CsomEventMessage {
+  type: typeof CSOM_MESSAGE.event;
+  event: string;
+  payload?: unknown;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+export class TangleEmbedClient {
+  private readonly pending = new Map<string, Pending>();
+  private readonly queue: object[] = [];
+  private ready = false;
+  private disposed = false;
+
+  private readonly iframe: HTMLIFrameElement;
+  /** Origin of the Tangle UI host; gates inbound messages and targets posts. */
+  private readonly embedOrigin: string;
+  private readonly onEvent?: (event: string, payload: unknown) => void;
+
+  constructor(
+    iframe: HTMLIFrameElement,
+    embedOrigin: string,
+    onEvent?: (event: string, payload: unknown) => void,
+  ) {
+    this.iframe = iframe;
+    this.embedOrigin = embedOrigin;
+    this.onEvent = onEvent;
+    window.addEventListener("message", this.handleMessage);
+  }
+
+  /** Supplies/refreshes embed config. Safe to call before `ready`. */
+  init(config: TangleEmbedInit): void {
+    this.post({ type: CSOM_MESSAGE.init, config }, true);
+  }
+
+  /** Invokes a CSOM method by name with positional args; resolves its result. */
+  call<T = unknown>(method: string, ...args: unknown[]): Promise<T> {
+    const id = crypto.randomUUID();
+    return new Promise<T>((resolve, reject) => {
+      this.pending.set(id, {
+        resolve: resolve as (value: unknown) => void,
+        reject,
+      });
+      this.post({ type: CSOM_MESSAGE.call, id, method, args });
+    });
+  }
+
+  /** Tears down listeners and rejects any in-flight calls. */
+  dispose(): void {
+    this.disposed = true;
+    window.removeEventListener("message", this.handleMessage);
+    for (const pending of this.pending.values()) {
+      pending.reject(new Error("Pipeline editor closed"));
+    }
+    this.pending.clear();
+  }
+
+  private handleMessage = (event: MessageEvent): void => {
+    if (this.disposed || event.origin !== this.embedOrigin) return;
+    const msg = event.data;
+    if (!isRecord(msg) || typeof msg.type !== "string") return;
+
+    if (msg.type === CSOM_MESSAGE.ready) {
+      this.flushQueue();
+      return;
+    }
+    if (msg.type === CSOM_MESSAGE.result) {
+      this.resolveResult(msg as unknown as CsomResultMessage);
+      return;
+    }
+    if (msg.type === CSOM_MESSAGE.event) {
+      const evt = msg as unknown as CsomEventMessage;
+      this.onEvent?.(evt.event, evt.payload);
+    }
+  };
+
+  private flushQueue(): void {
+    this.ready = true;
+    const buffered = this.queue.splice(0, this.queue.length);
+    for (const message of buffered) this.postNow(message);
+  }
+
+  private resolveResult(msg: CsomResultMessage): void {
+    const pending = this.pending.get(msg.id);
+    if (!pending) return;
+    this.pending.delete(msg.id);
+    if (msg.ok) {
+      pending.resolve(msg.value);
+      return;
+    }
+    pending.reject(new Error(msg.error ?? "CSOM call failed"));
+  }
+
+  /** Posts a message, buffering until `ready` unless `immediate` is set. */
+  private post(message: object, immediate = false): void {
+    if (!this.ready && !immediate) {
+      this.queue.push(message);
+      return;
+    }
+    this.postNow(message);
+  }
+
+  private postNow(message: object): void {
+    this.iframe.contentWindow?.postMessage(message, this.embedOrigin);
+  }
+}
diff --git a/apps/web/src/features/chat/model/assets.ts b/apps/web/src/features/chat/model/assets.ts
index 0490b51..b6ada94 100644
--- a/apps/web/src/features/chat/model/assets.ts
+++ b/apps/web/src/features/chat/model/assets.ts
@@ -43,8 +43,12 @@ export type Asset =
       trigger: Trigger;
     };
 
-/** Discriminant union of every asset kind, including reserved future kinds. */
-export type AssetKind = Asset["kind"] | "app";
+/**
+ * Discriminant union of every tab-icon kind. Beyond the sidebar {@link Asset}
+ * kinds it includes the reserved `app` kind and `pipeline-editor` (a
+ * non-sidebar, full-screen tab opened via `execUICommand`).
+ */
+export type AssetKind = Asset["kind"] | "app" | "pipeline-editor";
 
 /** Leading icon per asset kind. `app` is reserved for a future asset type. */
 export const ASSET_ICON: Record<AssetKind, IconName> = {
@@ -52,6 +56,7 @@ export const ASSET_ICON: Record<AssetKind, IconName> = {
   file: "Paperclip",
   trigger: "Zap",
   app: "AppWindow",
+  "pipeline-editor": "Workflow",
 };
 
 /** Short, human-readable subtitle describing a trigger's signal source. */
diff --git a/apps/web/src/shared/config/env.ts b/apps/web/src/shared/config/env.ts
index be93c13..754141d 100644
--- a/apps/web/src/shared/config/env.ts
+++ b/apps/web/src/shared/config/env.ts
@@ -4,4 +4,16 @@ export const env = {
   isProd: import.meta.env.PROD,
   defaultSessionBundleId:
     import.meta.env.VITE_DEFAULT_SESSION_BUNDLE_ID ?? "tangle-oss",
+  /**
+   * Origin of the Tangle UI host serving the embeddable pipeline editor
+   * (`<origin>/embed/editor`). Empty until configured; the Pipeline Editor tab
+   * shows a setup hint when unset.
+   */
+  tangleEmbedUrl: import.meta.env.VITE_TANGLE_EMBED_URL ?? "",
+  /**
+   * Optional Tangle backend base URL passed to the embed's `init` handshake
+   * (`backendUrl`). When empty the editor still boots for in-memory CSOM
+   * editing; backend-backed actions (component search, submit) need it set.
+   */
+  tangleBackendUrl: import.meta.env.VITE_TANGLE_BACKEND_URL ?? "",
 } as const;
diff --git a/apps/web/src/shared/lib/markdown/Markdown.tsx b/apps/web/src/shared/lib/markdown/Markdown.tsx
index 275670c..286bb8e 100644
--- a/apps/web/src/shared/lib/markdown/Markdown.tsx
+++ b/apps/web/src/shared/lib/markdown/Markdown.tsx
@@ -1,6 +1,7 @@
 // local primitive — renders agent markdown output, styling the raw markdown
 // HTML elements (h1/ul/a/img/code/table/...). These are not Tangle UI
 // primitives, so the scoped classNames here are an allowed escape hatch.
+import type { UICommand } from "@tangent/ui-extensions-sdk/types";
 import { Icon } from "@tangent/ui-primitives/icon";
 import { InlineStack } from "@tangent/ui-primitives/layout";
 import { Link } from "@tangent/ui-primitives/link";
@@ -36,6 +37,9 @@ import { CodeBlock } from "./CodeBlock";
  */
 const BUNDLE_UI_LANGUAGE = /language-tangent-ui:([a-z0-9][a-z0-9-]*)/;
 
+/** The `openTab` UI command a bundle message component can request. */
+type OpenTabCommand = Extract<UICommand, { type: "openTab" }>;
+
 /** Body-text size for flowing markdown content (paragraphs, list items, links). */
 type MarkdownSize = "xs" | "sm" | "md";
 
@@ -112,6 +116,11 @@ interface MarkdownProps {
    * components so they can request collapse via `host.execUICommand`.
    */
   onCollapse?: () => void;
+  /**
+   * Opens a full-screen in-app tab requested by a bundle message component via
+   * `host.execUICommand({ type: "openTab" })`. Omitted disables the command.
+   */
+  onOpenTab?: (command: OpenTabCommand) => void;
 }
 
 /**
@@ -131,6 +140,7 @@ interface MarkdownComponentsOptions {
   sessionId?: string;
   messageId?: string;
   onCollapse?: () => void;
+  onOpenTab?: (command: OpenTabCommand) => void;
 }
 
 /**
@@ -344,6 +354,7 @@ interface BundleUiMessageProps {
   sessionId?: string;
   messageId?: string;
   onCollapse?: () => void;
+  onOpenTab?: (command: OpenTabCommand) => void;
 }
 
 function BundleUiMessage({
@@ -355,6 +366,7 @@ function BundleUiMessage({
   sessionId,
   messageId,
   onCollapse,
+  onOpenTab,
 }: BundleUiMessageProps) {
   let props: Record<string, unknown> | undefined;
   try {
@@ -389,6 +401,7 @@ function BundleUiMessage({
       onSendPrompt={onSendPrompt}
       stateNamespace={stateNamespace}
       onCollapse={onCollapse}
+      onOpenTab={onOpenTab}
     />
   );
 }
@@ -540,8 +553,14 @@ function MdImage({ src, alt, title }: ImageProps) {
 }
 
 function MdCode({ className, children, node }: CodeProps) {
-  const { bundleId, onSendPrompt, sessionId, messageId, onCollapse } =
-    useMarkdownOptions();
+  const {
+    bundleId,
+    onSendPrompt,
+    sessionId,
+    messageId,
+    onCollapse,
+    onOpenTab,
+  } = useMarkdownOptions();
 
   // Bundle-UI message token: render the bundle's sandboxed component when we
   // know which bundle to load it from; otherwise treat it as code.
@@ -563,6 +582,7 @@ function MdCode({ className, children, node }: CodeProps) {
         sessionId={sessionId}
         messageId={messageId}
         onCollapse={onCollapse}
+        onOpenTab={onOpenTab}
       />
     );
   }
@@ -645,6 +665,7 @@ export function Markdown({
   sessionId,
   messageId,
   onCollapse,
+  onOpenTab,
 }: MarkdownProps) {
   const options: MarkdownComponentsOptions = {
     artifactBaseUrl,
@@ -658,6 +679,7 @@ export function Markdown({
     sessionId,
     messageId,
     onCollapse,
+    onOpenTab,
   };
 
   return (
diff --git a/apps/web/vite.config.ts b/apps/web/vite.config.ts
index bed7700..df5e7a5 100644
--- a/apps/web/vite.config.ts
+++ b/apps/web/vite.config.ts
@@ -12,6 +12,10 @@ const apiTarget = process.env.API_TARGET ?? "http://localhost:8787";
 
 // https://vite.dev/config/
 export default defineConfig({
+  // Load env from the monorepo root so a single top-level `.env` (also read by
+  // the server via loadEnv.ts) feeds the client's `VITE_*` vars — otherwise Vite
+  // would only look in `apps/web`.
+  envDir: path.resolve(__dirname, "../.."),
   // Relative asset base so the built index.html references assets as
   // "./assets/..." rather than "/assets/...". Behind the tangle pod-proxy the
   // Kubernetes apiserver rewrites same-host absolute-path URLs in HTML to its
diff --git a/docs/server/agent-communication.md b/docs/server/agent-communication.md
index 3f2c0a0..4ac6878 100644
--- a/docs/server/agent-communication.md
+++ b/docs/server/agent-communication.md
@@ -8,12 +8,12 @@ Agent communication in this system is deliberately **server-mediated**. Agents
 never talk to each other directly. There are exactly three transports, each with
 a distinct job:
 
-| Layer                                                               | Direction                                | Who uses it                                                     |
-| ------------------------------------------------------------------- | ---------------------------------------- | --------------------------------------------------------------- |
-| **Pi-RPC** (JSONL over stdin/stdout)                                | server ↔ a single Pi child process       | `PiAgentManager` ↔ each `pi --mode rpc` subprocess              |
-| **Internal HTTP API** (`/internal/*` + bearer token)               | Pi child → server                        | extension tools (orchestrator, memory, triggers, session)       |
-| **WebSockets** (Socket.IO rooms)                                    | server → browser                         | the UI                                                          |
-| **Remote sub-agent transport** (Socket.IO `/remote-env` namespace)  | server ↔ a connected remote environment  | `RemoteEnvironmentGateway` ↔ the `@tangent/remote-subagent` SDK |
+| Layer                                                              | Direction                               | Who uses it                                                     |
+| ------------------------------------------------------------------ | --------------------------------------- | --------------------------------------------------------------- |
+| **Pi-RPC** (JSONL over stdin/stdout)                               | server ↔ a single Pi child process      | `PiAgentManager` ↔ each `pi --mode rpc` subprocess              |
+| **Internal HTTP API** (`/internal/*` + bearer token)               | Pi child → server                       | extension tools (orchestrator, memory, triggers, session)       |
+| **WebSockets** (Socket.IO rooms)                                   | server → browser                        | the UI                                                          |
+| **Remote sub-agent transport** (Socket.IO `/remote-env` namespace) | server ↔ a connected remote environment | `RemoteEnvironmentGateway` ↔ the `@tangent/remote-subagent` SDK |
 
 The `PiAgentManager` (`apps/server/src/pi/piAgentManager.ts`) is the single hub.
 Every "A talks to B" path actually goes A → server → B.
@@ -292,3 +292,31 @@ The wire shapes live in `@tangent/shared/remoteSubagent.ts`, shared by both
 sides so the protocol cannot drift. Remote sub-agents are **not** revived after
 a server restart (`reviveSubagents` skips `host: "remote"` rows); they
 re-establish when their environment reconnects.
+
+## 6. Remote CSOM (Prime drives the pipeline editor live)
+
+The `/remote-env` transport carries one more command besides spawn/message/kill:
+`remote:csom:call`. It lets Prime build a Tangle pipeline in real time inside the
+embedded editor, without hosting an agent runtime in the environment.
+
+- **The environment is the browser tab.** When the user opens the Pipeline
+  Editor tab (`PipelineEditorTabView`, triggered by the `openTab` UI command),
+  it embeds `/embed/editor` in an iframe (driven over the CSOM `postMessage`
+  bridge) and connects to `/remote-env` as a CSOM executor, passing its
+  `sessionId` in the handshake. The gateway records a `sessionId → environmentId`
+  binding (`csomBindings`).
+- **Prime's tools relay through the server.** Prime gets `csom_*` tools
+  (`examples/tangle-oss/tools/csom.ts`) that `POST /internal/csom/invoke`
+  `{ sessionId, method, args }`. `createInternalCsomRouter` calls
+  `RemoteEnvironmentGateway.invokeCsom`, which emits `remote:csom:call` to the
+  bound socket **with a Socket.IO ack** and resolves with the response.
+- **The browser runs the call.** `@tangent/remote-subagent`'s optional
+  `onCsomCall` handler forwards `method`/`args` to the embed's `TangleEmbedClient`
+  and returns the value; the connector answers the ack. When no editor is bound
+  (tab closed), `invokeCsom` returns `{ ok: false, error }` so the tool tells
+  Prime to ask the user to open the editor.
+
+So the flow is: Prime tool call (Pi-RPC out) → internal HTTP → gateway →
+`remote:csom:call` (ack) → browser → `tangle-csom:call` (postMessage) → editor,
+and the result travels back the same way. The graph updates live in the iframe
+as Prime works.
diff --git a/examples/tangle-oss/prompts/prime.md b/examples/tangle-oss/prompts/prime.md
index 617fc0a..2412b82 100644
--- a/examples/tangle-oss/prompts/prime.md
+++ b/examples/tangle-oss/prompts/prime.md
@@ -48,9 +48,10 @@ Handle a request directly — without a worker — only in these cases:
 - A single trivial read-only lookup where the spawn overhead isn't worth it
   (e.g. one `tangle_run_status` / "what's the status of X" / "my runs"). Anything
   multi-step, or any write/action (submit, cancel, annotate), goes to a worker.
-- Work only you can do: emitting UI cards (`tangent-ui:pipeline-progress`),
-  talking to the human, managing triggers / memory / session naming, and
-  relaying between workers.
+- Work only you can do: emitting UI cards (`tangent-ui:pipeline-progress`,
+  `tangent-ui:pipeline-editor`), driving the live pipeline editor via the
+  `csom_*` tools (see "Building a pipeline live"), talking to the human, managing
+  triggers / memory / session naming, and relaying between workers.
 
 ## Tracking worker activity
 
@@ -211,6 +212,48 @@ emit a live progress chip so the user sees status without re-asking:
 - The info string MUST be `tangent-ui:pipeline-progress` — a bare
   `pipeline-progress` block will not render.
 
+## Building a pipeline live (the Pipeline Editor + CSOM)
+
+You can build a Tangle pipeline **with the user in real time** inside an embedded
+editor. There is no sidebar button for it — you open it by surfacing a launcher
+card, and the user clicks it.
+
+When the user wants to build, assemble, sketch, or edit a pipeline visually (e.g.
+"open the editor", "let's build a pipeline together", "add these tasks to a
+graph"), do this:
+
+1. **Surface the launcher.** Emit the card once so the user can open the tab:
+
+````
+```tangent-ui:pipeline-editor
+{ "title": "Example pipeline" }
+```
+````
+
+   The info string MUST be `tangent-ui:pipeline-editor` (a bare
+   `pipeline-editor` block will not render). `title` is optional. Tell the user
+   to press **Open Pipeline Editor** on the card; that opens a full-screen tab
+   that connects back to you over CSOM.
+
+2. **Wait until it's connected.** The `csom_*` tools only work once the editor
+   tab is open and bound to this session. Until then they return a "no pipeline
+   editor is connected" message — if you see that, re-surface the launcher and
+   ask the user to open it, then continue.
+
+3. **Load a spec first, then edit.** CSOM mutations require a loaded pipeline.
+   Call `csom_load_spec` first (pass a minimal/blank spec to start fresh, or an
+   existing one to edit), then build with `csom_search_components` →
+   `csom_add_task`, `csom_add_input` / `csom_add_output`, `csom_connect_nodes`,
+   `csom_set_task_argument`, and inspect with `csom_get_pipeline_state` /
+   `csom_get_spec_yaml`. Reference entities by the `$id`s those calls return.
+   Finish with `csom_validate_pipeline`, and `csom_submit_run` only when the user
+   asks to run it.
+
+Unlike the heavy ML work, driving the editor is **your** job (it's a UI + tool
+loop, not a delegable assignment) — don't spawn a worker for it. Keep prose
+light: the graph updates live in the editor, so narrate decisions, not every
+node you add.
+
 ## Tracking a run ("track", "watch", "notify me when…")
 
 When the user asks you to **track**, **watch**, **keep an eye on**, or **notify
diff --git a/examples/tangle-oss/tangent.yaml b/examples/tangle-oss/tangent.yaml
index d93ec3b..bf04c73 100644
--- a/examples/tangle-oss/tangent.yaml
+++ b/examples/tangle-oss/tangent.yaml
@@ -1,7 +1,7 @@
 schemaVersion: 1
 id: tangle-oss
 name: Tangle OSS
-version: 1.0.0
+version: 1.2.0
 description: An open-source Tangle-aware assistant with Tangle API tools and scoped worker agents for everyday work with Tangle ML pipelines and runs, driven by the open-source Tangle CLI.
 author: Tangent
 icon: icon.svg
@@ -35,6 +35,24 @@ prime:
     - enable_trigger
     - disable_trigger
     - delete_trigger
+    # CSOM pipeline-editor tools (tools/csom.ts). Drive the embedded Tangle
+    # editor live; require the user to have the Pipeline Editor tab open.
+    - csom_load_spec
+    - csom_get_pipeline_state
+    - csom_get_spec_yaml
+    - csom_set_pipeline_name
+    - csom_set_pipeline_description
+    - csom_search_components
+    - csom_add_task
+    - csom_delete_task
+    - csom_rename_task
+    - csom_add_input
+    - csom_add_output
+    - csom_connect_nodes
+    - csom_delete_edge
+    - csom_set_task_argument
+    - csom_validate_pipeline
+    - csom_submit_run
 
 subagents:
   defaultSystemPrompt: prompts/subagent.md
@@ -84,3 +102,8 @@ ui:
     - name: pipeline-progress
       kind: message
       entry: ui/pipeline-progress.tsx
+    # Launcher card: opens the full-screen Pipeline Editor tab (embedded Tangle
+    # editor) via the `openTab` UI command, so Prime can build a pipeline live.
+    - name: pipeline-editor
+      kind: message
+      entry: ui/pipeline-editor.tsx
diff --git a/examples/tangle-oss/tools/csom.ts b/examples/tangle-oss/tools/csom.ts
new file mode 100644
index 0000000..ca2e468
--- /dev/null
+++ b/examples/tangle-oss/tools/csom.ts
@@ -0,0 +1,296 @@
+// @ts-nocheck
+/**
+ * CSOM pipeline-editor tool extension, loaded into every session Pi process via
+ * `--extension` (auto-discovered from this bundle's `tools/` dir).
+ *
+ * These tools let Prime build a Tangle pipeline *live* in the embedded editor.
+ * Each tool is a thin client over the server's internal CSOM relay
+ * (`POST /internal/csom/invoke`): the server forwards the call to the browser
+ * tab hosting the Pipeline Editor (the session's connected remote environment),
+ * which runs it against the editor and returns the result. The agent never
+ * touches the editor directly.
+ *
+ * The editor tab must be open (Prime can surface the `pipeline-editor` UI
+ * component to prompt the user). Until it is, calls return a "no editor
+ * connected" message.
+ *
+ * Authored against Pi's extension runtime (it imports modules Pi resolves when
+ * loading extensions, e.g. `typebox`), not this repo's `node_modules`. It is
+ * excluded from type-check (`@ts-nocheck`) and never imported by the server.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+
+const INTERNAL_URL = process.env.TANGENT_INTERNAL_URL ?? "";
+const INTERNAL_TOKEN = process.env.TANGENT_INTERNAL_TOKEN ?? "";
+const SESSION_ID = process.env.TANGENT_SESSION_ID ?? "";
+
+interface CsomResponse {
+  ok: boolean;
+  value?: unknown;
+  error?: string;
+}
+
+/** Relays one CSOM method call to the session's editor and returns its result. */
+async function invoke(method: string, args: unknown[]): Promise<CsomResponse> {
+  const response = await fetch(`${INTERNAL_URL}/internal/csom/invoke`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${INTERNAL_TOKEN}`,
+    },
+    body: JSON.stringify({ sessionId: SESSION_ID, method, args }),
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`csom ${method} failed (${response.status}): ${text}`);
+  }
+  return response.json() as Promise<CsomResponse>;
+}
+
+function textResult(text: string) {
+  return { content: [{ type: "text", text }], details: {} };
+}
+
+/** Runs a CSOM method and renders its outcome as readable text for the agent. */
+async function run(method: string, args: unknown[]) {
+  const res = await invoke(method, args);
+  if (!res.ok) return textResult(res.error ?? `csom ${method} failed`);
+  const value =
+    res.value === undefined ? "ok" : JSON.stringify(res.value, null, 2);
+  return textResult(value);
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "csom_load_spec",
+    label: "Pipeline: Load Spec",
+    description:
+      "Load a pipeline spec (YAML or JSON) into the editor in memory. Call this " +
+      "first — mutating tools require a loaded pipeline. Pass an empty/minimal " +
+      "spec to start a new pipeline from scratch.",
+    promptSnippet: "Load a pipeline spec into the editor",
+    parameters: Type.Object({
+      spec: Type.String({ description: "Pipeline YAML or JSON to load." }),
+      name: Type.Optional(Type.String({ description: "Optional name." })),
+    }),
+    execute: (_id, p) =>
+      run("loadSpec", p.name === undefined ? [p.spec] : [p.spec, p.name]),
+  });
+
+  pi.registerTool({
+    name: "csom_get_pipeline_state",
+    label: "Pipeline: Get State",
+    description:
+      "Return the current pipeline graph (tasks, inputs, outputs, edges) with " +
+      "their internal `$id`s. Use it to discover ids for mutating calls.",
+    promptSnippet: "Read the current pipeline graph state",
+    parameters: Type.Object({}),
+    execute: () => run("getPipelineState", []),
+  });
+
+  pi.registerTool({
+    name: "csom_get_spec_yaml",
+    label: "Pipeline: Get YAML",
+    description: "Serialize the current pipeline spec to YAML.",
+    promptSnippet: "Get the current pipeline as YAML",
+    parameters: Type.Object({}),
+    execute: () => run("getSpecYaml", []),
+  });
+
+  pi.registerTool({
+    name: "csom_set_pipeline_name",
+    label: "Pipeline: Set Name",
+    description: "Set the pipeline's display name.",
+    promptSnippet: "Set the pipeline name",
+    parameters: Type.Object({
+      name: Type.String({ description: "New pipeline name." }),
+    }),
+    execute: (_id, p) => run("setPipelineName", [p.name]),
+  });
+
+  pi.registerTool({
+    name: "csom_set_pipeline_description",
+    label: "Pipeline: Set Description",
+    description: "Set the pipeline's description.",
+    promptSnippet: "Set the pipeline description",
+    parameters: Type.Object({
+      description: Type.String({ description: "New description." }),
+    }),
+    execute: (_id, p) => run("setPipelineDescription", [p.description]),
+  });
+
+  pi.registerTool({
+    name: "csom_search_components",
+    label: "Pipeline: Search Components",
+    description:
+      "Search the Tangle component library. Returns matches with the " +
+      "`componentRef` you pass to `csom_add_task`.",
+    promptSnippet: "Search Tangle components to add as tasks",
+    parameters: Type.Object({
+      query: Type.String({ description: "Search text." }),
+      limit: Type.Optional(Type.Number({ description: "Max results." })),
+    }),
+    execute: (_id, p) =>
+      run("searchComponents", [
+        p.limit === undefined
+          ? { query: p.query }
+          : { query: p.query, limit: p.limit },
+      ]),
+  });
+
+  pi.registerTool({
+    name: "csom_add_task",
+    label: "Pipeline: Add Task",
+    description:
+      "Add a task (a component instance) to the pipeline. `componentRef` comes " +
+      "from `csom_search_components` (e.g. `{ url: 'https://.../train.yaml' }`). " +
+      "Returns the new task's `taskId`.",
+    promptSnippet: "Add a task to the pipeline",
+    parameters: Type.Object({
+      name: Type.String({ description: "Task name (unique in the pipeline)." }),
+      componentRef: Type.Unknown({
+        description: "ComponentReference for the task's component.",
+      }),
+    }),
+    execute: (_id, p) =>
+      run("addTask", [{ name: p.name, componentRef: p.componentRef }]),
+  });
+
+  pi.registerTool({
+    name: "csom_delete_task",
+    label: "Pipeline: Delete Task",
+    description: "Delete a task by its entity `$id`.",
+    promptSnippet: "Delete a task from the pipeline",
+    parameters: Type.Object({
+      entityId: Type.String({ description: "Task entity id." }),
+    }),
+    execute: (_id, p) => run("deleteTask", [p.entityId]),
+  });
+
+  pi.registerTool({
+    name: "csom_rename_task",
+    label: "Pipeline: Rename Task",
+    description: "Rename a task by its entity `$id`.",
+    promptSnippet: "Rename a task in the pipeline",
+    parameters: Type.Object({
+      entityId: Type.String({ description: "Task entity id." }),
+      newName: Type.String({ description: "New task name." }),
+    }),
+    execute: (_id, p) => run("renameTask", [p.entityId, p.newName]),
+  });
+
+  pi.registerTool({
+    name: "csom_add_input",
+    label: "Pipeline: Add Input",
+    description: "Add a pipeline-level input. Returns the new `inputId`.",
+    promptSnippet: "Add a pipeline input",
+    parameters: Type.Object({
+      name: Type.String({ description: "Input name." }),
+      type: Type.Optional(Type.String({ description: "Type annotation." })),
+      description: Type.Optional(Type.String()),
+      defaultValue: Type.Optional(Type.Unknown()),
+      optional: Type.Optional(Type.Boolean()),
+    }),
+    execute: (_id, p) =>
+      run("addInput", [
+        {
+          name: p.name,
+          type: p.type,
+          description: p.description,
+          defaultValue: p.defaultValue,
+          optional: p.optional,
+        },
+      ]),
+  });
+
+  pi.registerTool({
+    name: "csom_add_output",
+    label: "Pipeline: Add Output",
+    description: "Add a pipeline-level output. Returns the new `outputId`.",
+    promptSnippet: "Add a pipeline output",
+    parameters: Type.Object({
+      name: Type.String({ description: "Output name." }),
+      type: Type.Optional(Type.String({ description: "Type annotation." })),
+      description: Type.Optional(Type.String()),
+    }),
+    execute: (_id, p) =>
+      run("addOutput", [
+        { name: p.name, type: p.type, description: p.description },
+      ]),
+  });
+
+  pi.registerTool({
+    name: "csom_connect_nodes",
+    label: "Pipeline: Connect Nodes",
+    description:
+      "Create an edge between two ports. Reference entities by their `$id` " +
+      "(from `csom_get_pipeline_state` or a prior add call).",
+    promptSnippet: "Connect two pipeline ports with an edge",
+    parameters: Type.Object({
+      sourceEntityId: Type.String(),
+      sourcePortName: Type.String(),
+      targetEntityId: Type.String(),
+      targetPortName: Type.String(),
+    }),
+    execute: (_id, p) =>
+      run("connectNodes", [
+        {
+          sourceEntityId: p.sourceEntityId,
+          sourcePortName: p.sourcePortName,
+          targetEntityId: p.targetEntityId,
+          targetPortName: p.targetPortName,
+        },
+      ]),
+  });
+
+  pi.registerTool({
+    name: "csom_delete_edge",
+    label: "Pipeline: Delete Edge",
+    description: "Delete an edge (binding) by its entity `$id`.",
+    promptSnippet: "Delete an edge from the pipeline",
+    parameters: Type.Object({
+      entityId: Type.String({ description: "Edge/binding entity id." }),
+    }),
+    execute: (_id, p) => run("deleteEdge", [p.entityId]),
+  });
+
+  pi.registerTool({
+    name: "csom_set_task_argument",
+    label: "Pipeline: Set Task Argument",
+    description:
+      "Set a constant argument on a task's input. Reference the task by its " +
+      "entity `$id`.",
+    promptSnippet: "Set a task's input argument",
+    parameters: Type.Object({
+      taskEntityId: Type.String({ description: "Task entity id." }),
+      inputName: Type.String({ description: "Input name on the task." }),
+      value: Type.Unknown({ description: "Argument value." }),
+    }),
+    execute: (_id, p) =>
+      run("setTaskArgument", [p.taskEntityId, p.inputName, p.value]),
+  });
+
+  pi.registerTool({
+    name: "csom_validate_pipeline",
+    label: "Pipeline: Validate",
+    description:
+      "Validate the current pipeline, returning any issues found (missing " +
+      "connections, type mismatches, etc.).",
+    promptSnippet: "Validate the current pipeline",
+    parameters: Type.Object({}),
+    execute: () => run("validatePipeline", []),
+  });
+
+  pi.registerTool({
+    name: "csom_submit_run",
+    label: "Pipeline: Submit Run",
+    description:
+      "Submit the current pipeline for a run. Returns the `runId` and root " +
+      "execution id. Validate first.",
+    promptSnippet: "Submit the current pipeline for a run",
+    parameters: Type.Object({}),
+    execute: () => run("submitPipelineRun", []),
+  });
+}
diff --git a/examples/tangle-oss/ui/pipeline-editor.tsx b/examples/tangle-oss/ui/pipeline-editor.tsx
new file mode 100644
index 0000000..63a30f5
--- /dev/null
+++ b/examples/tangle-oss/ui/pipeline-editor.tsx
@@ -0,0 +1,64 @@
+/**
+ * Message component: a launcher card for the embedded Tangle pipeline editor.
+ *
+ * The agent emits a `tangent-ui:pipeline-editor` block (optionally carrying a
+ * `{ "title": "..." }`); pressing the button asks the host to open a full-screen
+ * in-app Pipeline Editor tab via the `openTab` UI command. That tab embeds the
+ * Tangle editor and connects back as this session's CSOM executor, so Prime's
+ * `csom_*` tools can build the pipeline live.
+ *
+ * The sandbox itself cannot render an iframe or open a socket, so this component
+ * is purely the entry point — all the real work happens in the host tab.
+ */
+import {
+  BlockStack,
+  Button,
+  Card,
+  CardContent,
+  CardHeader,
+  host,
+  Icon,
+  InlineStack,
+  Text,
+} from "@tangent/ui-extensions-sdk";
+import { useEffect, useState } from "react";
+
+export default function PipelineEditor() {
+  const [title, setTitle] = useState<string | null>(null);
+
+  useEffect(() => {
+    host.getProps().then((props) => {
+      if (props && typeof props.title === "string") setTitle(props.title);
+    });
+  }, []);
+
+  const open = async () => {
+    await host.execUICommand({
+      type: "openTab",
+      tab: "pipeline-editor",
+      title: title ?? undefined,
+    });
+  };
+
+  return (
+    <Card density="compact">
+      <CardHeader>
+        <InlineStack gap="1" blockAlign="center" align="start">
+          <Icon name="Workflow" />
+          <Text size="sm">{title ?? "Pipeline Editor"}</Text>
+        </InlineStack>
+      </CardHeader>
+      <CardContent>
+        <BlockStack gap="2">
+          <Text size="xs" tone="subdued">
+            Open the editor to build this pipeline together in real time.
+          </Text>
+          <Button variant="secondary" size="sm" onPress={open}>
+            <Icon name="SquareArrowOutUpRight" size="xs" />
+            Open Pipeline Editor
+          </Button>
+        </BlockStack>
+      </CardContent>
+    </Card>
+  );
+}
diff --git a/packages/remote-subagent/README.md b/packages/remote-subagent/README.md
index 7fb1d85..c991116 100644
--- a/packages/remote-subagent/README.md
+++ b/packages/remote-subagent/README.md
@@ -13,6 +13,13 @@ This package is **only the connector**. It contains no agent runtime — you
 plug your own agent implementation (built on whatever agent SDK you like) into
 the handlers. Unimplemented handlers throw, so the integration gap is explicit.
 
+An environment can also act as a **CSOM executor** rather than (or in addition
+to) hosting sub-agents: implement the optional `onCsomCall` handler and pass a
+`sessionId` when connecting. The server then routes that session's
+`remote:csom:call` invocations to this connection and awaits the result — this
+is how the browser Pipeline Editor tab lets Prime drive the embedded Tangle
+editor live. Its host binding is the connection's `sessionId`.
+
 ## Install
 
 ```bash
@@ -59,6 +66,11 @@ const client = connectRemoteEnvironment({
         command.completed ? "completed" : "killed",
       );
     },
+    async onCsomCall(request) {
+      // Optional: run a CSOM editing method against an embedded pipeline editor
+      // this environment hosts and return the result. Throw to reject.
+      return editor.call(request.method, ...request.args);
+    },
   },
 });
 
@@ -76,6 +88,13 @@ const messages = await client.readRoom(sessionId, 30);
 - `client.readRoom(sessionId, limit?)` — read the tail of the shared transcript.
 - `client.disconnect()` — close the connection.
 
+## Inbound handlers
+
+- `onSpawn` / `onMessage` / `onKill` — sub-agent orchestration (required if the
+  corresponding command can arrive; unimplemented handlers throw).
+- `onCsomCall(request)` — optional; run `request.method` with `request.args`
+  against an embedded editor and return the value. Errors become an error ack.
+
 ## Protocol
 
 The wire shapes live in `@tangent/shared/remoteSubagent.ts` and are shared with
diff --git a/packages/remote-subagent/src/index.ts b/packages/remote-subagent/src/index.ts
index fd5a1dc..f6a27c5 100644
--- a/packages/remote-subagent/src/index.ts
+++ b/packages/remote-subagent/src/index.ts
@@ -18,6 +18,8 @@ import {
   type RemoteAgentEvent,
   type RemoteAgentEventPayload,
   type RemoteAgentMessagePayload,
+  type RemoteCsomCallRequest,
+  type RemoteCsomCallResponse,
   RemoteEnvEvents,
   type RemoteEnvHandshake,
   type RemoteKillCommand,
@@ -44,6 +46,13 @@ export interface RemoteEnvironmentHandlers {
   onMessage(command: RemoteMessageCommand): void | Promise<void>;
   /** Terminate a sub-agent. */
   onKill(command: RemoteKillCommand): void | Promise<void>;
+  /**
+   * Execute a CSOM editing method against the environment's embedded pipeline
+   * editor and return its result. Optional: environments that don't host an
+   * editor can omit it (incoming CSOM calls are then rejected). Return the
+   * method's raw value; the connector wraps thrown errors into an error ack.
+   */
+  onCsomCall?(request: RemoteCsomCallRequest): unknown | Promise<unknown>;
 }
 
 /** Options for {@link connectRemoteEnvironment}. */
@@ -54,6 +63,11 @@ export interface ConnectRemoteEnvironmentOptions {
   token: string;
   /** Stable id identifying this environment when several are connected. */
   environmentId: string;
+  /**
+   * When set, binds this connection as the CSOM executor for `sessionId` so the
+   * server can route that session's `onCsomCall` invocations here.
+   */
+  sessionId?: string;
   /** Command handlers; any omitted handler throws when its command arrives. */
   handlers?: Partial<RemoteEnvironmentHandlers>;
 }
@@ -98,6 +112,7 @@ function withDefaultHandlers(
     onSpawn: handlers.onSpawn ?? (() => notImplemented("onSpawn")),
     onMessage: handlers.onMessage ?? (() => notImplemented("onMessage")),
     onKill: handlers.onKill ?? (() => notImplemented("onKill")),
+    onCsomCall: handlers.onCsomCall,
   };
 }
 
@@ -132,6 +147,31 @@ function registerCommandHandlers(
   socket.on(RemoteEnvEvents.Kill, (command: RemoteKillCommand) => {
     void runHandler("onKill", () => handlers.onKill(command));
   });
+  socket.on(
+    RemoteEnvEvents.CsomCall,
+    (
+      request: RemoteCsomCallRequest,
+      ack: (response: RemoteCsomCallResponse) => void,
+    ) => void respondToCsomCall(handlers, request, ack),
+  );
+}
+
+/** Runs the CSOM handler and answers the server's ack with a typed response. */
+async function respondToCsomCall(
+  handlers: RemoteEnvironmentHandlers,
+  request: RemoteCsomCallRequest,
+  ack: (response: RemoteCsomCallResponse) => void,
+): Promise<void> {
+  if (!handlers.onCsomCall) {
+    ack({ ok: false, error: "This environment does not host a CSOM editor." });
+    return;
+  }
+  try {
+    const value = await handlers.onCsomCall(request);
+    ack({ ok: true, value });
+  } catch (err) {
+    ack({ ok: false, error: (err as Error).message });
+  }
 }
 
 /**
@@ -147,6 +187,7 @@ export function connectRemoteEnvironment(
   const auth: RemoteEnvHandshake = {
     token: options.token,
     environmentId: options.environmentId,
+    sessionId: options.sessionId,
   };
   const socket = io(`${normalizeUrl(options.url)}${REMOTE_ENV_NAMESPACE}`, {
     auth,
@@ -199,6 +240,8 @@ export function connectRemoteEnvironment(
 
 export type {
   RemoteAgentEvent,
+  RemoteCsomCallRequest,
+  RemoteCsomCallResponse,
   RemoteKillCommand,
   RemoteMessageCommand,
   RemoteSpawnCommand,
diff --git a/packages/shared/src/remoteSubagent.ts b/packages/shared/src/remoteSubagent.ts
index 9e58d2b..58acda6 100644
--- a/packages/shared/src/remoteSubagent.ts
+++ b/packages/shared/src/remoteSubagent.ts
@@ -34,6 +34,12 @@ export const REMOTE_ENV_NAMESPACE = "/remote-env";
 export interface RemoteEnvHandshake {
   environmentId: string;
   token: string;
+  /**
+   * When set, binds this environment as the CSOM executor for `sessionId`, so
+   * the gateway can route `remote:csom:call` invocations for that session to
+   * this connection (e.g. a browser tab hosting the embedded pipeline editor).
+   */
+  sessionId?: string;
 }
 
 /**
@@ -56,6 +62,12 @@ export const RemoteEnvEvents = {
   AgentMessage: "remote:agent-message",
   /** remote -> server (ack): read the shared session transcript. */
   RoomRead: "remote:room:read",
+  /**
+   * server -> remote (ack): invoke a CSOM editing method on the environment's
+   * embedded pipeline editor and return the result. Lets Prime drive the editor
+   * live without hosting an agent runtime in the environment.
+   */
+  CsomCall: "remote:csom:call",
 } as const;
 
 export type RemoteEnvEvent =
@@ -155,3 +167,27 @@ export interface RemoteRoomReadRequest {
 export interface RemoteRoomReadResponse {
   messages: ChatMessage[];
 }
+
+/**
+ * server -> remote (ack request): invoke a single CSOM editing method (the
+ * camelCase names from the embed's CSOM bridge, e.g. `addTask`, `connectNodes`,
+ * `getSpecYaml`) with positional `args` against the environment's embedded
+ * pipeline editor.
+ */
+export interface RemoteCsomCallRequest {
+  sessionId: string;
+  method: string;
+  args: unknown[];
+}
+
+/**
+ * remote -> server (ack response): the CSOM call outcome. `ok` reports whether
+ * the call itself succeeded; on success `value` carries the method's return
+ * (which may itself be a domain-level `{ success: false, error }`), and on
+ * failure `error` explains why (e.g. no editor connected, unknown method).
+ */
+export interface RemoteCsomCallResponse {
+  ok: boolean;
+  value?: unknown;
+  error?: string;
+}
diff --git a/packages/ui-extensions-sdk/README.md b/packages/ui-extensions-sdk/README.md
index 108e939..9704bd0 100644
--- a/packages/ui-extensions-sdk/README.md
+++ b/packages/ui-extensions-sdk/README.md
@@ -118,8 +118,15 @@ await host.fetch("https://api.example.com/…", { method: "POST", body: {…} })
 await host.getState("key"); // per-instance persisted value (message only)
 await host.setState("key", value);
 await host.execUICommand({ type: "collapse" }); // collapse the host message
+await host.execUICommand({ type: "openTab", tab: "pipeline-editor" }); // open a full-screen in-app tab
 ```
 
+`openTab` asks the host to open one of its built-in full-screen tabs. Today the
+only tab is `"pipeline-editor"` — a native surface that embeds the Tangle
+pipeline editor and lets Prime drive it live over CSOM. The sandbox itself
+cannot render an iframe or open a socket, so a component uses this command to
+hand off to the app instead.
+
 `host.fetch` is proxied through the server's egress allowlist; direct/global
 `fetch` is not available. See `docs/bundle-ui/` for the full host-bridge and
 security reference.
diff --git a/packages/ui-extensions-sdk/src/types.ts b/packages/ui-extensions-sdk/src/types.ts
index 534d74c..319ed7f 100644
--- a/packages/ui-extensions-sdk/src/types.ts
+++ b/packages/ui-extensions-sdk/src/types.ts
@@ -48,13 +48,15 @@ export interface HostResponse {
  * Modeled as a discriminated union (rather than bespoke methods) so new actions
  * can be added — each carrying its own payload — without growing the bridge
  * surface. `collapse` collapses the chat message the component is rendered in,
- * and URL commands open either a supplied `https:` URL or a server-configured
- * target URL in a new browser tab.
+ * URL commands open either a supplied `https:` URL or a server-configured
+ * target URL in a new browser tab, and `openTab` opens a full-screen in-app tab
+ * hosted by the app (e.g. the embedded Tangle pipeline editor).
  */
 export type UICommand =
   | { type: "collapse" }
   | { type: "openUrl"; url: string }
-  | { type: "openTargetUrl"; target: "tangle"; path: string };
+  | { type: "openTargetUrl"; target: "tangle"; path: string }
+  | { type: "openTab"; tab: "pipeline-editor"; title?: string };
 
 /**
  * The only channel a sandboxed component has to the host. Exposed to the worker
@@ -75,6 +77,10 @@ export interface HostBridge {
   getState(key: string): Promise<unknown>;
   /** Persists a JSON-serializable `value` under `key` for this instance. */
   setState(key: string, value: unknown): Promise<void>;
-  /** Requests a host UI action (e.g. collapsing the component's message). */
+  /**
+   * Requests a host UI action: collapse the component's message, open a URL /
+   * server-resolved target in a new browser tab, or open a full-screen in-app
+   * tab (`openTab`) such as the embedded Tangle pipeline editor.
+   */
   execUICommand(command: UICommand): Promise<void>;
 }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index f9d8be5..83f0e8f 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -136,6 +136,9 @@ importers:
       '@remote-dom/react':
         specifier: ^1.2.2
         version: 1.2.2(@preact/signals-core@1.14.2)(react@19.2.6)
+      '@tangent/remote-subagent':
+        specifier: workspace:*
+        version: link:../../packages/remote-subagent
       '@tangent/shared':
         specifier: workspace:*
         version: link:../../packages/shared