coder · ibetitsmike · Aug 19, 2026 · Aug 13, 2026 · Aug 13, 2026 · Aug 13, 2026
diff --git a/coderd/audit.go b/coderd/audit.go
@@ -8,6 +8,7 @@ import (
 	"net"
 	"net/http"
 	"net/netip"
+	"net/url"
 	"strings"
 	"time"
 
@@ -22,7 +23,6 @@ import (
 	"github.com/coder/coder/v2/coderd/database/dbauthz"
 	"github.com/coder/coder/v2/coderd/httpapi"
 	"github.com/coder/coder/v2/coderd/httpmw"
-	"github.com/coder/coder/v2/coderd/rbac"
 	"github.com/coder/coder/v2/coderd/rbac/policy"
 	"github.com/coder/coder/v2/coderd/searchquery"
 	"github.com/coder/coder/v2/codersdk"
@@ -619,16 +619,29 @@ func (api *API) auditLogResourceLink(ctx context.Context, alog database.GetAudit
 		// not username-scoped in the URL like workspaces or tasks.
 		return fmt.Sprintf("/agents/%s", alog.AuditLog.ResourceID)
 	case database.ResourceTypeMCPServerConfig:
+		// Mutation-only administrators may lack read access, so fetch
+		// with system access; the explicit checks below authorize.
+		//nolint:gocritic // The requester is authorized against the fetched config right below.
+		config, err := api.Database.GetMCPServerConfigByID(dbauthz.AsSystemRestricted(ctx), alog.AuditLog.ResourceID)
+		if err != nil {
+			return ""
+		}
 		actor, ok := dbauthz.ActorFromContext(ctx)
 		if !ok {
 			return ""
 		}
-		// The MCP settings page admits only deployment-config managers,
-		// so emit the link only for callers the page will accept.
-		if err := api.HTTPAuth.Authorizer.Authorize(ctx, actor, policy.ActionUpdate, rbac.ResourceDeploymentConfig); err != nil {
+		// The MCP settings page admits anyone who can manage the
+		// config, so emit the link only for callers it will accept.
+		if err := api.HTTPAuth.Authorizer.Authorize(ctx, actor, policy.ActionUpdate, config.RBACObject()); err != nil {
+			if err := api.HTTPAuth.Authorizer.Authorize(ctx, actor, policy.ActionDelete, config.RBACObject()); err != nil {
+				return ""
+			}
+		}
+		organization, err := api.Database.GetOrganizationByID(ctx, alog.AuditLog.OrganizationID)
+		if err != nil {
 			return ""
 		}
-		return fmt.Sprintf("/ai/settings/mcp-servers/%s", alog.AuditLog.ResourceID)
+		return fmt.Sprintf("/ai/settings/mcp-servers/%s?org=%s", alog.AuditLog.ResourceID, url.QueryEscape(organization.Name))
 	case database.ResourceTypeUserSecret:
 		// TODO(PLAT-102): point at the user secrets management page once
 		// it ships. Until then, the audit row links nowhere.

diff --git a/coderd/audit_test.go b/coderd/audit_test.go
@@ -152,16 +152,20 @@ func TestAuditLogs(t *testing.T) {
 		client := coderdtest.New(t, &coderdtest.Options{Database: db, Pubsub: ps})
 		user := coderdtest.CreateFirstUser(t, client)
 		auditor, _ := coderdtest.CreateAnotherUser(t, client, user.OrganizationID, rbac.RoleAuditor())
-		orgAdmin, _ := coderdtest.CreateAnotherUser(t, client, user.OrganizationID, rbac.ScopedRoleOrgAdmin(user.OrganizationID))
+		organization := dbgen.Organization(t, db, database.Organization{
+			Name: "mcp-audit-link-org",
+		})
+		require.NotEqual(t, user.OrganizationID, organization.ID)
+		orgAdmin, _ := coderdtest.CreateAnotherUser(t, client, organization.ID, rbac.ScopedRoleOrgAdmin(organization.ID))
 
 		config := dbgen.MCPServerConfig(t, db, database.MCPServerConfig{
-			OrganizationID: user.OrganizationID,
+			OrganizationID: organization.ID,
 		})
 		err := client.CreateTestAuditLog(ctx, codersdk.CreateTestAuditLogRequest{
 			Action:         codersdk.AuditActionCreate,
 			ResourceType:   codersdk.ResourceTypeMCPServerConfig,
 			ResourceID:     config.ID,
-			OrganizationID: user.OrganizationID,
+			OrganizationID: organization.ID,
 		})
 		require.NoError(t, err)
 
@@ -174,16 +178,16 @@ func TestAuditLogs(t *testing.T) {
 		require.Len(t, auditorLogs.AuditLogs, 1)
 		require.Empty(t, auditorLogs.AuditLogs[0].ResourceLink)
 
-		// Organization admins hold MCP permissions but not the
-		// deployment-config access the settings page requires.
+		// Organization admins hold MCP management permissions, and the
+		// settings page now admits them.
 		orgAdminLogs, err := orgAdmin.AuditLogs(ctx, codersdk.AuditLogsRequest{
 			Pagination: codersdk.Pagination{
 				Limit: 1,
 			},
 		})
 		require.NoError(t, err)
 		require.Len(t, orgAdminLogs.AuditLogs, 1)
-		require.Empty(t, orgAdminLogs.AuditLogs[0].ResourceLink)
+		require.Equal(t, fmt.Sprintf("/ai/settings/mcp-servers/%s?org=mcp-audit-link-org", config.ID), orgAdminLogs.AuditLogs[0].ResourceLink)
 
 		ownerLogs, err := client.AuditLogs(ctx, codersdk.AuditLogsRequest{
 			Pagination: codersdk.Pagination{
@@ -192,7 +196,7 @@ func TestAuditLogs(t *testing.T) {
 		})
 		require.NoError(t, err)
 		require.Len(t, ownerLogs.AuditLogs, 1)
-		require.Equal(t, fmt.Sprintf("/ai/settings/mcp-servers/%s", config.ID), ownerLogs.AuditLogs[0].ResourceLink)
+		require.Equal(t, fmt.Sprintf("/ai/settings/mcp-servers/%s?org=mcp-audit-link-org", config.ID), ownerLogs.AuditLogs[0].ResourceLink)
 	})
 
 	t.Run("Organization", func(t *testing.T) {

diff --git a/docs/ai-coder/agents/platform-controls/mcp-servers.md b/docs/ai-coder/agents/platform-controls/mcp-servers.md
@@ -7,8 +7,11 @@ servers are injected into or offered to users during chat depending on the
 availability policy.
 
 This is an admin-only feature accessible at **AI Settings** > **Coder Agents** > **MCP servers**
-(`/ai/settings/mcp-servers`). The settings page currently manages the default
-organization's servers; other organizations are managed through the API.
+(`/ai/settings/mcp-servers`). In multi-organization deployments, use the
+organization picker to choose which organization's servers to manage. The
+server list shows the picker when you can access more than one organization's
+servers. The add and update views always show the target organization, as a
+read-only field when only one organization is available.
 
 ## Add an MCP server
 

diff --git a/enterprise/coderd/audit_test.go b/enterprise/coderd/audit_test.go
@@ -2,14 +2,18 @@ package coderd_test
 
 import (
 	"context"
+	"fmt"
 	"testing"
 
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/require"
 
+	"github.com/coder/coder/v2/coderd/coderdtest"
+	"github.com/coder/coder/v2/coderd/rbac"
 	"github.com/coder/coder/v2/codersdk"
 	"github.com/coder/coder/v2/enterprise/coderd/coderdenttest"
 	"github.com/coder/coder/v2/enterprise/coderd/license"
+	"github.com/coder/coder/v2/testutil"
 )
 
 func TestEnterpriseAuditLogs(t *testing.T) {
@@ -102,4 +106,60 @@ func TestEnterpriseAuditLogs(t *testing.T) {
 		// OrganizationID is deprecated, but make sure it is empty.
 		require.Equal(t, uuid.Nil, alogs.AuditLogs[0].OrganizationID)
 	})
+
+	t.Run("MCPServerConfigLinkForMutationOnlyRole", func(t *testing.T) {
+		t.Parallel()
+
+		ctx := testutil.Context(t, testutil.WaitLong)
+		owner, firstUser := coderdenttest.New(t, &coderdenttest.Options{
+			LicenseOptions: &coderdenttest.LicenseOptions{
+				Features: license.Features{
+					codersdk.FeatureCustomRoles: 1,
+				},
+			},
+		})
+
+		config := createMCPServerConfigForOrganization(t, owner, firstUser.OrganizationID, "audit-link-mcp")
+		// Remove the default everyone-in-org ACL grant so the custom
+		// role's update permission is the requester's only access.
+		//nolint:gocritic // Owner access removes the default ACL grant.
+		err := owner.UpdateMCPServerConfigACL(ctx, firstUser.OrganizationID, config.ID, codersdk.UpdateMCPServerConfigACLRequest{
+			GroupRoles: map[string]codersdk.MCPServerConfigRole{
+				firstUser.OrganizationID.String(): codersdk.MCPServerConfigRoleDeleted,
+			},
+		})
+		require.NoError(t, err)
+
+		//nolint:gocritic // Owner access isolates custom-role setup from the behavior under test.
+		role, err := owner.CreateOrganizationRole(ctx, codersdk.Role{
+			Name:           "mcp-update-only-audit",
+			OrganizationID: firstUser.OrganizationID.String(),
+			OrganizationPermissions: codersdk.CreatePermissions(map[codersdk.RBACResource][]codersdk.RBACAction{
+				codersdk.ResourceMCPServerConfig: {codersdk.ActionUpdate},
+				codersdk.ResourceAuditLog:        {codersdk.ActionRead},
+			}),
+		})
+		require.NoError(t, err)
+		updateOnly, _ := coderdtest.CreateAnotherUser(t, owner, firstUser.OrganizationID,
+			rbac.RoleIdentifier{Name: role.Name, OrganizationID: firstUser.OrganizationID})
+
+		err = owner.CreateTestAuditLog(ctx, codersdk.CreateTestAuditLogRequest{
+			Action:         codersdk.AuditActionCreate,
+			ResourceType:   codersdk.ResourceTypeMCPServerConfig,
+			ResourceID:     config.ID,
+			OrganizationID: firstUser.OrganizationID,
+		})
+		require.NoError(t, err)
+
+		// Update-only administrators lack config read access, yet the
+		// settings page admits them, so the link must still appear.
+		logs, err := updateOnly.AuditLogs(ctx, codersdk.AuditLogsRequest{
+			Pagination: codersdk.Pagination{
+				Limit: 1,
+			},
+		})
+		require.NoError(t, err)
+		require.Len(t, logs.AuditLogs, 1)
+		require.Contains(t, logs.AuditLogs[0].ResourceLink, fmt.Sprintf("/ai/settings/mcp-servers/%s", config.ID))
+	})
 }
diff --git a/site/permissions.json b/site/permissions.json
@@ -91,6 +91,22 @@
 		"object": { "resource_type": "idpsync_settings", "any_org": true },
 		"action": "read"
 	},
+	"viewAnyMCPServerConfigs": {
+		"object": { "resource_type": "mcp_server_config", "any_org": true },
+		"action": "read"
+	},
+	"createAnyMCPServerConfig": {
+		"object": { "resource_type": "mcp_server_config", "any_org": true },
+		"action": "create"
+	},
+	"updateAnyMCPServerConfig": {
+		"object": { "resource_type": "mcp_server_config", "any_org": true },
+		"action": "update"
+	},
+	"deleteAnyMCPServerConfig": {
+		"object": { "resource_type": "mcp_server_config", "any_org": true },
+		"action": "delete"
+	},
 	"editAnySettings": {
 		"object": { "resource_type": "organization", "any_org": true },
 		"action": "update"

diff --git a/site/src/api/api.ts b/site/src/api/api.ts
@@ -3921,6 +3921,16 @@ class ExperimentalApiMethods {
 		return response.data;
 	};
 
+	getMCPServerConfig = async (
+		organization: string,
+		id: string,
+	): Promise<TypesGen.MCPServerConfig> => {
+		const response = await this.axios.get<TypesGen.MCPServerConfig>(
+			mcpServerConfigPath(organization, id),
+		);
+		return response.data;
+	};
+
 	createMCPServerConfig = async (
 		organization: string,
 		req: TypesGen.CreateMCPServerConfigRequest,

diff --git a/site/src/api/queries/chats.ts b/site/src/api/queries/chats.ts
@@ -2336,6 +2336,15 @@ export const mcpServerConfigs = (organization: string) => ({
 		API.experimental.getMCPServerConfigs(organization),
 });
 
+export const mcpServerConfigKey = (organization: string, id: string) =>
+	[...mcpServerConfigsKey(organization), "detail", id] as const;
+
+export const mcpServerConfig = (organization: string, id: string) => ({
+	queryKey: mcpServerConfigKey(organization, id),
+	queryFn: (): Promise<TypesGen.MCPServerConfig> =>
+		API.experimental.getMCPServerConfig(organization, id),
+});
+
 const invalidateMCPServerConfigQueries = async (queryClient: QueryClient) => {
 	await queryClient.invalidateQueries({ queryKey: mcpServersKey });
 };

diff --git a/site/src/components/OrganizationAutocomplete/OrganizationAutocomplete.stories.tsx b/site/src/components/OrganizationAutocomplete/OrganizationAutocomplete.stories.tsx
@@ -34,6 +34,92 @@ export const ManyOrgs: Story = {
 	},
 };
 
+const collidingDisplayNameOrganizations = [
+	{ ...MockOrganization, name: "org-a", display_name: "Dev" },
+	{ ...MockOrganization2, name: "org-b", display_name: "Dev" },
+	{ ...MockOrganization, id: "org-c", name: "org-c", display_name: "Ops" },
+];
+
+export const CollidingDisplayNames: Story = {
+	args: {
+		value: collidingDisplayNameOrganizations[0],
+		options: collidingDisplayNameOrganizations,
+	},
+	play: async ({ canvasElement }) => {
+		const canvas = within(canvasElement);
+		expect(
+			canvas.getByRole("button", { name: /Dev \(org-a\)/ }),
+		).toBeInTheDocument();
+		await userEvent.click(canvas.getByRole("button"));
+		await waitFor(() => {
+			expect(
+				screen.getByRole("option", { name: "Dev (org-a)" }),
+			).toBeInTheDocument();
+			expect(
+				screen.getByRole("option", { name: "Dev (org-b)" }),
+			).toBeInTheDocument();
+			expect(screen.getByRole("option", { name: "Ops" })).toBeInTheDocument();
+		});
+	},
+};
+
+// Collides with an option but is not itself selectable, mirroring a
+// deep link to a list-only organization.
+const listOnlyOrganization = {
+	...MockOrganization,
+	id: "org-t",
+	name: "org-t",
+	display_name: "Dev",
+};
+
+export const NonOptionValueDisambiguatesOptions: Story = {
+	args: {
+		value: listOnlyOrganization,
+		options: collidingDisplayNameOrganizations.slice(0, 1),
+		labelOrganizations: [
+			...collidingDisplayNameOrganizations.slice(0, 1),
+			listOnlyOrganization,
+		],
+	},
+	play: async ({ canvasElement }) => {
+		const canvas = within(canvasElement);
+		expect(
+			canvas.getByRole("button", { name: /Dev \(org-t\)/ }),
+		).toBeInTheDocument();
+		await userEvent.click(canvas.getByRole("button"));
+		await waitFor(() => {
+			expect(
+				screen.getByRole("option", { name: "Dev (org-a)" }),
+			).toBeInTheDocument();
+			expect(
+				screen.queryByRole("option", { name: /org-t/ }),
+			).not.toBeInTheDocument();
+		});
+	},
+};
+
+export const FallbackNameCollision: Story = {
+	args: {
+		value: null,
+		options: [
+			{ ...MockOrganization, name: "dev", display_name: "" },
+			{ ...MockOrganization2, name: "org-b", display_name: "dev" },
+			{ ...MockOrganization, id: "org-c", name: "org-c", display_name: "Ops" },
+		],
+	},
+	play: async ({ canvasElement }) => {
+		const canvas = within(canvasElement);
+		await userEvent.click(canvas.getByRole("button"));
+		await waitFor(() => {
+			expect(screen.getByRole("option", { name: /^dev$/ })).toBeInTheDocument();
+			expect(
+				screen.getByRole("option", { name: "dev (org-b)" }),
+			).toBeInTheDocument();
+			expect(screen.getByRole("option", { name: "Ops" })).toBeInTheDocument();
+		});
+	},
+};
+
 export const WithValue: Story = {
 	args: {
 		value: MockOrganization2,