diff --git a/packages/twenty-front/src/pages/settings/ai/components/SettingsAIMCP.tsx b/packages/twenty-front/src/pages/settings/ai/components/SettingsAIMCP.tsx
index e8c40fa5653f4..84131ef4a6ca4 100644
--- a/packages/twenty-front/src/pages/settings/ai/components/SettingsAIMCP.tsx
+++ b/packages/twenty-front/src/pages/settings/ai/components/SettingsAIMCP.tsx
@@ -1,13 +1,6 @@
-import { Select } from '@/ui/input/components/Select';
 import styled from '@emotion/styled';
-import { Trans, useLingui } from '@lingui/react/macro';
-import { useState } from 'react';
-import {
-  H2Title,
-  IconCopy,
-  IconDatabase,
-  IconSitemap,
-} from 'twenty-ui/display';
+import { useLingui } from '@lingui/react/macro';
+import { H2Title, IconCopy } from 'twenty-ui/display';
 import { Button, CodeEditor } from 'twenty-ui/input';
 import { Section } from 'twenty-ui/layout';
 import { REACT_APP_SERVER_BASE_URL } from '~/config';
@@ -19,29 +12,6 @@ const StyledWrapper = styled.div`
   border-radius: ${({ theme }) => theme.border.radius.md};
 `;
 
-// TODO: Re-enable when MCP image is ready
-// const StyledImage = styled.img`
-//   border-bottom: 1px solid ${({ theme }) => theme.border.color.light};
-//   height: 100%;
-//   object-fit: cover;
-//   width: 100%;
-// `;
-
-const StyledSchemaSelector = styled.div`
-  align-items: center;
-  border-bottom: 1px solid ${({ theme }) => theme.border.color.light};
-  display: flex;
-  flex-direction: row;
-  justify-content: space-between;
-  padding: ${({ theme }) => theme.spacing(3)};
-`;
-
-const StyledLabel = styled.span`
-  color: ${({ theme }) => theme.font.color.light};
-  font-size: ${({ theme }) => theme.font.size.md};
-  font-weight: ${({ theme }) => theme.font.weight.semiBold};
-`;
-
 const StyledCopyButton = styled.div`
   position: absolute;
   top: ${({ theme }) => theme.spacing(3)};
@@ -65,50 +35,22 @@ export const SettingsAIMCP = () => {
   const { t } = useLingui();
   const { copyToClipboard } = useCopyToClipboard();
 
-  const generateMcpContent = (pathSuffix: string, serverName: string) => {
-    return JSON.stringify(
-      {
-        mcpServers: {
-          [serverName]: {
-            type: 'streamable-http',
-            url: `${REACT_APP_SERVER_BASE_URL}${pathSuffix}`,
-            headers: {
-              Authorization: 'Bearer [API_KEY]',
-            },
+  const mcpConfig = JSON.stringify(
+    {
+      mcpServers: {
+        twenty: {
+          type: 'streamable-http',
+          url: `${REACT_APP_SERVER_BASE_URL}/mcp`,
+          headers: {
+            Authorization: 'Bearer [API_KEY]',
           },
         },
       },
-      null,
-      2,
-    );
-  };
-
-  const options = [
-    {
-      label: t`Core Schema`,
-      value: 'core-schema',
-      Icon: IconDatabase,
-      content: generateMcpContent('/mcp', 'twenty'),
-    },
-    {
-      label: t`Metadata Schema`,
-      value: 'metadata-schema',
-      Icon: IconSitemap,
-      content: generateMcpContent('/mcp/metadata', 'twenty-metadata'),
     },
-  ];
-  const [selectedSchemaValue, setSelectedSchemaValue] = useState(
-    options[0].value,
+    null,
+    2,
   );
 
-  const selectedOption =
-    options.find((option) => option.value === selectedSchemaValue) ||
-    options[0];
-
-  const onChange = (value: string) => {
-    setSelectedSchemaValue(value);
-  };
-
   return (
     <Section>
       <H2Title
@@ -116,24 +58,13 @@ export const SettingsAIMCP = () => {
         description={t`Access your workspace data from your favorite MCP client like Claude Desktop, Windsurf or Cursor.`}
       />
       <StyledWrapper>
-        <StyledSchemaSelector>
-          <Select
-            dropdownId="mcp-schema-selector"
-            value={selectedSchemaValue}
-            options={options}
-            onChange={onChange}
-          />
-          <StyledLabel>
-            <Trans>Interact with your workspace data</Trans>
-          </StyledLabel>
-        </StyledSchemaSelector>
         <StyledEditorContainer style={{ position: 'relative' }}>
           <StyledCopyButton>
             <Button
               Icon={IconCopy}
               onClick={() => {
                 copyToClipboard(
-                  selectedOption.content,
+                  mcpConfig,
                   t`MCP Configuration copied to clipboard`,
                 );
               }}
@@ -141,7 +72,7 @@ export const SettingsAIMCP = () => {
             />
           </StyledCopyButton>
           <CodeEditor
-            value={selectedOption.content}
+            value={mcpConfig}
             language="application/json"
             options={{
               readOnly: true,
diff --git a/packages/twenty-server/src/engine/api/mcp/constants/mcp.const.ts b/packages/twenty-server/src/engine/api/mcp/constants/mcp.const.ts
index ac8de416384c5..a3d48ae56b314 100644
--- a/packages/twenty-server/src/engine/api/mcp/constants/mcp.const.ts
+++ b/packages/twenty-server/src/engine/api/mcp/constants/mcp.const.ts
@@ -1,10 +1,10 @@
 export const MCP_SERVER_METADATA = {
   metadata: {
-    info: 'Objects structure your business entities in Twenty. **Standard Objects** (e.g. People, Companies, Opportunities) are built‑in, pre‑configured data models. **Custom Objects** let you define entities specific to your needs (like Rockets, Properties, etc.). **Fields** work like spreadsheet columns and can be standard or custom. Always use the `fields` and `objects` parameters to select only the data you need—this **strongly reduces response size and token usage**, improving performance.',
+    info: 'Twenty CRM MCP Server. Follow this workflow: (1) get_tool_catalog to discover tools, (2) learn_tools to get input schemas, (3) execute_tool to run them. Never guess tool names — always start with get_tool_catalog. Use load_skills for guidance on complex tasks like workflow or dashboard building.',
   },
   protocolVersion: '2024-11-05',
   serverInfo: {
     name: 'Twenty MCP Server',
-    version: '0.0.1',
+    version: '0.1.0',
   },
 };
diff --git a/packages/twenty-server/src/engine/api/mcp/controllers/__tests__/mcp-core.controller.spec.ts b/packages/twenty-server/src/engine/api/mcp/controllers/__tests__/mcp-core.controller.spec.ts
index 627bfb8da96c7..cce0bdaf54b74 100644
--- a/packages/twenty-server/src/engine/api/mcp/controllers/__tests__/mcp-core.controller.spec.ts
+++ b/packages/twenty-server/src/engine/api/mcp/controllers/__tests__/mcp-core.controller.spec.ts
@@ -9,6 +9,7 @@ import { McpProtocolService } from 'src/engine/api/mcp/services/mcp-protocol.ser
 import { type ApiKeyEntity } from 'src/engine/core-modules/api-key/api-key.entity';
 import { AccessTokenService } from 'src/engine/core-modules/auth/token/services/access-token.service';
 import { HttpExceptionHandlerService } from 'src/engine/core-modules/exception-handler/http-exception-handler.service';
+import { type UserEntity } from 'src/engine/core-modules/user/user.entity';
 import { type WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
 import { WorkspaceCacheStorageService } from 'src/engine/workspace-cache-storage/workspace-cache-storage.service';
 
@@ -55,6 +56,7 @@ describe('McpCoreController', () => {
 
   describe('handleMcpCore', () => {
     const mockWorkspace = { id: 'workspace-1' } as WorkspaceEntity;
+    const mockUser = { id: 'user-1' } as UserEntity;
     const mockUserWorkspaceId = 'user-workspace-1';
     const mockApiKey = { id: 'api-key-1' } as ApiKeyEntity;
 
@@ -81,6 +83,7 @@ describe('McpCoreController', () => {
         mockRequest,
         mockWorkspace,
         mockApiKey,
+        mockUser,
         mockUserWorkspaceId,
       );
 
@@ -88,6 +91,7 @@ describe('McpCoreController', () => {
         mockRequest,
         {
           workspace: mockWorkspace,
+          userId: mockUser.id,
           userWorkspaceId: mockUserWorkspaceId,
           apiKey: mockApiKey,
         },
@@ -121,6 +125,7 @@ describe('McpCoreController', () => {
         mockRequest,
         mockWorkspace,
         mockApiKey,
+        mockUser,
         mockUserWorkspaceId,
       );
 
@@ -128,6 +133,7 @@ describe('McpCoreController', () => {
         mockRequest,
         {
           workspace: mockWorkspace,
+          userId: mockUser.id,
           userWorkspaceId: mockUserWorkspaceId,
           apiKey: mockApiKey,
         },
@@ -166,6 +172,7 @@ describe('McpCoreController', () => {
         mockRequest,
         mockWorkspace,
         mockApiKey,
+        mockUser,
         mockUserWorkspaceId,
       );
 
@@ -173,11 +180,51 @@ describe('McpCoreController', () => {
         mockRequest,
         {
           workspace: mockWorkspace,
+          userId: mockUser.id,
           userWorkspaceId: mockUserWorkspaceId,
           apiKey: mockApiKey,
         },
       );
       expect(result).toEqual(mockResponse);
     });
+
+    it('should handle API key auth without user', async () => {
+      const mockRequest: JsonRpc = {
+        jsonrpc: '2.0',
+        method: 'tools/call',
+        params: { name: 'get_tool_catalog', arguments: {} },
+        id: '456',
+      };
+
+      const mockResponse = {
+        id: '456',
+        jsonrpc: '2.0',
+        result: {
+          content: [{ type: 'text', text: '{}' }],
+          isError: false,
+        },
+      };
+
+      mcpProtocolService.handleMCPCoreQuery.mockResolvedValue(mockResponse);
+
+      const result = await controller.handleMcpCore(
+        mockRequest,
+        mockWorkspace,
+        mockApiKey,
+        undefined,
+        undefined,
+      );
+
+      expect(mcpProtocolService.handleMCPCoreQuery).toHaveBeenCalledWith(
+        mockRequest,
+        {
+          workspace: mockWorkspace,
+          userId: undefined,
+          userWorkspaceId: undefined,
+          apiKey: mockApiKey,
+        },
+      );
+      expect(result).toEqual(mockResponse);
+    });
   });
 });
diff --git a/packages/twenty-server/src/engine/api/mcp/controllers/mcp-core.controller.ts b/packages/twenty-server/src/engine/api/mcp/controllers/mcp-core.controller.ts
index 1a038ddb489be..6d665506301b4 100644
--- a/packages/twenty-server/src/engine/api/mcp/controllers/mcp-core.controller.ts
+++ b/packages/twenty-server/src/engine/api/mcp/controllers/mcp-core.controller.ts
@@ -12,8 +12,10 @@ import { JsonRpc } from 'src/engine/api/mcp/dtos/json-rpc';
 import { McpProtocolService } from 'src/engine/api/mcp/services/mcp-protocol.service';
 import { RestApiExceptionFilter } from 'src/engine/api/rest/rest-api-exception.filter';
 import { ApiKeyEntity } from 'src/engine/core-modules/api-key/api-key.entity';
+import { UserEntity } from 'src/engine/core-modules/user/user.entity';
 import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
 import { AuthApiKey } from 'src/engine/decorators/auth/auth-api-key.decorator';
+import { AuthUser } from 'src/engine/decorators/auth/auth-user.decorator';
 import { AuthUserWorkspaceId } from 'src/engine/decorators/auth/auth-user-workspace-id.decorator';
 import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
 import { JwtAuthGuard } from 'src/engine/guards/jwt-auth.guard';
@@ -38,10 +40,12 @@ export class McpCoreController {
     @Body() body: JsonRpc,
     @AuthWorkspace() workspace: WorkspaceEntity,
     @AuthApiKey() apiKey: ApiKeyEntity | undefined,
+    @AuthUser({ allowUndefined: true }) user: UserEntity | undefined,
     @AuthUserWorkspaceId() userWorkspaceId: string | undefined,
   ) {
     return await this.mcpProtocolService.handleMCPCoreQuery(body, {
       workspace,
+      userId: user?.id,
       userWorkspaceId,
       apiKey,
     });
diff --git a/packages/twenty-server/src/engine/api/mcp/controllers/mcp-metadata.controller.ts b/packages/twenty-server/src/engine/api/mcp/controllers/mcp-metadata.controller.ts
deleted file mode 100644
index 5fa840cc41614..0000000000000
--- a/packages/twenty-server/src/engine/api/mcp/controllers/mcp-metadata.controller.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { Controller, Post, Req, UseGuards } from '@nestjs/common';
-
-import { Request } from 'express';
-
-import { MCPMetadataService } from 'src/engine/api/mcp/services/mcp-metadata.service';
-import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
-import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
-import { JwtAuthGuard } from 'src/engine/guards/jwt-auth.guard';
-import { NoPermissionGuard } from 'src/engine/guards/no-permission.guard';
-import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
-
-@Controller('mcp/metadata')
-@UseGuards(JwtAuthGuard, WorkspaceAuthGuard, NoPermissionGuard)
-export class McpMetadataController {
-  constructor(private readonly mCPMetadataService: MCPMetadataService) {}
-
-  @Post()
-  async handleMcpMetadata(
-    @AuthWorkspace() workspace: WorkspaceEntity,
-    @Req() request: Request,
-  ) {
-    return await this.mCPMetadataService.handleMCPMetadataQuery(request, {
-      workspace,
-    });
-  }
-}
diff --git a/packages/twenty-server/src/engine/api/mcp/mcp.module.ts b/packages/twenty-server/src/engine/api/mcp/mcp.module.ts
index 8f2463c47a1fb..4ced94e9300da 100644
--- a/packages/twenty-server/src/engine/api/mcp/mcp.module.ts
+++ b/packages/twenty-server/src/engine/api/mcp/mcp.module.ts
@@ -1,21 +1,15 @@
 import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
 
 import { McpCoreController } from 'src/engine/api/mcp/controllers/mcp-core.controller';
-import { McpMetadataController } from 'src/engine/api/mcp/controllers/mcp-metadata.controller';
-import { MCPMetadataService } from 'src/engine/api/mcp/services/mcp-metadata.service';
 import { McpProtocolService } from 'src/engine/api/mcp/services/mcp-protocol.service';
 import { McpToolExecutorService } from 'src/engine/api/mcp/services/mcp-tool-executor.service';
 import { ApiKeyModule } from 'src/engine/core-modules/api-key/api-key.module';
 import { TokenModule } from 'src/engine/core-modules/auth/token/token.module';
 import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
-import { MetricsModule } from 'src/engine/core-modules/metrics/metrics.module';
 import { ToolProviderModule } from 'src/engine/core-modules/tool-provider/tool-provider.module';
-import { UserWorkspaceEntity } from 'src/engine/core-modules/user-workspace/user-workspace.entity';
-import { UserEntity } from 'src/engine/core-modules/user/user.entity';
+import { SkillModule } from 'src/engine/metadata-modules/skill/skill.module';
 import { UserRoleModule } from 'src/engine/metadata-modules/user-role/user-role.module';
 import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/workspace-cache-storage.module';
-import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
 
 @Module({
   imports: [
@@ -23,14 +17,12 @@ import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache
     TokenModule,
     WorkspaceCacheStorageModule,
     FeatureFlagModule,
-    MetricsModule,
     UserRoleModule,
     ToolProviderModule,
-    TypeOrmModule.forFeature([UserEntity, UserWorkspaceEntity]),
-    WorkspaceCacheModule,
+    SkillModule,
   ],
-  controllers: [McpCoreController, McpMetadataController],
+  controllers: [McpCoreController],
   exports: [McpProtocolService],
-  providers: [McpProtocolService, McpToolExecutorService, MCPMetadataService],
+  providers: [McpProtocolService, McpToolExecutorService],
 })
 export class McpModule {}
diff --git a/packages/twenty-server/src/engine/api/mcp/services/__tests__/mcp-protocol.service.spec.ts b/packages/twenty-server/src/engine/api/mcp/services/__tests__/mcp-protocol.service.spec.ts
index 4ad465c52ba63..2d536fc18536e 100644
--- a/packages/twenty-server/src/engine/api/mcp/services/__tests__/mcp-protocol.service.spec.ts
+++ b/packages/twenty-server/src/engine/api/mcp/services/__tests__/mcp-protocol.service.spec.ts
@@ -1,10 +1,5 @@
 import { HttpException, HttpStatus } from '@nestjs/common';
 import { Test, type TestingModule } from '@nestjs/testing';
-import { getRepositoryToken } from '@nestjs/typeorm';
-
-import { jsonSchema } from 'ai';
-import { type JSONSchema7 } from 'json-schema';
-import { DEFAULT_TOOL_INPUT_SCHEMA } from 'twenty-shared/logic-function';
 
 import { MCP_SERVER_METADATA } from 'src/engine/api/mcp/constants/mcp.const';
 import { type JsonRpc } from 'src/engine/api/mcp/dtos/json-rpc';
@@ -14,75 +9,45 @@ import { type ApiKeyEntity } from 'src/engine/core-modules/api-key/api-key.entit
 import { ApiKeyRoleService } from 'src/engine/core-modules/api-key/services/api-key-role.service';
 import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
+import { EXECUTE_TOOL_TOOL_NAME } from 'src/engine/core-modules/tool-provider/tools/execute-tool.tool';
+import { GET_TOOL_CATALOG_TOOL_NAME } from 'src/engine/core-modules/tool-provider/tools/get-tool-catalog.tool';
+import { LEARN_TOOLS_TOOL_NAME } from 'src/engine/core-modules/tool-provider/tools/learn-tools.tool';
+import { LOAD_SKILL_TOOL_NAME } from 'src/engine/core-modules/tool-provider/tools/load-skill.tool';
 import { ToolRegistryService } from 'src/engine/core-modules/tool-provider/services/tool-registry.service';
-import { UserWorkspaceEntity } from 'src/engine/core-modules/user-workspace/user-workspace.entity';
 import { type WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { SkillService } from 'src/engine/metadata-modules/skill/skill.service';
 import { UserRoleService } from 'src/engine/metadata-modules/user-role/user-role.service';
-import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
 
 describe('McpProtocolService', () => {
   let service: McpProtocolService;
   let featureFlagService: jest.Mocked<FeatureFlagService>;
-  let toolRegistryService: jest.Mocked<ToolRegistryService>;
+  let _toolRegistryService: jest.Mocked<ToolRegistryService>;
   let userRoleService: jest.Mocked<UserRoleService>;
   let mcpToolExecutorService: jest.Mocked<McpToolExecutorService>;
   let apiKeyRoleService: jest.Mocked<ApiKeyRoleService>;
-  let userWorkspaceRepository: jest.Mocked<{ findOne: jest.Mock }>;
-  let workspaceCacheService: jest.Mocked<{ getOrRecompute: jest.Mock }>;
 
   const mockWorkspace = { id: 'workspace-1' } as WorkspaceEntity;
   const mockUserWorkspaceId = 'user-workspace-1';
-  const mockUserId = 'user-1';
-  const mockWorkspaceMemberId = 'workspace-member-1';
   const mockRoleId = 'role-1';
   const mockAdminRoleId = 'admin-role-1';
   const mockApiKey = {
     id: 'api-key-1',
     workspaceId: mockWorkspace.id,
   } as ApiKeyEntity;
-  const mockUser = { id: mockUserId };
-  const mockUserWorkspace = {
-    id: mockUserWorkspaceId,
-    user: mockUser,
-  };
-  const mockWorkspaceMember = {
-    id: mockWorkspaceMemberId,
-    userId: mockUserId,
-  };
-  const mockFlatWorkspaceMemberMaps = {
-    idByUserId: { [mockUserId]: mockWorkspaceMemberId },
-    byId: { [mockWorkspaceMemberId]: mockWorkspaceMember },
-  };
-
-  beforeEach(async () => {
-    const mockFeatureFlagService = {
-      isFeatureEnabled: jest.fn(),
-    };
-
-    const mockToolRegistryService = {
-      getToolsByCategories: jest.fn(),
-    };
 
-    const mockUserRoleService = {
-      getRoleIdForUserWorkspace: jest.fn(),
-    };
-
-    const mockMcpToolExecutorService = {
-      handleToolCall: jest.fn(),
-      handleToolsListing: jest.fn(),
-    };
-
-    const mockApiKeyRoleService = {
-      getRoleIdForApiKeyId: jest.fn().mockResolvedValue(mockAdminRoleId),
-    };
+  const EXPECTED_MCP_TOOL_NAMES = [
+    GET_TOOL_CATALOG_TOOL_NAME,
+    LEARN_TOOLS_TOOL_NAME,
+    EXECUTE_TOOL_TOOL_NAME,
+    LOAD_SKILL_TOOL_NAME,
+    'search_help_center',
+  ];
 
-    const mockWorkspaceCacheService = {
-      getOrRecompute: jest.fn(),
-      invalidateAndRecompute: jest.fn(),
-    };
-
-    const mockUserWorkspaceRepository = {
-      findOne: jest.fn(),
+  beforeEach(async () => {
+    const mockSearchHelpCenterTool = {
+      description: 'Search help center',
+      inputSchema: { jsonSchema: { type: 'object' } },
+      execute: jest.fn(),
     };
 
     const module: TestingModule = await Test.createTestingModule({
@@ -90,45 +55,49 @@ describe('McpProtocolService', () => {
         McpProtocolService,
         {
           provide: FeatureFlagService,
-          useValue: mockFeatureFlagService,
+          useValue: { isFeatureEnabled: jest.fn() },
         },
         {
           provide: ToolRegistryService,
-          useValue: mockToolRegistryService,
+          useValue: {
+            buildToolIndex: jest.fn().mockResolvedValue([]),
+            getToolsByName: jest.fn().mockResolvedValue({
+              search_help_center: mockSearchHelpCenterTool,
+            }),
+            getToolInfo: jest.fn().mockResolvedValue([]),
+            resolveAndExecute: jest.fn(),
+          },
         },
         {
           provide: UserRoleService,
-          useValue: mockUserRoleService,
+          useValue: { getRoleIdForUserWorkspace: jest.fn() },
         },
         {
           provide: McpToolExecutorService,
-          useValue: mockMcpToolExecutorService,
+          useValue: {
+            handleToolCall: jest.fn(),
+            handleToolsListing: jest.fn(),
+          },
         },
         {
           provide: ApiKeyRoleService,
-          useValue: mockApiKeyRoleService,
-        },
-        {
-          provide: WorkspaceCacheService,
-          useValue: mockWorkspaceCacheService,
+          useValue: {
+            getRoleIdForApiKeyId: jest.fn().mockResolvedValue(mockAdminRoleId),
+          },
         },
         {
-          provide: getRepositoryToken(UserWorkspaceEntity),
-          useValue: mockUserWorkspaceRepository,
+          provide: SkillService,
+          useValue: { findFlatSkillsByNames: jest.fn().mockResolvedValue([]) },
         },
       ],
     }).compile();
 
     service = module.get<McpProtocolService>(McpProtocolService);
     featureFlagService = module.get(FeatureFlagService);
-    toolRegistryService = module.get(ToolRegistryService);
+    _toolRegistryService = module.get(ToolRegistryService);
     userRoleService = module.get(UserRoleService);
     mcpToolExecutorService = module.get(McpToolExecutorService);
     apiKeyRoleService = module.get(ApiKeyRoleService);
-    userWorkspaceRepository = module.get(
-      getRepositoryToken(UserWorkspaceEntity),
-    );
-    workspaceCacheService = module.get(WorkspaceCacheService);
   });
 
   it('should be defined', () => {
@@ -256,37 +225,16 @@ describe('McpProtocolService', () => {
       });
     });
 
-    it('should handle tools/call method with userWorkspaceId', async () => {
+    it('should build a ToolSet with exactly 5 tools and pass it to executor for tools/call', async () => {
       featureFlagService.isFeatureEnabled.mockResolvedValue(true);
       userRoleService.getRoleIdForUserWorkspace.mockResolvedValue(mockRoleId);
-      userWorkspaceRepository.findOne.mockResolvedValue(mockUserWorkspace);
-      workspaceCacheService.getOrRecompute.mockResolvedValue({
-        flatWorkspaceMemberMaps: mockFlatWorkspaceMemberMaps,
-      });
-
-      const mockTool = {
-        description: 'Test tool',
-        inputSchema: jsonSchema(DEFAULT_TOOL_INPUT_SCHEMA as JSONSchema7),
-        execute: jest.fn().mockResolvedValue({ result: 'success' }),
-      };
-
-      const mockToolsMap = {
-        testTool: mockTool,
-      };
-
-      toolRegistryService.getToolsByCategories.mockResolvedValue(mockToolsMap);
 
       const mockToolCallResponse = {
         id: '123',
         jsonrpc: '2.0',
         result: {
           ...MCP_SERVER_METADATA,
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify({ result: 'success' }),
-            },
-          ],
+          content: [{ type: 'text', text: '{}' }],
           isError: false,
         },
       };
@@ -298,126 +246,103 @@ describe('McpProtocolService', () => {
       const mockRequest: JsonRpc = {
         jsonrpc: '2.0',
         method: 'tools/call',
-        params: { name: 'testTool', arguments: { arg1: 'value1' } },
+        params: {
+          name: 'execute_tool',
+          arguments: { toolName: 'find_companies', arguments: {} },
+        },
         id: '123',
       };
 
-      const result = await service.handleMCPCoreQuery(mockRequest, {
+      await service.handleMCPCoreQuery(mockRequest, {
         workspace: mockWorkspace,
         userWorkspaceId: mockUserWorkspaceId,
         apiKey: undefined,
       });
 
-      expect(result).toEqual(mockToolCallResponse);
       expect(mcpToolExecutorService.handleToolCall).toHaveBeenCalledWith(
         '123',
-        mockToolsMap,
-        { name: 'testTool', arguments: { arg1: 'value1' } },
+        expect.objectContaining(
+          Object.fromEntries(
+            EXPECTED_MCP_TOOL_NAMES.map((name) => [
+              name,
+              expect.objectContaining({
+                description: expect.any(String),
+                execute: expect.any(Function),
+              }),
+            ]),
+          ),
+        ),
+        mockRequest.params,
       );
     });
 
-    it('should handle tools/call method with apiKey', async () => {
+    it('should build a ToolSet with exactly 5 tools and pass it to executor for tools/list', async () => {
       featureFlagService.isFeatureEnabled.mockResolvedValue(true);
+      userRoleService.getRoleIdForUserWorkspace.mockResolvedValue(mockRoleId);
 
-      const mockTool = {
-        description: 'Test tool',
-        inputSchema: jsonSchema(DEFAULT_TOOL_INPUT_SCHEMA as JSONSchema7),
-        execute: jest.fn().mockResolvedValue({ result: 'success' }),
-      };
-
-      const mockToolsMap = {
-        testTool: mockTool,
-      };
-
-      toolRegistryService.getToolsByCategories.mockResolvedValue(mockToolsMap);
-
-      const mockToolCallResponse = {
+      mcpToolExecutorService.handleToolsListing.mockReturnValue({
         id: '123',
         jsonrpc: '2.0',
-        result: {
-          ...MCP_SERVER_METADATA,
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify({ result: 'success' }),
-            },
-          ],
-          isError: false,
-        },
-      };
-
-      mcpToolExecutorService.handleToolCall.mockResolvedValue(
-        mockToolCallResponse,
-      );
+        result: { tools: [] },
+      });
 
       const mockRequest: JsonRpc = {
         jsonrpc: '2.0',
-        method: 'tools/call',
-        params: { name: 'testTool', arguments: { arg1: 'value1' } },
+        method: 'tools/list',
         id: '123',
       };
 
-      const result = await service.handleMCPCoreQuery(mockRequest, {
+      await service.handleMCPCoreQuery(mockRequest, {
         workspace: mockWorkspace,
-        apiKey: mockApiKey,
+        userWorkspaceId: mockUserWorkspaceId,
+        apiKey: undefined,
       });
 
-      expect(result).toEqual(mockToolCallResponse);
-      expect(toolRegistryService.getToolsByCategories).toHaveBeenCalled();
+      expect(mcpToolExecutorService.handleToolsListing).toHaveBeenCalledWith(
+        '123',
+        expect.objectContaining(
+          Object.fromEntries(
+            EXPECTED_MCP_TOOL_NAMES.map((name) => [
+              name,
+              expect.objectContaining({
+                description: expect.any(String),
+              }),
+            ]),
+          ),
+        ),
+      );
     });
 
-    it('should handle tools listing', async () => {
+    it('should handle tools/call with apiKey authentication', async () => {
       featureFlagService.isFeatureEnabled.mockResolvedValue(true);
-      userRoleService.getRoleIdForUserWorkspace.mockResolvedValue(mockRoleId);
-      userWorkspaceRepository.findOne.mockResolvedValue(mockUserWorkspace);
-      workspaceCacheService.getOrRecompute.mockResolvedValue({
-        flatWorkspaceMemberMaps: mockFlatWorkspaceMemberMaps,
-      });
-
-      const mockToolsMap = {
-        testTool: {
-          description: 'Test tool',
-          inputSchema: jsonSchema(DEFAULT_TOOL_INPUT_SCHEMA as JSONSchema7),
-        },
-      };
 
-      toolRegistryService.getToolsByCategories.mockResolvedValue(mockToolsMap);
-
-      const mockToolsListingResponse = {
+      const mockToolCallResponse = {
         id: '123',
         jsonrpc: '2.0',
-        result: expect.objectContaining({
-          ...MCP_SERVER_METADATA,
-          capabilities: {
-            tools: { listChanged: false },
-          },
-          tools: [
-            {
-              name: 'testTool',
-              description: 'Test tool',
-              inputSchema: DEFAULT_TOOL_INPUT_SCHEMA,
-            },
-          ],
-        }),
+        result: { content: [{ type: 'text', text: '{}' }], isError: false },
       };
 
-      mcpToolExecutorService.handleToolsListing.mockReturnValue(
-        mockToolsListingResponse,
+      mcpToolExecutorService.handleToolCall.mockResolvedValue(
+        mockToolCallResponse,
       );
 
       const mockRequest: JsonRpc = {
         jsonrpc: '2.0',
-        method: 'tools/list',
+        method: 'tools/call',
+        params: { name: 'get_tool_catalog', arguments: {} },
         id: '123',
       };
 
       const result = await service.handleMCPCoreQuery(mockRequest, {
         workspace: mockWorkspace,
-        userWorkspaceId: mockUserWorkspaceId,
-        apiKey: undefined,
+        apiKey: mockApiKey,
       });
 
-      expect(result).toMatchObject(mockToolsListingResponse);
+      expect(result).toEqual(mockToolCallResponse);
+      expect(apiKeyRoleService.getRoleIdForApiKeyId).toHaveBeenCalledWith(
+        mockApiKey.id,
+        mockWorkspace.id,
+      );
     });
 
     it('should handle error when AI is disabled', async () => {
@@ -446,14 +371,9 @@ describe('McpProtocolService', () => {
       });
     });
 
-    it('should handle error when tool is not found', async () => {
+    it('should handle error when tool execution fails', async () => {
       featureFlagService.isFeatureEnabled.mockResolvedValue(true);
       userRoleService.getRoleIdForUserWorkspace.mockResolvedValue(mockRoleId);
-      userWorkspaceRepository.findOne.mockResolvedValue(mockUserWorkspace);
-      workspaceCacheService.getOrRecompute.mockResolvedValue({
-        flatWorkspaceMemberMaps: mockFlatWorkspaceMemberMaps,
-      });
-      toolRegistryService.getToolsByCategories.mockResolvedValue({});
 
       mcpToolExecutorService.handleToolCall.mockRejectedValue(
         new HttpException(
diff --git a/packages/twenty-server/src/engine/api/mcp/services/mcp-metadata.service.ts b/packages/twenty-server/src/engine/api/mcp/services/mcp-metadata.service.ts
deleted file mode 100644
index a464b5e46ca0f..0000000000000
--- a/packages/twenty-server/src/engine/api/mcp/services/mcp-metadata.service.ts
+++ /dev/null
@@ -1,215 +0,0 @@
-import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
-
-import { type ToolSet } from 'ai';
-import { type Request } from 'express';
-
-import { wrapJsonRpcResponse } from 'src/engine/api/mcp/utils/wrap-jsonrpc-response.util';
-import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
-import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
-import { MetricsService } from 'src/engine/core-modules/metrics/metrics.service';
-import { MetricsKeys } from 'src/engine/core-modules/metrics/types/metrics-keys.type';
-import { ToolCategory } from 'src/engine/core-modules/tool-provider/enums/tool-category.enum';
-import { ToolRegistryService } from 'src/engine/core-modules/tool-provider/services/tool-registry.service';
-import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
-
-@Injectable()
-export class MCPMetadataService {
-  constructor(
-    private readonly featureFlagService: FeatureFlagService,
-    private readonly toolRegistry: ToolRegistryService,
-    private readonly metricsService: MetricsService,
-  ) {}
-
-  async checkAiEnabled(workspaceId: string): Promise<void> {
-    const isAiEnabled = await this.featureFlagService.isFeatureEnabled(
-      FeatureFlagKey.IS_AI_ENABLED,
-      workspaceId,
-    );
-
-    if (!isAiEnabled) {
-      throw new HttpException(
-        'AI feature is not enabled for this workspace',
-        HttpStatus.FORBIDDEN,
-      );
-    }
-  }
-
-  handleInitialize(requestId: string | number) {
-    return wrapJsonRpcResponse(requestId, {
-      result: {
-        capabilities: {
-          tools: { listChanged: false },
-          resources: { listChanged: false },
-          prompts: { listChanged: false },
-        },
-        tools: [],
-        resources: [],
-        prompts: [],
-      },
-    });
-  }
-
-  async getTools(workspaceId: string): Promise<ToolSet> {
-    // Metadata tools don't require role-based permissions, using empty roleId
-    return this.toolRegistry.getToolsByCategories(
-      {
-        workspaceId,
-        roleId: '',
-        rolePermissionConfig: { unionOf: [] },
-      },
-      {
-        categories: [ToolCategory.METADATA],
-        wrapWithErrorContext: false,
-      },
-    );
-  }
-
-  async handleToolCall(
-    request: Request,
-    workspaceId: string,
-  ): Promise<Parameters<typeof wrapJsonRpcResponse>[1]> {
-    const tools = await this.getTools(workspaceId);
-    const toolName = request.body.params.name as keyof typeof tools;
-    const tool = tools[toolName];
-
-    if (tool && tool.execute) {
-      try {
-        const result = await tool.execute(
-          { input: request.body.params.arguments },
-          { toolCallId: '1', messages: [] },
-        );
-
-        await this.metricsService.incrementCounter({
-          key: MetricsKeys.AIToolExecutionSucceeded,
-          attributes: {
-            tool: request.body.params.name,
-          },
-        });
-
-        return { result };
-      } catch (err) {
-        await this.metricsService.incrementCounter({
-          key: MetricsKeys.AIToolExecutionFailed,
-          attributes: {
-            tool: request.body.params.name,
-          },
-        });
-        throw err;
-      }
-    }
-
-    return {
-      error: {
-        code: HttpStatus.NOT_FOUND,
-        message: `Tool ${request.body.params.name} not found`,
-      },
-    };
-  }
-
-  async listTools(request: Request, workspaceId: string) {
-    const tools = await this.getTools(workspaceId);
-
-    const toolsArray = Object.entries(tools)
-      .filter(([, def]) => !!def.inputSchema)
-      .map(([name, def]) => {
-        const inputSchema = def.inputSchema;
-        const unwrappedSchema =
-          inputSchema &&
-          typeof inputSchema === 'object' &&
-          'jsonSchema' in inputSchema
-            ? inputSchema.jsonSchema
-            : inputSchema;
-
-        return {
-          name,
-          description: def.description,
-          inputSchema: unwrappedSchema,
-        };
-      });
-
-    return wrapJsonRpcResponse(request.body.id, {
-      result: {
-        capabilities: {
-          tools: { listChanged: false },
-        },
-        tools: toolsArray,
-        resources: [],
-        prompts: [],
-      },
-    });
-  }
-
-  async handleMCPMetadataQuery(
-    request: Request,
-    {
-      workspace,
-    }: {
-      workspace: WorkspaceEntity;
-      userWorkspaceId?: string;
-      apiKey?: string;
-    },
-  ): Promise<Record<string, unknown>> {
-    try {
-      await this.checkAiEnabled(workspace.id);
-
-      if (request.body.method === 'initialize') {
-        return this.handleInitialize(request.body.id);
-      }
-
-      if (request.body.method === 'ping') {
-        return wrapJsonRpcResponse(
-          request.body.id,
-          {
-            result: {},
-          },
-          true,
-        );
-      }
-
-      if (request.body.method === 'tools/call' && request.body.params) {
-        return wrapJsonRpcResponse(
-          request.body.id,
-          await this.handleToolCall(request, workspace.id),
-        );
-      }
-
-      if (request.body.method === 'tools/list') {
-        return await this.listTools(request, workspace.id);
-      }
-
-      if (request.body.method === 'prompts/list') {
-        return wrapJsonRpcResponse(request.body.id, {
-          result: {
-            capabilities: {
-              prompts: { listChanged: false },
-            },
-            prompts: [],
-          },
-        });
-      }
-
-      if (request.body.method === 'resources/list') {
-        return wrapJsonRpcResponse(request.body.id, {
-          result: {
-            capabilities: {
-              resources: { listChanged: false },
-            },
-            resources: [],
-          },
-        });
-      }
-
-      return wrapJsonRpcResponse(request.body.id ?? crypto.randomUUID(), {
-        result: {},
-      });
-    } catch (error) {
-      return wrapJsonRpcResponse(request.body.id ?? crypto.randomUUID(), {
-        error: {
-          code: error.status || HttpStatus.INTERNAL_SERVER_ERROR,
-          message:
-            error.response?.messages?.join?.('\n') || 'Failed to execute tool',
-        },
-      });
-    }
-  }
-}
diff --git a/packages/twenty-server/src/engine/api/mcp/services/mcp-protocol.service.ts b/packages/twenty-server/src/engine/api/mcp/services/mcp-protocol.service.ts
index 12156bff7dfef..2cf66b52ac8b7 100644
--- a/packages/twenty-server/src/engine/api/mcp/services/mcp-protocol.service.ts
+++ b/packages/twenty-server/src/engine/api/mcp/services/mcp-protocol.service.ts
@@ -1,8 +1,7 @@
 import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
 
+import { type ToolSet, zodSchema } from 'ai';
 import { isDefined } from 'twenty-shared/utils';
-import { Repository } from 'typeorm';
 
 import { type JsonRpc } from 'src/engine/api/mcp/dtos/json-rpc';
 import { McpToolExecutorService } from 'src/engine/api/mcp/services/mcp-tool-executor.service';
@@ -11,17 +10,35 @@ import { type ApiKeyEntity } from 'src/engine/core-modules/api-key/api-key.entit
 import { ApiKeyRoleService } from 'src/engine/core-modules/api-key/services/api-key-role.service';
 import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
 import { buildApiKeyAuthContext } from 'src/engine/core-modules/auth/utils/build-api-key-auth-context.util';
-import { buildSystemAuthContext } from 'src/engine/core-modules/auth/utils/build-system-auth-context.util';
-import { buildUserAuthContext } from 'src/engine/core-modules/auth/utils/build-user-auth-context.util';
 import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
 import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
-import { ToolCategory } from 'src/engine/core-modules/tool-provider/enums/tool-category.enum';
+import { COMMON_PRELOAD_TOOLS } from 'src/engine/core-modules/tool-provider/constants/common-preload-tools.const';
 import { ToolRegistryService } from 'src/engine/core-modules/tool-provider/services/tool-registry.service';
-import { ToolType } from 'src/engine/core-modules/tool/enums/tool-type.enum';
-import { UserWorkspaceEntity } from 'src/engine/core-modules/user-workspace/user-workspace.entity';
+import {
+  createExecuteToolTool,
+  EXECUTE_TOOL_TOOL_NAME,
+  executeToolInputSchema,
+} from 'src/engine/core-modules/tool-provider/tools/execute-tool.tool';
+import {
+  createGetToolCatalogTool,
+  GET_TOOL_CATALOG_TOOL_NAME,
+  getToolCatalogInputSchema,
+} from 'src/engine/core-modules/tool-provider/tools/get-tool-catalog.tool';
+import {
+  createLearnToolsTool,
+  LEARN_TOOLS_TOOL_NAME,
+  learnToolsInputSchema,
+} from 'src/engine/core-modules/tool-provider/tools/learn-tools.tool';
+import {
+  createLoadSkillTool,
+  LOAD_SKILL_TOOL_NAME,
+  loadSkillInputSchema,
+} from 'src/engine/core-modules/tool-provider/tools/load-skill.tool';
 import { type WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { SkillService } from 'src/engine/metadata-modules/skill/skill.service';
 import { UserRoleService } from 'src/engine/metadata-modules/user-role/user-role.service';
-import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+
+const MCP_EXCLUDED_TOOLS = new Set(['code_interpreter', 'http_request']);
 
 @Injectable()
 export class McpProtocolService {
@@ -31,9 +48,7 @@ export class McpProtocolService {
     private readonly userRoleService: UserRoleService,
     private readonly mcpToolExecutorService: McpToolExecutorService,
     private readonly apiKeyRoleService: ApiKeyRoleService,
-    @InjectRepository(UserWorkspaceEntity)
-    private readonly userWorkspaceRepository: Repository<UserWorkspaceEntity>,
-    private readonly workspaceCacheService: WorkspaceCacheService,
+    private readonly skillService: SkillService,
   ) {}
 
   async checkAiEnabled(workspaceId: string): Promise<void> {
@@ -96,69 +111,74 @@ export class McpProtocolService {
     return roleId;
   }
 
-  private async buildAuthContext(
+  private async buildMcpToolSet(
     workspace: WorkspaceEntity,
-    userWorkspaceId?: string,
-    apiKey?: ApiKeyEntity,
-  ): Promise<WorkspaceAuthContext> {
-    if (isDefined(apiKey)) {
-      return buildApiKeyAuthContext({ workspace, apiKey });
-    }
-
-    if (isDefined(userWorkspaceId)) {
-      const userWorkspace = await this.userWorkspaceRepository.findOne({
-        where: {
-          id: userWorkspaceId,
-        },
-        relations: {
-          user: true,
-        },
-      });
-
-      const user = userWorkspace?.user;
-
-      if (!isDefined(user)) {
-        throw new HttpException('User not found', HttpStatus.FORBIDDEN);
-      }
-
-      const { flatWorkspaceMemberMaps } =
-        await this.workspaceCacheService.getOrRecompute(workspace.id, [
-          'flatWorkspaceMemberMaps',
-        ]);
-
-      const workspaceMemberId = flatWorkspaceMemberMaps.idByUserId[user.id];
-
-      const workspaceMember = isDefined(workspaceMemberId)
-        ? flatWorkspaceMemberMaps.byId[workspaceMemberId]
-        : undefined;
-
-      if (!isDefined(workspaceMemberId) || !isDefined(workspaceMember)) {
-        throw new HttpException(
-          'Workspace member not found',
-          HttpStatus.FORBIDDEN,
-        );
-      }
-
-      return buildUserAuthContext({
-        workspace,
-        userWorkspaceId,
-        user,
-        workspaceMemberId,
-        workspaceMember,
-      });
-    }
+    roleId: string,
+    options?: {
+      authContext?: WorkspaceAuthContext;
+      userId?: string;
+      userWorkspaceId?: string;
+    },
+  ): Promise<ToolSet> {
+    const toolContext = {
+      workspaceId: workspace.id,
+      roleId,
+      authContext: options?.authContext,
+      userId: options?.userId,
+      userWorkspaceId: options?.userWorkspaceId,
+    };
+
+    const preloadedTools = await this.toolRegistry.getToolsByName(
+      COMMON_PRELOAD_TOOLS,
+      toolContext,
+    );
 
-    return buildSystemAuthContext({ workspace });
+    return {
+      ...preloadedTools,
+      [GET_TOOL_CATALOG_TOOL_NAME]: {
+        ...createGetToolCatalogTool(this.toolRegistry, workspace.id, roleId, {
+          userId: options?.userId,
+          userWorkspaceId: options?.userWorkspaceId,
+          excludeTools: MCP_EXCLUDED_TOOLS,
+        }),
+        inputSchema: zodSchema(getToolCatalogInputSchema),
+      },
+      [LEARN_TOOLS_TOOL_NAME]: {
+        ...createLearnToolsTool(
+          this.toolRegistry,
+          toolContext,
+          MCP_EXCLUDED_TOOLS,
+        ),
+        inputSchema: zodSchema(learnToolsInputSchema),
+      },
+      [EXECUTE_TOOL_TOOL_NAME]: {
+        ...createExecuteToolTool(
+          this.toolRegistry,
+          toolContext,
+          preloadedTools,
+          MCP_EXCLUDED_TOOLS,
+        ),
+        inputSchema: zodSchema(executeToolInputSchema),
+      },
+      [LOAD_SKILL_TOOL_NAME]: {
+        ...createLoadSkillTool((names) =>
+          this.skillService.findFlatSkillsByNames(names, workspace.id),
+        ),
+        inputSchema: zodSchema(loadSkillInputSchema),
+      },
+    };
   }
 
   async handleMCPCoreQuery(
     { id, method, params }: JsonRpc,
     {
       workspace,
+      userId,
       userWorkspaceId,
       apiKey,
     }: {
       workspace: WorkspaceEntity;
+      userId?: string;
       userWorkspaceId?: string;
       apiKey: ApiKeyEntity | undefined;
     },
@@ -186,28 +206,15 @@ export class McpProtocolService {
         apiKey,
       );
 
-      const authContext = await this.buildAuthContext(
-        workspace,
-        userWorkspaceId,
-        apiKey,
-      );
+      const authContext = isDefined(apiKey)
+        ? buildApiKeyAuthContext({ workspace, apiKey })
+        : undefined;
 
-      // Exclude code_interpreter from MCP to prevent recursive execution attacks
-      // (code running in the sandbox could call code_interpreter via MCP)
-      const toolSet = await this.toolRegistry.getToolsByCategories(
-        {
-          workspaceId: workspace.id,
-          roleId,
-          rolePermissionConfig: { unionOf: [roleId] },
-          authContext,
-          userWorkspaceId,
-        },
-        {
-          categories: [ToolCategory.DATABASE_CRUD, ToolCategory.ACTION],
-          excludeTools: [ToolType.CODE_INTERPRETER],
-          wrapWithErrorContext: false,
-        },
-      );
+      const toolSet = await this.buildMcpToolSet(workspace, roleId, {
+        authContext,
+        userId,
+        userWorkspaceId,
+      });
 
       if (method === 'tools/call' && params) {
         return await this.mcpToolExecutorService.handleToolCall(
diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/providers/database-tool.provider.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/providers/database-tool.provider.ts
index cb367873888ff..6d4a3f03f18a4 100644
--- a/packages/twenty-server/src/engine/core-modules/tool-provider/providers/database-tool.provider.ts
+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/providers/database-tool.provider.ts
@@ -52,10 +52,6 @@ export class DatabaseToolProvider implements ToolProvider {
     const includeSchemas = options?.includeSchemas ?? true;
     const descriptors: (ToolIndexEntry | ToolDescriptor)[] = [];
 
-    if (!isDefined(context.userId) || !isDefined(context.userWorkspaceId)) {
-      return descriptors;
-    }
-
     const { rolesPermissions } =
       await this.workspaceCacheService.getOrRecompute(context.workspaceId, [
         'rolesPermissions',
diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/services/tool-registry.service.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/services/tool-registry.service.ts
index d739cdfd06447..f8da58c5788e9 100644
--- a/packages/twenty-server/src/engine/core-modules/tool-provider/services/tool-registry.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/services/tool-registry.service.ts
@@ -3,7 +3,6 @@ import { Inject, Injectable, Logger } from '@nestjs/common';
 import { type ToolCallOptions, type ToolSet, jsonSchema } from 'ai';
 
 import {
-  type CodeExecutionStreamEmitter,
   type NativeToolProvider,
   type ToolProvider,
   type ToolProviderContext,
@@ -146,13 +145,12 @@ export class ToolRegistryService {
     roleId: string,
     options?: { userId?: string; userWorkspaceId?: string },
   ): Promise<ToolIndexEntry[]> {
-    const context = this.buildContext(
+    const context = this.buildContextFromToolContext({
       workspaceId,
       roleId,
-      undefined,
-      options?.userId,
-      options?.userWorkspaceId,
-    );
+      userId: options?.userId,
+      userWorkspaceId: options?.userWorkspaceId,
+    });
 
     return this.getCatalog(context);
   }
@@ -161,13 +159,7 @@ export class ToolRegistryService {
     names: string[],
     context: ToolContext,
   ): Promise<ToolSet> {
-    const fullContext = this.buildContext(
-      context.workspaceId,
-      context.roleId,
-      context.onCodeExecutionUpdate,
-      context.userId,
-      context.userWorkspaceId,
-    );
+    const fullContext = this.buildContextFromToolContext(context);
 
     const index = await this.getCatalog(fullContext);
     const nameSet = new Set(names);
@@ -192,13 +184,7 @@ export class ToolRegistryService {
   ): Promise<
     Array<{ name: string; description?: string; inputSchema?: object }>
   > {
-    const fullContext = this.buildContext(
-      context.workspaceId,
-      context.roleId,
-      context.onCodeExecutionUpdate,
-      context.userId,
-      context.userWorkspaceId,
-    );
+    const fullContext = this.buildContextFromToolContext(context);
 
     const index = await this.getCatalog(fullContext);
     const nameSet = new Set(names);
@@ -236,13 +222,7 @@ export class ToolRegistryService {
     _options: ToolCallOptions,
   ): Promise<ExecuteToolResult> {
     try {
-      const fullContext = this.buildContext(
-        context.workspaceId,
-        context.roleId,
-        context.onCodeExecutionUpdate,
-        context.userId,
-        context.userWorkspaceId,
-      );
+      const fullContext = this.buildContextFromToolContext(context);
 
       const index = await this.getCatalog(fullContext);
       const entry = index.find((indexEntry) => indexEntry.name === toolName);
@@ -342,24 +322,21 @@ export class ToolRegistryService {
     return toolSet;
   }
 
-  private buildContext(
-    workspaceId: string,
-    roleId: string,
-    onCodeExecutionUpdate?: CodeExecutionStreamEmitter,
-    userId?: string,
-    userWorkspaceId?: string,
+  private buildContextFromToolContext(
+    context: ToolContext,
   ): ToolProviderContext {
     const rolePermissionConfig: RolePermissionConfig = {
-      unionOf: [roleId],
+      unionOf: [context.roleId],
     };
 
     return {
-      workspaceId,
-      roleId,
+      workspaceId: context.workspaceId,
+      roleId: context.roleId,
       rolePermissionConfig,
-      userId,
-      userWorkspaceId,
-      onCodeExecutionUpdate,
+      authContext: context.authContext,
+      userId: context.userId,
+      userWorkspaceId: context.userWorkspaceId,
+      onCodeExecutionUpdate: context.onCodeExecutionUpdate,
     };
   }
 }
diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/tools/execute-tool.tool.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/tools/execute-tool.tool.ts
index efeee663871c4..5df23fb7a0685 100644
--- a/packages/twenty-server/src/engine/core-modules/tool-provider/tools/execute-tool.tool.ts
+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/tools/execute-tool.tool.ts
@@ -7,12 +7,12 @@ import { type ToolContext } from 'src/engine/core-modules/tool-provider/types/to
 export const EXECUTE_TOOL_TOOL_NAME = 'execute_tool';
 
 export const executeToolInputSchema = z.object({
-  toolName: z.string().describe('Exact name of the tool to execute.'),
+  toolName: z
+    .string()
+    .describe('Exact tool name from get_tool_catalog. Do not guess.'),
   arguments: z
     .record(z.string(), z.unknown())
-    .describe(
-      'Arguments to pass to the tool. Must match the schema from learn_tools.',
-    ),
+    .describe('Arguments matching the schema returned by learn_tools.'),
 });
 
 export type ExecuteToolInput = z.infer<typeof executeToolInputSchema>;
@@ -30,9 +30,10 @@ export const createExecuteToolTool = (
   toolRegistry: ToolRegistryService,
   context: ToolContext,
   directTools?: ToolSet,
+  excludeTools?: Set<string>,
 ) => ({
   description:
-    'Execute a tool by name. Use learn_tools first to discover the correct schema, then call this with the tool name and arguments.',
+    'STEP 3: Execute a tool by name with arguments. You MUST call get_tool_catalog (step 1) and learn_tools (step 2) first to discover the tool name and its required input schema.',
   inputSchema: executeToolInputSchema,
   execute: async (
     parameters: ExecuteToolInput,
@@ -40,8 +41,16 @@ export const createExecuteToolTool = (
   ): Promise<ExecuteToolResult> => {
     const { toolName, arguments: args } = parameters;
 
-    // Native provider tools and preloaded tools are already in the ToolSet;
-    // dispatch directly if the LLM routes them through execute_tool.
+    if (excludeTools?.has(toolName)) {
+      return {
+        toolName,
+        error: {
+          message: `Tool "${toolName}" is not available in this context.`,
+          suggestion: 'Use get_tool_catalog to see which tools are available.',
+        },
+      };
+    }
+
     const directTool = directTools?.[toolName];
 
     if (directTool?.execute) {
diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/tools/get-tool-catalog.tool.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/tools/get-tool-catalog.tool.ts
new file mode 100644
index 0000000000000..abaa29c6086cb
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/tools/get-tool-catalog.tool.ts
@@ -0,0 +1,86 @@
+import { z } from 'zod';
+
+import { type ToolRegistryService } from 'src/engine/core-modules/tool-provider/services/tool-registry.service';
+import { type ToolIndexEntry } from 'src/engine/core-modules/tool-provider/types/tool-descriptor.type';
+
+export const GET_TOOL_CATALOG_TOOL_NAME = 'get_tool_catalog';
+
+export const getToolCatalogInputSchema = z.object({
+  categories: z
+    .array(z.string())
+    .optional()
+    .describe(
+      'Filter by category (e.g. DATABASE_CRUD, METADATA, VIEW, WORKFLOW, DASHBOARD, LOGIC_FUNCTION, ACTION). Omit to get all.',
+    ),
+});
+
+export type GetToolCatalogInput = z.infer<typeof getToolCatalogInputSchema>;
+
+export type GetToolCatalogResult = {
+  catalog: Record<string, Array<{ name: string; description: string }>>;
+  message: string;
+};
+
+export const createGetToolCatalogTool = (
+  toolRegistry: ToolRegistryService,
+  workspaceId: string,
+  roleId: string,
+  options?: {
+    userId?: string;
+    userWorkspaceId?: string;
+    excludeTools?: Set<string>;
+  },
+) => ({
+  description:
+    'STEP 1: Start here. Browse available tools by category. Returns tool names and descriptions. You MUST call this before using learn_tools or execute_tool — do not guess tool names.',
+  inputSchema: getToolCatalogInputSchema,
+  execute: async (
+    parameters: GetToolCatalogInput,
+  ): Promise<GetToolCatalogResult> => {
+    const entries = await toolRegistry.buildToolIndex(
+      workspaceId,
+      roleId,
+      options,
+    );
+
+    const categoryFilter = parameters.categories
+      ? new Set(parameters.categories)
+      : undefined;
+
+    const excludeSet = options?.excludeTools;
+
+    const catalog: Record<
+      string,
+      Array<{ name: string; description: string }>
+    > = {};
+
+    for (const entry of entries as ToolIndexEntry[]) {
+      if (excludeSet?.has(entry.name)) {
+        continue;
+      }
+
+      if (categoryFilter && !categoryFilter.has(entry.category)) {
+        continue;
+      }
+
+      if (!catalog[entry.category]) {
+        catalog[entry.category] = [];
+      }
+
+      catalog[entry.category].push({
+        name: entry.name,
+        description: entry.description,
+      });
+    }
+
+    const totalTools = Object.values(catalog).reduce(
+      (sum, tools) => sum + tools.length,
+      0,
+    );
+
+    return {
+      catalog,
+      message: `Found ${totalTools} tool(s) across ${Object.keys(catalog).length} category(ies).`,
+    };
+  },
+});
diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/tools/learn-tools.tool.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/tools/learn-tools.tool.ts
index 989db798ad5a7..0fef395a8fabc 100644
--- a/packages/twenty-server/src/engine/core-modules/tool-provider/tools/learn-tools.tool.ts
+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/tools/learn-tools.tool.ts
@@ -13,7 +13,7 @@ export const learnToolsInputSchema = z.object({
   toolNames: z
     .array(z.string())
     .describe(
-      'Tool names to learn about. Use exact names from the tool catalog.',
+      'Exact tool names from get_tool_catalog. Do not guess tool names.',
     ),
   aspects: z
     .array(learnToolsAspectSchema)
@@ -39,15 +39,20 @@ export type LearnToolsResult = {
 export const createLearnToolsTool = (
   toolRegistry: ToolRegistryService,
   context: ToolContext,
+  excludeTools?: Set<string>,
 ) => ({
   description:
-    'Learn about tools before using them. Returns tool descriptions and/or input schemas so you know how to call them via execute_tool.',
+    'STEP 2: Get input schemas for tools discovered via get_tool_catalog. Call this with exact tool names to learn the required arguments before calling execute_tool.',
   inputSchema: learnToolsInputSchema,
   execute: async (parameters: LearnToolsInput): Promise<LearnToolsResult> => {
     const { toolNames, aspects } = parameters;
 
+    const allowedNames = excludeTools
+      ? toolNames.filter((name) => !excludeTools.has(name))
+      : toolNames;
+
     const toolInfos = await toolRegistry.getToolInfo(
-      toolNames,
+      allowedNames,
       context,
       aspects,
     );
diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/tools/load-skill.tool.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/tools/load-skill.tool.ts
index 952cfd7e2d2b1..442f912647b22 100644
--- a/packages/twenty-server/src/engine/core-modules/tool-provider/tools/load-skill.tool.ts
+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/tools/load-skill.tool.ts
@@ -27,7 +27,7 @@ export type LoadSkillFunction = (names: string[]) => Promise<FlatSkill[]>;
 
 export const createLoadSkillTool = (loadSkills: LoadSkillFunction) => ({
   description:
-    'Load specialized skills/expertise by name. Returns detailed instructions for workflows, data manipulation, dashboards, metadata, or research.',
+    'Load specialized skills for complex tasks. Returns detailed step-by-step instructions for building workflows, dashboards, manipulating data, or managing metadata. Call this before attempting complex operations.',
   inputSchema: loadSkillInputSchema,
   execute: async (parameters: LoadSkillInput): Promise<LoadSkillResult> => {
     const { skillNames } = parameters;
diff --git a/packages/twenty-server/src/engine/core-modules/tool-provider/types/tool-context.type.ts b/packages/twenty-server/src/engine/core-modules/tool-provider/types/tool-context.type.ts
index afe4bb8560dd5..0d8ae1ef385cd 100644
--- a/packages/twenty-server/src/engine/core-modules/tool-provider/types/tool-context.type.ts
+++ b/packages/twenty-server/src/engine/core-modules/tool-provider/types/tool-context.type.ts
@@ -2,9 +2,12 @@ import { type ActorMetadata } from 'twenty-shared/types';
 
 import { type CodeExecutionStreamEmitter } from 'src/engine/core-modules/tool-provider/interfaces/tool-provider.interface';
 
+import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
+
 export type ToolContext = {
   workspaceId: string;
   roleId: string;
+  authContext?: WorkspaceAuthContext;
   actorContext?: ActorMetadata;
   userId?: string;
   userWorkspaceId?: string;