diff --git a/README.md b/README.md
index 8aa78f81b9ad..bca0300716a5 100644
--- a/README.md
+++ b/README.md
@@ -84,6 +84,15 @@ yay -S t3code-nightly-bin
 
 The AUR packaging is maintained in this repository under [`packaging/aur`](./packaging/aur).
 
+## Share MCP servers with every agent
+
+Add an MCP server once in **Settings → Integrations → Shared MCP servers**, and every new agent session can use its tools, whichever provider runs it. T3 Code connects to the server for the agents, so logins stay in T3 Code:
+
+- **OAuth servers** such as Linear (`https://mcp.linear.app/mcp`), Notion (`https://mcp.notion.com/mcp`), or Sentry (`https://mcp.sentry.dev/mcp`): add the URL, then choose **Sign in** and approve in your browser. T3 Code keeps the login and refreshes it.
+- **Token servers** such as GitHub (`https://api.githubcopilot.com/mcp/`): add a header like `Authorization: Bearer <personal-token>`. It's stored as a secret.
+
+Agents never see the tokens. See [Shared MCP servers](./docs/user/shared-mcp-servers.md).
+
 ## Some notes
 
 We are very very early in this project. Expect bugs.
@@ -101,6 +110,7 @@ Full docs live in [docs/](./docs). There's no docs site yet.
 - [Appearance preferences](./docs/user/appearance.md)
 - [Remote access from a phone or another machine](./docs/user/remote-access.md)
 - [Connect Claude Code, Codex, ChatGPT and other agents over MCP](./docs/user/outside-agents.md)
+- [Share MCP servers, including ones that need a login, with every agent](./docs/user/shared-mcp-servers.md)
 - [Keeping app and server in sync](./docs/user/updating.md)
 - [Source control integrations](./docs/user/source-control.md)
 - Multiple accounts: [Codex](./docs/user/providers-codex.md) · [Claude](./docs/user/providers-claude.md)
diff --git a/apps/mobile/src/Stack.tsx b/apps/mobile/src/Stack.tsx
index 4e3c53268f24..fbd11ce5bc48 100644
--- a/apps/mobile/src/Stack.tsx
+++ b/apps/mobile/src/Stack.tsx
@@ -84,6 +84,7 @@ import { SettingsAuthRouteScreen } from "./features/settings/SettingsAuthRouteSc
 import { SettingsEnvironmentDetailRouteScreen } from "./features/settings/SettingsEnvironmentDetailRouteScreen";
 import { SettingsEnvironmentsRouteScreen } from "./features/settings/SettingsEnvironmentsRouteScreen";
 import { SettingsFollowUpRouteScreen } from "./features/settings/SettingsFollowUpRouteScreen";
+import { SettingsSharedMcpServersRouteScreen } from "./features/settings/SettingsSharedMcpServersRouteScreen";
 import {
   SettingsEnvironmentAgentBehaviorRouteScreen,
   SettingsEnvironmentMaintenanceRouteScreen,
@@ -244,6 +245,11 @@ const SettingsContentStack = createV5SheetStackNavigator({
       linking: "provider-accounts",
       options: { title: "Provider accounts" },
     }),
+    SettingsSharedMcpServers: createNativeStackScreen({
+      screen: SettingsSharedMcpServersRouteScreen,
+      linking: "shared-mcp-servers",
+      options: { title: "Shared MCP servers" },
+    }),
     SettingsEnvironmentMaintenance: createNativeStackScreen({
       screen: SettingsEnvironmentMaintenanceRouteScreen,
       linking: "maintenance",
diff --git a/apps/mobile/src/features/settings/SettingsRouteScreen.tsx b/apps/mobile/src/features/settings/SettingsRouteScreen.tsx
index adb6551cf5fa..4209ff172b69 100644
--- a/apps/mobile/src/features/settings/SettingsRouteScreen.tsx
+++ b/apps/mobile/src/features/settings/SettingsRouteScreen.tsx
@@ -205,6 +205,12 @@ function SettingsIndexSections() {
           target="SettingsEnvironmentAgentBehavior"
           disabled={noServerTargets}
         />
+        <SettingsRow
+          icon="server.rack"
+          label="Shared MCP servers"
+          target="SettingsSharedMcpServers"
+          disabled={noServerTargets}
+        />
         <SettingsRow
           icon="arrow.clockwise"
           label="Maintenance"
diff --git a/apps/mobile/src/features/settings/SettingsSharedMcpServersRouteScreen.tsx b/apps/mobile/src/features/settings/SettingsSharedMcpServersRouteScreen.tsx
new file mode 100644
index 000000000000..9a7cb2930349
--- /dev/null
+++ b/apps/mobile/src/features/settings/SettingsSharedMcpServersRouteScreen.tsx
@@ -0,0 +1,380 @@
+import {
+  isAtomCommandInterrupted,
+  squashAtomCommandFailure,
+} from "@t3tools/client-runtime/state/runtime";
+import {
+  parseSharedMcpServerDraft,
+  sharedMcpServerDraft,
+  upsertSharedMcpServer,
+  type SharedMcpServerDraft,
+} from "@t3tools/client-runtime/state/shared-mcp-servers";
+import type { SharedMcpServer } from "@t3tools/contracts";
+import * as Option from "effect/Option";
+import { useRef, useState } from "react";
+import { Alert, Linking, Pressable, View } from "react-native";
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+
+import { AppText as Text, AppTextInput } from "../../components/AppText";
+import { ScreenScrollView } from "../../components/ScreenScrollView";
+import { serverEnvironment } from "../../state/server";
+import { usePreparedConnection } from "../../state/session";
+import { useAtomCommand } from "../../state/use-atom-command";
+import { SettingsActionRow } from "./components/SettingsActionRow";
+import {
+  AndroidSettingsEnvironmentFilter,
+  SettingsEnvironmentFilterHeader,
+} from "./components/SettingsEnvironmentFilterHeader";
+import { SettingsScreen } from "./components/SettingsScreen";
+import { SettingsSection } from "./components/SettingsSection";
+import { SettingsSwitchRow } from "./components/SettingsSwitchRow";
+import { useSettingsEnvironmentFilter, type SettingsTarget } from "./settings-environment-filter";
+
+const EMPTY_DRAFT: SharedMcpServerDraft = { name: "", url: "", headers: "" };
+
+export function SettingsSharedMcpServersRouteScreen() {
+  const { selectedTargets } = useSettingsEnvironmentFilter();
+  const insets = useSafeAreaInsets();
+  return (
+    <>
+      <SettingsEnvironmentFilterHeader />
+      <SettingsScreen title="Shared MCP servers" trailing={<AndroidSettingsEnvironmentFilter />}>
+        <ScreenScrollView
+          className="flex-1"
+          contentInsetAdjustmentBehavior="automatic"
+          contentContainerClassName="gap-6 px-5 pt-4"
+          contentContainerStyle={{ paddingBottom: Math.max(insets.bottom, 18) + 18 }}
+        >
+          {selectedTargets.length === 0 ? (
+            <Text className="px-2 text-base text-foreground-muted">
+              Use the filter above to select a connected environment.
+            </Text>
+          ) : (
+            selectedTargets.map((environment) => (
+              <SharedMcpServersSection key={environment.environmentId} environment={environment} />
+            ))
+          )}
+        </ScreenScrollView>
+      </SettingsScreen>
+    </>
+  );
+}
+
+/** One environment's saved servers. Every write sends the whole list back. */
+function SharedMcpServersSection({ environment }: { readonly environment: SettingsTarget }) {
+  const environmentId = environment.environmentId;
+  const servers = environment.serverConfig.settings.sharedMcpServers;
+  const updateSettings = useAtomCommand(serverEnvironment.updateSettings, {
+    label: "shared MCP servers update",
+    reportFailure: true,
+  });
+  const [form, setForm] = useState<{
+    readonly editing: SharedMcpServer | undefined;
+    readonly draft: SharedMcpServerDraft;
+  } | null>(null);
+  const [pending, setPending] = useState(false);
+  const pendingRef = useRef(false);
+  const [error, setError] = useState<string | null>(null);
+
+  async function write(next: ReadonlyArray<SharedMcpServer>) {
+    if (pendingRef.current) return false;
+    pendingRef.current = true;
+    setPending(true);
+    setError(null);
+    const result = await updateSettings({
+      environmentId,
+      input: { patch: { sharedMcpServers: next } },
+    });
+    pendingRef.current = false;
+    setPending(false);
+    if (result._tag === "Success") return true;
+    if (!isAtomCommandInterrupted(result)) setError("Could not save shared MCP servers.");
+    return false;
+  }
+
+  const save = () => {
+    if (form === null) return;
+    const parsed = parseSharedMcpServerDraft(servers, form.draft, form.editing);
+    if ("error" in parsed) {
+      setError(parsed.error);
+      return;
+    }
+    void write(upsertSharedMcpServer(servers, parsed.server, form.editing)).then((saved) => {
+      if (saved) setForm(null);
+    });
+  };
+
+  const confirmRemove = (server: SharedMcpServer) =>
+    Alert.alert(
+      `Remove ${server.name}?`,
+      `New agent sessions on ${environment.label} stop getting it.`,
+      [
+        { text: "Cancel", style: "cancel" },
+        {
+          text: "Remove",
+          style: "destructive",
+          onPress: () => void write(servers.filter((entry) => entry.name !== server.name)),
+        },
+      ],
+    );
+
+  return (
+    <SettingsSection title={environment.label}>
+      {servers.length === 0 && form === null ? (
+        <Text className="p-4 text-sm text-foreground-muted">
+          Add a server once and every new agent session on this environment gets it: Claude, Codex,
+          Cursor, OpenCode, Pi, and ACP agents. Point it at a local MCP gateway to share many
+          servers at once.
+        </Text>
+      ) : null}
+      {servers.map((server, index) => (
+        <SharedMcpServerRow
+          // Any saved change, headers included, clears a stale Test result.
+          key={JSON.stringify(server)}
+          environmentId={environmentId}
+          server={server}
+          separated={index > 0}
+          disabled={pending || form !== null}
+          onEnabledChange={(enabled) =>
+            void write(
+              servers.map((entry) => (entry.name === server.name ? { ...entry, enabled } : entry)),
+            )
+          }
+          onEdit={() => {
+            setError(null);
+            setForm({ editing: server, draft: sharedMcpServerDraft(server) });
+          }}
+          onRemove={() => confirmRemove(server)}
+        />
+      ))}
+      {form !== null ? (
+        <View className="gap-2 border-t border-border-subtle p-4">
+          <Text className="text-lg font-semibold text-foreground">
+            {form.editing ? `Edit ${form.editing.name}` : "New MCP server"}
+          </Text>
+          <AppTextInput
+            accessibilityLabel="Server name"
+            placeholder="gateway"
+            autoCapitalize="none"
+            autoCorrect={false}
+            editable={!pending}
+            value={form.draft.name}
+            onChangeText={(name) => setForm({ ...form, draft: { ...form.draft, name } })}
+          />
+          <AppTextInput
+            accessibilityLabel="Server URL"
+            placeholder="http://127.0.0.1:3050/mcp"
+            autoCapitalize="none"
+            autoCorrect={false}
+            keyboardType="url"
+            editable={!pending}
+            value={form.draft.url}
+            onChangeText={(url) => setForm({ ...form, draft: { ...form.draft, url } })}
+          />
+          <AppTextInput
+            accessibilityLabel="Headers"
+            placeholder="Authorization: Bearer …"
+            autoCapitalize="none"
+            autoCorrect={false}
+            multiline
+            editable={!pending}
+            className="min-h-24"
+            value={form.draft.headers}
+            onChangeText={(headers) => setForm({ ...form, draft: { ...form.draft, headers } })}
+          />
+          <Text className="text-sm text-foreground-muted">
+            One header per line, as Name: value. Leave •••••• to keep a saved value.
+          </Text>
+        </View>
+      ) : null}
+      {error ? (
+        <Text accessibilityRole="alert" className="px-4 pb-4 text-danger-foreground">
+          {error}
+        </Text>
+      ) : null}
+      {form !== null ? (
+        <>
+          <SettingsActionRow
+            icon="checkmark"
+            label={form.editing ? "Save" : "Add server"}
+            disabled={pending}
+            loading={pending}
+            onPress={save}
+          />
+          <SettingsActionRow
+            icon="xmark"
+            label="Cancel"
+            disabled={pending}
+            onPress={() => {
+              setError(null);
+              setForm(null);
+            }}
+          />
+        </>
+      ) : (
+        <SettingsActionRow
+          icon="plus"
+          label="Add server"
+          disabled={pending}
+          onPress={() => {
+            setError(null);
+            setForm({ editing: undefined, draft: EMPTY_DRAFT });
+          }}
+        />
+      )}
+    </SettingsSection>
+  );
+}
+
+function SharedMcpServerRow(props: {
+  readonly environmentId: SettingsTarget["environmentId"];
+  readonly server: SharedMcpServer;
+  readonly separated: boolean;
+  readonly disabled: boolean;
+  readonly onEnabledChange: (enabled: boolean) => void;
+  readonly onEdit: () => void;
+  readonly onRemove: () => void;
+}) {
+  const { server } = props;
+  const testServer = useAtomCommand(serverEnvironment.testSharedMcpServer, {
+    label: "shared MCP server test",
+    reportFailure: false,
+  });
+  const signInServer = useAtomCommand(serverEnvironment.signInSharedMcpServer, {
+    label: "shared MCP server sign-in",
+    reportFailure: false,
+  });
+  // The provider sends the browser back to this environment's server, which
+  // keeps the tokens.
+  const connection = usePreparedConnection(props.environmentId);
+  const redirectBaseUrl = Option.isSome(connection) ? connection.value.httpBaseUrl : null;
+  const [testing, setTesting] = useState(false);
+  const [result, setResult] = useState<{ readonly ok: boolean; readonly message: string } | null>(
+    null,
+  );
+  const headerCount = Object.keys(server.headers).length;
+
+  const test = () => {
+    setTesting(true);
+    setResult(null);
+    void testServer({ environmentId: props.environmentId, input: { name: server.name } })
+      .then((outcome) => {
+        if (outcome._tag === "Success") {
+          const { serverName, toolCount } = outcome.value;
+          const tools = `${toolCount} ${toolCount === 1 ? "tool" : "tools"}`;
+          setResult({
+            ok: true,
+            message: serverName ? `Connected: ${serverName} · ${tools}` : `Connected · ${tools}`,
+          });
+        } else if (!isAtomCommandInterrupted(outcome)) {
+          const failure = squashAtomCommandFailure(outcome);
+          setResult({
+            ok: false,
+            message: failure instanceof Error ? failure.message : "Could not reach the server.",
+          });
+        }
+      })
+      .finally(() => setTesting(false));
+  };
+
+  const signIn = () => {
+    if (redirectBaseUrl === null) return;
+    setTesting(true);
+    setResult(null);
+    void signInServer({
+      environmentId: props.environmentId,
+      input: { name: server.name, redirectBaseUrl },
+    })
+      .then((outcome) => {
+        if (outcome._tag === "Success") {
+          const { authorizationUrl } = outcome.value;
+          if (authorizationUrl === null) {
+            setResult({ ok: true, message: "Connected · no sign-in needed" });
+            return;
+          }
+          setResult({
+            ok: true,
+            message: "Finish signing in in your browser, then test the connection.",
+          });
+          void Linking.openURL(authorizationUrl).catch(() =>
+            setResult({ ok: false, message: "Could not open the sign-in page." }),
+          );
+        } else if (!isAtomCommandInterrupted(outcome)) {
+          const failure = squashAtomCommandFailure(outcome);
+          setResult({
+            ok: false,
+            message: failure instanceof Error ? failure.message : "Could not start the sign-in.",
+          });
+        }
+      })
+      .finally(() => setTesting(false));
+  };
+
+  return (
+    <View className={props.separated ? "border-t border-border-subtle" : undefined}>
+      <SettingsSwitchRow
+        icon="server.rack"
+        label={server.name}
+        subtitle={
+          headerCount > 0
+            ? `${server.url} · ${headerCount} ${headerCount === 1 ? "header" : "headers"}`
+            : server.url
+        }
+        value={server.enabled}
+        disabled={props.disabled}
+        onValueChange={props.onEnabledChange}
+      />
+      <View className="flex-row flex-wrap gap-2 px-4 pb-4">
+        <ServerAction
+          label={testing ? "Testing…" : "Test"}
+          disabled={props.disabled || testing}
+          onPress={test}
+        />
+        <ServerAction
+          label="Sign in"
+          disabled={props.disabled || testing || redirectBaseUrl === null}
+          onPress={signIn}
+        />
+        <ServerAction label="Edit" disabled={props.disabled} onPress={props.onEdit} />
+        <ServerAction label="Remove" danger disabled={props.disabled} onPress={props.onRemove} />
+      </View>
+      {result ? (
+        <Text
+          accessibilityLiveRegion="polite"
+          className={
+            result.ok
+              ? "px-4 pb-4 text-sm text-foreground-muted"
+              : "px-4 pb-4 text-sm text-danger-foreground"
+          }
+        >
+          {result.message}
+        </Text>
+      ) : null}
+    </View>
+  );
+}
+
+function ServerAction(props: {
+  readonly label: string;
+  readonly danger?: boolean;
+  readonly disabled: boolean;
+  readonly onPress: () => void;
+}) {
+  return (
+    <Pressable
+      accessibilityRole="button"
+      disabled={props.disabled}
+      onPress={props.onPress}
+      className="rounded-full bg-subtle px-4 py-2 active:opacity-70 disabled:opacity-40"
+    >
+      <Text
+        className={
+          props.danger
+            ? "text-sm font-t3-medium text-danger-foreground"
+            : "text-sm font-t3-medium text-foreground"
+        }
+      >
+        {props.label}
+      </Text>
+    </Pressable>
+  );
+}
diff --git a/apps/mobile/src/features/settings/components/settings-sheet-targets.ts b/apps/mobile/src/features/settings/components/settings-sheet-targets.ts
index 611a1b3410c7..b901c2461fb0 100644
--- a/apps/mobile/src/features/settings/components/settings-sheet-targets.ts
+++ b/apps/mobile/src/features/settings/components/settings-sheet-targets.ts
@@ -12,6 +12,7 @@ export type SettingsSheetTarget =
   | "SettingsEnvironmentAgentBehavior"
   | "SettingsEnvironmentMaintenance"
   | "SettingsProviderAccounts"
+  | "SettingsSharedMcpServers"
   | "SettingsKeyboard"
   | "SettingsMicrophone"
   | "SettingsFollowUp"
diff --git a/apps/server/package.json b/apps/server/package.json
index cc1bddb2ee6d..3b2c9c7af5b9 100644
--- a/apps/server/package.json
+++ b/apps/server/package.json
@@ -34,6 +34,7 @@
     "@effect/platform-node": "catalog:",
     "@effect/platform-node-shared": "catalog:",
     "@ff-labs/fff-node": "0.11.0",
+    "@modelcontextprotocol/sdk": "1.29.0",
     "@muse-code/sdk": "1.4.2",
     "@napi-rs/keyring": "^1.3.0",
     "@opencode-ai/sdk": "^1.3.15",
@@ -64,7 +65,6 @@
   },
   "devDependencies": {
     "@effect/vitest": "catalog:",
-    "@modelcontextprotocol/sdk": "1.29.0",
     "@t3tools/contracts": "workspace:*",
     "@t3tools/provider-testing": "workspace:*",
     "@t3tools/shared": "workspace:*",
diff --git a/apps/server/src/auth/RpcAuthorization.ts b/apps/server/src/auth/RpcAuthorization.ts
index 7d67d92f4f71..cb60307ef43d 100644
--- a/apps/server/src/auth/RpcAuthorization.ts
+++ b/apps/server/src/auth/RpcAuthorization.ts
@@ -87,6 +87,10 @@ export const RPC_REQUIRED_SCOPES = {
   [WS_METHODS.serverGetStorageCleanupReport]: AuthOrchestrationReadScope,
   [WS_METHODS.serverGetSettings]: AuthOrchestrationReadScope,
   [WS_METHODS.serverUpdateSettings]: AuthSettingsWriteScope,
+  // Sends the saved headers to the server's URL, so it needs the same scope as editing them.
+  [WS_METHODS.serverTestSharedMcpServer]: AuthSettingsWriteScope,
+  // Registers T3 as an OAuth client of the server and stores its tokens.
+  [WS_METHODS.serverSignInSharedMcpServer]: AuthSettingsWriteScope,
   [WS_METHODS.serverSearchAcpRegistry]: AuthOrchestrationReadScope,
   [WS_METHODS.serverPrepareAcpRegistryAgent]: AuthProvidersManageScope,
   [WS_METHODS.serverUninstallAcpRegistryManagedBinary]: AuthProvidersManageScope,
diff --git a/apps/server/src/mcp/SharedMcpHttp.test.ts b/apps/server/src/mcp/SharedMcpHttp.test.ts
new file mode 100644
index 000000000000..38960e7a6b35
--- /dev/null
+++ b/apps/server/src/mcp/SharedMcpHttp.test.ts
@@ -0,0 +1,135 @@
+import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer";
+import { assert, it } from "@effect/vitest";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { HttpClient, HttpClientRequest, HttpRouter } from "effect/http";
+
+import * as ServerSettings from "../serverSettings.ts";
+import type * as McpInvocationContext from "./McpInvocationContext.ts";
+import * as McpSessionRegistry from "./McpSessionRegistry.ts";
+import * as SharedMcpHttp from "./SharedMcpHttp.ts";
+import { SharedMcpProxy, SharedMcpProxyError } from "./SharedMcpProxy.ts";
+
+const calls: Array<{ readonly server: string; readonly params: unknown }> = [];
+
+const layerDependencies = Layer.mergeAll(
+  Layer.mock(McpSessionRegistry.McpSessionRegistry)({
+    resolve: (token) =>
+      Effect.succeed(
+        token === "thread-token"
+          ? ({} as McpInvocationContext.McpThreadInvocationScope)
+          : undefined,
+      ),
+  }),
+  Layer.mock(SharedMcpProxy)({
+    listTools: (server) => Effect.succeed({ tools: [{ name: `${server.name}_tool` }] }),
+    callTool: (server, params) =>
+      Effect.suspend(() => {
+        calls.push({ server: server.name, params });
+        return Effect.fail(
+          new SharedMcpProxyError({
+            server: server.name,
+            message: "Sign in first.",
+            needsSignIn: true,
+          }),
+        );
+      }),
+    finishSignIn: () =>
+      Effect.fail(
+        new SharedMcpProxyError({
+          server: "",
+          message: "This link has <expired>.",
+          needsSignIn: true,
+        }),
+      ),
+  }),
+  ServerSettings.layerTest({
+    sharedMcpServers: [
+      { id: "docs", name: "docs", url: "http://127.0.0.1:9/mcp", enabled: true, headers: {} },
+      { id: "off", name: "off", url: "http://127.0.0.1:9/mcp", enabled: false, headers: {} },
+    ],
+  }).pipe(Layer.orDie),
+);
+
+const makeClient = Effect.gen(function* () {
+  const services = yield* Layer.build(
+    HttpRouter.serve(SharedMcpHttp.layer, { disableListenLog: true }).pipe(
+      Layer.provide(layerDependencies),
+      Layer.provideMerge(NodeHttpServer.layerTest),
+    ),
+  );
+  const client = Context.get(services, HttpClient.HttpClient);
+  return {
+    rpc: (path: string, body: unknown, token = "thread-token") =>
+      client.execute(
+        HttpClientRequest.post(path).pipe(
+          HttpClientRequest.setHeader("authorization", `Bearer ${token}`),
+          HttpClientRequest.bodyJsonUnsafe(body),
+        ),
+      ),
+    get: (path: string) => client.get(path),
+  };
+});
+
+it.effect("serves each enabled shared server to agents holding a thread credential", () =>
+  Effect.gen(function* () {
+    const { rpc } = yield* makeClient;
+
+    assert.equal((yield* rpc("/mcp/shared/docs", {}, "stolen")).status, 401);
+    assert.equal((yield* rpc("/mcp/shared/off", {})).status, 404);
+
+    const initialize = yield* rpc("/mcp/shared/docs", {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "initialize",
+      params: { protocolVersion: "2025-03-26", capabilities: {} },
+    });
+    const initialized = (yield* initialize.json) as {
+      result: { protocolVersion: string; serverInfo: { name: string } };
+    };
+    assert.equal(initialized.result.protocolVersion, "2025-03-26");
+    assert.equal(initialized.result.serverInfo.name, "docs");
+
+    const notified = yield* rpc("/mcp/shared/docs", {
+      jsonrpc: "2.0",
+      method: "notifications/initialized",
+    });
+    assert.equal(notified.status, 202);
+
+    const listed = yield* rpc("/mcp/shared/docs", { jsonrpc: "2.0", id: 2, method: "tools/list" });
+    assert.deepEqual(yield* listed.json, {
+      jsonrpc: "2.0",
+      id: 2,
+      result: { tools: [{ name: "docs_tool" }] },
+    });
+
+    // An upstream failure comes back as a tool error the agent can read.
+    const called = yield* rpc("/mcp/shared/docs", {
+      jsonrpc: "2.0",
+      id: 3,
+      method: "tools/call",
+      params: { name: "search", arguments: { q: "x" } },
+    });
+    assert.deepEqual(yield* called.json, {
+      jsonrpc: "2.0",
+      id: 3,
+      result: { isError: true, content: [{ type: "text", text: "Sign in first." }] },
+    });
+    assert.deepEqual(calls, [
+      { server: "docs", params: { name: "search", arguments: { q: "x" } } },
+    ]);
+  }).pipe(Effect.scoped),
+);
+
+it.effect("answers the OAuth callback with a page, escaping what it echoes", () =>
+  Effect.gen(function* () {
+    const { get } = yield* makeClient;
+    const failed = yield* (yield* get("/api/mcp-oauth/callback?state=s&code=c")).text;
+    assert.include(failed, "Sign-in failed");
+    assert.include(failed, "This link has &#60;expired&#62;.");
+
+    const denied = yield* (yield* get("/api/mcp-oauth/callback?error=access_denied")).text;
+    assert.include(denied, "access_denied");
+  }).pipe(Effect.scoped),
+);
diff --git a/apps/server/src/mcp/SharedMcpHttp.ts b/apps/server/src/mcp/SharedMcpHttp.ts
new file mode 100644
index 000000000000..3c3822be03ec
--- /dev/null
+++ b/apps/server/src/mcp/SharedMcpHttp.ts
@@ -0,0 +1,146 @@
+/**
+ * HTTP routes for shared MCP servers: the per-server MCP endpoint agents call
+ * with their thread credential, and the OAuth callback a sign-in returns to.
+ *
+ * The endpoint speaks stateless streamable HTTP: each POST carries one
+ * JSON-RPC message and gets a JSON reply. Only tools are proxied.
+ *
+ * @module mcp/SharedMcpHttp
+ */
+import { sharedMcpServerKey } from "@t3tools/contracts";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/http";
+
+import { ServerSettingsService } from "../serverSettings.ts";
+import * as McpSessionRegistry from "./McpSessionRegistry.ts";
+import {
+  SHARED_MCP_OAUTH_CALLBACK_PATH,
+  SHARED_MCP_PATH_SEGMENT,
+  SharedMcpProxy,
+  type SharedMcpProxyError,
+} from "./SharedMcpProxy.ts";
+
+const ROUTE_PREFIX = `/mcp/${SHARED_MCP_PATH_SEGMENT}/`;
+const SUPPORTED_PROTOCOL_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+
+type JsonRpcRequest = {
+  readonly jsonrpc?: unknown;
+  readonly id?: string | number | null;
+  readonly method?: unknown;
+  readonly params?: Record<string, unknown>;
+};
+
+const reply = (id: JsonRpcRequest["id"], result: unknown) =>
+  HttpServerResponse.jsonUnsafe({ jsonrpc: "2.0", id: id ?? null, result });
+const replyError = (id: JsonRpcRequest["id"], code: number, message: string) =>
+  HttpServerResponse.jsonUnsafe({ jsonrpc: "2.0", id: id ?? null, error: { code, message } });
+
+/** A tool call that can't reach the server is a tool error the agent can read, not a transport failure. */
+const toolError = (error: SharedMcpProxyError) => ({
+  isError: true,
+  content: [{ type: "text", text: error.message }],
+});
+
+const handleMcp = Effect.gen(function* () {
+  const request = yield* HttpServerRequest.HttpServerRequest;
+  const registry = yield* McpSessionRegistry.McpSessionRegistry;
+  const authorization = request.headers.authorization;
+  const token =
+    authorization?.startsWith("Bearer ") === true
+      ? authorization.slice("Bearer ".length).trim()
+      : "";
+  if ((yield* registry.resolve(token)) === undefined) {
+    return HttpServerResponse.text("Unauthorized", { status: 401 });
+  }
+
+  const pathname = new URL(request.originalUrl, "http://localhost").pathname;
+  const key = decodeURIComponent(pathname.slice(ROUTE_PREFIX.length));
+  const settings = yield* (yield* ServerSettingsService).getSettings.pipe(Effect.orDie);
+  const server = settings.sharedMcpServers.find(
+    (entry) => entry.enabled && sharedMcpServerKey(entry) === key,
+  );
+  if (server === undefined) return HttpServerResponse.text("Not Found", { status: 404 });
+
+  const message = (yield* request.json.pipe(Effect.orElseSucceed(() => undefined))) as
+    | JsonRpcRequest
+    | undefined;
+  if (typeof message !== "object" || message === null || Array.isArray(message)) {
+    return replyError(null, -32600, "Expected one JSON-RPC message.");
+  }
+  // Notifications and responses need no reply.
+  if (message.id === undefined || typeof message.method !== "string") {
+    return HttpServerResponse.empty({ status: 202 });
+  }
+  const proxy = yield* SharedMcpProxy;
+  switch (message.method) {
+    case "initialize": {
+      const requested = message.params?.protocolVersion;
+      return reply(message.id, {
+        protocolVersion:
+          typeof requested === "string" && SUPPORTED_PROTOCOL_VERSIONS.includes(requested)
+            ? requested
+            : SUPPORTED_PROTOCOL_VERSIONS[0],
+        capabilities: { tools: {} },
+        serverInfo: { name: server.name, version: "1.0.0" },
+      });
+    }
+    case "ping":
+      return reply(message.id, {});
+    case "tools/list":
+      return yield* proxy.listTools(server, message.params).pipe(
+        Effect.map((result) => reply(message.id, result)),
+        Effect.catch((error) => Effect.succeed(replyError(message.id, -32000, error.message))),
+      );
+    case "tools/call":
+      return yield* proxy.callTool(server, message.params).pipe(
+        Effect.map((result) => reply(message.id, result)),
+        Effect.catch((error) => Effect.succeed(reply(message.id, toolError(error)))),
+      );
+    default:
+      return replyError(message.id, -32601, `${message.method} is not supported by this proxy.`);
+  }
+});
+
+const page = (title: string, detail: string) =>
+  HttpServerResponse.html(
+    `<!doctype html><meta charset="utf-8"><meta name="color-scheme" content="light dark"><title>${title}</title>` +
+      `<body style="font-family:system-ui;max-width:32rem;margin:4rem auto;padding:0 1rem">` +
+      `<h1 style="font-size:1.25rem">${title}</h1><p>${detail}</p></body>`,
+  );
+const escapeHtml = (value: string) =>
+  value.replaceAll(/[&<>"']/g, (char) => `&#${char.charCodeAt(0)};`);
+
+/** Public: the provider sends the browser here; the one-time `state` ties it to a sign-in T3 started. */
+const handleOAuthCallback = Effect.gen(function* () {
+  const request = yield* HttpServerRequest.HttpServerRequest;
+  const params = new URL(request.originalUrl, "http://localhost").searchParams;
+  const state = params.get("state");
+  const code = params.get("code");
+  if (state === null || code === null) {
+    const denied =
+      params.get("error_description") ?? params.get("error") ?? "No code was returned.";
+    return page("Sign-in did not finish", escapeHtml(denied));
+  }
+  return yield* (yield* SharedMcpProxy).finishSignIn(state, code).pipe(
+    Effect.map(({ server }) =>
+      page(
+        `Signed in to ${escapeHtml(server)}`,
+        "You can close this tab. Agents in T3 Code can use this server in their next session.",
+      ),
+    ),
+    Effect.catch((error) => Effect.succeed(page("Sign-in failed", escapeHtml(error.message)))),
+  );
+});
+
+export const layer = Layer.mergeAll(
+  HttpRouter.add("POST", `${ROUTE_PREFIX}*`, handleMcp),
+  // Clients may open a server-sent event stream or end a session; neither is needed here.
+  HttpRouter.add(
+    "GET",
+    `${ROUTE_PREFIX}*`,
+    HttpServerResponse.text("Method Not Allowed", { status: 405 }),
+  ),
+  HttpRouter.add("DELETE", `${ROUTE_PREFIX}*`, HttpServerResponse.empty({ status: 204 })),
+  HttpRouter.add("GET", SHARED_MCP_OAUTH_CALLBACK_PATH, handleOAuthCallback),
+);
diff --git a/apps/server/src/mcp/SharedMcpProxy.test.ts b/apps/server/src/mcp/SharedMcpProxy.test.ts
new file mode 100644
index 000000000000..0661b5fe8f66
--- /dev/null
+++ b/apps/server/src/mcp/SharedMcpProxy.test.ts
@@ -0,0 +1,207 @@
+// A fake upstream MCP server and OAuth provider on a local port.
+// @effect-diagnostics nodeBuiltinImport:off preferSchemaOverJson:off
+import * as NodeHttp from "node:http";
+
+import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
+import { assert, describe, it } from "@effect/vitest";
+import type { SharedMcpServer } from "@t3tools/contracts";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+
+import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
+import * as SharedMcpProxy from "./SharedMcpProxy.ts";
+
+const layerMemorySecretStore = Layer.sync(ServerSecretStore.ServerSecretStore, () => {
+  const stored = new Map<string, Uint8Array>();
+  return ServerSecretStore.ServerSecretStore.of({
+    get: (name) => Effect.succeed(Option.fromNullishOr(stored.get(name))),
+    set: (name, value) => Effect.sync(() => void stored.set(name, value)),
+    create: (name, value) => Effect.sync(() => void stored.set(name, value)),
+    getOrCreateRandom: () => Effect.die("unused"),
+    remove: (name) => Effect.sync(() => void stored.delete(name)),
+  });
+});
+
+const layer = SharedMcpProxy.layer.pipe(
+  Layer.provide(Layer.mergeAll(layerMemorySecretStore, NodeCrypto.layer)),
+);
+
+type Fake = { readonly base: string; readonly tokenRequests: Array<URLSearchParams> };
+
+/**
+ * An MCP server whose `/mcp` answers `initialize`, `tools/list` and
+ * `tools/call` once `authorized(request)` holds. With `oauth`, it also serves
+ * the discovery documents, client registration, and a token endpoint that
+ * trades `the-code` for `good-token`.
+ */
+const fakeUpstream = (options: {
+  readonly oauth: boolean;
+  readonly authorized: (request: NodeHttp.IncomingMessage) => boolean;
+}) =>
+  Effect.acquireRelease(
+    Effect.promise(
+      () =>
+        new Promise<{ readonly server: NodeHttp.Server; readonly fake: Fake }>((resolve) => {
+          const tokenRequests: Array<URLSearchParams> = [];
+          const fake: Fake = { base: "", tokenRequests };
+          const json = (response: NodeHttp.ServerResponse, status: number, body: unknown) => {
+            response.writeHead(status, { "content-type": "application/json" });
+            response.end(JSON.stringify(body));
+          };
+          const server = NodeHttp.createServer((request, response) => {
+            let body = "";
+            request.on("data", (chunk) => (body += chunk));
+            request.on("end", () => {
+              const path = new URL(request.url ?? "/", fake.base).pathname;
+              if (options.oauth && path === "/.well-known/oauth-protected-resource/mcp") {
+                return json(response, 200, {
+                  resource: `${fake.base}/mcp`,
+                  authorization_servers: [fake.base],
+                });
+              }
+              if (options.oauth && path === "/.well-known/oauth-authorization-server") {
+                return json(response, 200, {
+                  issuer: fake.base,
+                  authorization_endpoint: `${fake.base}/authorize`,
+                  token_endpoint: `${fake.base}/token`,
+                  registration_endpoint: `${fake.base}/register`,
+                  response_types_supported: ["code"],
+                  code_challenge_methods_supported: ["S256"],
+                });
+              }
+              if (options.oauth && path === "/register") {
+                return json(response, 201, { ...JSON.parse(body), client_id: "client-1" });
+              }
+              if (options.oauth && path === "/token") {
+                const form = new URLSearchParams(body);
+                tokenRequests.push(form);
+                return form.get("code") === "the-code"
+                  ? json(response, 200, { access_token: "good-token", token_type: "Bearer" })
+                  : json(response, 400, { error: "invalid_grant" });
+              }
+              if (path !== "/mcp") return json(response, 404, {});
+              if (request.method !== "POST") {
+                response.writeHead(405);
+                return response.end();
+              }
+              if (!options.authorized(request)) {
+                response.writeHead(
+                  401,
+                  options.oauth
+                    ? {
+                        "www-authenticate": `Bearer resource_metadata="${fake.base}/.well-known/oauth-protected-resource/mcp"`,
+                      }
+                    : {},
+                );
+                return response.end();
+              }
+              const message = JSON.parse(body) as {
+                id?: number;
+                method: string;
+                params?: { arguments?: unknown };
+              };
+              if (message.id === undefined) {
+                response.writeHead(202);
+                return response.end();
+              }
+              const result =
+                message.method === "initialize"
+                  ? {
+                      protocolVersion: "2025-06-18",
+                      capabilities: { tools: {} },
+                      serverInfo: { name: "fake", version: "1" },
+                    }
+                  : message.method === "tools/list"
+                    ? { tools: [{ name: "echo", inputSchema: { type: "object" } }] }
+                    : {
+                        content: [
+                          { type: "text", text: JSON.stringify(message.params?.arguments) },
+                        ],
+                      };
+              json(response, 200, { jsonrpc: "2.0", id: message.id, result });
+            });
+          });
+          server.listen(0, "127.0.0.1", () => {
+            const address = server.address() as { port: number };
+            (fake as { base: string }).base = `http://127.0.0.1:${address.port}`;
+            resolve({ server, fake });
+          });
+        }),
+    ),
+    ({ server }) => Effect.promise(() => new Promise<void>((done) => server.close(() => done()))),
+  ).pipe(Effect.map(({ fake }) => fake));
+
+const shared = (url: string, headers: Record<string, string> = {}): SharedMcpServer => ({
+  id: "fake",
+  name: "fake",
+  url,
+  enabled: true,
+  headers,
+});
+
+describe("SharedMcpProxy", () => {
+  it.effect("signs in once with OAuth, then lists and calls tools with the stored token", () =>
+    Effect.gen(function* () {
+      const fake = yield* fakeUpstream({
+        oauth: true,
+        authorized: (request) => request.headers.authorization === "Bearer good-token",
+      });
+      const proxy = yield* SharedMcpProxy.SharedMcpProxy;
+      const server = shared(`${fake.base}/mcp`);
+
+      const before = yield* proxy.probe(server).pipe(Effect.flip);
+      assert.isTrue(before.needsSignIn, before.message);
+
+      const { authorizationUrl } = yield* proxy.startSignIn(server, "http://t3.local:3773");
+      assert.isNotNull(authorizationUrl);
+      const authorize = new URL(authorizationUrl!);
+      assert.equal(`${authorize.origin}${authorize.pathname}`, `${fake.base}/authorize`);
+      assert.equal(
+        authorize.searchParams.get("redirect_uri"),
+        "http://t3.local:3773/api/mcp-oauth/callback",
+      );
+      assert.equal(authorize.searchParams.get("code_challenge_method"), "S256");
+
+      const finished = yield* proxy.finishSignIn(authorize.searchParams.get("state")!, "the-code");
+      assert.equal(finished.server, "fake");
+      // PKCE: the token request proves it started the sign-in.
+      assert.isNotEmpty(fake.tokenRequests[0]?.get("code_verifier") ?? "");
+
+      assert.deepEqual(yield* proxy.probe(server), { serverName: "fake", toolCount: 1 });
+      const called = yield* proxy.callTool(server, { name: "echo", arguments: { q: "hi" } });
+      assert.deepEqual(called, { content: [{ type: "text", text: '{"q":"hi"}' }] });
+
+      // The callback's state is single-use.
+      const replay = yield* proxy
+        .finishSignIn(authorize.searchParams.get("state")!, "the-code")
+        .pipe(Effect.flip);
+      assert.include(replay.message, "expired");
+    }).pipe(Effect.provide(layer), Effect.scoped),
+  );
+
+  it.effect("sends a server's saved headers, and reports a refusal without asking to sign in", () =>
+    Effect.gen(function* () {
+      const fake = yield* fakeUpstream({
+        oauth: false,
+        authorized: (request) => request.headers.authorization === "Bearer k-123",
+      });
+      const proxy = yield* SharedMcpProxy.SharedMcpProxy;
+
+      assert.deepEqual(
+        yield* proxy.probe(shared(`${fake.base}/mcp`, { Authorization: "Bearer k-123" })),
+        {
+          serverName: "fake",
+          toolCount: 1,
+        },
+      );
+      // A changed header is a new connection, not the cached one.
+      const refused = yield* proxy
+        .probe(shared(`${fake.base}/mcp`, { Authorization: "Bearer wrong" }))
+        .pipe(Effect.flip);
+      // A refused token is fixed by editing the header, not by an OAuth sign-in.
+      assert.isFalse(refused.needsSignIn);
+      assert.include(refused.message, "refused the saved Authorization header");
+    }).pipe(Effect.provide(layer), Effect.scoped),
+  );
+});
diff --git a/apps/server/src/mcp/SharedMcpProxy.ts b/apps/server/src/mcp/SharedMcpProxy.ts
new file mode 100644
index 000000000000..f2554fb4eba4
--- /dev/null
+++ b/apps/server/src/mcp/SharedMcpProxy.ts
@@ -0,0 +1,400 @@
+/**
+ * SharedMcpProxy — T3 Code's own client for the user's shared MCP servers.
+ *
+ * Agents never connect to a shared server themselves: each one reaches it at
+ * `<t3-code endpoint>/shared/<key>` with its thread credential, and T3 opens
+ * the real connection with the server's saved headers and OAuth tokens, which
+ * stay in the secret store. One connection per server is kept and reused by
+ * every thread; a sign-in started from Settings completes through the OAuth
+ * callback route and is picked up by the next request.
+ *
+ * @module mcp/SharedMcpProxy
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import {
+  type OAuthClientProvider,
+  UnauthorizedError,
+} from "@modelcontextprotocol/sdk/client/auth.js";
+import { SseError, SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import {
+  StreamableHTTPClientTransport,
+  StreamableHTTPError,
+} from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import type {
+  OAuthClientInformationMixed,
+  OAuthClientMetadata,
+  OAuthTokens,
+} from "@modelcontextprotocol/sdk/shared/auth.js";
+import { type SharedMcpServer, sharedMcpServerKey } from "@t3tools/contracts";
+import * as Clock from "effect/Clock";
+import * as Context from "effect/Context";
+import * as Crypto from "effect/Crypto";
+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 { ServerSecretStore } from "../auth/ServerSecretStore.ts";
+import { sharedMcpOAuthSecretName } from "../serverSettings.ts";
+
+/** Path under T3's MCP endpoint that serves one shared server. */
+export const SHARED_MCP_PATH_SEGMENT = "shared";
+/** Route the OAuth provider redirects back to after a sign-in. */
+export const SHARED_MCP_OAUTH_CALLBACK_PATH = "/api/mcp-oauth/callback";
+
+/** Long enough for slow tools; progress notifications keep extending it. */
+const TOOL_CALL_TIMEOUT_MS = 10 * 60_000;
+/** A sign-in the user never finishes is dropped after this long. */
+const PENDING_SIGN_IN_TTL_MS = 15 * 60_000;
+
+export class SharedMcpProxyError extends Schema.TaggedError<SharedMcpProxyError>()(
+  "SharedMcpProxyError",
+  {
+    server: Schema.String,
+    message: Schema.String,
+    /** The server needs a sign-in from Settings before it can be used. */
+    needsSignIn: Schema.Boolean,
+  },
+) {}
+
+/** OAuth state kept per server: the registered client, its tokens, and the in-flight PKCE verifier. */
+const StoredOAuth = Schema.Struct({
+  redirectUrl: Schema.optionalKey(Schema.String),
+  clientInformation: Schema.optionalKey(Schema.Unknown),
+  tokens: Schema.optionalKey(Schema.Unknown),
+  codeVerifier: Schema.optionalKey(Schema.String),
+});
+type StoredOAuth = typeof StoredOAuth.Type;
+const decodeStoredOAuth = Schema.decodeUnknownOption(Schema.fromJsonString(StoredOAuth));
+const encodeStoredOAuth = Schema.encodeSync(Schema.fromJsonString(StoredOAuth));
+
+/** The server refused us for want of a login, whether or not an OAuth flow ran. */
+const isUnauthorized = (cause: unknown) =>
+  cause instanceof UnauthorizedError ||
+  ((cause instanceof StreamableHTTPError || cause instanceof SseError) && cause.code === 401);
+
+export class SharedMcpProxy extends Context.Service<
+  SharedMcpProxy,
+  {
+    /** Upstream tool list, as the agent's `tools/list` would see it. */
+    readonly listTools: (
+      server: SharedMcpServer,
+      params: unknown,
+    ) => Effect.Effect<unknown, SharedMcpProxyError>;
+    /** Forward one tool call; the result is passed back unchanged. */
+    readonly callTool: (
+      server: SharedMcpServer,
+      params: unknown,
+    ) => Effect.Effect<unknown, SharedMcpProxyError>;
+    /** Connect and count tools, for Settings' Test connection. */
+    readonly probe: (
+      server: SharedMcpServer,
+    ) => Effect.Effect<
+      { readonly serverName: string | null; readonly toolCount: number },
+      SharedMcpProxyError
+    >;
+    /**
+     * Start an OAuth sign-in, redirecting back to `redirectBaseUrl`. Returns the
+     * URL to open, or null when the server needs no sign-in.
+     */
+    readonly startSignIn: (
+      server: SharedMcpServer,
+      redirectBaseUrl: string,
+    ) => Effect.Effect<{ readonly authorizationUrl: string | null }, SharedMcpProxyError>;
+    /** Complete a sign-in from the provider's callback. */
+    readonly finishSignIn: (
+      state: string,
+      code: string,
+    ) => Effect.Effect<{ readonly server: string }, SharedMcpProxyError>;
+  }
+>()("t3/mcp/SharedMcpProxy") {}
+
+/**
+ * The SDK's transports declare optional fields without `| undefined`, which
+ * this repo's `exactOptionalPropertyTypes` rejects; they are the SDK's own
+ * types on both sides, so the cast is sound.
+ */
+const asTransport = (transport: StreamableHTTPClientTransport | SSEClientTransport) =>
+  transport as unknown as Parameters<Client["connect"]>[0];
+
+type Upstream = { readonly fingerprint: string; readonly client: Promise<Client> };
+type PendingSignIn = {
+  readonly server: SharedMcpServer;
+  readonly transport: StreamableHTTPClientTransport;
+  readonly expiresAt: number;
+};
+
+const make = Effect.gen(function* () {
+  const secretStore = yield* ServerSecretStore;
+  const crypto = yield* Crypto.Crypto;
+  const context = yield* Effect.context<never>();
+  const run = Effect.runPromiseWith(context);
+  const textEncoder = new TextEncoder();
+  const textDecoder = new TextDecoder();
+
+  const loadOAuth = (key: string) =>
+    secretStore.get(sharedMcpOAuthSecretName(key)).pipe(
+      Effect.map((secret) =>
+        Option.isSome(secret)
+          ? Option.getOrElse(
+              decodeStoredOAuth(textDecoder.decode(secret.value)),
+              (): StoredOAuth => ({}),
+            )
+          : ({} satisfies StoredOAuth),
+      ),
+      Effect.orElseSucceed((): StoredOAuth => ({})),
+    );
+  const saveOAuth = (key: string, stored: StoredOAuth) =>
+    secretStore
+      .set(sharedMcpOAuthSecretName(key), textEncoder.encode(encodeStoredOAuth(stored)))
+      .pipe(Effect.ignore({ log: true }));
+  const newState = crypto.randomUUIDv4.pipe(Effect.orDie);
+
+  /**
+   * The SDK's view of a server's OAuth state, written through to the secret
+   * store. `interactive` providers record the authorization URL for a sign-in;
+   * the others leave a missing or expired login as "needs sign-in".
+   */
+  const makeProvider = (
+    key: string,
+    initial: StoredOAuth,
+    interactive: boolean,
+  ): OAuthClientProvider & {
+    readonly authorizationUrl: () => URL | undefined;
+    readonly lastState: () => string | undefined;
+  } => {
+    let stored = initial;
+    let authorizationUrl: URL | undefined;
+    let lastState: string | undefined;
+    const update = (patch: Partial<StoredOAuth>) => {
+      stored = { ...stored, ...patch };
+      return run(saveOAuth(key, stored));
+    };
+    return {
+      get redirectUrl() {
+        return stored.redirectUrl;
+      },
+      get clientMetadata(): OAuthClientMetadata {
+        return {
+          client_name: "T3 Code",
+          redirect_uris: stored.redirectUrl === undefined ? [] : [stored.redirectUrl],
+          grant_types: ["authorization_code", "refresh_token"],
+          response_types: ["code"],
+          token_endpoint_auth_method: "none",
+        };
+      },
+      state: async () => {
+        lastState = await run(newState);
+        return lastState;
+      },
+      clientInformation: () => stored.clientInformation as OAuthClientInformationMixed | undefined,
+      saveClientInformation: (clientInformation) => update({ clientInformation }),
+      tokens: () => stored.tokens as OAuthTokens | undefined,
+      saveTokens: (tokens) => update({ tokens }),
+      redirectToAuthorization: (url) => {
+        if (interactive) authorizationUrl = url;
+      },
+      saveCodeVerifier: (codeVerifier) => update({ codeVerifier }),
+      codeVerifier: () => {
+        if (stored.codeVerifier === undefined) throw new Error("No sign-in is in progress.");
+        return stored.codeVerifier;
+      },
+      authorizationUrl: () => authorizationUrl,
+      lastState: () => lastState,
+    };
+  };
+
+  const fail = (server: SharedMcpServer, cause: unknown) => {
+    // With a saved `Authorization` header, a 401 means that token was
+    // refused, and signing in with OAuth would not replace it.
+    const tokenRefused =
+      isUnauthorized(cause) &&
+      Object.keys(server.headers).some((name) => name.toLowerCase() === "authorization");
+    return new SharedMcpProxyError({
+      server: server.name,
+      needsSignIn: isUnauthorized(cause) && !tokenRefused,
+      message: tokenRefused
+        ? `${server.name} refused the saved Authorization header. Update it in Settings → Integrations → Shared MCP servers.`
+        : isUnauthorized(cause)
+          ? `Sign in to ${server.name} in T3 Code (Settings → Integrations → Shared MCP servers).`
+          : `Could not reach ${server.name}: ${cause instanceof Error ? cause.message : String(cause)}`,
+    });
+  };
+
+  const connect = async (server: SharedMcpServer): Promise<Client> => {
+    const key = sharedMcpServerKey(server);
+    const stored = await run(loadOAuth(key));
+    const url = new URL(server.url);
+    // Without tokens there is nothing to refresh, and a 401 means "sign in";
+    // the SDK would otherwise try a token request with no code.
+    const options = () => ({
+      requestInit: { headers: { ...server.headers } },
+      ...(stored.tokens === undefined ? {} : { authProvider: makeProvider(key, stored, false) }),
+    });
+    const client = new Client({ name: "T3 Code", version: "1.0.0" });
+    try {
+      await client.connect(asTransport(new StreamableHTTPClientTransport(url, options())));
+      return client;
+    } catch (error) {
+      // A server that predates streamable HTTP still speaks the SSE transport.
+      if (isUnauthorized(error)) throw error;
+      const fallback = new Client({ name: "T3 Code", version: "1.0.0" });
+      try {
+        await fallback.connect(asTransport(new SSEClientTransport(url, options())));
+        return fallback;
+      } catch {
+        throw error;
+      }
+    }
+  };
+
+  const upstreams = new Map<string, Upstream>();
+  const fingerprintOf = (server: SharedMcpServer) =>
+    `${server.url}\n${Object.entries(server.headers)
+      .map(([name, value]) => `${name.toLowerCase()}:${value}`)
+      .toSorted()
+      .join("\n")}`;
+  const clientFor = (server: SharedMcpServer): Promise<Client> => {
+    const key = sharedMcpServerKey(server);
+    const fingerprint = fingerprintOf(server);
+    const existing = upstreams.get(key);
+    if (existing !== undefined && existing.fingerprint === fingerprint) return existing.client;
+    if (existing !== undefined)
+      void existing.client.then((client) => client.close()).catch(() => {});
+    const client = connect(server);
+    upstreams.set(key, { fingerprint, client });
+    // A failed connect is retried on the next request rather than cached.
+    client.catch(() => {
+      if (upstreams.get(key)?.client === client) upstreams.delete(key);
+    });
+    return client;
+  };
+  const dropClient = (key: string) => {
+    const existing = upstreams.get(key);
+    upstreams.delete(key);
+    if (existing !== undefined)
+      void existing.client.then((client) => client.close()).catch(() => {});
+  };
+  yield* Effect.addFinalizer(() =>
+    Effect.sync(() => {
+      for (const key of upstreams.keys()) dropClient(key);
+    }),
+  );
+
+  /** Runs `use` on the server's connection, reconnecting once if it went stale. */
+  const withClient = <A>(server: SharedMcpServer, use: (client: Client) => Promise<A>) =>
+    Effect.tryPromise({
+      try: async () => {
+        try {
+          return await use(await clientFor(server));
+        } catch (error) {
+          if (isUnauthorized(error)) throw error;
+          dropClient(sharedMcpServerKey(server));
+          return await use(await clientFor(server));
+        }
+      },
+      catch: (cause) => fail(server, cause),
+    });
+
+  const pending = new Map<string, PendingSignIn>();
+  const prunePending = (now: number) => {
+    for (const [state, entry] of pending) if (entry.expiresAt <= now) pending.delete(state);
+  };
+
+  const startSignIn = Effect.fn("SharedMcpProxy.startSignIn")(function* (
+    server: SharedMcpServer,
+    redirectBaseUrl: string,
+  ) {
+    const key = sharedMcpServerKey(server);
+    const redirectUrl = new URL(SHARED_MCP_OAUTH_CALLBACK_PATH, redirectBaseUrl).toString();
+    const stored: StoredOAuth = yield* loadOAuth(key);
+    // A client registered for another origin can't receive this redirect.
+    const { clientInformation: _client, codeVerifier: _verifier, ...kept } = stored;
+    const next: StoredOAuth =
+      stored.redirectUrl === redirectUrl ? stored : { ...kept, redirectUrl };
+    yield* saveOAuth(key, next);
+    const provider = makeProvider(key, next, true);
+    const transport = new StreamableHTTPClientTransport(new URL(server.url), {
+      requestInit: { headers: { ...server.headers } },
+      authProvider: provider,
+    });
+    const client = new Client({ name: "T3 Code", version: "1.0.0" });
+    // An unauthorized connect is the expected path: the provider has just
+    // recorded where to send the user.
+    const connected = yield* Effect.tryPromise({
+      try: () =>
+        client.connect(asTransport(transport)).then(
+          () => true,
+          (cause: unknown) => {
+            if (isUnauthorized(cause)) return false;
+            throw cause;
+          },
+        ),
+      catch: (cause) => fail(server, cause),
+    });
+    if (connected) {
+      // Already signed in (or no sign-in needed): use this connection.
+      dropClient(key);
+      upstreams.set(key, { fingerprint: fingerprintOf(server), client: Promise.resolve(client) });
+      return { authorizationUrl: null };
+    }
+    const authorizationUrl = provider.authorizationUrl();
+    const state = provider.lastState();
+    if (authorizationUrl === undefined || state === undefined) {
+      return yield* new SharedMcpProxyError({
+        server: server.name,
+        needsSignIn: true,
+        message: `${server.name} asked for a sign-in T3 Code could not start.`,
+      });
+    }
+    const now = yield* Clock.currentTimeMillis;
+    prunePending(now);
+    pending.set(state, { server, transport, expiresAt: now + PENDING_SIGN_IN_TTL_MS });
+    return { authorizationUrl: authorizationUrl.toString() };
+  });
+
+  const finishSignIn = Effect.fn("SharedMcpProxy.finishSignIn")(function* (
+    state: string,
+    code: string,
+  ) {
+    const entry = pending.get(state);
+    pending.delete(state);
+    if (entry === undefined || entry.expiresAt <= (yield* Clock.currentTimeMillis)) {
+      return yield* new SharedMcpProxyError({
+        server: "",
+        needsSignIn: true,
+        message: "This sign-in link has expired. Start it again from T3 Code.",
+      });
+    }
+    yield* Effect.tryPromise({
+      try: () => entry.transport.finishAuth(code),
+      catch: (cause) => fail(entry.server, cause),
+    });
+    // The next request connects with the new tokens.
+    dropClient(sharedMcpServerKey(entry.server));
+    return { server: entry.server.name };
+  });
+
+  return SharedMcpProxy.of({
+    listTools: (server, params) =>
+      withClient(server, (client) =>
+        client.listTools(params as Parameters<Client["listTools"]>[0]),
+      ),
+    callTool: (server, params) =>
+      withClient(server, (client) =>
+        client.callTool(params as Parameters<Client["callTool"]>[0], undefined, {
+          timeout: TOOL_CALL_TIMEOUT_MS,
+          resetTimeoutOnProgress: true,
+        }),
+      ),
+    probe: (server) =>
+      withClient(server, async (client) => ({
+        serverName: client.getServerVersion()?.name ?? null,
+        toolCount: (await client.listTools()).tools.length,
+      })),
+    startSignIn,
+    finishSignIn,
+  });
+});
+
+export const layer = Layer.effect(SharedMcpProxy, make);
diff --git a/apps/server/src/mcp/SharedMcpServerProbe.test.ts b/apps/server/src/mcp/SharedMcpServerProbe.test.ts
new file mode 100644
index 000000000000..98af97126ca5
--- /dev/null
+++ b/apps/server/src/mcp/SharedMcpServerProbe.test.ts
@@ -0,0 +1,54 @@
+import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
+import { assert, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+
+import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
+import * as ServerSettings from "../serverSettings.ts";
+import * as SharedMcpProxy from "./SharedMcpProxy.ts";
+import * as SharedMcpServerProbe from "./SharedMcpServerProbe.ts";
+
+const layerEmptySecretStore = Layer.succeed(
+  ServerSecretStore.ServerSecretStore,
+  ServerSecretStore.ServerSecretStore.of({
+    get: () => Effect.succeed(Option.none()),
+    set: () => Effect.void,
+    create: () => Effect.void,
+    getOrCreateRandom: () => Effect.die("unused"),
+    remove: () => Effect.void,
+  }),
+);
+
+const layer = SharedMcpServerProbe.layer.pipe(
+  Layer.provide(
+    SharedMcpProxy.layer.pipe(
+      Layer.provide(Layer.mergeAll(layerEmptySecretStore, NodeCrypto.layer)),
+    ),
+  ),
+  Layer.provide(
+    ServerSettings.layerTest({
+      sharedMcpServers: [
+        // Port 9 (discard) refuses connections, so the probe fails fast.
+        { name: "offline", url: "http://127.0.0.1:9/mcp", enabled: true, headers: {} },
+      ],
+    }).pipe(Layer.orDie),
+  ),
+);
+
+it.effect("reports a server that is no longer saved", () =>
+  Effect.gen(function* () {
+    const probe = yield* SharedMcpServerProbe.SharedMcpServerProbe;
+    const error = yield* probe.test({ name: "missing" }).pipe(Effect.flip);
+    assert.equal(error.message, "This server is no longer saved.");
+  }).pipe(Effect.provide(layer)),
+);
+
+it.effect("turns an unreachable server into a readable test failure", () =>
+  Effect.gen(function* () {
+    const probe = yield* SharedMcpServerProbe.SharedMcpServerProbe;
+    const error = yield* probe.test({ name: "offline" }).pipe(Effect.flip);
+    assert.equal(error._tag, "SharedMcpServerTestError");
+    assert.equal(error.server, "offline");
+  }).pipe(Effect.provide(layer)),
+);
diff --git a/apps/server/src/mcp/SharedMcpServerProbe.ts b/apps/server/src/mcp/SharedMcpServerProbe.ts
new file mode 100644
index 000000000000..e899f91d8bd7
--- /dev/null
+++ b/apps/server/src/mcp/SharedMcpServerProbe.ts
@@ -0,0 +1,80 @@
+/**
+ * SharedMcpServerProbe — Settings' view of a saved shared MCP server: check
+ * that it answers through T3's proxy, and start its OAuth sign-in.
+ *
+ * @module mcp/SharedMcpServerProbe
+ */
+import {
+  type SharedMcpServer,
+  type SharedMcpServerSignInResult,
+  SharedMcpServerTestError,
+  type SharedMcpServerTestResult,
+} from "@t3tools/contracts";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import { ServerSettingsService } from "../serverSettings.ts";
+import { SharedMcpProxy, type SharedMcpProxyError } from "./SharedMcpProxy.ts";
+
+const PROBE_TIMEOUT = "10 seconds";
+
+export class SharedMcpServerProbe extends Context.Service<
+  SharedMcpServerProbe,
+  {
+    /** Connect to the named saved server through the proxy and count its tools. */
+    readonly test: (input: {
+      readonly name: string;
+    }) => Effect.Effect<SharedMcpServerTestResult, SharedMcpServerTestError>;
+    /** Start the named server's OAuth sign-in, redirecting back to `redirectBaseUrl`. */
+    readonly signIn: (input: {
+      readonly name: string;
+      readonly redirectBaseUrl: string;
+    }) => Effect.Effect<SharedMcpServerSignInResult, SharedMcpServerTestError>;
+  }
+>()("t3/mcp/SharedMcpServerProbe") {}
+
+const make = Effect.gen(function* () {
+  const settingsService = yield* ServerSettingsService;
+  const proxy = yield* SharedMcpProxy;
+
+  const fail = (server: string, message: string, needsSignIn = false) =>
+    Effect.fail(new SharedMcpServerTestError({ server, message, needsSignIn }));
+  const fromProxy = (error: SharedMcpProxyError) =>
+    fail(error.server, error.message, error.needsSignIn);
+  const saved = (name: string) =>
+    Effect.gen(function* () {
+      const settings = yield* settingsService.getSettings.pipe(
+        Effect.catch(() => fail(name, "Could not read settings.")),
+      );
+      const server: SharedMcpServer | undefined = settings.sharedMcpServers.find(
+        (entry) => entry.name === name,
+      );
+      return server ?? (yield* fail(name, "This server is no longer saved."));
+    });
+
+  const test = Effect.fn("SharedMcpServerProbe.test")(function* (input: { readonly name: string }) {
+    const server = yield* saved(input.name);
+    return yield* proxy.probe(server).pipe(
+      Effect.timeoutOrElse({
+        duration: PROBE_TIMEOUT,
+        orElse: () => fail(input.name, "The server did not answer within 10 seconds."),
+      }),
+      Effect.catchTags({ SharedMcpProxyError: fromProxy }),
+    );
+  });
+
+  const signIn = Effect.fn("SharedMcpServerProbe.signIn")(function* (input: {
+    readonly name: string;
+    readonly redirectBaseUrl: string;
+  }) {
+    const server = yield* saved(input.name);
+    return yield* proxy
+      .startSignIn(server, input.redirectBaseUrl)
+      .pipe(Effect.catchTags({ SharedMcpProxyError: fromProxy }));
+  });
+
+  return SharedMcpServerProbe.of({ test, signIn });
+});
+
+export const layer = Layer.effect(SharedMcpServerProbe, make);
diff --git a/apps/server/src/observability/RpcInstrumentation.ts b/apps/server/src/observability/RpcInstrumentation.ts
index 69b8b3d325ab..0d59a23015f6 100644
--- a/apps/server/src/observability/RpcInstrumentation.ts
+++ b/apps/server/src/observability/RpcInstrumentation.ts
@@ -59,6 +59,8 @@ const RPC_AGGREGATES = {
   [WS_METHODS.serverGetStorageCleanupReport]: "server",
   [WS_METHODS.serverGetSettings]: "server",
   [WS_METHODS.serverUpdateSettings]: "server",
+  [WS_METHODS.serverTestSharedMcpServer]: "server",
+  [WS_METHODS.serverSignInSharedMcpServer]: "server",
   [WS_METHODS.serverSearchAcpRegistry]: "server",
   [WS_METHODS.serverPrepareAcpRegistryAgent]: "server",
   [WS_METHODS.serverUninstallAcpRegistryManagedBinary]: "server",
diff --git a/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts
index cfde3367a593..6296afdd022d 100644
--- a/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts
@@ -2503,6 +2503,13 @@ describe("AcpAdapterV2", () => {
         endpoint: "http://127.0.0.1:43123/mcp",
         authorizationHeader: "Bearer target-thread-token",
         browserToolsAvailable: true,
+        sharedServers: [
+          {
+            name: "docs",
+            url: "http://127.0.0.1:43123/mcp/shared/docs",
+            headers: { Authorization: "Bearer target-thread-token" },
+          },
+        ],
       });
       const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
         runtimeMode: "full-access",
@@ -2554,6 +2561,21 @@ describe("AcpAdapterV2", () => {
         sessionId: "mock-session-1",
         cwd: process.cwd(),
         mcpServers: [
+          // A shared server is a T3 endpoint, reached through the same bridge.
+          {
+            type: "stdio",
+            name: "docs",
+            command: process.execPath,
+            args: [
+              process.argv[1] === undefined ? "t3" : NodePath.resolve(process.argv[1]),
+              "acp-mcp-bridge",
+            ],
+            env: [
+              { name: "ELECTRON_RUN_AS_NODE", value: "1" },
+              { name: "T3_ACP_MCP_ENDPOINT", value: "http://127.0.0.1:43123/mcp/shared/docs" },
+              { name: "T3_ACP_MCP_AUTHORIZATION", value: "Bearer target-thread-token" },
+            ],
+          },
           {
             type: "stdio",
             name: "t3-code",
diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
index 7652b5636926..e3fe5beff65d 100644
--- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
@@ -580,6 +580,34 @@ describe("ClaudeAdapterV2 MCP query overrides", () => {
     });
   });
 
+  it("attaches shared MCP servers next to t3-code without pre-approving them", () => {
+    const threadId = ThreadId.make("thread-claude-shared-mcp");
+    const overrides = ClaudeAdapterV2.claudeMcpQueryOverrides({
+      mcpSession: {
+        ...mcpSessionFor(threadId),
+        sharedServers: [
+          {
+            name: "gateway",
+            url: "http://127.0.0.1:3050/mcp",
+            headers: { Authorization: "Bearer gateway-token" },
+          },
+        ],
+      },
+      readOnlySandbox: false,
+    });
+    assert.deepEqual(overrides, {
+      allowedTools: [ClaudeAdapterV2.CLAUDE_T3_MCP_TOOL_WILDCARD],
+      mcpServers: {
+        gateway: {
+          type: "http",
+          url: "http://127.0.0.1:3050/mcp",
+          headers: { Authorization: "Bearer gateway-token" },
+        },
+        ...T3_MCP_SERVERS,
+      },
+    });
+  });
+
   it("extends an explicit allowlist with the t3-code wildcard", () => {
     const threadId = ThreadId.make("thread-claude-mcp-with-allowlist");
     const mcpSession = mcpSessionFor(threadId);
diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
index 80eb47436534..54bada0a9477 100644
--- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
+++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts
@@ -1128,6 +1128,16 @@ export function claudeMcpQueryOverrides(input: {
   return {
     allowedTools: Array.from(new Set([...(input.allowedTools ?? []), ...mcpAllowedTools])),
     mcpServers: {
+      ...Object.fromEntries(
+        (session.sharedServers ?? []).map((server) => [
+          server.name,
+          {
+            type: "http" as const,
+            url: server.url,
+            ...(Object.keys(server.headers).length === 0 ? {} : { headers: server.headers }),
+          },
+        ]),
+      ),
       "t3-code": {
         type: "http",
         url: session.endpoint,
diff --git a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts
index 9a1c8f6c900f..79a19e80be91 100644
--- a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts
@@ -677,6 +677,36 @@ describe("CodexAdapterV2 process spawning", () => {
     );
   });
 
+  it("adds shared MCP servers to the thread's MCP table", () => {
+    const threadId = ThreadId.make("thread-codex-shared-mcp");
+    const mcpSession = {
+      environmentId: EnvironmentId.make("environment-codex-shared-mcp"),
+      threadId,
+      providerSessionId: "mcp-session-codex-shared",
+      providerInstanceId: ProviderInstanceId.make("codex"),
+      endpoint: "http://127.0.0.1:43123/mcp",
+      authorizationHeader: "Bearer secret-codex-token",
+      browserToolsAvailable: true,
+      sharedServers: [
+        {
+          name: "gateway",
+          url: "http://127.0.0.1:3050/mcp",
+          headers: { Authorization: "Bearer gateway-token" },
+        },
+      ],
+    };
+    assert.deepEqual(CodexAdapterV2.codexThreadRuntimeParams({ mcpSession }).config.mcp_servers, {
+      gateway: {
+        url: "http://127.0.0.1:3050/mcp",
+        http_headers: { Authorization: "Bearer gateway-token" },
+      },
+      "t3-code": {
+        url: "http://127.0.0.1:43123/mcp",
+        http_headers: { Authorization: "Bearer secret-codex-token" },
+      },
+    });
+  });
+
   it.effect("resolves Windows command shims through the shared spawn policy", () =>
     Effect.gen(function* () {
       const command = yield* CodexAdapterV2.makeCodexAppServerSpawnCommand({
diff --git a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts
index 38e64af02e12..f21c7513cf73 100644
--- a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts
+++ b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts
@@ -1316,6 +1316,17 @@ export function codexThreadRuntimeParams(input: {
         ? {}
         : {
             mcp_servers: {
+              ...Object.fromEntries(
+                (mcpSession.sharedServers ?? []).map((server) => [
+                  server.name,
+                  {
+                    url: server.url,
+                    ...(Object.keys(server.headers).length === 0
+                      ? {}
+                      : { http_headers: server.headers }),
+                  },
+                ]),
+              ),
               "t3-code": {
                 url: mcpSession.endpoint,
                 http_headers: {
diff --git a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts
index 548ff5cb6643..33468ec8740c 100644
--- a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts
+++ b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts
@@ -45,6 +45,7 @@ import * as ProviderContinuationRequests from "@t3tools/provider-core/server/Pro
 import {
   OPENCODE_2_STILL_STOPPING,
   OPENCODE_PROVIDER,
+  sharedMcpServerPrefix,
   t3McpServerName,
 } from "@t3tools/provider-opencode/testing";
 import { openCode2ReplayRuntime } from "./OpenCode2AdapterV2.testkit.ts";
@@ -88,7 +89,16 @@ const mcpRules = [
   { action: "t3-code-*", resource: "*", effect: "deny" },
   { action: "t3-code-thread_opencode2-adapter_*", resource: "*", effect: "allow" },
 ];
-const t3Rules = [{ action: "*", resource: "*", effect: "allow" }, ...mcpRules];
+/** Other threads' shared MCP servers are denied; this thread's run under the mode. */
+const sharedRules = (effect: "allow" | "ask", thread = "thread_opencode2-adapter") => [
+  { action: "t3-shared-*", resource: "*", effect: "deny" },
+  { action: `t3-shared-${thread}_*`, resource: "*", effect },
+];
+const t3Rules = [
+  { action: "*", resource: "*", effect: "allow" },
+  ...sharedRules("allow"),
+  ...mcpRules,
+];
 /** The thread's title, which the recorded session already carries. */
 const TITLE = "Prime check";
 const sessionInfo = (overrides: Record<string, unknown> = {}) => ({
@@ -167,8 +177,8 @@ const withInstructions = (
         "skill.list",
       ].includes(String(entry.frame.type)),
   );
-  // T3's MCP server is added before the entry that describes it.
-  const after = entries.findIndex(
+  // T3's MCP servers are added before the entry that describes them.
+  const after = entries.findLastIndex(
     (entry, index) =>
       index < first &&
       entry.type === "emit_inbound" &&
@@ -287,6 +297,7 @@ const supervisedRules = [
   { action: "shell", resource: "*", effect: "ask" },
   { action: "edit", resource: "*", effect: "ask" },
   { action: "external_directory", resource: "*", effect: "ask" },
+  ...sharedRules("ask"),
   ...buildPaths,
   ...mcpRules,
 ];
@@ -908,7 +919,7 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
         // A subagent's session may use its thread's T3 MCP server.
         out("session.update", {
           sessionID: CHILD,
-          permissions: [...supervisedRules.slice(0, 3), ...mcpRules],
+          permissions: [...supervisedRules.slice(0, 5), ...mcpRules],
         }),
         reply("session.update", null),
         out("session.prompt", { sessionID: SESSION, text: "<any>" }),
@@ -2654,7 +2665,7 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
           out("session.update", {
             sessionID: CHILD,
             permissions: [
-              ...supervisedRules.slice(0, 3),
+              ...supervisedRules.slice(0, 5),
               { action: "shell", resource: "echo *", effect: "allow" },
               // A subagent's session may use its thread's T3 MCP server.
               ...mcpRules,
@@ -2832,7 +2843,7 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
         // The subagent gets them too before its execution runs anything.
         out("session.update", {
           sessionID: CHILD,
-          permissions: [...supervisedRules.slice(0, 3), ...mcpRules],
+          permissions: [...supervisedRules.slice(0, 5), ...mcpRules],
         }),
         reply("session.update", null),
         event("session.execution.started", { sessionID: CHILD }),
@@ -2892,9 +2903,9 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
           out("session.update", {
             sessionID: SESSION,
             permissions: [
-              ...supervisedRules.slice(0, 3),
+              ...supervisedRules.slice(0, 5),
               { action: "shell", resource: "echo *", effect: "allow" },
-              ...supervisedRules.slice(3),
+              ...supervisedRules.slice(5),
             ],
           }),
           reply("session.update", null),
@@ -3442,6 +3453,105 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
       }).pipe(Effect.scoped),
   );
 
+  it.effect(
+    "adds the thread's shared MCP servers next to T3's, retries a refused one, and removes them with it",
+    () =>
+      Effect.gen(function* () {
+        const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
+        yield* mcpSessions.set({
+          environmentId: EnvironmentId.make("environment:opencode2-adapter"),
+          threadId,
+          providerSessionId: "mcp:opencode2-adapter",
+          providerInstanceId: instanceId,
+          endpoint: "http://127.0.0.1:3773/mcp",
+          authorizationHeader: "Bearer thread-credential",
+          browserToolsAvailable: false,
+          sharedServers: [
+            {
+              name: "gateway",
+              url: "http://127.0.0.1:3050/mcp",
+              headers: { Authorization: "Bearer gateway-token" },
+            },
+            { name: "broken", url: "http://127.0.0.1:1/mcp", headers: {} },
+          ],
+        });
+        yield* Effect.addFinalizer(() => mcpSessions.clear(threadId));
+        const server = "t3-code-thread_opencode2-adapter";
+        const gateway = "t3-shared-thread_opencode2-adapter_gateway";
+        const broken = "t3-shared-thread_opencode2-adapter_broken";
+        const { runtime, thread } = yield* resumed([
+          out("mcp.add", { server, "location[directory]": WORK, config: "<any>" }),
+          reply("mcp.add", null),
+          out("mcp.add", {
+            server: gateway,
+            "location[directory]": WORK,
+            config: {
+              type: "remote",
+              url: "http://127.0.0.1:3050/mcp",
+              headers: { Authorization: "Bearer gateway-token" },
+              oauth: false,
+            },
+          }),
+          reply("mcp.add", null),
+          // A shared server OpenCode refuses is skipped; the turn still runs.
+          out("mcp.add", {
+            server: broken,
+            "location[directory]": WORK,
+            config: { type: "remote", url: "http://127.0.0.1:1/mcp", oauth: false },
+          }),
+          reply("mcp.add", { status: 500, body: { _tag: "UnknownError", message: "add failed" } }),
+          out("session.prompt", { sessionID: SESSION, text: "<any>" }),
+          promptAccepted,
+          event("session.execution.succeeded", { sessionID: SESSION }),
+          // The next turn retries the one OpenCode refused, as it would T3's own.
+          out("mcp.add", {
+            server: broken,
+            "location[directory]": WORK,
+            config: { type: "remote", url: "http://127.0.0.1:1/mcp", oauth: false },
+          }),
+          reply("mcp.add", null),
+          out("session.prompt", { sessionID: SESSION, text: "<any>" }),
+          promptAccepted,
+          event("session.execution.succeeded", { sessionID: SESSION }),
+          out("mcp.remove", { server, "location[directory]": WORK }),
+          reply("mcp.remove", null),
+          out("mcp.remove", { server: gateway, "location[directory]": WORK }),
+          reply("mcp.remove", null),
+          out("mcp.remove", { server: broken, "location[directory]": WORK }),
+          reply("mcp.remove", null),
+        ]);
+        const firstEnded = yield* Deferred.make<void>();
+        const ended = yield* runtime.events.pipe(
+          Stream.filter(
+            (
+              event,
+            ): event is Extract<
+              ProviderAdapter.ProviderAdapterV2Event,
+              { type: "turn.terminal" }
+            > => event.type === "turn.terminal",
+          ),
+          Stream.tap(() => Deferred.succeed(firstEnded, undefined)),
+          Stream.take(2),
+          Stream.runCollect,
+          Effect.forkScoped,
+        );
+        yield* runtime.startTurn(turnInput(thread));
+        yield* Deferred.await(firstEnded);
+        yield* runtime.startTurn({
+          ...turnInput(thread),
+          runId: RunId.make("run:opencode2-adapter:2"),
+          runOrdinal: 2,
+          providerTurnOrdinal: 2,
+          attemptId: RunAttemptId.make("attempt:opencode2-adapter:2"),
+        });
+        assert.deepEqual(
+          [...(yield* Fiber.join(ended))].map((terminal) => terminal.status),
+          ["completed", "completed"],
+        );
+        yield* runtime.unloadThread!({ providerThread: thread });
+      }).pipe(Effect.scoped),
+  );
+
   it.effect("registers a long thread id's MCP server under a name OpenCode accepts", () =>
     Effect.gen(function* () {
       // Spelled out, this delegated thread's server name would be 120 characters.
@@ -3469,6 +3579,8 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
           sessionInfo({
             permissions: [
               { action: "*", resource: "*", effect: "allow" },
+              // Shared servers' prefix is shortened the same way as T3's name.
+              ...sharedRules("allow", "aa73fa1e03099934"),
               { action: "t3-code-*", resource: "*", effect: "deny" },
               { action: `${server}_*`, resource: "*", effect: "allow" },
             ],
@@ -3522,6 +3634,12 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
       assert.equal(names[0], "t3-code-63abb5df2b188bdd");
       // A name that already fits stays readable.
       assert.equal(yield* t3McpServerName(threadId), "t3-code-thread_opencode2-adapter");
+      // Shared servers' names fit too, with the longest allowed server name.
+      for (const id of ids) {
+        const name = `${yield* sharedMcpServerPrefix(id)}_${"x".repeat(24)}`;
+        assert.isAtMost(name.length, 64);
+        assert.match(name, /^t3-shared-[A-Za-z0-9_-]+$/);
+      }
     }).pipe(Effect.provide(NodeCrypto.layer)),
   );
 
@@ -4418,6 +4536,7 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
           sessionID: FORK,
           permissions: [
             { action: "*", resource: "*", effect: "allow" },
+            ...sharedRules("allow", "thread_opencode2-adapter_fork"),
             { action: "t3-code-*", resource: "*", effect: "deny" },
             { action: "t3-code-thread_opencode2-adapter_fork_*", resource: "*", effect: "allow" },
           ],
diff --git a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts
index ceb230b00894..3acd8191e12d 100644
--- a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts
+++ b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts
@@ -1913,6 +1913,64 @@ it.effect(
     }),
 );
 
+it.effect(
+  "ProviderSessionManagerV2 hands the user's enabled shared MCP servers to the session",
+  () =>
+    Effect.gen(function* () {
+      const state = yield* Ref.make(emptyState);
+      const mcpConfigs = yield* Ref.make<
+        ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
+      >([]);
+      const gateway = {
+        name: "gateway",
+        url: "http://127.0.0.1:3050/mcp",
+        enabled: true,
+        headers: {},
+      };
+      const sharedMcpServers = [gateway, { ...gateway, name: "paused", enabled: false }];
+      const effect = Effect.gen(function* () {
+        const eventSink = yield* EventSink.EventSinkV2;
+        const idAllocator = yield* IdAllocator.IdAllocatorV2;
+        const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
+        const now = yield* DateTime.now;
+        const threadId = ThreadId.make("thread-provider-session-manager-shared-mcp");
+        const providerSessionId = yield* idAllocator.allocate.providerSession({
+          providerInstanceId: modelSelection.instanceId,
+          threadId,
+        });
+
+        yield* eventSink.write({
+          events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
+        });
+        yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
+
+        // Switched-off servers stay out of the session, and agents reach the
+        // others through T3's proxy with the thread's own credential.
+        const config = (yield* Ref.get(mcpConfigs))[0];
+        assert.isDefined(config);
+        assert.deepEqual(config.sharedServers, [
+          {
+            name: "gateway",
+            url: `${config.endpoint}/shared/gateway`,
+            headers: { Authorization: config.authorizationHeader },
+          },
+        ]);
+        yield* manager.close(providerSessionId);
+      });
+
+      yield* effect.pipe(
+        Effect.provide(
+          layerTest({
+            state,
+            idleTimeoutMs: 1_000,
+            mcpConfigs,
+            serverSettingsLayer: ServerSettings.layerTest({ sharedMcpServers }).pipe(Layer.orDie),
+          }),
+        ),
+      );
+    }),
+);
+
 it.effect("ProviderSessionManagerV2 honors a project browser-access opt-out", () =>
   Effect.gen(function* () {
     const captured = yield* runBrowserAccessScenario({
diff --git a/apps/server/src/orchestration-v2/ProviderSessionManager.ts b/apps/server/src/orchestration-v2/ProviderSessionManager.ts
index f0ec5282ef5b..5ce31d060623 100644
--- a/apps/server/src/orchestration-v2/ProviderSessionManager.ts
+++ b/apps/server/src/orchestration-v2/ProviderSessionManager.ts
@@ -41,6 +41,7 @@ import {
 } from "../observability/Metrics.ts";
 import { ProviderWorkspaceMissingError } from "../provider/Errors.ts";
 import * as ProjectService from "../project/ProjectService.ts";
+import * as McpProviderSession from "@t3tools/provider-core/server/mcpSession";
 import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
 import * as ServerSettings from "../serverSettings.ts";
 import * as McpSessionRegistry from "../mcp/McpSessionRegistry.ts";
@@ -360,6 +361,18 @@ export const layerWithOptions = (
       const providerEventIngestor = yield* ProviderEventIngestor.ProviderEventIngestorV2;
       const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
       const agentScope = yield* AgentScope;
+      // Read fresh on every prepare, so a server added in Settings → Integrations
+      // reaches the next session without restarting T3.
+      const sharedMcpServers = Option.isNone(serverSettings)
+        ? Effect.succeed([])
+        : serverSettings.value.getSettings.pipe(
+            Effect.map((settings) => settings.sharedMcpServers.filter((server) => server.enabled)),
+            Effect.catch((cause) =>
+              Effect.logWarning("Could not read shared MCP servers; sessions get none.", {
+                cause,
+              }).pipe(Effect.as([])),
+            ),
+          );
       const agentAccessSettings = Effect.fn("ProviderSessionManagerV2.agentAccessSettings")(
         function* (threadId: ThreadId) {
           if (Option.isNone(serverSettings)) return { browser: true, device: false };
@@ -495,6 +508,7 @@ export const layerWithOptions = (
                 >(["orchestration", "worktree", "pull-requests"]);
                 if (browserToolsAvailable) capabilities.add("preview");
                 if (deviceToolsAvailable) capabilities.add("device");
+                const sharedServers = yield* sharedMcpServers;
                 const existing = yield* mcpSessions.read(threadId);
                 if (existing !== undefined) {
                   // Reserve before the async resolve so a release cannot
@@ -521,6 +535,13 @@ export const layerWithOptions = (
                     resolved.capabilities.has("preview") === browserToolsAvailable &&
                     resolved.capabilities.has("device") === deviceToolsAvailable
                   ) {
+                    yield* mcpSessions.set({
+                      ...existing,
+                      sharedServers: McpProviderSession.sharedMcpSessionServers(
+                        sharedServers,
+                        existing,
+                      ),
+                    });
                     return { mcpCredentialId: existing.providerSessionId, issued: false };
                   }
                   dropMcpCredentialReservation(threadId, existing.providerSessionId);
@@ -532,7 +553,13 @@ export const layerWithOptions = (
                   browserToolsAvailable,
                   capabilities,
                 });
-                yield* mcpSessions.set(credential.config);
+                yield* mcpSessions.set({
+                  ...credential.config,
+                  sharedServers: McpProviderSession.sharedMcpSessionServers(
+                    sharedServers,
+                    credential.config,
+                  ),
+                });
                 reserveMcpCredential(threadId, credential.config.providerSessionId);
                 return { mcpCredentialId: credential.config.providerSessionId, issued: true };
               }),
diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
index f1daa720016f..e57231abd682 100644
--- a/apps/server/src/server.ts
+++ b/apps/server/src/server.ts
@@ -72,6 +72,9 @@ import * as ProcessRunner from "./processRunner.ts";
 import * as GitManager from "./git/GitManager.ts";
 import * as EnvironmentTheme from "./environmentTheme.ts";
 import * as Keybindings from "./keybindings.ts";
+import * as SharedMcpHttp from "./mcp/SharedMcpHttp.ts";
+import * as SharedMcpProxy from "./mcp/SharedMcpProxy.ts";
+import * as SharedMcpServerProbe from "./mcp/SharedMcpServerProbe.ts";
 import * as ServerRuntimeStartup from "./serverRuntimeStartup.ts";
 import * as AgentAwarenessRelay from "./relay/AgentAwarenessRelay.ts";
 import { hasCloudPublicConfig } from "./cloud/publicConfig.ts";
@@ -592,7 +595,17 @@ const layerRuntimeCoreDependenciesBase = Layer.mergeAll(
   // Both read a user-owned file out of the state directory and stream changes
   // to clients; neither depends on the other.
   Layer.provideMerge(
-    Layer.mergeAll(Keybindings.layer, EnvironmentTheme.layer, UsageLimitSources.layer),
+    Layer.mergeAll(
+      Keybindings.layer,
+      EnvironmentTheme.layer,
+      UsageLimitSources.layer,
+      // One proxy instance: Settings start sign-ins over RPC and the HTTP
+      // callback finishes them, so both must see the same pending sign-ins.
+      SharedMcpServerProbe.layer.pipe(
+        Layer.provideMerge(SharedMcpProxy.layer.pipe(Layer.provide(ServerSecretStore.layer))),
+        Layer.provide(layerServerSettings),
+      ),
+    ),
   ),
   Layer.provideMerge(ProviderRegistry.layer),
   // The instance registry is the new routing keystone — text generation,
@@ -703,6 +716,7 @@ const layerMakeRoutes = Layer.mergeAll(
     ServerHttp.layerAssetRoute,
     ServerHttp.layerAttachmentUploadRoute,
     DeviceHubProxy.layer,
+    SharedMcpHttp.layer,
     ServerBrowserStream.routeLayer,
     ServerHttp.layerStaticAndDevRoute,
     Ws.layer,
diff --git a/apps/server/src/serverSettings.test.ts b/apps/server/src/serverSettings.test.ts
index 5c7466b472db..64cf7d486cd9 100644
--- a/apps/server/src/serverSettings.test.ts
+++ b/apps/server/src/serverSettings.test.ts
@@ -14,6 +14,7 @@ import { createModelSelection } from "@t3tools/shared/model";
 import { assert, it } from "@effect/vitest";
 import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
 import * as Duration from "effect/Duration";
 import * as FileSystem from "effect/FileSystem";
 import * as Fiber from "effect/Fiber";
@@ -34,6 +35,7 @@ import * as ServerSettingsModule from "./serverSettings.ts";
 import { resolveProviderInstanceTerminalEnvironment } from "./terminal/Manager.ts";
 
 const decodeSettingsPatch = Schema.decodeUnknownEffect(ServerSettingsPatch);
+const decodePatch = Schema.decodeUnknownExit(ServerSettingsPatch);
 const decodeServerSettings = Schema.decodeUnknownEffect(ServerSettings);
 const decodeServerSettingsJson = Schema.decodeUnknownEffect(Schema.fromJsonString(ServerSettings));
 
@@ -1500,6 +1502,118 @@ it.layer(NodeServices.layer)("server settings", (it) => {
     }).pipe(Effect.provide(layerServerSettings())),
   );
 
+  it.effect("keeps shared MCP header values in the secret store and redacts them for clients", () =>
+    Effect.gen(function* () {
+      const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
+      const serverConfig = yield* ServerConfig.ServerConfig;
+      const fileSystem = yield* FileSystem.FileSystem;
+      const gateway = {
+        name: "gateway",
+        url: "http://127.0.0.1:3050/mcp",
+        enabled: true,
+        headers: { Authorization: "Bearer gw-secret" },
+      };
+
+      const saved = yield* serverSettings.updateSettings({ sharedMcpServers: [gateway] });
+      assert.deepEqual(saved.sharedMcpServers, [gateway]);
+      assert.notInclude(yield* fileSystem.readFileString(serverConfig.settingsPath), "gw-secret");
+
+      const forClient = ServerSettingsModule.redactServerSettingsForClient(saved).sharedMcpServers;
+      assert.notInclude(forClient[0]?.headers.Authorization ?? "", "gw-secret");
+
+      // Echoing the redacted value back (e.g. toggling the server off) keeps the stored one.
+      yield* serverSettings.updateSettings({
+        sharedMcpServers: [{ ...forClient[0]!, enabled: false }],
+      });
+      assert.deepEqual((yield* serverSettings.getSettings).sharedMcpServers, [
+        { ...gateway, enabled: false },
+      ]);
+
+      // Removing the server drops its secret, so re-adding it starts clean.
+      yield* serverSettings.updateSettings({ sharedMcpServers: [] });
+      const readded = yield* serverSettings.updateSettings({
+        sharedMcpServers: [{ ...gateway, headers: {} }],
+      });
+      assert.deepEqual(readded.sharedMcpServers[0]?.headers, {});
+    }).pipe(Effect.provide(layerServerSettingsWithSecrets())),
+  );
+
+  it.effect("keeps a shared MCP server's header secret through a rename", () =>
+    Effect.gen(function* () {
+      const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
+      const saved = yield* serverSettings.updateSettings({
+        sharedMcpServers: [
+          {
+            id: "mcp_1",
+            name: "gateway",
+            url: "http://127.0.0.1:3050/mcp",
+            enabled: true,
+            headers: { Authorization: "Bearer gw-secret" },
+          },
+        ],
+      });
+      const [forClient] =
+        ServerSettingsModule.redactServerSettingsForClient(saved).sharedMcpServers;
+
+      yield* serverSettings.updateSettings({ sharedMcpServers: [{ ...forClient!, name: "gw" }] });
+
+      assert.deepEqual((yield* serverSettings.getSettings).sharedMcpServers[0]?.headers, {
+        Authorization: "Bearer gw-secret",
+      });
+    }).pipe(Effect.provide(layerServerSettingsWithSecrets())),
+  );
+
+  it.effect("moves a hand-edited shared MCP header into the secret store", () =>
+    Effect.gen(function* () {
+      const serverConfig = yield* ServerConfig.ServerConfig;
+      const fileSystem = yield* FileSystem.FileSystem;
+      const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
+      yield* fileSystem.writeFileString(
+        serverConfig.settingsPath,
+        '{"sharedMcpServers":[{"name":"gateway","url":"http://127.0.0.1:3050/mcp","headers":{"Authorization":"Bearer hand-edited"}}]}',
+      );
+      const loaded = yield* serverSettings.getSettings;
+      const [forClient] =
+        ServerSettingsModule.redactServerSettingsForClient(loaded).sharedMcpServers;
+
+      // A client toggling the server echoes the marker back.
+      yield* serverSettings.updateSettings({
+        sharedMcpServers: [{ ...forClient!, enabled: false }],
+      });
+
+      assert.notInclude(yield* fileSystem.readFileString(serverConfig.settingsPath), "hand-edited");
+      assert.deepEqual((yield* serverSettings.getSettings).sharedMcpServers[0]?.headers, {
+        Authorization: "Bearer hand-edited",
+      });
+    }).pipe(Effect.provide(layerServerSettingsWithSecrets())),
+  );
+
+  it.effect("rejects shared MCP servers that share a name or a header name", () =>
+    Effect.gen(function* () {
+      const server = { name: "gateway", url: "http://127.0.0.1:3050/mcp", enabled: true };
+      assert.isTrue(
+        Exit.isFailure(
+          decodePatch({
+            sharedMcpServers: [
+              { ...server, headers: {} },
+              { ...server, headers: {} },
+            ],
+          }),
+        ),
+      );
+      assert.isTrue(
+        Exit.isFailure(
+          decodePatch({
+            sharedMcpServers: [{ ...server, headers: { Authorization: "a", authorization: "b" } }],
+          }),
+        ),
+      );
+      assert.isTrue(
+        Exit.isSuccess(decodePatch({ sharedMcpServers: [{ ...server, headers: {} }] })),
+      );
+    }),
+  );
+
   it.effect(
     "keeps source control host secrets in the secret store and tells clients only that one is set",
     () =>
diff --git a/apps/server/src/serverSettings.ts b/apps/server/src/serverSettings.ts
index 5a36f77e4220..487dde2a2cd1 100644
--- a/apps/server/src/serverSettings.ts
+++ b/apps/server/src/serverSettings.ts
@@ -32,6 +32,7 @@ import {
   ServerSettings,
   ServerSettingsError,
   type ServerSettingsPatch,
+  sharedMcpServerKey,
 } from "@t3tools/contracts";
 import * as Cache from "effect/Cache";
 import * as Cause from "effect/Cause";
@@ -164,6 +165,17 @@ function usageLimitSourceSecretName(sourceId: string): string {
   return `usage-limit-source-${Buffer.from(sourceId, "utf8").toString("base64url")}`;
 }
 
+/** Secret holding a shared server's OAuth sign-in (see `SharedMcpProxy`); removed with the server. */
+export function sharedMcpOAuthSecretName(serverKey: string): string {
+  return `shared-mcp-oauth-${Buffer.from(serverKey, "utf8").toString("base64url")}`;
+}
+
+/** Keyed by the server's stable id (see `sharedMcpServerKey`), so a rename keeps its secrets. */
+function sharedMcpHeaderSecretName(serverKey: string, headerName: string): string {
+  const encode = (value: string) => Buffer.from(value, "utf8").toString("base64url");
+  return `shared-mcp-header-${encode(serverKey)}-${encode(headerName.toLowerCase())}`;
+}
+
 const redactSecret = (value: string) => (value.length > 0 ? SECRET_REDACTED : "");
 
 /** Each host's settings with every secret slot's value replaced by `map(slot, value)`. */
@@ -245,7 +257,20 @@ export function redactServerSettingsForClient(settings: ServerSettings): ServerS
   const sourceControlHosts = mapSlotValues(settings.sourceControlHosts, (_slot, value) =>
     redactSecret(value),
   );
-  return { ...settings, providerInstances, usageLimitSources, sourceControlHosts };
+  // Shared MCP header values are usually bearer tokens.
+  const sharedMcpServers = settings.sharedMcpServers.map((server) => ({
+    ...server,
+    headers: Object.fromEntries(
+      Object.entries(server.headers).map(([name, value]) => [name, redactSecret(value)]),
+    ),
+  }));
+  return {
+    ...settings,
+    providerInstances,
+    usageLimitSources,
+    sourceControlHosts,
+    sharedMcpServers,
+  };
 }
 
 export function applyProviderInstanceMutation(
@@ -1053,6 +1078,26 @@ const make = Effect.gen(function* () {
           Option.isSome(secret) ? textDecoder.decode(secret.value) : "",
         );
       }
+      const sharedMcpServers: Array<ServerSettings["sharedMcpServers"][number]> = [];
+      for (const server of settings.sharedMcpServers) {
+        const headers: Record<string, string> = {};
+        for (const [name, value] of Object.entries(server.headers)) {
+          if (value !== SECRET_REDACTED) {
+            headers[name] = value;
+            continue;
+          }
+          const secret = yield* secretStore
+            .get(sharedMcpHeaderSecretName(sharedMcpServerKey(server), name))
+            .pipe(
+              Effect.mapError(
+                (cause) =>
+                  new ServerSettingsError({ settingsPath, operation: "read-secret", cause }),
+              ),
+            );
+          headers[name] = Option.isSome(secret) ? textDecoder.decode(secret.value) : "";
+        }
+        sharedMcpServers.push({ ...server, headers });
+      }
       return {
         ...settings,
         providerInstances: providerInstances as ServerSettings["providerInstances"],
@@ -1062,6 +1107,7 @@ const make = Effect.gen(function* () {
             ? (storedSecrets.get(sourceControlHostSecretName(slot)) ?? "")
             : value,
         ),
+        sharedMcpServers,
       };
     });
 
@@ -1203,6 +1249,51 @@ const make = Effect.gen(function* () {
         });
       }
 
+      // Each shared MCP header value is its own secret. The marker keeps the
+      // stored value; a value hand-edited into settings.json is moved into the
+      // store instead of dropped, and a marker with nothing behind it is
+      // dropped rather than saved as an empty header. Headers or servers that
+      // disappear drop their secrets.
+      const currentHeaders = new Map(
+        current.sharedMcpServers.map((server) => [sharedMcpServerKey(server), server.headers]),
+      );
+      const nextHeaderSecrets = new Set<string>();
+      const sharedMcpServers = next.sharedMcpServers.map((server) => {
+        const key = sharedMcpServerKey(server);
+        const headers: Record<string, string> = {};
+        for (const [name, value] of Object.entries(server.headers)) {
+          const secretName = sharedMcpHeaderSecretName(key, name);
+          const previous = currentHeaders.get(key)?.[name];
+          const stored = value === SECRET_REDACTED ? previous : value;
+          if (stored === undefined || stored.length === 0) {
+            changes.push({ kind: "remove", secretName, operation: "remove-secret" });
+            continue;
+          }
+          nextHeaderSecrets.add(secretName);
+          if (stored !== SECRET_REDACTED) {
+            changes.push({ kind: "write", secretName, value: textEncoder.encode(stored) });
+          }
+          headers[name] = SECRET_REDACTED;
+        }
+        return { ...server, headers };
+      });
+      const nextServerKeys = new Set(next.sharedMcpServers.map(sharedMcpServerKey));
+      for (const server of current.sharedMcpServers) {
+        for (const name of Object.keys(server.headers)) {
+          const secretName = sharedMcpHeaderSecretName(sharedMcpServerKey(server), name);
+          if (nextHeaderSecrets.has(secretName)) continue;
+          changes.push({ kind: "remove", secretName, operation: "remove-stale-secret" });
+        }
+        // A removed server's OAuth sign-in goes with it.
+        if (!nextServerKeys.has(sharedMcpServerKey(server))) {
+          changes.push({
+            kind: "remove",
+            secretName: sharedMcpOAuthSecretName(sharedMcpServerKey(server)),
+            operation: "remove-stale-secret",
+          });
+        }
+      }
+
       // Hand-edited plaintext not yet in the store, so the redaction marker can move it there.
       const inlineSecrets = new Map(
         sourceControlHostSecretSlots(current.sourceControlHosts).flatMap((slot) =>
@@ -1241,6 +1332,7 @@ const make = Effect.gen(function* () {
           providerInstances: providerInstances as ServerSettings["providerInstances"],
           usageLimitSources: usageLimitSources as ServerSettings["usageLimitSources"],
           sourceControlHosts,
+          sharedMcpServers,
         },
         changes,
       };
diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.ts
index 61bad3faf318..7cb3c79b5ff0 100644
--- a/apps/server/src/ws.ts
+++ b/apps/server/src/ws.ts
@@ -176,6 +176,7 @@ import * as ServerSelfUpdate from "./cloud/selfUpdate.ts";
 import * as ServerLifecycleEvents from "./serverLifecycleEvents.ts";
 import * as ServerRuntimeStartup from "./serverRuntimeStartup.ts";
 import * as ServerSettings from "./serverSettings.ts";
+import * as SharedMcpServerProbe from "./mcp/SharedMcpServerProbe.ts";
 import * as StorageCleanup from "./storageCleanup.ts";
 import * as TerminalManager from "./terminal/Manager.ts";
 import { withTerminalOutputWindow } from "./terminal/OutputProtocol.ts";
@@ -1282,6 +1283,7 @@ const layerWsRpc = (
       const lifecycleEvents = yield* ServerLifecycleEvents.ServerLifecycleEvents;
       const storageCleanup = yield* StorageCleanup.StorageCleanup;
       const serverSettings = yield* ServerSettings.ServerSettingsService;
+      const sharedMcpServerProbe = yield* SharedMcpServerProbe.SharedMcpServerProbe;
       const startup = yield* ServerRuntimeStartup.ServerRuntimeStartup;
       const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
       const workspaceFileSystem = yield* WorkspaceFileSystem.WorkspaceFileSystem;
@@ -2404,6 +2406,8 @@ const layerWsRpc = (
               : serverSettings.updateProviderInstance(providerInstanceMutation, nextPatch);
             return ServerSettings.redactServerSettingsForClient(settings);
           }),
+        [WS_METHODS.serverTestSharedMcpServer]: ({ name }) => sharedMcpServerProbe.test({ name }),
+        [WS_METHODS.serverSignInSharedMcpServer]: (input) => sharedMcpServerProbe.signIn(input),
         [WS_METHODS.serverDiscoverSourceControl]: (_input) => sourceControlDiscovery.discover,
         [WS_METHODS.serverGetTraceDiagnostics]: (_input) =>
           TraceDiagnostics.readTraceDiagnostics({
diff --git a/apps/web/src/components/settings/IntegrationsSettings.tsx b/apps/web/src/components/settings/IntegrationsSettings.tsx
index a0c0a79bebc6..002dd4d4e91a 100644
--- a/apps/web/src/components/settings/IntegrationsSettings.tsx
+++ b/apps/web/src/components/settings/IntegrationsSettings.tsx
@@ -3,6 +3,7 @@ import { DeviceToolVersions } from "../device/DeviceToolVersions";
 import { useScopedSettings, useUpdateScopedSettings } from "./useScopedSettings";
 import { ScopedSwitch } from "./ScopedSwitch";
 import { DeviceHostsSettings } from "./DeviceHostsSettings";
+import { SharedMcpServersSettings } from "./SharedMcpServersSettings";
 /**
  * Integrations settings - preferences for surfaces T3 Code embeds rather than
  * owns. Browser is the first section: the defaults a preview tab opens at,
@@ -1537,6 +1538,7 @@ export function IntegrationsSettingsPanel() {
       {/* Server-authoritative agent access is scoped by the header selection;
           the preview defaults below are device-local and ignore it. */}
       <ProjectDefaultsSettings category="integrations" />
+      <SharedMcpServersSettings />
       <SettingsSection id="browser" title="Browser">
         {previewDefaultsDisabled ? (
           <SettingsUnavailableGroup message="Only available in the desktop app.">
diff --git a/apps/web/src/components/settings/SharedMcpServersSettings.tsx b/apps/web/src/components/settings/SharedMcpServersSettings.tsx
new file mode 100644
index 000000000000..3aa85661437f
--- /dev/null
+++ b/apps/web/src/components/settings/SharedMcpServersSettings.tsx
@@ -0,0 +1,440 @@
+import { type SharedMcpServer, SharedMcpServerTestError } from "@t3tools/contracts";
+import {
+  parseSharedMcpServerDraft,
+  sharedMcpServerDraft,
+  type SharedMcpServerDraft,
+  upsertSharedMcpServer,
+} from "@t3tools/client-runtime/state/shared-mcp-servers";
+import {
+  isAtomCommandInterrupted,
+  squashAtomCommandFailure,
+} from "@t3tools/client-runtime/state/runtime";
+import {
+  LogInIcon,
+  MoreHorizontalIcon,
+  PencilIcon,
+  PlugZapIcon,
+  PlusIcon,
+  Trash2Icon,
+} from "lucide-react";
+import * as Schema from "effect/Schema";
+import { type Dispatch, type SetStateAction, useState } from "react";
+
+import { useOpenLink } from "../../browser/useOpenLink";
+import { useEnvironmentSettings } from "../../hooks/useSettings";
+import { type EnvironmentPresentation, useEnvironmentHttpBaseUrl } from "../../state/environments";
+import { serverEnvironment } from "../../state/server";
+import { useAtomCommand } from "../../state/use-atom-command";
+import { Badge } from "../ui/badge";
+import { Button } from "../ui/button";
+import { Input } from "../ui/input";
+import { Menu, MenuItem, MenuPopup, MenuSeparator, MenuTrigger } from "../ui/menu";
+import { Switch } from "../ui/switch";
+import { Textarea } from "../ui/textarea";
+import { useSettingsScope } from "./SettingsScopeContext";
+import { SettingsRow, SettingsSection } from "./settingsLayout";
+import { searchableSetting } from "./settingsSearch";
+
+const isTestError = Schema.is(SharedMcpServerTestError);
+
+type FormState = {
+  readonly environmentId: EnvironmentPresentation["environmentId"];
+  readonly editing?: SharedMcpServer;
+} | null;
+
+/** MCP servers added once here reach every agent session on the selected environment. */
+export function SharedMcpServersSettings() {
+  const scope = useSettingsScope();
+  // "All environments" with a single connected one still has an obvious target.
+  const environment =
+    scope.environment ??
+    (scope.connectedEnvironments.length === 1 ? scope.connectedEnvironments[0] : undefined);
+  const { environments } = scope;
+  const connected =
+    environment?.connection.phase === "connected" && environment.serverConfig !== null;
+  const [openForm, setForm] = useState<FormState>(null);
+  // A form opened for another environment doesn't follow a scope change.
+  const form = openForm?.environmentId === environment?.environmentId ? openForm : null;
+
+  return (
+    <SettingsSection
+      {...searchableSetting("shared-mcp-servers")}
+      headerAction={
+        connected ? (
+          <Button
+            size="xs"
+            variant="outline"
+            disabled={form !== null}
+            onClick={() => environment && setForm({ environmentId: environment.environmentId })}
+          >
+            <PlusIcon className="size-3" aria-hidden />
+            Add server
+          </Button>
+        ) : null
+      }
+    >
+      {environment && connected ? (
+        <SharedMcpServerRows
+          key={environment.environmentId}
+          environment={environment}
+          form={form}
+          onFormChange={setForm}
+        />
+      ) : (
+        <SettingsRow
+          title={environment ? "Environment disconnected" : "Select one environment"}
+          description={
+            environment
+              ? `Reconnect ${environment.label} to manage its shared MCP servers.`
+              : environments.length > 1
+                ? "Shared MCP servers belong to one environment. Select a single environment above."
+                : "Connect an environment to manage its shared MCP servers."
+          }
+        />
+      )}
+    </SettingsSection>
+  );
+}
+
+function SharedMcpServerRows({
+  environment,
+  form,
+  onFormChange,
+}: {
+  readonly environment: EnvironmentPresentation;
+  readonly form: FormState;
+  readonly onFormChange: Dispatch<SetStateAction<FormState>>;
+}) {
+  const servers = useEnvironmentSettings(
+    environment.environmentId,
+    (settings) => settings.sharedMcpServers,
+  );
+  const updateSettings = useAtomCommand(serverEnvironment.updateSettings, {
+    label: "shared MCP servers update",
+  });
+  // Each write replaces the whole list, so one runs at a time: a second built
+  // from the same snapshot would undo the first.
+  const [saving, setSaving] = useState(false);
+  const save = async (sharedMcpServers: ReadonlyArray<SharedMcpServer>) => {
+    setSaving(true);
+    const result = await updateSettings({
+      environmentId: environment.environmentId,
+      input: { patch: { sharedMcpServers: [...sharedMcpServers] } },
+    });
+    setSaving(false);
+    return result._tag === "Success";
+  };
+  // A failed save keeps the form open, so nothing typed is lost; a late one
+  // closes only the form that started it, not one opened since.
+  const saveAndClose = (sharedMcpServers: ReadonlyArray<SharedMcpServer>) => {
+    const started = form;
+    void save(sharedMcpServers).then((saved) => {
+      if (saved) onFormChange((current) => (current === started ? null : current));
+    });
+  };
+
+  return (
+    <>
+      {servers.length === 0 && form === null ? (
+        <SettingsRow
+          title="No shared MCP servers"
+          description="Add a server once and every new agent session gets it: Claude, Codex, Cursor, OpenCode, Pi, and ACP agents. Point it at a local MCP gateway to share many servers at once."
+        />
+      ) : null}
+      {servers.map((server) =>
+        form?.editing?.name === server.name ? (
+          <SharedMcpServerForm
+            key={server.name}
+            servers={servers}
+            editing={server}
+            onCancel={() => onFormChange(null)}
+            saving={saving}
+            onSave={(next) => saveAndClose(upsertSharedMcpServer(servers, next, server))}
+          />
+        ) : (
+          <SharedMcpServerRow
+            key={server.name}
+            environment={environment}
+            server={server}
+            saving={saving}
+            onToggle={(enabled) =>
+              void save(servers.map((entry) => (entry === server ? { ...entry, enabled } : entry)))
+            }
+            onEdit={() =>
+              onFormChange({ environmentId: environment.environmentId, editing: server })
+            }
+            onRemove={() => void save(servers.filter((entry) => entry !== server))}
+          />
+        ),
+      )}
+      {form !== null && form.editing === undefined ? (
+        <SharedMcpServerForm
+          servers={servers}
+          saving={saving}
+          onCancel={() => onFormChange(null)}
+          onSave={(next) => saveAndClose(upsertSharedMcpServer(servers, next))}
+        />
+      ) : null}
+    </>
+  );
+}
+
+function SharedMcpServerRow({
+  environment,
+  server,
+  saving,
+  onToggle,
+  onEdit,
+  onRemove,
+}: {
+  readonly environment: EnvironmentPresentation;
+  readonly server: SharedMcpServer;
+  readonly saving: boolean;
+  readonly onToggle: (enabled: boolean) => void;
+  readonly onEdit: () => void;
+  readonly onRemove: () => void;
+}) {
+  const testServer = useAtomCommand(serverEnvironment.testSharedMcpServer, {
+    reportFailure: false,
+  });
+  const signInServer = useAtomCommand(serverEnvironment.signInSharedMcpServer, {
+    reportFailure: false,
+  });
+  const openLink = useOpenLink(null);
+  // The provider sends the browser back to this environment's server, which
+  // keeps the tokens; agents never see them.
+  const redirectBaseUrl = useEnvironmentHttpBaseUrl(environment.environmentId);
+  const [test, setTest] = useState<
+    | { readonly state: "running"; readonly message: string }
+    | {
+        readonly state: "done";
+        readonly message: string;
+        readonly ok: boolean;
+        readonly needsSignIn?: boolean;
+      }
+    | null
+  >(null);
+  const headerCount = Object.keys(server.headers).length;
+  const failed = (result: Parameters<typeof squashAtomCommandFailure>[0]) => {
+    const failure = squashAtomCommandFailure(result);
+    setTest({
+      state: "done",
+      ok: false,
+      needsSignIn: isTestError(failure) && failure.needsSignIn,
+      message: failure instanceof Error ? failure.message : String(failure),
+    });
+  };
+
+  const runTest = async () => {
+    setTest({ state: "running", message: "Testing…" });
+    const result = await testServer({
+      environmentId: environment.environmentId,
+      input: { name: server.name },
+    });
+    if (result._tag === "Success") {
+      const { serverName, toolCount } = result.value;
+      setTest({
+        state: "done",
+        ok: true,
+        message: `Connected${serverName ? ` to ${serverName}` : ""} · ${toolCount} ${toolCount === 1 ? "tool" : "tools"}`,
+      });
+    } else if (isAtomCommandInterrupted(result)) {
+      setTest(null);
+    } else {
+      failed(result);
+    }
+  };
+
+  const signIn = async () => {
+    if (redirectBaseUrl === null) return;
+    setTest({ state: "running", message: "Starting sign-in…" });
+    const result = await signInServer({
+      environmentId: environment.environmentId,
+      input: { name: server.name, redirectBaseUrl },
+    });
+    if (result._tag === "Success") {
+      const { authorizationUrl } = result.value;
+      if (authorizationUrl === null) {
+        setTest({ state: "done", ok: true, message: "Connected · no sign-in needed" });
+        return;
+      }
+      setTest({
+        state: "done",
+        ok: true,
+        message: "Finish signing in in your browser, then test the connection.",
+      });
+      await openLink(authorizationUrl).catch((error: unknown) =>
+        setTest({ state: "done", ok: false, message: String(error) }),
+      );
+    } else if (isAtomCommandInterrupted(result)) {
+      setTest(null);
+    } else {
+      failed(result);
+    }
+  };
+
+  return (
+    <SettingsRow
+      title={
+        <span className="flex items-center gap-1.5">
+          {server.name}
+          {headerCount > 0 ? (
+            <Badge size="sm" variant="outline">
+              {headerCount} {headerCount === 1 ? "header" : "headers"}
+            </Badge>
+          ) : null}
+        </span>
+      }
+      description={<span className="break-all font-mono">{server.url}</span>}
+      status={
+        test === null ? undefined : test.state === "running" ? (
+          test.message
+        ) : test.needsSignIn ? (
+          <span className="flex items-center gap-2 text-destructive">
+            Needs sign-in
+            <Button size="xs" variant="outline" onClick={() => void signIn()}>
+              Sign in
+            </Button>
+          </span>
+        ) : (
+          <span className={test.ok ? "text-success-foreground" : "text-destructive"}>
+            {test.message}
+          </span>
+        )
+      }
+      control={
+        <div className="flex items-center gap-2">
+          <Switch
+            checked={server.enabled}
+            disabled={saving}
+            aria-label={`Share ${server.name} with agents`}
+            onCheckedChange={onToggle}
+          />
+          <Menu>
+            <MenuTrigger
+              render={
+                <Button
+                  size="icon-sm"
+                  variant="ghost"
+                  disabled={saving}
+                  aria-label={`Actions for ${server.name}`}
+                />
+              }
+            >
+              <MoreHorizontalIcon className="size-4" />
+            </MenuTrigger>
+            <MenuPopup align="end">
+              <MenuItem disabled={test?.state === "running"} onClick={() => void runTest()}>
+                <PlugZapIcon />
+                Test connection
+              </MenuItem>
+              <MenuItem disabled={test?.state === "running"} onClick={() => void signIn()}>
+                <LogInIcon />
+                Sign in
+              </MenuItem>
+              <MenuItem onClick={onEdit}>
+                <PencilIcon />
+                Edit
+              </MenuItem>
+              <MenuSeparator />
+              <MenuItem onClick={onRemove}>
+                <Trash2Icon />
+                Remove
+              </MenuItem>
+            </MenuPopup>
+          </Menu>
+        </div>
+      }
+    />
+  );
+}
+
+function SharedMcpServerForm({
+  servers,
+  editing,
+  saving,
+  onCancel,
+  onSave,
+}: {
+  readonly servers: ReadonlyArray<SharedMcpServer>;
+  readonly editing?: SharedMcpServer;
+  readonly saving: boolean;
+  readonly onCancel: () => void;
+  readonly onSave: (server: SharedMcpServer) => void;
+}) {
+  const [draft, setDraft] = useState<SharedMcpServerDraft>(() =>
+    editing ? sharedMcpServerDraft(editing) : { name: "", url: "", headers: "" },
+  );
+  const [error, setError] = useState<string | null>(null);
+  const submit = () => {
+    if (saving) return;
+    const parsed = parseSharedMcpServerDraft(servers, draft, editing);
+    if ("error" in parsed) {
+      setError(parsed.error);
+      return;
+    }
+    onSave(parsed.server);
+  };
+  const field = (key: keyof SharedMcpServerDraft) => ({
+    value: draft[key],
+    onChange: (event: { currentTarget: { value: string } }) => {
+      // Read now: React clears `currentTarget` before a deferred updater runs.
+      const value = event.currentTarget.value;
+      setDraft((current) => ({ ...current, [key]: value }));
+    },
+  });
+
+  return (
+    <SettingsRow
+      title={editing ? `Edit ${editing.name}` : "New MCP server"}
+      description={
+        error ??
+        "Agents pick it up in their next session. Header values are stored as secrets; a server that uses OAuth signs in from its menu."
+      }
+      control={
+        <div className="flex items-center gap-2">
+          <Button size="xs" variant="ghost" onClick={onCancel}>
+            Cancel
+          </Button>
+          <Button size="xs" disabled={saving} onClick={submit}>
+            {editing ? "Save" : "Add"}
+          </Button>
+        </div>
+      }
+    >
+      <form
+        className="grid gap-2 pt-2"
+        onSubmit={(event) => {
+          event.preventDefault();
+          submit();
+        }}
+      >
+        <div className="flex flex-wrap gap-2">
+          <Input
+            className="w-40"
+            size="sm"
+            autoFocus
+            placeholder="gateway"
+            aria-label="Server name"
+            {...field("name")}
+          />
+          <Input
+            className="min-w-64 flex-1"
+            size="sm"
+            placeholder="http://127.0.0.1:3050/mcp"
+            aria-label="Server URL"
+            {...field("url")}
+          />
+        </div>
+        <Textarea
+          size="sm"
+          rows={2}
+          placeholder="Optional headers, one per line: Authorization: Bearer …"
+          aria-label="Server headers"
+          {...field("headers")}
+        />
+        <button type="submit" hidden />
+      </form>
+    </SettingsRow>
+  );
+}
diff --git a/apps/web/src/components/settings/settingsSearch.ts b/apps/web/src/components/settings/settingsSearch.ts
index 798aabeb8bae..fb940bdde795 100644
--- a/apps/web/src/components/settings/settingsSearch.ts
+++ b/apps/web/src/components/settings/settingsSearch.ts
@@ -691,6 +691,12 @@ export const SETTINGS_SEARCH_ITEMS = [
     searchTerms: ["refresh availability versions auth state models background probes seconds off"],
     providerSettingsOnly: true,
   },
+  {
+    id: "shared-mcp-servers",
+    title: "Shared MCP servers",
+    to: "/settings/integrations",
+    searchTerms: ["mcp model context protocol gateway tools add server claude codex cursor"],
+  },
   {
     id: "agent-browser-access",
     title: "Agent browser access",
diff --git a/docs/user/composer.md b/docs/user/composer.md
index 831a8ac9792d..2f7235af1513 100644
--- a/docs/user/composer.md
+++ b/docs/user/composer.md
@@ -211,6 +211,10 @@ After you add or change skills, plugins, or MCP servers, use **Restart agent
 session** in the command palette on web and desktop. The conversation continues,
 and your next message starts the agent again with the new setup.
 
+To give every agent the same MCP server, including one that needs a login, add
+it once in **Settings → Integrations → Shared MCP servers**. See
+[Shared MCP servers](./shared-mcp-servers.md).
+
 Provider commands must start the message to run. T3 Code commands such as
 `/model` and `/plan`, and skill mentions, work on any line.
 
diff --git a/docs/user/shared-mcp-servers.md b/docs/user/shared-mcp-servers.md
new file mode 100644
index 000000000000..c5282649d4b8
--- /dev/null
+++ b/docs/user/shared-mcp-servers.md
@@ -0,0 +1,84 @@
+# Shared MCP servers
+
+Add an MCP server once and every new agent session on that environment can use
+its tools, whichever provider runs the session: Claude, Codex, Cursor,
+OpenCode, Pi, or ACP agents. If the server needs a login, you sign in once in
+T3 Code. You don't sign in separately in each agent, and you don't edit each
+agent's own MCP config.
+
+Open **Settings → Integrations → Shared MCP servers**. On mobile, it's
+**Settings → Shared MCP servers**. Shared servers belong to one environment, so
+pick a single environment at the top of Settings first.
+
+## How logins stay in T3 Code
+
+Agents never connect to a shared server themselves. Each agent reaches it
+through T3 Code with the same per-thread credential it already uses for T3's
+own tools. T3 Code then connects to the real server with the server's headers
+or OAuth login. Those stay in T3 Code's secret store, so no agent's config,
+environment, or transcript ever holds them.
+
+A login belongs to the environment, not to a person. Every session on that
+environment, whoever starts it, reaches the server as the account that signed
+in. If several people share one environment, the server sees all of their
+changes as made by that one account.
+
+Only tools are shared. Resources and prompts are not.
+
+## Servers that sign in with OAuth
+
+Most hosted MCP servers use an OAuth login. Add the server with just its name
+and URL, and leave **Headers** empty:
+
+| Name     | URL                          |
+| -------- | ---------------------------- |
+| `linear` | `https://mcp.linear.app/mcp` |
+| `notion` | `https://mcp.notion.com/mcp` |
+| `sentry` | `https://mcp.sentry.dev/mcp` |
+
+1. Choose **Test connection** from the server's menu. A server you haven't
+   signed in to yet shows **Needs sign-in**.
+2. Choose **Sign in**. Your browser opens the provider's login page.
+3. Approve access. The provider sends you back to a T3 Code page that says
+   **Signed in to linear** (or the server's name). You can close it.
+4. Choose **Test connection** again. It shows the server's name and how many
+   tools it has.
+
+T3 Code keeps the login and refreshes it. If the provider ends it, **Test
+connection** shows **Needs sign-in** again, and agents get a tool error asking
+you to sign in from Settings.
+
+The provider sends your browser back to the environment's own address. That
+address must open from the browser you sign in with. Any address that opens
+T3 Code from that browser works.
+
+## Servers that take a token in a header
+
+Some servers take an API key or a personal access token instead of an OAuth
+login. Put it under **Headers**, one per line, as `Name: value`:
+
+| Name      | URL                                  | Headers                                  |
+| --------- | ------------------------------------ | ---------------------------------------- |
+| `github`  | `https://api.githubcopilot.com/mcp/` | `Authorization: Bearer <personal-token>` |
+| `context` | `https://mcp.context7.com/mcp`       | `CONTEXT7_API_KEY: <key>`                |
+
+Header values are stored as secrets. When you edit the server, they show as
+`••••••`. Leave that as it is to keep the saved value, or type a new one.
+
+## Servers with no login
+
+A public server needs only a name and URL. For example, `deepwiki` at
+`https://mcp.deepwiki.com/mcp`.
+
+## Turning a server off
+
+Use the server's switch to keep it out of new sessions without removing it.
+New sessions pick up any change. For a session that's already running, use
+**Restart agent session** in the command palette.
+
+## Limits
+
+- Servers are reached over `http(s)`. A command-line (stdio) server can be
+  shared through a local MCP gateway, then added here by its URL.
+- An OpenCode server you run yourself doesn't get shared servers, the same as
+  T3 Code's own tools.
diff --git a/packages/client-runtime/package.json b/packages/client-runtime/package.json
index 4f1d4e20752a..1579893cfe98 100644
--- a/packages/client-runtime/package.json
+++ b/packages/client-runtime/package.json
@@ -219,6 +219,10 @@
       "types": "./src/state/usage.ts",
       "default": "./src/state/usage.ts"
     },
+    "./state/shared-mcp-servers": {
+      "types": "./src/state/sharedMcpServers.ts",
+      "default": "./src/state/sharedMcpServers.ts"
+    },
     "./state/usage-progress": {
       "types": "./src/state/usageProgress.ts",
       "default": "./src/state/usageProgress.ts"
diff --git a/packages/client-runtime/src/state/server.ts b/packages/client-runtime/src/state/server.ts
index 31aadd0025bb..97b10c41b9b9 100644
--- a/packages/client-runtime/src/state/server.ts
+++ b/packages/client-runtime/src/state/server.ts
@@ -1170,6 +1170,14 @@ export function createServerEnvironmentAtoms<R, E>(
         key: ({ environmentId, input }) => JSON.stringify([environmentId, input]),
       },
     }),
+    testSharedMcpServer: createEnvironmentRpcCommand(runtime, {
+      label: "environment-data:server:test-shared-mcp-server",
+      tag: WS_METHODS.serverTestSharedMcpServer,
+    }),
+    signInSharedMcpServer: createEnvironmentRpcCommand(runtime, {
+      label: "environment-data:server:sign-in-shared-mcp-server",
+      tag: WS_METHODS.serverSignInSharedMcpServer,
+    }),
     refreshProviders: createEnvironmentRpcCommand(runtime, {
       label: "environment-data:server:refresh-providers",
       tag: WS_METHODS.serverRefreshProviders,
diff --git a/packages/client-runtime/src/state/sharedMcpServers.test.ts b/packages/client-runtime/src/state/sharedMcpServers.test.ts
new file mode 100644
index 000000000000..b6799f59d0ed
--- /dev/null
+++ b/packages/client-runtime/src/state/sharedMcpServers.test.ts
@@ -0,0 +1,90 @@
+import { describe, expect, it } from "vite-plus/test";
+
+import {
+  parseSharedMcpServerDraft,
+  sharedMcpServerDraft,
+  upsertSharedMcpServer,
+} from "./sharedMcpServers.ts";
+
+const gateway = {
+  name: "gateway",
+  url: "http://127.0.0.1:3050/mcp",
+  enabled: false,
+  headers: { Authorization: "••••••" },
+};
+
+describe("parseSharedMcpServerDraft", () => {
+  it("trims fields and parses one header per line", () => {
+    expect(
+      parseSharedMcpServerDraft([], {
+        name: " docs ",
+        url: " https://mcp.example.com ",
+        headers: "Authorization: Bearer abc\n\nX-Api-Key:k:1",
+      }),
+    ).toMatchObject({
+      server: {
+        name: "docs",
+        url: "https://mcp.example.com",
+        enabled: true,
+        headers: { Authorization: "Bearer abc", "X-Api-Key": "k:1" },
+      },
+    });
+  });
+
+  it("rejects names agents can't use, duplicates, bad headers, and non-http URLs", () => {
+    const draft = { name: "docs", url: "http://x", headers: "" };
+    expect(parseSharedMcpServerDraft([], { ...draft, name: "my server" })).toHaveProperty("error");
+    expect(parseSharedMcpServerDraft([], { ...draft, name: "t3-code" })).toHaveProperty("error");
+    expect(parseSharedMcpServerDraft([], { ...draft, name: "x".repeat(25) })).toHaveProperty(
+      "error",
+    );
+    expect(parseSharedMcpServerDraft([gateway], { ...draft, name: "gateway" })).toHaveProperty(
+      "error",
+    );
+    expect(parseSharedMcpServerDraft([], { ...draft, headers: "no separator" })).toHaveProperty(
+      "error",
+    );
+    expect(
+      parseSharedMcpServerDraft([], { ...draft, headers: "Authorization: a\nauthorization: b" }),
+    ).toHaveProperty("error");
+    expect(parseSharedMcpServerDraft([], { ...draft, url: "npx some-server" })).toHaveProperty(
+      "error",
+    );
+  });
+
+  it("gives a new server an id and keeps a saved server's key through a rename", () => {
+    expect(
+      parseSharedMcpServerDraft([], { name: "docs", url: "http://x", headers: "" }),
+    ).toMatchObject({ server: { id: "docs" } });
+    // `gateway` was renamed to `gw` but still owns the `gateway` key.
+    const renamedGateway = { ...gateway, id: "gateway", name: "gw" };
+    expect(
+      parseSharedMcpServerDraft([renamedGateway], {
+        name: "gateway",
+        url: "http://x",
+        headers: "",
+      }),
+    ).toMatchObject({ server: { id: "gateway-2", name: "gateway" } });
+
+    // An entry saved without an id keeps its name as the key, so its secrets follow it.
+    const renamed = parseSharedMcpServerDraft(
+      [gateway],
+      { ...sharedMcpServerDraft(gateway), name: "gw" },
+      gateway,
+    );
+    expect(renamed).toMatchObject({ server: { id: "gateway", name: "gw" } });
+  });
+
+  it("edits a saved server in place, keeping its switch and redacted header", () => {
+    const parsed = parseSharedMcpServerDraft(
+      [gateway],
+      { ...sharedMcpServerDraft(gateway), url: "http://127.0.0.1:4000/mcp" },
+      gateway,
+    );
+    expect(parsed).toEqual({
+      server: { ...gateway, id: "gateway", url: "http://127.0.0.1:4000/mcp" },
+    });
+    if (!("server" in parsed)) return;
+    expect(upsertSharedMcpServer([gateway], parsed.server, gateway)).toEqual([parsed.server]);
+  });
+});
diff --git a/packages/client-runtime/src/state/sharedMcpServers.ts b/packages/client-runtime/src/state/sharedMcpServers.ts
new file mode 100644
index 000000000000..0fde10e9db52
--- /dev/null
+++ b/packages/client-runtime/src/state/sharedMcpServers.ts
@@ -0,0 +1,97 @@
+import { SharedMcpServer, sharedMcpServerKey } from "@t3tools/contracts";
+import * as Exit from "effect/Exit";
+import * as Schema from "effect/Schema";
+
+const decodeSharedMcpServer = Schema.decodeUnknownExit(SharedMcpServer);
+
+/**
+ * A new server's id: its name, or the name with a suffix when that key is
+ * still held by a renamed server. Unique within the list, which is all the
+ * secret store needs.
+ */
+function newSharedMcpServerId(saved: ReadonlyArray<SharedMcpServer>, name: string): string {
+  const taken = new Set(saved.map(sharedMcpServerKey));
+  let id = name;
+  for (let suffix = 2; taken.has(id); suffix += 1) id = `${name}-${suffix}`;
+  return id;
+}
+
+/** The add/edit form for one shared MCP server, as typed by the user. */
+export interface SharedMcpServerDraft {
+  readonly name: string;
+  readonly url: string;
+  /** One `Name: value` header per line. */
+  readonly headers: string;
+}
+
+/**
+ * Headers as editable text. Saved values arrive redacted; leaving a line
+ * untouched sends the marker back, which keeps the stored value.
+ */
+function formatSharedMcpServerHeaders(headers: Readonly<Record<string, string>>): string {
+  return Object.entries(headers)
+    .map(([name, value]) => `${name}: ${value}`)
+    .join("\n");
+}
+
+/** Draft for editing a saved server. */
+export function sharedMcpServerDraft(server: SharedMcpServer): SharedMcpServerDraft {
+  return {
+    name: server.name,
+    url: server.url,
+    headers: formatSharedMcpServerHeaders(server.headers),
+  };
+}
+
+/**
+ * Validate a draft against the settings schema and the other saved servers.
+ * `editing` names the server being replaced, so it may keep its own name.
+ */
+export function parseSharedMcpServerDraft(
+  saved: ReadonlyArray<SharedMcpServer>,
+  draft: SharedMcpServerDraft,
+  editing?: SharedMcpServer,
+): { readonly server: SharedMcpServer } | { readonly error: string } {
+  const name = draft.name.trim();
+  if (name === "t3-code") return { error: "t3-code is T3 Code's own server." };
+  if (!/^[A-Za-z0-9_-]{1,24}$/.test(name)) {
+    return { error: "Use up to 24 letters, numbers, dashes, or underscores for the name." };
+  }
+  if (saved.some((server) => server.name === name && server.name !== editing?.name)) {
+    return { error: `A server named ${name} already exists.` };
+  }
+  const headers: Record<string, string> = {};
+  for (const line of draft.headers.split("\n")) {
+    if (line.trim().length === 0) continue;
+    const separator = line.indexOf(":");
+    const headerName = separator > 0 ? line.slice(0, separator).trim() : "";
+    if (!/^[A-Za-z0-9-]+$/.test(headerName)) {
+      return { error: `Write each header as "Name: value" (got "${line.trim()}").` };
+    }
+    if (Object.keys(headers).some((name) => name.toLowerCase() === headerName.toLowerCase())) {
+      return { error: `The ${headerName} header is listed twice.` };
+    }
+    headers[headerName] = line.slice(separator + 1).trim();
+  }
+  const decoded = decodeSharedMcpServer({
+    // Header secrets are stored under the id, so an edit keeps the saved
+    // server's (or its name, for an entry saved without one) through a rename.
+    id: editing === undefined ? newSharedMcpServerId(saved, name) : sharedMcpServerKey(editing),
+    name,
+    url: draft.url.trim(),
+    enabled: editing?.enabled ?? true,
+    headers,
+  });
+  if (Exit.isFailure(decoded)) return { error: "Enter an http:// or https:// URL." };
+  return { server: decoded.value };
+}
+
+/** Replace `editing` (or append) and return the next saved list. */
+export function upsertSharedMcpServer(
+  saved: ReadonlyArray<SharedMcpServer>,
+  server: SharedMcpServer,
+  editing?: SharedMcpServer,
+): ReadonlyArray<SharedMcpServer> {
+  if (editing === undefined) return [...saved, server];
+  return saved.map((entry) => (entry.name === editing.name ? server : entry));
+}
diff --git a/packages/contracts/src/rpc.ts b/packages/contracts/src/rpc.ts
index 225a38176e15..1a9334a34f44 100644
--- a/packages/contracts/src/rpc.ts
+++ b/packages/contracts/src/rpc.ts
@@ -328,6 +328,10 @@ import {
   ServerSettings,
   ServerSettingsError,
   ServerSettingsPatch,
+  SharedMcpServerName,
+  SharedMcpServerSignInResult,
+  SharedMcpServerTestError,
+  SharedMcpServerTestResult,
 } from "./settings.ts";
 import {
   ScheduledTaskDeleteInput,
@@ -484,6 +488,8 @@ export const WS_METHODS = {
   serverGetStorageCleanupReport: "server.getStorageCleanupReport",
   serverGetSettings: "server.getSettings",
   serverUpdateSettings: "server.updateSettings",
+  serverTestSharedMcpServer: "server.testSharedMcpServer",
+  serverSignInSharedMcpServer: "server.signInSharedMcpServer",
   serverDiscoverSourceControl: "server.discoverSourceControl",
   serverSearchAcpRegistry: "server.searchAcpRegistry",
   serverPrepareAcpRegistryAgent: "server.prepareAcpRegistryAgent",
@@ -773,6 +779,22 @@ const WsServerUpdateSettingsRpc = Rpc.make(WS_METHODS.serverUpdateSettings, {
   error: Schema.Union([ServerSettingsError, EnvironmentAuthorizationError]),
 });
 
+const WsServerTestSharedMcpServerRpc = Rpc.make(WS_METHODS.serverTestSharedMcpServer, {
+  payload: Schema.Struct({ name: SharedMcpServerName }),
+  success: SharedMcpServerTestResult,
+  error: Schema.Union([SharedMcpServerTestError, EnvironmentAuthorizationError]),
+});
+
+const WsServerSignInSharedMcpServerRpc = Rpc.make(WS_METHODS.serverSignInSharedMcpServer, {
+  payload: Schema.Struct({
+    name: SharedMcpServerName,
+    /** The environment's HTTP origin as the browser reaches it; the provider redirects back there. */
+    redirectBaseUrl: TrimmedNonEmptyString,
+  }),
+  success: SharedMcpServerSignInResult,
+  error: Schema.Union([SharedMcpServerTestError, EnvironmentAuthorizationError]),
+});
+
 const WsServerDiscoverSourceControlRpc = Rpc.make(WS_METHODS.serverDiscoverSourceControl, {
   payload: Schema.Struct({}),
   success: SourceControlDiscoveryResult,
@@ -1889,6 +1911,8 @@ export const WsRpcGroup = RpcGroup.make(
   WsServerGetStorageCleanupReportRpc,
   WsServerGetSettingsRpc,
   WsServerUpdateSettingsRpc,
+  WsServerTestSharedMcpServerRpc,
+  WsServerSignInSharedMcpServerRpc,
   WsServerDiscoverSourceControlRpc,
   WsServerSearchAcpRegistryRpc,
   WsServerPrepareAcpRegistryAgentRpc,
diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.ts
index e325729428ae..62dd238ffe7a 100644
--- a/packages/contracts/src/settings.ts
+++ b/packages/contracts/src/settings.ts
@@ -1058,6 +1058,88 @@ export const StorageCleanupSettings = Schema.Struct({
 });
 export type StorageCleanupSettings = typeof StorageCleanupSettings.Type;
 
+/**
+ * An MCP server the user adds once in T3 Code. Every agent session that gets
+ * T3's own `t3-code` server gets these too, so one entry (often a local MCP
+ * gateway) reaches Claude, Codex, Cursor, OpenCode, and ACP agents alike.
+ */
+export const SharedMcpServerName = TrimmedNonEmptyString.check(
+  // Names become TOML keys and tool prefixes, so keep them short and to a
+  // safe charset: providers cap MCP tool names at 64 characters.
+  Schema.isPattern(/^[A-Za-z0-9_-]+$/),
+  Schema.isMaxLength(24),
+  Schema.makeFilter((name: string) => name !== "t3-code" || "t3-code is T3 Code's own server"),
+);
+const SharedMcpServerUrl = TrimmedNonEmptyString.check(Schema.isPattern(/^https?:\/\/\S+$/));
+const SharedMcpServerHeaderName = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9-]+$/));
+
+export const SharedMcpServer = Schema.Struct({
+  /**
+   * Stable identity for the server's header secrets, so renaming keeps them.
+   * Clients assign one when adding a server; entries without one (e.g. hand
+   * edited) are keyed by name.
+   */
+  id: Schema.optionalKey(TrimmedNonEmptyString),
+  name: SharedMcpServerName,
+  url: SharedMcpServerUrl,
+  enabled: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(true))),
+  /**
+   * Request headers, typically auth. Values live in the server's secret store
+   * and reach clients redacted; a client sending the redaction marker back
+   * keeps the stored value.
+   */
+  headers: Schema.Record(SharedMcpServerHeaderName, Schema.String).pipe(
+    Schema.withDecodingDefault(Effect.succeed({})),
+  ),
+});
+export type SharedMcpServer = typeof SharedMcpServer.Type;
+
+/** The key a server's header secrets are stored under. */
+export const sharedMcpServerKey = (server: Pick<SharedMcpServer, "id" | "name">) =>
+  server.id ?? server.name;
+
+/**
+ * The list as written through a settings update: names identify servers in
+ * every provider, keys own header secrets, and header names are matched
+ * case-insensitively on the wire, so each must be unique. Enforced on writes
+ * only, so a hand-edited settings file still loads.
+ */
+const SharedMcpServersPatch = Schema.Array(SharedMcpServer).check(
+  Schema.makeFilter((servers: ReadonlyArray<SharedMcpServer>) => {
+    const unique = (values: ReadonlyArray<string>) => new Set(values).size === values.length;
+    if (!unique(servers.map((server) => server.name)))
+      return "Shared MCP server names must be unique";
+    if (!unique(servers.map(sharedMcpServerKey))) return "Shared MCP server ids must be unique";
+    return (
+      servers.every((server) =>
+        unique(Object.keys(server.headers).map((name) => name.toLowerCase())),
+      ) || "A shared MCP server's header names must be unique, ignoring case"
+    );
+  }),
+);
+
+export const SharedMcpServerTestResult = Schema.Struct({
+  serverName: Schema.NullOr(Schema.String),
+  toolCount: Schema.Number,
+});
+export type SharedMcpServerTestResult = typeof SharedMcpServerTestResult.Type;
+
+export class SharedMcpServerTestError extends Schema.TaggedError<SharedMcpServerTestError>()(
+  "SharedMcpServerTestError",
+  {
+    server: Schema.String,
+    message: Schema.String,
+    /** The server needs an OAuth sign-in from Settings before it can be used. */
+    needsSignIn: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))),
+  },
+) {}
+
+export const SharedMcpServerSignInResult = Schema.Struct({
+  /** Where to send the user; null when the server needs no sign-in. */
+  authorizationUrl: Schema.NullOr(Schema.String),
+});
+export type SharedMcpServerSignInResult = typeof SharedMcpServerSignInResult.Type;
+
 export const ServerSettings = Schema.Struct({
   // Null means no client has migrated this preference yet; an empty value is
   // authoritative so another device cannot resurrect cleared preferences.
@@ -1101,6 +1183,9 @@ export const ServerSettings = Schema.Struct({
    * between a desktop window and a phone attached to the same server.
    */
   enableAgentBrowserAccess: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(true))),
+  sharedMcpServers: Schema.Array(SharedMcpServer).pipe(
+    Schema.withDecodingDefault(Effect.succeed([])),
+  ),
   projectAgentBrowserAccessOverrides: Schema.Record(ProjectId, Schema.Boolean).pipe(
     Schema.withDecodingDefault(Effect.succeed({})),
   ),
@@ -1456,6 +1541,7 @@ export const ServerSettingsPatch = Schema.Struct({
   enableProviderUpdateChecks: Schema.optionalKey(Schema.Boolean),
   continueThreadsAfterServerUpdate: Schema.optionalKey(Schema.Boolean),
   enableAgentBrowserAccess: Schema.optionalKey(Schema.Boolean),
+  sharedMcpServers: Schema.optionalKey(SharedMcpServersPatch),
   projectAgentBrowserAccessOverrides: Schema.optionalKey(
     Schema.Record(ProjectId, Schema.NullOr(Schema.Boolean)),
   ),
diff --git a/packages/provider-acp/src/server/adapter.ts b/packages/provider-acp/src/server/adapter.ts
index 6e125b2318cf..b2185da7b5ad 100644
--- a/packages/provider-acp/src/server/adapter.ts
+++ b/packages/provider-acp/src/server/adapter.ts
@@ -693,8 +693,20 @@ function acpMcpContext(
   // every ACP session gets the `t3 acp-mcp-bridge` stdio server, which
   // forwards JSON-RPC to T3's authenticated MCP endpoint. The credential
   // travels via environment variables, never the command line.
+  // Shared servers are T3 endpoints too, so they ride the same bridge.
+  const sharedServers = (session.sharedServers ?? []).map((server) => ({
+    name: server.name,
+    command: self.command,
+    args: [...selfInvocationArgs(self, ["acp-mcp-bridge"])],
+    env: [
+      { name: "ELECTRON_RUN_AS_NODE", value: "1" },
+      { name: "T3_ACP_MCP_ENDPOINT", value: server.url },
+      { name: "T3_ACP_MCP_AUTHORIZATION", value: session.authorizationHeader },
+    ],
+  }));
   return {
     servers: [
+      ...sharedServers,
       {
         name: "t3-code",
         command: self.command,
@@ -706,7 +718,7 @@ function acpMcpContext(
         ],
       },
     ],
-    acpServers: [{ type: "acp", name: "t3-code", serverId: "t3-code" }],
+    acpServers: [...sharedServers, { type: "acp", name: "t3-code", serverId: "t3-code" }],
     endpoint: session.endpoint,
     authorization: session.authorizationHeader,
     processEnvironment: {
diff --git a/packages/provider-core/src/server/mcpSession.ts b/packages/provider-core/src/server/mcpSession.ts
index bea9b3ac5f4a..e7d10330aeaf 100644
--- a/packages/provider-core/src/server/mcpSession.ts
+++ b/packages/provider-core/src/server/mcpSession.ts
@@ -1,4 +1,32 @@
-import type { EnvironmentId, ProviderInstanceId, ThreadId } from "@t3tools/contracts";
+import {
+  type EnvironmentId,
+  type ProviderInstanceId,
+  type SharedMcpServer,
+  sharedMcpServerKey,
+  type ThreadId,
+} from "@t3tools/contracts";
+
+/** A shared MCP server as an agent session reaches it: through T3's proxy. */
+export interface SharedMcpSessionServer {
+  readonly name: string;
+  readonly url: string;
+  readonly headers: Readonly<Record<string, string>>;
+}
+
+/**
+ * The session entries for `servers`, each at `<endpoint>/shared/<key>` with
+ * the session's own credential.
+ */
+export function sharedMcpSessionServers(
+  servers: ReadonlyArray<SharedMcpServer>,
+  session: Pick<McpProviderSessionConfig, "endpoint" | "authorizationHeader">,
+): ReadonlyArray<SharedMcpSessionServer> {
+  return servers.map((server) => ({
+    name: server.name,
+    url: `${session.endpoint}/shared/${encodeURIComponent(sharedMcpServerKey(server))}`,
+    headers: { Authorization: session.authorizationHeader },
+  }));
+}
 
 export interface McpProviderSessionConfig {
   readonly environmentId: EnvironmentId;
@@ -22,6 +50,13 @@ export interface McpProviderSessionConfig {
    * already pointed at the server's daemon; the agent never handles a token.
    */
   readonly agentDeviceEnvironment?: Readonly<Record<string, string>>;
+  /**
+   * The user's enabled shared MCP servers (Settings → Integrations), captured
+   * when the session is prepared. Each points at T3's own proxy for that
+   * server and carries this session's credential, so agents attach them next
+   * to `t3-code` and never see the server's own headers or tokens.
+   */
+  readonly sharedServers?: ReadonlyArray<SharedMcpSessionServer>;
 }
 
 /** Provider env with the device variables applied over `base`, or `base` untouched. */
diff --git a/packages/provider-cursor/src/server/adapter.test.ts b/packages/provider-cursor/src/server/adapter.test.ts
index bbd813400da9..6190e4b6f199 100644
--- a/packages/provider-cursor/src/server/adapter.test.ts
+++ b/packages/provider-cursor/src/server/adapter.test.ts
@@ -870,6 +870,31 @@ describe("CursorAdapterV2", () => {
     }
   });
 
+  it("adds shared MCP servers next to t3-code", () => {
+    const servers = cursorMcpServers({
+      environmentId: EnvironmentId.make("environment-cursor-shared-mcp"),
+      threadId: ThreadId.make("thread-cursor-shared-mcp"),
+      providerSessionId: "mcp-session-cursor-shared",
+      providerInstanceId: ProviderInstanceId.make("cursor"),
+      endpoint: "http://127.0.0.1:43123/mcp",
+      authorizationHeader: "Bearer secret-cursor-mcp-token",
+      browserToolsAvailable: true,
+      sharedServers: [
+        {
+          name: "gateway",
+          url: "http://127.0.0.1:3050/mcp",
+          headers: { Authorization: "Bearer gateway-token" },
+        },
+      ],
+    });
+    assert.deepEqual(Object.keys(servers ?? {}), ["gateway", "t3-code"]);
+    assert.deepEqual(servers?.gateway, {
+      type: "http",
+      url: "http://127.0.0.1:3050/mcp",
+      headers: { Authorization: "Bearer gateway-token" },
+    });
+  });
+
   it("injects thread-scoped MCP credentials without logging them", () => {
     const threadId = ThreadId.make("thread-cursor-mcp");
     const mcpSession = {
diff --git a/packages/provider-cursor/src/server/adapter.ts b/packages/provider-cursor/src/server/adapter.ts
index f7cd8005eef5..21beb792e43d 100644
--- a/packages/provider-cursor/src/server/adapter.ts
+++ b/packages/provider-cursor/src/server/adapter.ts
@@ -208,6 +208,16 @@ export function cursorMcpServers(
     return undefined;
   }
   return {
+    ...Object.fromEntries(
+      (session.sharedServers ?? []).map((server) => [
+        server.name,
+        {
+          type: "http" as const,
+          url: server.url,
+          ...(Object.keys(server.headers).length === 0 ? {} : { headers: server.headers }),
+        },
+      ]),
+    ),
     "t3-code": {
       type: "http",
       url: session.endpoint,
diff --git a/packages/provider-opencode/src/server/adapter.test.ts b/packages/provider-opencode/src/server/adapter.test.ts
index c2ec42bd16b5..bb8c218174fe 100644
--- a/packages/provider-opencode/src/server/adapter.test.ts
+++ b/packages/provider-opencode/src/server/adapter.test.ts
@@ -3,6 +3,7 @@ import * as NodeServices from "@effect/platform-node/NodeServices";
 import type { OpencodeClient, ToolPart } from "@opencode-ai/sdk/v2";
 import {
   CheckpointId,
+  EnvironmentId,
   NodeId,
   ProjectId,
   ProviderInstanceId,
@@ -507,6 +508,51 @@ describe("OpenCodeAdapterV2", () => {
     ),
   );
 
+  it.effect("skips shared MCP servers on an external server, which may not reach T3's proxy", () =>
+    Effect.gen(function* () {
+      const scope = yield* Scope.make();
+      const threadId = ThreadId.make("thread-opencode-shared");
+      const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
+      yield* mcpSessions.set({
+        environmentId: EnvironmentId.make("environment-opencode-shared"),
+        threadId,
+        providerSessionId: "mcp-session-opencode-shared",
+        providerInstanceId: ProviderInstanceId.make("opencode-shared"),
+        endpoint: "http://127.0.0.1:43123/mcp",
+        authorizationHeader: "Bearer thread-credential",
+        browserToolsAvailable: false,
+        sharedServers: [
+          {
+            name: "gateway",
+            url: "http://127.0.0.1:43123/mcp/shared/gateway",
+            headers: { Authorization: "Bearer thread-credential" },
+          },
+        ],
+      });
+      yield* Effect.addFinalizer(() => mcpSessions.clear(threadId));
+      const calls: string[] = [];
+      yield* makeOpenCodeRuntimeHarness("shared", "root", {
+        event: { subscribe: async () => ({ stream: asyncEventStream().stream }) },
+        session: {
+          create: async () => ({ data: { id: "root", time: { created: 1, updated: 1 } } }),
+          abort: async () => ({ data: true }),
+          children: async () => ({ data: [] }),
+        },
+        mcp: {
+          add: async ({ name }: { name: string }) => {
+            calls.push(`add:${name}`);
+            return { data: {} };
+          },
+        },
+      }).pipe(Effect.provideService(Scope.Scope, scope));
+      yield* Scope.close(scope, Exit.void);
+      assert.deepEqual(calls, []);
+    }).pipe(
+      Effect.provide(Layer.merge(IdAllocator.layer, McpProviderSessions.layer)),
+      Effect.scoped,
+    ),
+  );
+
   it.effect.each(["enumeration", "abort", "not-found", "timeout"] as const)(
     "reports descendant cleanup %s",
     (failure) =>
diff --git a/packages/provider-opencode/src/server/adapter.ts b/packages/provider-opencode/src/server/adapter.ts
index b0b7f0ad29a3..f1eb14de59ce 100644
--- a/packages/provider-opencode/src/server/adapter.ts
+++ b/packages/provider-opencode/src/server/adapter.ts
@@ -84,6 +84,9 @@ import { openCodeToolTurnItem } from "./toolItems.ts";
 
 export { openCodeToolProjectionKind } from "./toolItems.ts";
 
+/** How long session opening waits for each shared MCP server add. */
+const SHARED_MCP_ADD_TIMEOUT = "5 seconds";
+
 export const OPENCODE_PROVIDER = ProviderDriverKind.make("opencode");
 export const OPENCODE_DEFAULT_INSTANCE_ID = defaultInstanceIdForDriver(OPENCODE_PROVIDER);
 export const OPENCODE_SDK_PROTOCOL = "opencode-sdk.sse" as const;
@@ -984,6 +987,34 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function
             }),
           );
         }
+        // Shared servers are T3's proxy endpoints, so they follow `t3-code`:
+        // an external server may not reach them. Each is an addition: one
+        // OpenCode cannot register must not fail the session, and a server
+        // that never answers can't hold it open.
+        for (const server of hasT3Mcp ? (mcpSession?.sharedServers ?? []) : []) {
+          yield* OpenCodeRuntime.runOpenCodeSdk("mcp.add", (signal) =>
+            client.mcp.add(
+              {
+                name: server.name,
+                config: {
+                  type: "remote",
+                  url: server.url,
+                  headers: { ...server.headers },
+                  oauth: false,
+                },
+              },
+              { signal },
+            ),
+          ).pipe(
+            Effect.timeout(SHARED_MCP_ADD_TIMEOUT),
+            Effect.catchCause((cause) =>
+              Effect.logWarning("Could not add a shared MCP server to OpenCode.", {
+                server: server.name,
+                cause,
+              }),
+            ),
+          );
+        }
 
         const now = yield* DateTime.now;
         let sessionEntity: OrchestrationV2ProviderSession = {
diff --git a/packages/provider-opencode/src/server/v2/adapter.ts b/packages/provider-opencode/src/server/v2/adapter.ts
index 785bf1a06e70..923347eb640d 100644
--- a/packages/provider-opencode/src/server/v2/adapter.ts
+++ b/packages/provider-opencode/src/server/v2/adapter.ts
@@ -75,6 +75,7 @@ import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost";
 import * as OpenCode2Client from "./OpenCode2Client.ts";
 import * as OpenCode2Server from "./OpenCode2Server.ts";
 import * as OpenCodeRuntime from "../OpenCodeRuntime.ts";
+import * as McpProviderSession from "@t3tools/provider-core/server/mcpSession";
 import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
 import { buildRuntimeInstructions } from "@t3tools/provider-core/server/runtimeInstructions";
 import { t3OrchestrationSystemPrompt } from "@t3tools/provider-core/server/orchestrationInstructions";
@@ -414,9 +415,24 @@ interface ThreadState {
    * inbox, where the next prompt would deliver them first, so it cancels them.
    */
   readonly strandedSteers: Set<string>;
-  /** T3's MCP server as registered for this thread, and the instructions entry sent with it. */
+  /**
+   * The MCP servers registered for this thread: T3's own (unless the server is
+   * external or adding it failed) and the shared ones (`names` lists every
+   * registered entry), and the instructions entry sent with them.
+   */
   mcp:
-    | { readonly name: string; readonly directory: string; readonly credential: string }
+    | {
+        readonly name: string;
+        readonly directory: string;
+        readonly credential: string;
+        /** The shared servers it was added with, to notice a change. */
+        readonly shared: ReadonlyArray<McpProviderSession.SharedMcpSessionServer>;
+        /** Whether T3's own server is among `names`, which gates its instructions. */
+        readonly t3: boolean;
+        readonly names: ReadonlyArray<string>;
+        /** Shared servers OpenCode refused, retried on the next turn. */
+        readonly missing: ReadonlyArray<McpProviderSession.SharedMcpSessionServer>;
+      }
     | undefined;
   instructions: string | undefined;
 }
@@ -488,6 +504,51 @@ export const t3McpServerName = Effect.fn("t3McpServerName")(function* (threadId:
  * this thread's own is allowed again, in every mode. A subagent's session
  * inherits the thread's.
  */
+
+/**
+ * A shared MCP server (Settings → Integrations) is registered per thread next
+ * to T3's, as `t3-shared-<thread>_<server>`. A distinct prefix keeps its tools
+ * out of T3's blanket allow. Like `t3McpServerName`, a thread id that would
+ * push the name past OpenCode's 64 characters (with the longest, 24-character
+ * server name) is replaced by a digest of it.
+ */
+export const sharedMcpServerPrefix = Effect.fn("sharedMcpServerPrefix")(function* (
+  threadId: string,
+) {
+  const prefix = `t3-shared-${threadId.replaceAll(/[^a-zA-Z0-9_-]/g, "_")}`;
+  if (prefix.length <= 39) return prefix;
+  const crypto = yield* Crypto.Crypto;
+  const digest = yield* crypto
+    .digest("SHA-256", new TextEncoder().encode(threadId))
+    .pipe(Effect.orDie);
+  return `t3-shared-${Hex.encode(digest).slice(0, 16)}`;
+});
+
+/**
+ * Other threads' shared entries are denied like their T3 servers. This
+ * thread's own ask for approval outside full access, as an agent's third-party
+ * tools should; they precede `grants` so "Always allow this session" holds.
+ */
+const sharedMcpRules = (policy: RulesPolicy, sharedPrefix: string | null): ReadonlyArray<Rule> =>
+  sharedPrefix === null
+    ? []
+    : [
+        rule("t3-shared-*", "deny"),
+        rule(`${sharedPrefix}_*`, policy.runtimeMode === "full-access" ? "allow" : "ask"),
+      ];
+
+const sameSharedServers = (
+  left: ReadonlyArray<McpProviderSession.SharedMcpSessionServer>,
+  right: ReadonlyArray<McpProviderSession.SharedMcpSessionServer>,
+) =>
+  left.length === right.length &&
+  left.every(
+    (server, index) =>
+      server.name === right[index]?.name &&
+      server.url === right[index]?.url &&
+      server.headers.Authorization === right[index]?.headers.Authorization,
+  );
+
 const mcpRules = (mcpServerName: string | null): ReadonlyArray<Rule> =>
   mcpServerName === null
     ? []
@@ -501,6 +562,7 @@ const sessionRules = (
   paths: ReadonlyArray<Rule>,
   grants: ReadonlyArray<Rule>,
   mcpServerName: string | null,
+  sharedPrefix: string | null,
 ): ReadonlyArray<Rule> => [
   ...(policy.runtimeMode === "full-access"
     ? [rule("*", "allow")]
@@ -509,6 +571,7 @@ const sessionRules = (
         rule("edit", policy.runtimeMode === "auto-accept-edits" ? "allow" : "ask"),
         rule("external_directory", "ask"),
       ]),
+  ...sharedMcpRules(policy, sharedPrefix),
   ...grants,
   // Plan mode writes only its plan, which `paths` allows again. Shell and read
   // are never denied: the free tier refuses sessions whose rules deny them.
@@ -855,6 +918,8 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
   const driver = OPENCODE_PROVIDER;
   const mcpServerNameFor = (threadId: string) =>
     t3McpServerName(threadId).pipe(Effect.provideService(Crypto.Crypto, crypto));
+  const sharedPrefixFor = (threadId: string) =>
+    sharedMcpServerPrefix(threadId).pipe(Effect.provideService(Crypto.Crypto, crypto));
 
   /**
    * Lends the instance's server to a session until its scope closes. A spawned
@@ -3102,6 +3167,7 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
         paths,
         policy.runtimeMode === "full-access" ? [] : thread.grants,
         appThreadId === null ? null : yield* mcpServerNameFor(appThreadId),
+        appThreadId === null ? null : yield* sharedPrefixFor(appThreadId),
       );
     });
 
@@ -3343,10 +3409,18 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
         resolveAttachmentPath: host.resolveAttachmentPath,
       }).trim();
 
-    const removeMcp = (mcp: { readonly name: string; readonly directory: string }) =>
-      Effect.suspend(() =>
-        client.mcp.remove({ server: mcp.name, location: { directory: mcp.directory } }),
-      ).pipe(Effect.timeout("5 seconds"), Effect.ignore({ log: true }));
+    const removeMcp = (mcp: {
+      readonly names: ReadonlyArray<string>;
+      readonly directory: string;
+    }) =>
+      Effect.forEach(
+        mcp.names,
+        (server) =>
+          Effect.suspend(() =>
+            client.mcp.remove({ server, location: { directory: mcp.directory } }),
+          ).pipe(Effect.timeout("5 seconds"), Effect.ignore({ log: true })),
+        { discard: true },
+      );
 
     // T3's MCP registrations outlive a session only on an external server; a
     // spawned one forgets them when it stops.
@@ -3361,10 +3435,11 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
     /**
      * T3's MCP server for this thread, and the per-turn instructions. The MCP
      * server is registered for the session's directory under the thread's own
-     * name and credential (the session rules allow only it), and removed when
-     * the thread unloads or the session closes. OpenCode 2 has no per-prompt
-     * system field, so the instructions are a session instructions entry,
-     * which applies from the next step; it is only rewritten when it changes.
+     * name and credential (the session rules allow only it), with the thread's
+     * shared servers next to it, and all are removed when the thread unloads or
+     * the session closes. OpenCode 2 has no per-prompt system field, so the
+     * instructions are a session instructions entry, which applies from the
+     * next step; it is only rewritten when it changes.
      */
     const prepareTurn = Effect.fnUntraced(function* (
       sessionId: string,
@@ -3374,47 +3449,97 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
       const mcpSession = yield* mcpSessions.read(turnInput.threadId);
       const directory = turnInput.runtimePolicy.cwd ?? host.paths.cwd;
       const name = yield* mcpServerNameFor(turnInput.threadId);
-      // An external server may not reach T3's MCP endpoint, as with 1.x.
+      const sharedPrefix = yield* sharedPrefixFor(turnInput.threadId);
+      // Shared servers are T3's proxy endpoints, so like T3's own server an
+      // external OpenCode may not reach them.
+      const sharedServers = connection.external ? [] : (mcpSession?.sharedServers ?? []);
       const wanted =
-        mcpSession === undefined || connection.external
+        mcpSession === undefined
           ? undefined
-          : { name, directory, credential: mcpSession.authorizationHeader };
+          : {
+              name,
+              directory,
+              credential: mcpSession.authorizationHeader,
+              shared: sharedServers,
+            };
       if (
         state.mcp !== undefined &&
         (wanted === undefined ||
           state.mcp.directory !== wanted.directory ||
-          state.mcp.credential !== wanted.credential)
+          state.mcp.credential !== wanted.credential ||
+          !sameSharedServers(state.mcp.shared, wanted.shared))
       ) {
         yield* removeMcp(state.mcp);
         state.mcp = undefined;
       }
-      // T3's tools are an addition: a server that cannot add them still runs the turn.
+      // Every registration is an addition: one OpenCode cannot add is logged
+      // and skipped, and the turn still runs.
+      const addMcp = (server: string, config: Mcp.RemoteConfig, label: string) =>
+        client.mcp.add({ server, location: { directory }, config }).pipe(
+          Effect.timeout(INVENTORY_TIMEOUT),
+          Effect.as(true),
+          Effect.catchCause((cause) =>
+            Effect.logWarning(`Could not add ${label} to OpenCode.`, cause).pipe(Effect.as(false)),
+          ),
+        );
+      // An external server may not reach T3's MCP endpoint, as with 1.x.
+      const addT3 = () =>
+        connection.external
+          ? Effect.succeed(false)
+          : addMcp(
+              name,
+              new Mcp.RemoteConfig({
+                type: "remote",
+                url: mcpSession!.endpoint,
+                headers: { Authorization: mcpSession!.authorizationHeader },
+                oauth: false,
+              }),
+              "T3 Code's MCP server",
+            );
+      const addShared = (server: McpProviderSession.SharedMcpSessionServer) =>
+        addMcp(
+          `${sharedPrefix}_${server.name}`,
+          new Mcp.RemoteConfig({
+            type: "remote",
+            url: server.url,
+            ...(Object.keys(server.headers).length === 0 ? {} : { headers: server.headers }),
+            oauth: false,
+          }),
+          `shared MCP server ${server.name}`,
+        );
+      // One that fails is retried next turn, as T3's own is.
+      const addAll = (
+        t3Wanted: boolean,
+        shared: ReadonlyArray<McpProviderSession.SharedMcpSessionServer>,
+      ) =>
+        Effect.gen(function* () {
+          const t3 = t3Wanted ? yield* addT3() : false;
+          const names: Array<string> = t3 ? [name] : [];
+          const missing: Array<McpProviderSession.SharedMcpSessionServer> = [];
+          for (const server of shared) {
+            if (yield* addShared(server)) {
+              names.push(`${sharedPrefix}_${server.name}`);
+            } else missing.push(server);
+          }
+          return { t3, names, missing };
+        });
       if (wanted !== undefined && state.mcp === undefined) {
-        const added = yield* client.mcp
-          .add({
-            server: name,
-            location: { directory },
-            config: new Mcp.RemoteConfig({
-              type: "remote",
-              url: mcpSession!.endpoint,
-              headers: { Authorization: wanted.credential },
-              oauth: false,
-            }),
-          })
-          .pipe(
-            Effect.timeout(INVENTORY_TIMEOUT),
-            Effect.as(true),
-            Effect.catchCause((cause) =>
-              Effect.logWarning("Could not add T3 Code's MCP server to OpenCode.", cause).pipe(
-                Effect.as(false),
-              ),
-            ),
-          );
-        if (added) state.mcp = wanted;
+        state.mcp = { ...wanted, ...(yield* addAll(true, sharedServers)) };
+      } else if (
+        state.mcp !== undefined &&
+        ((!state.mcp.t3 && !connection.external) || state.mcp.missing.length > 0)
+      ) {
+        const retried = yield* addAll(!state.mcp.t3, state.mcp.missing);
+        state.mcp = {
+          ...state.mcp,
+          t3: state.mcp.t3 || retried.t3,
+          names: [...state.mcp.names, ...retried.names],
+          missing: retried.missing,
+        };
       }
       const instructions = [
         buildRuntimeInstructions({ harness: "OpenCode", model: turnInput.modelSelection.model }),
-        t3OrchestrationSystemPrompt(state.mcp !== undefined),
+        t3OrchestrationSystemPrompt(state.mcp?.t3 === true),
       ]
         .filter((part) => part !== undefined && part.length > 0)
         .join("\n\n");
diff --git a/packages/provider-opencode/src/testing.ts b/packages/provider-opencode/src/testing.ts
index 5fa87cde4e50..4337988d3183 100644
--- a/packages/provider-opencode/src/testing.ts
+++ b/packages/provider-opencode/src/testing.ts
@@ -10,4 +10,8 @@ export {
   OPENCODE_PROVIDER,
   OPENCODE_SDK_PROTOCOL,
 } from "./server/adapter.ts";
-export { OPENCODE_2_STILL_STOPPING, t3McpServerName } from "./server/v2/adapter.ts";
+export {
+  OPENCODE_2_STILL_STOPPING,
+  sharedMcpServerPrefix,
+  t3McpServerName,
+} from "./server/v2/adapter.ts";
diff --git a/packages/provider-pi/src/server/mcpExtensionSource.test.ts b/packages/provider-pi/src/server/mcpExtensionSource.test.ts
index b8857d3c629c..8af5949fd28f 100644
--- a/packages/provider-pi/src/server/mcpExtensionSource.test.ts
+++ b/packages/provider-pi/src/server/mcpExtensionSource.test.ts
@@ -505,3 +505,125 @@ describe("Pi skill references", () => {
     }
   });
 });
+
+describe("Pi shared MCP servers", () => {
+  // Modern Pi discovers shared tools on demand, like t3-code's optional ones.
+  it.each([false, true])(
+    "registers each shared server's tools under its name, with its own headers (modern Pi: %s)",
+    async (modern) => {
+      type Request = { id?: number; method: string; params?: unknown };
+      const requests: Array<{ url: string; headers: Record<string, string>; body: Request }> = [];
+      const fetch = async (
+        url: string,
+        init: { headers: Record<string, string>; body: string },
+      ) => {
+        const body = JSON.parse(init.body) as Request;
+        requests.push({ url, headers: init.headers, body });
+        if (body.id === undefined) return new Response(null, { status: 202 });
+        const tool = url.includes("3050") ? "search" : "t3_thread_read";
+        const result =
+          body.method === "tools/list"
+            ? {
+                tools: [
+                  {
+                    name: tool,
+                    inputSchema: { type: "object" },
+                    annotations: { readOnlyHint: true },
+                  },
+                ],
+              }
+            : body.method === "tools/call"
+              ? { content: [{ type: "text", text: `${tool} ran` }] }
+              : {};
+        return Response.json({ jsonrpc: "2.0", id: body.id, result });
+      };
+      type Tool = {
+        exposure?: string;
+        execute: (id: string, params: unknown) => Promise<{ content: Array<{ text: string }> }>;
+      };
+      const tools = new Map<string, Tool>();
+      const handlers = new Map<string, Function>();
+      const extensionPath = "/t3/extensions/t3-mcp.ts";
+      const source = NodeModule.stripTypeScriptTypes(
+        PI_T3_MCP_EXTENSION_SOURCE.replace(/^import .*;$/gm, "").replace(
+          "export default async function",
+          "async function",
+        ),
+      );
+      await NodeVM.runInNewContext(`${source}\nt3McpExtension(pi)`, {
+        fetch,
+        AbortSignal,
+        NodePath,
+        Type: { Unsafe: (schema: unknown) => schema },
+        process: {
+          env: {
+            T3_MCP_URL: "http://127.0.0.1:43123/mcp",
+            T3_MCP_BEARER_TOKEN: "secret-pi-token",
+            T3_PI_RUNTIME_MODE: "approval-required",
+            T3_PI_MCP_EXTENSION_PATH: extensionPath,
+            T3_MCP_SHARED_SERVERS: JSON.stringify([
+              {
+                name: "gateway",
+                url: "http://127.0.0.1:3050/mcp",
+                headers: { Authorization: "Bearer gateway-token", "Content-Type": "text/plain" },
+              },
+            ]),
+          },
+        },
+        pi: {
+          on: (event: string, handler: Function) => handlers.set(event, handler),
+          registerTool: (tool: Tool & { name: string }) => tools.set(tool.name, tool),
+          ...(modern
+            ? {
+                registerMcpServer: () => undefined,
+                getAllTools: () => [
+                  { name: "tool_search", sourceInfo: { path: "builtin:tool-search" } },
+                  ...[...tools.keys()].map((name) => ({
+                    name,
+                    sourceInfo: { path: extensionPath },
+                  })),
+                ],
+              }
+            : {}),
+        },
+      });
+      assert.deepEqual([...tools.keys()].toSorted(), [
+        "mcp__gateway__search",
+        "mcp__t3-code__t3_thread_read",
+        ...(modern ? ["mcp__t3_code__t3_thread_read"] : []),
+      ]);
+      assert.equal(tools.get("mcp__gateway__search")?.exposure, modern ? "deferred" : undefined);
+
+      const result = await tools.get("mcp__gateway__search")!.execute("call-1", { q: "x" });
+      assert.equal(result.content[0]?.text, "search ran");
+      const call = requests.find((request) => request.body.method === "tools/call");
+      assert.equal(call?.url, "http://127.0.0.1:3050/mcp");
+      assert.deepEqual(call?.body.params, { name: "search", arguments: { q: "x" } });
+      // The gateway gets its own header, never T3's credential, and a user
+      // header can't sit beside the protocol's own under another casing.
+      for (const request of requests.filter((entry) => entry.url.includes("3050"))) {
+        assert.equal(request.headers.authorization, "Bearer gateway-token");
+        assert.equal(request.headers["content-type"], "application/json");
+        assert.isUndefined(request.headers["Content-Type"]);
+      }
+
+      // Only T3's own read-only hints skip approval; a shared server's are its own claim.
+      const confirmations: string[] = [];
+      const ctx = {
+        ui: {
+          confirm: async (title: string) => {
+            confirmations.push(title);
+            return false;
+          },
+        },
+      };
+      const toolCall = (toolName: string) =>
+        handlers.get("tool_call")!({ toolName, input: {} }, ctx) as Promise<
+          { block: true } | undefined
+        >;
+      assert.equal((await toolCall("mcp__gateway__search"))?.block, true);
+      if (modern) assert.isUndefined(await toolCall("mcp__t3-code__t3_thread_read"));
+      assert.equal(confirmations.length, 1);
+    },
+  );
+});
diff --git a/packages/provider-pi/src/server/mcpExtensionSource.ts b/packages/provider-pi/src/server/mcpExtensionSource.ts
index 7071b1ae6209..9cfa588b135b 100644
--- a/packages/provider-pi/src/server/mcpExtensionSource.ts
+++ b/packages/provider-pi/src/server/mcpExtensionSource.ts
@@ -16,6 +16,8 @@ export const T3_MCP_URL_ENV = "T3_MCP_URL";
 export const T3_MCP_BEARER_ENV = "T3_MCP_BEARER_TOKEN";
 export const T3_PI_RUNTIME_MODE_ENV = "T3_PI_RUNTIME_MODE";
 export const T3_PI_MCP_EXTENSION_PATH_ENV = "T3_PI_MCP_EXTENSION_PATH";
+/** The thread's shared MCP servers as a JSON array of `{ name, url, headers }`. */
+export const T3_MCP_SHARED_SERVERS_ENV = "T3_MCP_SHARED_SERVERS";
 
 /**
  * Pi tools whose confirmations the bridge raises as file-change approvals.
@@ -33,6 +35,7 @@ const URL_ENV = ${JSON.stringify(T3_MCP_URL_ENV)};
 const TOKEN_ENV = ${JSON.stringify(T3_MCP_BEARER_ENV)};
 const RUNTIME_MODE_ENV = ${JSON.stringify(T3_PI_RUNTIME_MODE_ENV)};
 const EXTENSION_PATH_ENV = ${JSON.stringify(T3_PI_MCP_EXTENSION_PATH_ENV)};
+const SHARED_SERVERS_ENV = ${JSON.stringify(T3_MCP_SHARED_SERVERS_ENV)};
 const ORCHESTRATION_INSTRUCTIONS = ${JSON.stringify(T3_CODE_ORCHESTRATION_INSTRUCTIONS.trim())};
 const PROTOCOL = "2025-06-18";
 const READ_ONLY_TOOLS = new Set(["read", "grep", "find", "ls"]);
@@ -56,11 +59,33 @@ type McpTool = {
   readonly outputSchema?: Record<string, unknown>;
 };
 
+type SharedServer = {
+  readonly name: string;
+  readonly url: string;
+  readonly headers: Record<string, string>;
+};
+
 function env(name: string): string | undefined {
   const value = process.env[name];
   return value && value.length > 0 ? value : undefined;
 }
 
+function sharedServers(): SharedServer[] {
+  try {
+    const parsed: unknown = JSON.parse(env(SHARED_SERVERS_ENV) ?? "[]");
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (server): server is SharedServer =>
+        typeof server?.name === "string" &&
+        typeof server?.url === "string" &&
+        typeof server?.headers === "object" &&
+        server.headers !== null,
+    );
+  } catch {
+    return [];
+  }
+}
+
 function runtimeMode(): RuntimeMode {
   const value = env(RUNTIME_MODE_ENV);
   return value === "approval-required" ||
@@ -164,14 +189,18 @@ function isMcpToolError(result: unknown): boolean {
   );
 }
 
-function createMcpClient(endpoint: string, token: string) {
+function createMcpClient(endpoint: string, requestHeaders: Record<string, string>) {
   let nextId = 1;
   let sessionId: string | undefined;
 
   const headers = (): Record<string, string> => {
+    // Lowercased, so a shared server's \`Accept\` or \`Content-Type\` is
+    // replaced by the protocol's own instead of merged with it.
     const next: Record<string, string> = {
+      ...Object.fromEntries(
+        Object.entries(requestHeaders).map(([name, value]) => [name.toLowerCase(), value]),
+      ),
       accept: "application/json, text/event-stream",
-      authorization: token.startsWith("Bearer ") ? token : \`Bearer \${token}\`,
       "content-type": "application/json",
       // Effect's HTTP MCP rejects post-initialize requests without this
       // (400). The worktree client in McpHttpServer tests sends the same
@@ -356,70 +385,89 @@ export default async function t3McpExtension(pi: ExtensionAPI) {
   const supportsExposure = "registerMcpServer" in pi && typeof pi.registerMcpServer === "function";
   const directTools = new Set(["orchestrator_capabilities", "delegate_task", "task_status"]);
   let deferOptionalTools = supportsExposure;
-  let catalog: ReadonlyArray<McpTool> = [];
-
-  const client = createMcpClient(endpoint, token);
-  let started: Promise<void> | undefined;
-
-  const registerTools = () => {
-    // Preserve public names for saved loadouts and tool selectors. Hidden
-    // canonical names reserve ownership against Pi's configured MCP servers.
-    const prefixes = supportsExposure ? ["mcp__t3-code__", "mcp__t3_code__"] : ["mcp__t3-code__"];
-    readOnlyMcpTools.clear();
-    for (const tool of catalog) {
-      const name = tool.name;
-      for (const prefix of prefixes) {
-        if (tool.annotations?.readOnlyHint === true) readOnlyMcpTools.add(\`\${prefix}\${name}\`);
-        const exposure = prefix === "mcp__t3_code__" ? "hidden" :
-          deferOptionalTools && !directTools.has(name) ? "deferred" : "direct";
-        pi.registerTool({
-          name: \`\${prefix}\${name}\`,
-          label: name,
-          description: tool.description ?? name,
-          parameters: jsonSchemaToTypebox(tool.inputSchema),
-          ...(supportsExposure ? { outputSchema: mcpOutputSchema(tool) } : {}),
-          ...(supportsExposure ? { exposure } : {}),
-          async execute(_toolCallId, params, signal) {
-            const result = await client.callTool(
-              name,
-              (params ?? {}) as Record<string, unknown>,
-              signal,
-            );
-            const content = mcpModelContent(result);
-            if (isMcpToolError(result) && !content.some((part) => part.type === "text" && part.text.length > 0)) {
-              content.push({ type: "text", text: "MCP tool t3-code/" + name + " returned an error" });
-            }
-            return {
-              content,
-              structuredContent: mcpScriptResult(result),
-              details: { server: "t3-code", tool: name },
-              ...(isMcpToolError(result) ? { isError: true } : {}),
-            };
-          },
-        });
+
+  // Registers one MCP server's tools as \`mcp__<server>__<tool>\`, once it answers.
+  const bridgeServer = (server: string, client: ReturnType<typeof createMcpClient>) => {
+    const isT3 = server === "t3-code";
+    let catalog: ReadonlyArray<McpTool> = [];
+    let started: Promise<void> | undefined;
+
+    const registerTools = () => {
+      // Preserve public names for saved loadouts and tool selectors. Hidden
+      // canonical names reserve ownership against Pi's configured MCP servers.
+      const prefixes =
+        isT3 && supportsExposure ? ["mcp__t3-code__", "mcp__t3_code__"] : [\`mcp__\${server}__\`];
+      // Only T3's own read-only hints skip approval; a shared server's are its own claim.
+      if (isT3) readOnlyMcpTools.clear();
+      for (const tool of catalog) {
+        const name = tool.name;
+        for (const prefix of prefixes) {
+          if (isT3 && tool.annotations?.readOnlyHint === true) readOnlyMcpTools.add(\`\${prefix}\${name}\`);
+          const exposure = prefix === "mcp__t3_code__" ? "hidden" :
+            deferOptionalTools && !(isT3 && directTools.has(name)) ? "deferred" : "direct";
+          pi.registerTool({
+            name: \`\${prefix}\${name}\`,
+            label: name,
+            description: tool.description ?? name,
+            parameters: jsonSchemaToTypebox(tool.inputSchema),
+            ...(supportsExposure ? { outputSchema: mcpOutputSchema(tool) } : {}),
+            ...(supportsExposure ? { exposure } : {}),
+            async execute(_toolCallId, params, signal) {
+              const result = await client.callTool(
+                name,
+                (params ?? {}) as Record<string, unknown>,
+                signal,
+              );
+              const content = mcpModelContent(result);
+              if (isMcpToolError(result) && !content.some((part) => part.type === "text" && part.text.length > 0)) {
+                content.push({ type: "text", text: "MCP tool " + server + "/" + name + " returned an error" });
+              }
+              return {
+                content,
+                structuredContent: mcpScriptResult(result),
+                details: { server, tool: name },
+                ...(isMcpToolError(result) ? { isError: true } : {}),
+              };
+            },
+          });
+        }
       }
-    }
-  };
+    };
 
-  const ensureStarted = () => {
-    if (started !== undefined) return started;
-    const attempt = (async () => {
-      const signal = AbortSignal.timeout(10_000);
-      await client.connect(signal);
-      catalog = await client.listTools(signal);
-      registerTools();
-    })();
-    started = attempt;
-    void attempt.catch(() => {
-      if (started === attempt) started = undefined;
-    });
-    return attempt;
+    const ensureStarted = () => {
+      if (started !== undefined) return started;
+      const attempt = (async () => {
+        const signal = AbortSignal.timeout(10_000);
+        await client.connect(signal);
+        catalog = await client.listTools(signal);
+        registerTools();
+      })();
+      started = attempt;
+      void attempt.catch(() => {
+        if (started === attempt) started = undefined;
+      });
+      return attempt;
+    };
+    return { server, ensureStarted, registerTools };
   };
 
+  // The user's shared servers ride along with t3-code, without its credential.
+  const servers = [
+    bridgeServer(
+      "t3-code",
+      createMcpClient(endpoint, {
+        authorization: token.startsWith("Bearer ") ? token : \`Bearer \${token}\`,
+      }),
+    ),
+    ...sharedServers().map((shared) =>
+      bridgeServer(shared.name, createMcpClient(shared.url, shared.headers)),
+    ),
+  ];
+
   // CLI extensions load before builtins, and Pi keeps the first registration
   // of a tool name. Register now so the bridge owns the T3 namespace even when
   // mcp.json configures it; retry a failed connection at session_start.
-  await ensureStarted().catch(() => undefined);
+  await Promise.all(servers.map((entry) => entry.ensureStarted().catch(() => undefined)));
 
   const reconcileDiscovery = () => {
     if (!supportsExposure) return;
@@ -427,7 +475,7 @@ export default async function t3McpExtension(pi: ExtensionAPI) {
     const hasToolSearch = hasBuiltinToolSearch();
     const exposureChanged = deferOptionalTools !== hasToolSearch;
     deferOptionalTools = hasToolSearch;
-    if (exposureChanged) registerTools();
+    if (exposureChanged) for (const entry of servers) entry.registerTools();
     if (hasToolSearch) {
       const active = pi.getActiveTools();
       if (!active.includes("tool_search")) pi.setActiveTools([...active, "tool_search"]);
@@ -438,11 +486,13 @@ export default async function t3McpExtension(pi: ExtensionAPI) {
   pi.on("session_tree", reconcileDiscovery);
   pi.on("session_start", async (_event, ctx) => {
     reconcileDiscovery();
-    try {
-      await ensureStarted();
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      ctx.ui.notify(\`t3-code MCP unavailable: \${message}\`, "warning");
+    for (const entry of servers) {
+      try {
+        await entry.ensureStarted();
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.ui.notify(\`\${entry.server} MCP unavailable: \${message}\`, "warning");
+      }
     }
   });
 
diff --git a/packages/provider-pi/src/server/mcpInjection.test.ts b/packages/provider-pi/src/server/mcpInjection.test.ts
index 50d21afd32b4..ea52cae43497 100644
--- a/packages/provider-pi/src/server/mcpInjection.test.ts
+++ b/packages/provider-pi/src/server/mcpInjection.test.ts
@@ -7,6 +7,7 @@ import * as FileSystem from "effect/FileSystem";
 import {
   PI_T3_MCP_EXTENSION_FILENAME,
   T3_MCP_BEARER_ENV,
+  T3_MCP_SHARED_SERVERS_ENV,
   T3_MCP_URL_ENV,
   T3_PI_RUNTIME_MODE_ENV,
   T3_PI_MCP_EXTENSION_PATH_ENV,
@@ -95,6 +96,36 @@ describe("pi T3 MCP injection", () => {
     );
   });
 
+  it("passes the thread's shared MCP servers to the extension only with T3's", () => {
+    const gateway = {
+      name: "gateway",
+      url: "http://127.0.0.1:3050/mcp",
+      enabled: true,
+      headers: { Authorization: "Bearer gateway-token" },
+    };
+    const launch = buildPiRpcLaunch({
+      launchArgs: [],
+      environment: { [T3_MCP_SHARED_SERVERS_ENV]: "[]" },
+      mcpSession: { ...mcpSession, sharedServers: [gateway] },
+      extensionPath: "/tmp/cache/pi-t3-mcp-extension.ts",
+    });
+    assert.deepEqual(JSON.parse(launch.env[T3_MCP_SHARED_SERVERS_ENV] ?? ""), [
+      {
+        name: "gateway",
+        url: "http://127.0.0.1:3050/mcp",
+        headers: { Authorization: "Bearer gateway-token" },
+      },
+    ]);
+    const withoutT3 = buildPiRpcLaunch({
+      launchArgs: [],
+      environment: { [T3_MCP_SHARED_SERVERS_ENV]: "[]" },
+      mcpSession: { ...mcpSession, sharedServers: [gateway] },
+      extensionPath: "/tmp/cache/pi-t3-mcp-extension.ts",
+      disableExtensions: true,
+    });
+    assert.isUndefined(withoutT3.env[T3_MCP_SHARED_SERVERS_ENV]);
+  });
+
   it("falls back to Pi's first supported mode for legacy auto threads", () => {
     const launch = buildPiRpcLaunch({
       launchArgs: [],
@@ -170,6 +201,7 @@ describe("pi T3 MCP injection", () => {
       assert.include(mcpSource, '"tools/call"');
       assert.include(mcpSource, "mcp__t3-code__");
       assert.include(mcpSource, "mcp__t3_code__");
+      assert.include(mcpSource, "mcp__${server}__");
     }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
   );
 });
diff --git a/packages/provider-pi/src/server/mcpInjection.ts b/packages/provider-pi/src/server/mcpInjection.ts
index 260b37642e91..c3da9f4e0693 100644
--- a/packages/provider-pi/src/server/mcpInjection.ts
+++ b/packages/provider-pi/src/server/mcpInjection.ts
@@ -7,6 +7,7 @@ import {
   PI_T3_MCP_EXTENSION_FILENAME,
   PI_T3_MCP_EXTENSION_SOURCE,
   T3_MCP_BEARER_ENV,
+  T3_MCP_SHARED_SERVERS_ENV,
   T3_MCP_URL_ENV,
   T3_PI_RUNTIME_MODE_ENV,
   T3_PI_MCP_EXTENSION_PATH_ENV,
@@ -293,6 +294,8 @@ export function buildPiRpcLaunch(input: {
   delete environment[T3_MCP_URL_ENV];
   delete environment[T3_MCP_BEARER_ENV];
   delete environment[T3_PI_MCP_EXTENSION_PATH_ENV];
+  delete environment[T3_MCP_SHARED_SERVERS_ENV];
+  const sharedServers = input.mcpSession?.sharedServers ?? [];
 
   return {
     args,
@@ -313,6 +316,13 @@ export function buildPiRpcLaunch(input: {
             [T3_MCP_BEARER_ENV]: bearerTokenFromAuthorizationHeader(
               input.mcpSession.authorizationHeader,
             ),
+            ...(sharedServers.length === 0
+              ? {}
+              : {
+                  [T3_MCP_SHARED_SERVERS_ENV]: JSON.stringify(
+                    sharedServers.map(({ name, url, headers }) => ({ name, url, headers })),
+                  ),
+                }),
           }
         : {}),
     },
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 7e6efe075030..678384ea2041 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -615,6 +615,9 @@ importers:
       '@ff-labs/fff-node':
         specifier: 0.11.0
         version: 0.11.0(patch_hash=8956d6ed6938a1bce69b2d0b067ff258dd9ca753c5bbe7006f7b68f760ea3ad2)
+      '@modelcontextprotocol/sdk':
+        specifier: 1.29.0
+        version: 1.29.0(zod@4.6.5)
       '@muse-code/sdk':
         specifier: 1.4.2
         version: 1.4.2(@types/node@24.12.4)
@@ -700,9 +703,6 @@ importers:
       '@effect/vitest':
         specifier: 4.0.2
         version: 4.0.2(patch_hash=595b7d26fb635caba9c3d39fcb189bb78a000192f8d3b60ead7174b310d1ade9)(@types/node@24.12.4)(@vitest/ui@5.0.1)(bufferutil@4.1.0)(effect@4.0.2(patch_hash=ec61ee307eaec3e17f757e0e6a16296ea4b7a8c3188df0c6ec5e66301fd78688))(esbuild@0.28.2)(jiti@2.7.0)(jsdom@30.1.0(@noble/hashes@1.8.0))(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0)
-      '@modelcontextprotocol/sdk':
-        specifier: 1.29.0
-        version: 1.29.0(zod@4.6.5)
       '@t3tools/contracts':
         specifier: workspace:*
         version: link:../../packages/contracts