diff --git a/README.md b/README.md
index 317aa02b9d..7afbda6469 100644
--- a/README.md
+++ b/README.md
@@ -190,6 +190,21 @@ Copilot is a Sim-managed service. To use Copilot on a self-hosted instance:
 - Go to https://sim.ai → Settings → Copilot and generate a Copilot API key
 - Set `COPILOT_API_KEY` environment variable in your self-hosted apps/sim/.env file to that value
 
+## Hosted MCP Servers
+
+Sim can now author and deploy Model Context Protocol servers without leaving the workspace:
+
+1. Scaffold a starter project locally (Reddit search + arXiv summaries included) with  
+   ```bash
+   simstudio mcp init my-research-server
+   ```
+2. Push the code to your repo or automation pipeline, then open `/workspace/<id>/mcp` to create a hosted
+   project, track versions, and trigger deployments.
+3. Each deployment spins up a managed MCP endpoint, stores credentials in your workspace, and immediately
+   appears inside the workflow tool picker.
+
+> **Note:** Set `HOSTED_MCP_BASE_URL` in your `.env` to route hosted deployments through your own reverse
+> proxy or edge network.
 ## Tech Stack
 
 - **Framework**: [Next.js](https://nextjs.org/) (App Router)
@@ -214,3 +229,4 @@ We welcome contributions! Please see our [Contributing Guide](.github/CONTRIBUTI
 This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.
 
 <p align="center">Made with ❤️ by the Sim Team</p>
+
diff --git a/apps/sim/app/.env.example b/apps/sim/app/.env.example
index 0f9db4fe66..a553c1b4d8 100644
--- a/apps/sim/app/.env.example
+++ b/apps/sim/app/.env.example
@@ -10,6 +10,7 @@ BETTER_AUTH_URL=http://localhost:3000
 
 # NextJS (Required)
 NEXT_PUBLIC_APP_URL=http://localhost:3000
+HOSTED_MCP_BASE_URL=http://localhost:8787
 
 # Security (Required)
 ENCRYPTION_KEY=your_encryption_key  # Use `openssl rand -hex 32` to generate, used to encrypt environment variables
@@ -20,4 +21,4 @@ INTERNAL_API_SECRET=your_internal_api_secret # Use `openssl rand -hex 32` to gen
                    # If left commented out, emails will be logged to console instead
 
 # Local AI Models (Optional)
-# OLLAMA_URL=http://localhost:11434  # URL for local Ollama server - uncomment if using local models
\ No newline at end of file
+# OLLAMA_URL=http://localhost:11434  # URL for local Ollama server - uncomment if using local models
diff --git a/apps/sim/app/api/mcp/projects/[projectId]/deployments/[deploymentId]/route.ts b/apps/sim/app/api/mcp/projects/[projectId]/deployments/[deploymentId]/route.ts
new file mode 100644
index 0000000000..39da62b402
--- /dev/null
+++ b/apps/sim/app/api/mcp/projects/[projectId]/deployments/[deploymentId]/route.ts
@@ -0,0 +1,105 @@
+import type { NextRequest } from 'next/server'
+import { getParsedBody, withMcpAuth } from '@/lib/mcp/middleware'
+import {
+  getProjectIdFromRequest,
+  getDeploymentIdFromRequest,
+} from '@/lib/mcp/request-utils'
+import {
+  getMcpServerDeployment,
+  updateMcpServerDeployment,
+} from '@/lib/mcp/deployment-service'
+import { createLogger } from '@/lib/logs/console/logger'
+import { createMcpErrorResponse, createMcpSuccessResponse } from '@/lib/mcp/utils'
+
+const logger = createLogger('McpProjectDeploymentDetailsAPI')
+const STATUS_VALUES = new Set(['pending', 'deploying', 'active', 'failed', 'decommissioned'])
+
+export const dynamic = 'force-dynamic'
+
+function getIds(request: NextRequest) {
+  return {
+    projectId: getProjectIdFromRequest(request),
+    deploymentId: getDeploymentIdFromRequest(request),
+  }
+}
+
+export const GET = withMcpAuth('read')(async (request: NextRequest, context) => {
+  const { projectId, deploymentId } = getIds(request)
+  if (!projectId || !deploymentId) {
+    return createMcpErrorResponse(
+      new Error('Missing projectId or deploymentId'),
+      'Missing parameters',
+      400
+    )
+  }
+
+  try {
+    const deployment = await getMcpServerDeployment(context.workspaceId, projectId, deploymentId)
+    if (!deployment) {
+      return createMcpErrorResponse(new Error('Deployment not found'), 'Deployment not found', 404)
+    }
+    return createMcpSuccessResponse({ deployment })
+  } catch (error) {
+    logger.error(`[${context.requestId}] Failed to fetch deployment ${deploymentId}`, error)
+    return createMcpErrorResponse(
+      error instanceof Error ? error : new Error('Failed to fetch deployment'),
+      'Failed to fetch deployment',
+      500
+    )
+  }
+})
+
+export const PATCH = withMcpAuth('write')(async (request: NextRequest, context) => {
+  const { projectId, deploymentId } = getIds(request)
+  if (!projectId || !deploymentId) {
+    return createMcpErrorResponse(
+      new Error('Missing projectId or deploymentId'),
+      'Missing parameters',
+      400
+    )
+  }
+
+  try {
+    const body = getParsedBody(request) || (await request.json())
+    const updates: Record<string, any> = {}
+
+    if (body.status && STATUS_VALUES.has(body.status)) {
+      updates.status = body.status
+    }
+
+    if ('endpointUrl' in body) {
+      updates.endpointUrl = body.endpointUrl ?? null
+    }
+
+    if ('logsUrl' in body) {
+      updates.logsUrl = body.logsUrl ?? null
+    }
+
+    if ('serverId' in body) {
+      updates.serverId = body.serverId ?? null
+    }
+
+    if ('rolledBackAt' in body) {
+      updates.rolledBackAt = body.rolledBackAt ? new Date(body.rolledBackAt) : null
+    }
+
+    if (Object.keys(updates).length === 0) {
+      return createMcpErrorResponse(new Error('No valid fields to update'), 'No updates', 400)
+    }
+
+    const deployment = await updateMcpServerDeployment(
+      context.workspaceId,
+      projectId,
+      deploymentId,
+      updates
+    )
+    return createMcpSuccessResponse({ deployment })
+  } catch (error) {
+    logger.error(`[${context.requestId}] Failed to update deployment ${deploymentId}`, error)
+    return createMcpErrorResponse(
+      error instanceof Error ? error : new Error('Failed to update deployment'),
+      error instanceof Error ? error.message : 'Failed to update deployment',
+      500
+    )
+  }
+})
diff --git a/apps/sim/app/api/mcp/projects/[projectId]/deployments/route.ts b/apps/sim/app/api/mcp/projects/[projectId]/deployments/route.ts
new file mode 100644
index 0000000000..9b7a5985c4
--- /dev/null
+++ b/apps/sim/app/api/mcp/projects/[projectId]/deployments/route.ts
@@ -0,0 +1,73 @@
+import type { NextRequest } from 'next/server'
+import { tasks } from '@trigger.dev/sdk'
+import { getParsedBody, withMcpAuth } from '@/lib/mcp/middleware'
+import { getProjectIdFromRequest } from '@/lib/mcp/request-utils'
+import {
+  createMcpServerDeployment,
+  listMcpServerDeployments,
+} from '@/lib/mcp/deployment-service'
+import { createLogger } from '@/lib/logs/console/logger'
+import { createMcpErrorResponse, createMcpSuccessResponse } from '@/lib/mcp/utils'
+
+const logger = createLogger('McpProjectDeploymentsAPI')
+export const dynamic = 'force-dynamic'
+
+export const GET = withMcpAuth('read')(async (request: NextRequest, context) => {
+  const projectId = getProjectIdFromRequest(request)
+  if (!projectId) {
+    return createMcpErrorResponse(new Error('Project ID missing from URL'), 'Missing projectId', 400)
+  }
+
+  try {
+    const deployments = await listMcpServerDeployments(context.workspaceId, projectId)
+    return createMcpSuccessResponse({ deployments })
+  } catch (error) {
+    logger.error(`[${context.requestId}] Failed to list deployments for ${projectId}`, error)
+    return createMcpErrorResponse(
+      error instanceof Error ? error : new Error('Failed to list deployments'),
+      'Failed to list deployments',
+      500
+    )
+  }
+})
+
+export const POST = withMcpAuth('write')(async (request: NextRequest, context) => {
+  const projectId = getProjectIdFromRequest(request)
+  if (!projectId) {
+    return createMcpErrorResponse(new Error('Project ID missing from URL'), 'Missing projectId', 400)
+  }
+
+  try {
+    const body = getParsedBody(request) || (await request.json())
+    if (!body?.versionId) {
+      return createMcpErrorResponse(new Error('versionId is required'), 'Missing versionId', 400)
+    }
+
+    const deployment = await createMcpServerDeployment({
+      workspaceId: context.workspaceId,
+      projectId,
+      versionId: body.versionId,
+      environment: body.environment,
+      region: body.region,
+      serverId: body.serverId,
+      deployedBy: context.userId,
+    })
+
+    await tasks.trigger('mcp-server-deploy', {
+      deploymentId: deployment.id,
+      projectId,
+      versionId: body.versionId,
+      workspaceId: context.workspaceId,
+      userId: context.userId,
+    })
+
+    return createMcpSuccessResponse({ deployment }, 201)
+  } catch (error) {
+    logger.error(`[${context.requestId}] Failed to create deployment for ${projectId}`, error)
+    return createMcpErrorResponse(
+      error instanceof Error ? error : new Error('Failed to create deployment'),
+      error instanceof Error ? error.message : 'Failed to create deployment',
+      500
+    )
+  }
+})
diff --git a/apps/sim/app/api/mcp/projects/[projectId]/route.ts b/apps/sim/app/api/mcp/projects/[projectId]/route.ts
new file mode 100644
index 0000000000..feb4fca63a
--- /dev/null
+++ b/apps/sim/app/api/mcp/projects/[projectId]/route.ts
@@ -0,0 +1,140 @@
+import type { NextRequest } from 'next/server'
+import {
+  archiveMcpServerProject,
+  getMcpServerProject,
+  updateMcpServerProject,
+} from '@/lib/mcp/project-service'
+import { getParsedBody, withMcpAuth } from '@/lib/mcp/middleware'
+import { createLogger } from '@/lib/logs/console/logger'
+import { getProjectIdFromRequest } from '@/lib/mcp/request-utils'
+import { createMcpErrorResponse, createMcpSuccessResponse } from '@/lib/mcp/utils'
+
+const logger = createLogger('McpProjectDetailsAPI')
+const VISIBILITY_VALUES = new Set(['private', 'workspace', 'public'])
+const SOURCE_TYPE_VALUES = new Set(['inline', 'repo', 'package'])
+const STATUS_VALUES = new Set(['draft', 'building', 'deploying', 'active', 'failed', 'archived'])
+
+export const dynamic = 'force-dynamic'
+
+export const GET = withMcpAuth('read')(async (request: NextRequest, context) => {
+  const { workspaceId, requestId } = context
+  const projectId = getProjectIdFromRequest(request)
+
+  try {
+    if (!projectId) {
+      return createMcpErrorResponse(new Error('Project ID missing from URL'), 'Missing projectId', 400)
+    }
+
+    const project = await getMcpServerProject(workspaceId, projectId)
+    if (!project) {
+      return createMcpErrorResponse(new Error('Project not found'), 'Project not found', 404)
+    }
+
+    return createMcpSuccessResponse({ project })
+  } catch (error) {
+    logger.error(`[${requestId}] Failed to fetch MCP project ${projectId}`, error)
+    return createMcpErrorResponse(
+      error instanceof Error ? error : new Error('Failed to fetch project'),
+      'Failed to fetch project',
+      500
+    )
+  }
+})
+
+export const PATCH = withMcpAuth('write')(async (request: NextRequest, context) => {
+  const { workspaceId, requestId } = context
+  const projectId = getProjectIdFromRequest(request)
+
+  try {
+    if (!projectId) {
+      return createMcpErrorResponse(new Error('Project ID missing from URL'), 'Missing projectId', 400)
+    }
+
+    const body = getParsedBody(request) || (await request.json())
+    const updates: Record<string, any> = {}
+
+    if (typeof body.name === 'string') {
+      updates.name = body.name
+    }
+
+    if ('description' in body) {
+      updates.description = body.description ?? null
+    }
+
+    if (body.visibility && VISIBILITY_VALUES.has(body.visibility)) {
+      updates.visibility = body.visibility
+    }
+
+    if (body.runtime) {
+      updates.runtime = body.runtime
+    }
+
+    if (body.entryPoint) {
+      updates.entryPoint = body.entryPoint
+    }
+
+    if ('template' in body) {
+      updates.template = body.template ?? null
+    }
+
+    if (body.sourceType && SOURCE_TYPE_VALUES.has(body.sourceType)) {
+      updates.sourceType = body.sourceType
+    }
+
+    if ('repositoryUrl' in body) {
+      updates.repositoryUrl = body.repositoryUrl ?? null
+    }
+
+    if ('repositoryBranch' in body) {
+      updates.repositoryBranch = body.repositoryBranch ?? null
+    }
+
+    if (body.environmentVariables && typeof body.environmentVariables === 'object') {
+      updates.environmentVariables = body.environmentVariables
+    }
+
+    if (body.metadata && typeof body.metadata === 'object') {
+      updates.metadata = body.metadata
+    }
+
+    if (body.status && STATUS_VALUES.has(body.status)) {
+      updates.status = body.status
+    }
+
+    if (Object.keys(updates).length === 0) {
+      return createMcpErrorResponse(new Error('No valid fields to update'), 'No updates', 400)
+    }
+
+    const project = await updateMcpServerProject(workspaceId, projectId, updates)
+    return createMcpSuccessResponse({ project })
+  } catch (error) {
+    logger.error(`[${requestId}] Failed to update MCP project ${projectId}`, error)
+    return createMcpErrorResponse(
+      error instanceof Error ? error : new Error('Failed to update project'),
+      error instanceof Error ? error.message : 'Failed to update project',
+      500
+    )
+  }
+})
+
+export const DELETE = withMcpAuth('admin')(async (request: NextRequest, context) => {
+  const { workspaceId, requestId } = context
+  const projectId = getProjectIdFromRequest(request)
+
+  try {
+    if (!projectId) {
+      return createMcpErrorResponse(new Error('Project ID missing from URL'), 'Missing projectId', 400)
+    }
+
+    await archiveMcpServerProject(workspaceId, projectId)
+    logger.info(`[${requestId}] Archived MCP project ${projectId}`)
+    return createMcpSuccessResponse({ projectId })
+  } catch (error) {
+    logger.error(`[${requestId}] Failed to archive MCP project ${projectId}`, error)
+    return createMcpErrorResponse(
+      error instanceof Error ? error : new Error('Failed to archive project'),
+      error instanceof Error ? error.message : 'Failed to archive project',
+      500
+    )
+  }
+})
diff --git a/apps/sim/app/api/mcp/projects/[projectId]/tokens/route.ts b/apps/sim/app/api/mcp/projects/[projectId]/tokens/route.ts
new file mode 100644
index 0000000000..2359a5a246
--- /dev/null
+++ b/apps/sim/app/api/mcp/projects/[projectId]/tokens/route.ts
@@ -0,0 +1,95 @@
+import type { NextRequest } from 'next/server'
+import { getParsedBody, withMcpAuth } from '@/lib/mcp/middleware'
+import { getProjectIdFromRequest } from '@/lib/mcp/request-utils'
+import {
+  issueMcpServerToken,
+  listMcpServerTokens,
+  revokeMcpServerToken,
+} from '@/lib/mcp/token-service'
+import { createLogger } from '@/lib/logs/console/logger'
+import { createMcpErrorResponse, createMcpSuccessResponse } from '@/lib/mcp/utils'
+
+const logger = createLogger('McpProjectTokensAPI')
+const SCOPE_VALUES = new Set(['deploy', 'runtime', 'logs'])
+
+export const dynamic = 'force-dynamic'
+
+export const GET = withMcpAuth('read')(async (request: NextRequest, context) => {
+  const projectId = getProjectIdFromRequest(request)
+  if (!projectId) {
+    return createMcpErrorResponse(new Error('Project ID missing from URL'), 'Missing projectId', 400)
+  }
+
+  try {
+    const tokens = await listMcpServerTokens(context.workspaceId, projectId)
+    return createMcpSuccessResponse({ tokens })
+  } catch (error) {
+    logger.error(`[${context.requestId}] Failed to list tokens for ${projectId}`, error)
+    return createMcpErrorResponse(
+      error instanceof Error ? error : new Error('Failed to list tokens'),
+      'Failed to list tokens',
+      500
+    )
+  }
+})
+
+export const POST = withMcpAuth('write')(async (request: NextRequest, context) => {
+  const projectId = getProjectIdFromRequest(request)
+  if (!projectId) {
+    return createMcpErrorResponse(new Error('Project ID missing from URL'), 'Missing projectId', 400)
+  }
+
+  try {
+    const body = getParsedBody(request) || (await request.json())
+    if (!body?.name) {
+      return createMcpErrorResponse(new Error('Token name is required'), 'Missing name', 400)
+    }
+
+    const scope = SCOPE_VALUES.has(body.scope) ? body.scope : undefined
+    const expiresAt = body.expiresAt ? new Date(body.expiresAt) : undefined
+
+    const result = await issueMcpServerToken({
+      workspaceId: context.workspaceId,
+      projectId,
+      name: body.name,
+      scope,
+      expiresAt,
+      createdBy: context.userId,
+    })
+
+    return createMcpSuccessResponse({ token: result.token, record: result.record }, 201)
+  } catch (error) {
+    logger.error(`[${context.requestId}] Failed to issue token for ${projectId}`, error)
+    return createMcpErrorResponse(
+      error instanceof Error ? error : new Error('Failed to issue token'),
+      error instanceof Error ? error.message : 'Failed to issue token',
+      500
+    )
+  }
+})
+
+export const DELETE = withMcpAuth('admin')(async (request: NextRequest, context) => {
+  const projectId = getProjectIdFromRequest(request)
+  if (!projectId) {
+    return createMcpErrorResponse(new Error('Project ID missing from URL'), 'Missing projectId', 400)
+  }
+
+  const { searchParams } = request.nextUrl
+  const tokenId = searchParams.get('tokenId')
+
+  if (!tokenId) {
+    return createMcpErrorResponse(new Error('tokenId is required'), 'Missing tokenId', 400)
+  }
+
+  try {
+    await revokeMcpServerToken(context.workspaceId, projectId, tokenId)
+    return createMcpSuccessResponse({ tokenId })
+  } catch (error) {
+    logger.error(`[${context.requestId}] Failed to revoke token ${tokenId}`, error)
+    return createMcpErrorResponse(
+      error instanceof Error ? error : new Error('Failed to revoke token'),
+      error instanceof Error ? error.message : 'Failed to revoke token',
+      500
+    )
+  }
+})
diff --git a/apps/sim/app/api/mcp/projects/[projectId]/versions/[versionId]/route.ts b/apps/sim/app/api/mcp/projects/[projectId]/versions/[versionId]/route.ts
new file mode 100644
index 0000000000..de9e13740b
--- /dev/null
+++ b/apps/sim/app/api/mcp/projects/[projectId]/versions/[versionId]/route.ts
@@ -0,0 +1,116 @@
+import type { NextRequest } from 'next/server'
+import {
+  getMcpServerVersion,
+  updateMcpServerVersion,
+} from '@/lib/mcp/version-service'
+import { getParsedBody, withMcpAuth } from '@/lib/mcp/middleware'
+import {
+  getProjectIdFromRequest,
+  getVersionIdFromRequest,
+} from '@/lib/mcp/request-utils'
+import { createLogger } from '@/lib/logs/console/logger'
+import { createMcpErrorResponse, createMcpSuccessResponse } from '@/lib/mcp/utils'
+
+const logger = createLogger('McpProjectVersionDetailsAPI')
+const STATUS_VALUES = new Set(['queued', 'building', 'ready', 'failed', 'deprecated'])
+
+export const dynamic = 'force-dynamic'
+
+function getIds(request: NextRequest) {
+  return {
+    projectId: getProjectIdFromRequest(request),
+    versionId: getVersionIdFromRequest(request),
+  }
+}
+
+export const GET = withMcpAuth('read')(async (request: NextRequest, context) => {
+  const { projectId, versionId } = getIds(request)
+
+  if (!projectId || !versionId) {
+    return createMcpErrorResponse(
+      new Error('Missing projectId or versionId'),
+      'Missing parameters',
+      400
+    )
+  }
+
+  try {
+    const version = await getMcpServerVersion(context.workspaceId, projectId, versionId)
+    if (!version) {
+      return createMcpErrorResponse(new Error('Version not found'), 'Version not found', 404)
+    }
+
+    return createMcpSuccessResponse({ version })
+  } catch (error) {
+    logger.error(`[${context.requestId}] Failed to fetch version ${versionId}`, error)
+    return createMcpErrorResponse(
+      error instanceof Error ? error : new Error('Failed to fetch version'),
+      'Failed to fetch version',
+      500
+    )
+  }
+})
+
+export const PATCH = withMcpAuth('write')(async (request: NextRequest, context) => {
+  const { projectId, versionId } = getIds(request)
+
+  if (!projectId || !versionId) {
+    return createMcpErrorResponse(
+      new Error('Missing projectId or versionId'),
+      'Missing parameters',
+      400
+    )
+  }
+
+  try {
+    const body = getParsedBody(request) || (await request.json())
+    const updates: Record<string, any> = {}
+
+    if (body.status && STATUS_VALUES.has(body.status)) {
+      updates.status = body.status
+    }
+
+    if ('artifactUrl' in body) {
+      updates.artifactUrl = body.artifactUrl ?? null
+    }
+
+    if ('runtimeMetadata' in body) {
+      updates.runtimeMetadata = body.runtimeMetadata ?? {}
+    }
+
+    if ('buildLogsUrl' in body) {
+      updates.buildLogsUrl = body.buildLogsUrl ?? null
+    }
+
+    if ('changelog' in body) {
+      updates.changelog = body.changelog ?? null
+    }
+
+    if ('promotedBy' in body) {
+      updates.promotedBy = body.promotedBy ?? null
+    }
+
+    if ('promotedAt' in body) {
+      updates.promotedAt = body.promotedAt ? new Date(body.promotedAt) : null
+    }
+
+    if (Object.keys(updates).length === 0) {
+      return createMcpErrorResponse(new Error('No valid fields to update'), 'No updates', 400)
+    }
+
+    const version = await updateMcpServerVersion(
+      context.workspaceId,
+      projectId,
+      versionId,
+      updates
+    )
+    return createMcpSuccessResponse({ version })
+  } catch (error) {
+    logger.error(`[${context.requestId}] Failed to update version ${versionId}`, error)
+    return createMcpErrorResponse(
+      error instanceof Error ? error : new Error('Failed to update version'),
+      error instanceof Error ? error.message : 'Failed to update version',
+      500
+    )
+  }
+})
diff --git a/apps/sim/app/api/mcp/projects/[projectId]/versions/route.ts b/apps/sim/app/api/mcp/projects/[projectId]/versions/route.ts
new file mode 100644
index 0000000000..114ab87db2
--- /dev/null
+++ b/apps/sim/app/api/mcp/projects/[projectId]/versions/route.ts
@@ -0,0 +1,61 @@
+import type { NextRequest } from 'next/server'
+import { createMcpServerVersion, listMcpServerVersions } from '@/lib/mcp/version-service'
+import { getParsedBody, withMcpAuth } from '@/lib/mcp/middleware'
+import { getProjectIdFromRequest } from '@/lib/mcp/request-utils'
+import { createLogger } from '@/lib/logs/console/logger'
+import { createMcpErrorResponse, createMcpSuccessResponse } from '@/lib/mcp/utils'
+
+const logger = createLogger('McpProjectVersionsAPI')
+export const dynamic = 'force-dynamic'
+
+export const GET = withMcpAuth('read')(async (request: NextRequest, context) => {
+  const projectId = getProjectIdFromRequest(request)
+
+  if (!projectId) {
+    return createMcpErrorResponse(new Error('Project ID missing from URL'), 'Missing projectId', 400)
+  }
+
+  try {
+    const versions = await listMcpServerVersions(context.workspaceId, projectId)
+    return createMcpSuccessResponse({ versions })
+  } catch (error) {
+    logger.error(`[${context.requestId}] Failed to list versions for ${projectId}`, error)
+    return createMcpErrorResponse(
+      error instanceof Error ? error : new Error('Failed to list versions'),
+      'Failed to list versions',
+      500
+    )
+  }
+})
+
+export const POST = withMcpAuth('write')(async (request: NextRequest, context) => {
+  const projectId = getProjectIdFromRequest(request)
+
+  if (!projectId) {
+    return createMcpErrorResponse(new Error('Project ID missing from URL'), 'Missing projectId', 400)
+  }
+
+  try {
+    const body = getParsedBody(request) || (await request.json())
+    const version = await createMcpServerVersion({
+      workspaceId: context.workspaceId,
+      projectId,
+      sourceHash: body.sourceHash,
+      manifest: body.manifest,
+      buildConfig: body.buildConfig,
+      artifactUrl: body.artifactUrl,
+      runtimeMetadata: body.runtimeMetadata,
+      changelog: body.changelog,
+      buildLogsUrl: body.buildLogsUrl,
+    })
+
+    return createMcpSuccessResponse({ version }, 201)
+  } catch (error) {
+    logger.error(`[${context.requestId}] Failed to create MCP version for ${projectId}`, error)
+    return createMcpErrorResponse(
+      error instanceof Error ? error : new Error('Failed to create version'),
+      error instanceof Error ? error.message : 'Failed to create version',
+      500
+    )
+  }
+})
diff --git a/apps/sim/app/api/mcp/projects/route.ts b/apps/sim/app/api/mcp/projects/route.ts
new file mode 100644
index 0000000000..f3cba887a3
--- /dev/null
+++ b/apps/sim/app/api/mcp/projects/route.ts
@@ -0,0 +1,78 @@
+import type { NextRequest } from 'next/server'
+import { createMcpServerProject, listMcpServerProjects } from '@/lib/mcp/project-service'
+import { getParsedBody, withMcpAuth } from '@/lib/mcp/middleware'
+import { createLogger } from '@/lib/logs/console/logger'
+import { createMcpErrorResponse, createMcpSuccessResponse } from '@/lib/mcp/utils'
+
+const logger = createLogger('McpProjectsAPI')
+export const dynamic = 'force-dynamic'
+
+const VISIBILITY_VALUES = new Set(['private', 'workspace', 'public'])
+const SOURCE_TYPE_VALUES = new Set(['inline', 'repo', 'package'])
+
+/**
+ * GET - List all MCP server projects for a workspace
+ */
+export const GET = withMcpAuth('read')(async (_request, { workspaceId, requestId }) => {
+  try {
+    logger.info(`[${requestId}] Listing MCP server projects for workspace ${workspaceId}`)
+    const projects = await listMcpServerProjects(workspaceId)
+    return createMcpSuccessResponse({ projects })
+  } catch (error) {
+    logger.error(`[${requestId}] Failed to list MCP server projects`, error)
+    return createMcpErrorResponse(
+      error instanceof Error ? error : new Error('Failed to list MCP server projects'),
+      'Failed to list MCP server projects',
+      500
+    )
+  }
+})
+
+/**
+ * POST - Create a new MCP server project
+ */
+export const POST = withMcpAuth('write')(async (request: NextRequest, authContext) => {
+  const { userId, workspaceId, requestId } = authContext
+
+  try {
+    const body = getParsedBody(request) || (await request.json())
+
+    if (!body?.name) {
+      return createMcpErrorResponse(new Error('Project name is required'), 'Missing name', 400)
+    }
+
+    const visibility = VISIBILITY_VALUES.has(body.visibility)
+      ? body.visibility
+      : undefined
+    const sourceType = SOURCE_TYPE_VALUES.has(body.sourceType)
+      ? body.sourceType
+      : undefined
+
+    const project = await createMcpServerProject({
+      workspaceId,
+      createdBy: userId,
+      name: body.name,
+      slug: body.slug,
+      description: body.description,
+      visibility,
+      runtime: body.runtime,
+      entryPoint: body.entryPoint,
+      template: body.template,
+      sourceType,
+      repositoryUrl: body.repositoryUrl,
+      repositoryBranch: body.repositoryBranch,
+      environmentVariables: body.environmentVariables,
+      metadata: body.metadata,
+    })
+
+    logger.info(`[${requestId}] Created MCP server project ${project.id}`)
+    return createMcpSuccessResponse({ project }, 201)
+  } catch (error) {
+    logger.error(`[${requestId}] Failed to create MCP server project`, error)
+    return createMcpErrorResponse(
+      error instanceof Error ? error : new Error('Failed to create MCP server project'),
+      error instanceof Error ? error.message : 'Failed to create MCP server project',
+      500
+    )
+  }
+})
diff --git a/apps/sim/app/workspace/[workspaceId]/mcp/components/mcp-project-manager.tsx b/apps/sim/app/workspace/[workspaceId]/mcp/components/mcp-project-manager.tsx
new file mode 100644
index 0000000000..8c2b1db395
--- /dev/null
+++ b/apps/sim/app/workspace/[workspaceId]/mcp/components/mcp-project-manager.tsx
@@ -0,0 +1,205 @@
+'use client'
+
+import { useCallback, useEffect, useMemo, useState, useTransition } from 'react'
+import { Loader2, RefreshCcw, Rocket } from 'lucide-react'
+import type { McpServerProject } from '@/lib/mcp/types'
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from '@/components/ui/card'
+import { Input } from '@/components/ui/input'
+import { Textarea } from '@/components/ui/textarea'
+import { cn } from '@/lib/utils'
+
+interface McpProjectManagerProps {
+  workspaceId: string
+}
+
+interface CreateProjectState {
+  name: string
+  description: string
+}
+
+const defaultState: CreateProjectState = {
+  name: '',
+  description: '',
+}
+
+export function McpProjectManager({ workspaceId }: McpProjectManagerProps) {
+  const [projects, setProjects] = useState<McpServerProject[]>([])
+  const [formState, setFormState] = useState<CreateProjectState>(defaultState)
+  const [error, setError] = useState<string | null>(null)
+  const [isLoading, setIsLoading] = useState(true)
+  const [isPending, startTransition] = useTransition()
+
+  const fetchProjects = useCallback(async () => {
+    setIsLoading(true)
+    setError(null)
+
+    try {
+      const response = await fetch(`/api/mcp/projects?workspaceId=${workspaceId}`, {
+        cache: 'no-store',
+      })
+
+      if (!response.ok) {
+        throw new Error(`Failed to load projects (${response.status})`)
+      }
+
+      const payload = await response.json()
+      const nextProjects =
+        payload?.data?.projects ?? payload?.projects ?? payload?.data ?? []
+      setProjects(nextProjects as McpServerProject[])
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to load MCP projects')
+    } finally {
+      setIsLoading(false)
+    }
+  }, [workspaceId])
+
+  useEffect(() => {
+    fetchProjects().catch(() => {
+      // Already handled inside fetchProjects
+    })
+  }, [fetchProjects])
+
+  const canSubmit = useMemo(() => formState.name.trim().length > 2, [formState.name])
+
+  const handleCreateProject = () => {
+    setError(null)
+    startTransition(async () => {
+      try {
+        const response = await fetch('/api/mcp/projects', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            ...formState,
+            workspaceId,
+            runtime: 'node',
+            entryPoint: 'index.ts',
+          }),
+        })
+
+        if (!response.ok) {
+          const payload = await response.json().catch(() => ({}))
+          throw new Error(payload.error || 'Failed to create project')
+        }
+
+        setFormState(defaultState)
+        await fetchProjects()
+      } catch (err) {
+        setError(err instanceof Error ? err.message : 'Failed to create project')
+      }
+    })
+  }
+
+  return (
+    <div className='grid gap-6 lg:grid-cols-[2fr,3fr]'>
+      <Card>
+        <CardHeader>
+          <CardTitle>New hosted server</CardTitle>
+          <CardDescription>
+            Start with a project name and optional description. You can define manifests, custom
+            tools, and deployments after the project is created.
+          </CardDescription>
+        </CardHeader>
+        <CardContent className='space-y-4'>
+          <div className='space-y-2'>
+            <label className='text-sm font-medium' htmlFor='mcp-name'>
+              Project name
+            </label>
+            <Input
+              id='mcp-name'
+              placeholder='Reddit Research Agent'
+              value={formState.name}
+              onChange={(event) => setFormState((prev) => ({ ...prev, name: event.target.value }))}
+              disabled={isPending}
+            />
+          </div>
+          <div className='space-y-2'>
+            <label className='text-sm font-medium' htmlFor='mcp-description'>
+              Description
+            </label>
+            <Textarea
+              id='mcp-description'
+              placeholder='Scrapes Reddit, summarises arXiv abstracts, and republishes insights to Substack.'
+              value={formState.description}
+              onChange={(event) =>
+                setFormState((prev) => ({ ...prev, description: event.target.value }))
+              }
+              disabled={isPending}
+              rows={4}
+            />
+          </div>
+          {error && (
+            <div className='rounded-md border border-destructive/50 bg-destructive/10 px-3 py-2 text-sm text-destructive'>
+              {error}
+            </div>
+          )}
+        </CardContent>
+        <CardFooter className='flex justify-between'>
+          <p className='text-sm text-muted-foreground'>
+            Use <code className='rounded bg-muted px-1 py-0.5 text-xs'>simstudio mcp init</code> to
+            scaffold code locally.
+          </p>
+          <Button onClick={handleCreateProject} disabled={!canSubmit || isPending}>
+            {isPending ? <Loader2 className='mr-2 h-4 w-4 animate-spin' /> : <Rocket className='mr-2 h-4 w-4' />}
+            Create project
+          </Button>
+        </CardFooter>
+      </Card>
+      <Card className='flex flex-col'>
+        <CardHeader className='flex flex-row items-center justify-between'>
+          <div>
+            <CardTitle>Existing projects</CardTitle>
+            <CardDescription>Track status, deployments, and active versions.</CardDescription>
+          </div>
+          <Button variant='ghost' size='icon' onClick={() => fetchProjects()} disabled={isLoading}>
+            <RefreshCcw className={cn('h-4 w-4', { 'animate-spin': isLoading })} />
+            <span className='sr-only'>Refresh projects</span>
+          </Button>
+        </CardHeader>
+        <CardContent className='flex-1 space-y-3 overflow-auto'>
+          {isLoading ? (
+            <div className='flex h-32 items-center justify-center text-muted-foreground'>
+              <Loader2 className='mr-2 h-4 w-4 animate-spin' />
+              Loading projects…
+            </div>
+          ) : projects.length === 0 ? (
+            <div className='text-sm text-muted-foreground'>
+              No projects yet. Create one to start exposing workflows, Reddit scrapers, YouTube
+              transcribers, or CRM integrations as MCP servers.
+            </div>
+          ) : (
+            projects.map((project) => (
+              <div
+                key={project.id}
+                className='rounded-lg border bg-card px-4 py-3 text-sm shadow-sm transition hover:border-primary/40'
+              >
+                <div className='flex flex-wrap items-center justify-between gap-2'>
+                  <div>
+                    <p className='font-medium'>{project.name}</p>
+                    <p className='text-xs text-muted-foreground'>{project.slug}</p>
+                  </div>
+                  <Badge variant={project.status === 'active' ? 'default' : 'secondary'}>
+                    {project.status}
+                  </Badge>
+                </div>
+                <p className='mt-2 text-muted-foreground'>
+                  {project.description || 'No description provided.'}
+                </p>
+                <div className='mt-3 flex flex-wrap items-center gap-3 text-xs text-muted-foreground'>
+                  {project.currentVersionNumber ? (
+                    <span>v{project.currentVersionNumber}</span>
+                  ) : (
+                    <span>No version deployed</span>
+                  )}
+                  <span>Runtime: {project.runtime}</span>
+                  <span>Visibility: {project.visibility}</span>
+                </div>
+              </div>
+            ))
+          )}
+        </CardContent>
+      </Card>
+    </div>
+  )
+}
diff --git a/apps/sim/app/workspace/[workspaceId]/mcp/page.tsx b/apps/sim/app/workspace/[workspaceId]/mcp/page.tsx
new file mode 100644
index 0000000000..cb0362a746
--- /dev/null
+++ b/apps/sim/app/workspace/[workspaceId]/mcp/page.tsx
@@ -0,0 +1,32 @@
+import { Suspense } from 'react'
+import { Loader2 } from 'lucide-react'
+import { McpProjectManager } from '@/app/workspace/[workspaceId]/mcp/components/mcp-project-manager'
+
+interface WorkspaceMcpPageProps {
+  params: { workspaceId: string }
+}
+
+export default function WorkspaceMcpPage({ params }: WorkspaceMcpPageProps) {
+  return (
+    <div className='flex flex-1 flex-col gap-6 p-6'>
+      <div className='max-w-3xl space-y-2'>
+        <h1 className='text-2xl font-semibold tracking-tight'>Hosted MCP Servers</h1>
+        <p className='text-sm text-muted-foreground'>
+          Create and deploy Model Context Protocol servers without leaving Sim. Projects inherit
+          your workspace permissions, tokens, and environment variables, making it simple to expose
+          internal tools, Reddit monitors, or arXiv scrapers to every workflow.
+        </p>
+      </div>
+      <Suspense
+        fallback={
+          <div className='flex h-32 items-center justify-center rounded-lg border bg-muted/40'>
+            <Loader2 className='mr-2 h-5 w-5 animate-spin text-muted-foreground' />
+            <span className='text-muted-foreground'>Loading projects…</span>
+          </div>
+        }
+      >
+        <McpProjectManager workspaceId={params.workspaceId} />
+      </Suspense>
+    </div>
+  )
+}
diff --git a/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/floating-navigation/floating-navigation.tsx b/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/floating-navigation/floating-navigation.tsx
index f0404047e3..1f5ae8b184 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/floating-navigation/floating-navigation.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/floating-navigation/floating-navigation.tsx
@@ -1,4 +1,4 @@
-import { HelpCircle, LibraryBig, ScrollText, Settings, Shapes } from 'lucide-react'
+import { HelpCircle, LibraryBig, ScrollText, ServerCog, Settings, Shapes } from 'lucide-react'
 import { NavigationItem } from '@/app/workspace/[workspaceId]/w/components/sidebar/components/navigation-item/navigation-item'
 
 interface FloatingNavigationProps {
@@ -51,6 +51,13 @@ export const FloatingNavigation = ({
       tooltip: 'Templates',
       active: pathname === `/workspace/${workspaceId}/templates`,
     },
+    {
+      id: 'mcp',
+      icon: ServerCog,
+      href: `/workspace/${workspaceId}/mcp`,
+      tooltip: 'MCP Projects',
+      active: pathname === `/workspace/${workspaceId}/mcp`,
+    },
   ]
 
   return (
diff --git a/apps/sim/background/mcp-server-deploy.ts b/apps/sim/background/mcp-server-deploy.ts
new file mode 100644
index 0000000000..7c53198fde
--- /dev/null
+++ b/apps/sim/background/mcp-server-deploy.ts
@@ -0,0 +1,205 @@
+import { randomUUID } from 'crypto'
+import { db } from '@sim/db'
+import {
+  mcpServerDeployment,
+  mcpServerProject,
+  mcpServers,
+  mcpServerVersion,
+} from '@sim/db/schema'
+import { task } from '@trigger.dev/sdk'
+import { and, eq } from 'drizzle-orm'
+import { createLogger } from '@/lib/logs/console/logger'
+import { activateHostedDeployment, buildHostedBundle } from '@/lib/mcp/hosted-orchestrator'
+import { mcpService } from '@/lib/mcp/service'
+
+const logger = createLogger('McpServerDeployTask')
+
+export type McpServerDeployPayload = {
+  deploymentId: string
+  projectId: string
+  versionId: string
+  workspaceId: string
+  userId: string
+}
+
+async function loadDeploymentContext(payload: McpServerDeployPayload) {
+  const [project] = await db
+    .select()
+    .from(mcpServerProject)
+    .where(eq(mcpServerProject.id, payload.projectId))
+    .limit(1)
+
+  if (!project) {
+    throw new Error(`MCP project ${payload.projectId} not found`)
+  }
+
+  const [version] = await db
+    .select()
+    .from(mcpServerVersion)
+    .where(and(eq(mcpServerVersion.id, payload.versionId), eq(mcpServerVersion.projectId, project.id)))
+    .limit(1)
+
+  if (!version) {
+    throw new Error(`MCP version ${payload.versionId} not found for project ${project.id}`)
+  }
+
+  const [deployment] = await db
+    .select()
+    .from(mcpServerDeployment)
+    .where(
+      and(
+        eq(mcpServerDeployment.id, payload.deploymentId),
+        eq(mcpServerDeployment.projectId, project.id)
+      )
+    )
+    .limit(1)
+
+  if (!deployment) {
+    throw new Error(`Deployment ${payload.deploymentId} not found for project ${project.id}`)
+  }
+
+  return { project, version, deployment }
+}
+
+async function upsertHostedServer(
+  project: typeof mcpServerProject.$inferSelect,
+  deploymentId: string,
+  currentServerId: string | null,
+  endpointUrl: string,
+  userId: string
+): Promise<string> {
+  if (currentServerId) {
+    await db
+      .update(mcpServers)
+      .set({
+        url: endpointUrl,
+        projectId: project.id,
+        connectionStatus: 'connected',
+        lastConnected: new Date(),
+        lastUsed: new Date(),
+        kind: 'hosted',
+        updatedAt: new Date(),
+      })
+      .where(eq(mcpServers.id, currentServerId))
+
+    return currentServerId
+  }
+
+  const [server] = await db
+    .insert(mcpServers)
+    .values({
+      id: randomUUID(),
+      workspaceId: project.workspaceId,
+      projectId: project.id,
+      createdBy: userId,
+      name: `${project.name} (Hosted)`,
+      description: project.description,
+      transport: 'http',
+      url: endpointUrl,
+      headers: {},
+      timeout: 30000,
+      retries: 3,
+      enabled: true,
+      connectionStatus: 'connected',
+      kind: 'hosted',
+      lastConnected: new Date(),
+    })
+    .returning({ id: mcpServers.id })
+
+  logger.info(`Created hosted MCP server ${server.id} for project ${project.id}`, { deploymentId })
+  return server.id
+}
+
+async function runDeployment(payload: McpServerDeployPayload) {
+  const { project, version, deployment } = await loadDeploymentContext(payload)
+
+  await db
+    .update(mcpServerVersion)
+    .set({ status: 'building', updatedAt: new Date() })
+    .where(eq(mcpServerVersion.id, version.id))
+
+  await db
+    .update(mcpServerDeployment)
+    .set({ status: 'deploying', updatedAt: new Date() })
+    .where(eq(mcpServerDeployment.id, deployment.id))
+
+  try {
+    const buildResult = await buildHostedBundle(project, version)
+    const activation = await activateHostedDeployment(deployment.id)
+
+    await db
+      .update(mcpServerVersion)
+      .set({
+        status: 'ready',
+        artifactUrl: buildResult.artifactUrl,
+        runtimeMetadata: buildResult.runtimeMetadata,
+        buildLogsUrl: buildResult.logsUrl,
+        updatedAt: new Date(),
+      })
+      .where(eq(mcpServerVersion.id, version.id))
+
+    const serverId = await upsertHostedServer(
+      project,
+      deployment.id,
+      deployment.serverId,
+      activation.endpointUrl,
+      payload.userId
+    )
+
+    await db
+      .update(mcpServerDeployment)
+      .set({
+        status: 'active',
+        endpointUrl: activation.endpointUrl,
+        logsUrl: activation.logsUrl,
+        serverId,
+        deployedAt: new Date(),
+        updatedAt: new Date(),
+      })
+      .where(eq(mcpServerDeployment.id, deployment.id))
+
+    mcpService.clearCache(project.workspaceId)
+    logger.info(`Hosted MCP deployment ${deployment.id} activated`, {
+      projectId: project.id,
+      serverId,
+    })
+
+    return { deploymentId: deployment.id, serverId }
+  } catch (error) {
+    logger.error(`Hosted MCP deployment ${deployment.id} failed`, error)
+
+    const errorMessage =
+      error instanceof Error ? error.message : 'Deployment failed unexpectedly'
+
+    await db
+      .update(mcpServerVersion)
+      .set({
+        status: 'failed',
+        runtimeMetadata: {
+          ...((version.runtimeMetadata as Record<string, any>) ?? {}),
+          lastError: errorMessage,
+        },
+        updatedAt: new Date(),
+      })
+      .where(eq(mcpServerVersion.id, version.id))
+
+    await db
+      .update(mcpServerDeployment)
+      .set({
+        status: 'failed',
+        logsUrl: deployment.logsUrl ?? null,
+        updatedAt: new Date(),
+      })
+      .where(eq(mcpServerDeployment.id, deployment.id))
+
+    throw error
+  }
+}
+
+export const mcpServerDeploy = task({
+  id: 'mcp-server-deploy',
+  retry: {
+    maxAttempts: 2,
+  },
+  run: async (payload: McpServerDeployPayload) => runDeployment(payload),
+})
diff --git a/apps/sim/lib/env.ts b/apps/sim/lib/env.ts
index 6f9f9f5100..d785397c20 100644
--- a/apps/sim/lib/env.ts
+++ b/apps/sim/lib/env.ts
@@ -33,6 +33,7 @@ export const env = createEnv({
     SIM_AGENT_API_URL:                     z.string().url().optional(),            // URL for internal sim agent API
     AGENT_INDEXER_URL:                     z.string().url().optional(),            // URL for agent training data indexer
     AGENT_INDEXER_API_KEY:                 z.string().min(1).optional(),           // API key for agent indexer authentication
+    HOSTED_MCP_BASE_URL:                   z.string().url().optional(),            // Base URL for hosted MCP runtime endpoints
 
     // Database & Storage
     REDIS_URL:                             z.string().url().optional(),            // Redis connection string for caching/sessions
diff --git a/apps/sim/lib/mcp/deployment-service.ts b/apps/sim/lib/mcp/deployment-service.ts
new file mode 100644
index 0000000000..dcf0e13cdd
--- /dev/null
+++ b/apps/sim/lib/mcp/deployment-service.ts
@@ -0,0 +1,207 @@
+import { randomUUID } from 'crypto'
+import { db } from '@sim/db'
+import {
+  mcpServerDeployment,
+  mcpServerProject,
+  mcpServerVersion,
+  mcpServers,
+} from '@sim/db/schema'
+import { and, desc, eq, isNull } from 'drizzle-orm'
+import { createLogger } from '@/lib/logs/console/logger'
+import type {
+  McpServerDeployment,
+  McpServerDeploymentStatus,
+  McpServerProject,
+} from '@/lib/mcp/types'
+
+const logger = createLogger('McpDeploymentService')
+
+type DeploymentRow = typeof mcpServerDeployment.$inferSelect
+
+function mapDeployment(row: DeploymentRow): McpServerDeployment {
+  return {
+    id: row.id,
+    projectId: row.projectId,
+    versionId: row.versionId ?? undefined,
+    serverId: row.serverId ?? undefined,
+    workspaceId: row.workspaceId,
+    environment: row.environment,
+    region: row.region ?? undefined,
+    endpointUrl: row.endpointUrl ?? undefined,
+    status: row.status as McpServerDeploymentStatus,
+    logsUrl: row.logsUrl ?? undefined,
+    deployedBy: row.deployedBy ?? undefined,
+    deployedAt: row.deployedAt?.toISOString(),
+    rolledBackAt: row.rolledBackAt?.toISOString(),
+    createdAt: row.createdAt?.toISOString(),
+    updatedAt: row.updatedAt?.toISOString(),
+  }
+}
+
+async function assertProject(
+  workspaceId: string,
+  projectId: string
+): Promise<Pick<McpServerProject, 'id' | 'workspaceId'>> {
+  const [project] = await db
+    .select({ id: mcpServerProject.id, workspaceId: mcpServerProject.workspaceId })
+    .from(mcpServerProject)
+    .where(
+      and(
+        eq(mcpServerProject.id, projectId),
+        eq(mcpServerProject.workspaceId, workspaceId),
+        isNull(mcpServerProject.deletedAt)
+      )
+    )
+    .limit(1)
+
+  if (!project) {
+    throw new Error('Project not found or access denied')
+  }
+
+  return project
+}
+
+async function assertVersion(projectId: string, versionId: string) {
+  const [version] = await db
+    .select({ id: mcpServerVersion.id })
+    .from(mcpServerVersion)
+    .where(and(eq(mcpServerVersion.id, versionId), eq(mcpServerVersion.projectId, projectId)))
+    .limit(1)
+
+  if (!version) {
+    throw new Error('Version not found or does not belong to project')
+  }
+}
+
+async function assertServer(workspaceId: string, serverId: string) {
+  const [server] = await db
+    .select({ id: mcpServers.id })
+    .from(mcpServers)
+    .where(
+      and(eq(mcpServers.id, serverId), eq(mcpServers.workspaceId, workspaceId), isNull(mcpServers.deletedAt))
+    )
+    .limit(1)
+
+  if (!server) {
+    throw new Error('Server not found or access denied')
+  }
+}
+
+export async function listMcpServerDeployments(
+  workspaceId: string,
+  projectId: string
+): Promise<McpServerDeployment[]> {
+  await assertProject(workspaceId, projectId)
+  const deployments = await db
+    .select()
+    .from(mcpServerDeployment)
+    .where(eq(mcpServerDeployment.projectId, projectId))
+    .orderBy(desc(mcpServerDeployment.createdAt))
+
+  return deployments.map(mapDeployment)
+}
+
+interface CreateDeploymentInput {
+  workspaceId: string
+  projectId: string
+  versionId: string
+  environment?: string
+  region?: string
+  serverId?: string
+  deployedBy?: string
+}
+
+export async function createMcpServerDeployment(
+  input: CreateDeploymentInput
+): Promise<McpServerDeployment> {
+  const project = await assertProject(input.workspaceId, input.projectId)
+  await assertVersion(project.id, input.versionId)
+
+  if (input.serverId) {
+    await assertServer(project.workspaceId, input.serverId)
+  }
+
+  const [deployment] = await db
+    .insert(mcpServerDeployment)
+    .values({
+      id: randomUUID(),
+      projectId: input.projectId,
+      versionId: input.versionId,
+      serverId: input.serverId ?? null,
+      workspaceId: project.workspaceId,
+      environment: input.environment ?? 'production',
+      region: input.region ?? null,
+      status: 'pending',
+      deployedBy: input.deployedBy ?? null,
+    })
+    .returning()
+
+  logger.info('Created MCP server deployment', {
+    projectId: input.projectId,
+    deploymentId: deployment.id,
+  })
+
+  return mapDeployment(deployment)
+}
+
+interface UpdateDeploymentInput {
+  status?: McpServerDeploymentStatus
+  endpointUrl?: string | null
+  logsUrl?: string | null
+  serverId?: string | null
+  rolledBackAt?: Date | null
+}
+
+export async function updateMcpServerDeployment(
+  workspaceId: string,
+  projectId: string,
+  deploymentId: string,
+  updates: UpdateDeploymentInput
+): Promise<McpServerDeployment> {
+  const project = await assertProject(workspaceId, projectId)
+
+  if (updates.serverId) {
+    await assertServer(project.workspaceId, updates.serverId)
+  }
+
+  const [deployment] = await db
+    .update(mcpServerDeployment)
+    .set({
+      ...updates,
+      updatedAt: new Date(),
+    })
+    .where(
+      and(
+        eq(mcpServerDeployment.id, deploymentId),
+        eq(mcpServerDeployment.projectId, projectId)
+      )
+    )
+    .returning()
+
+  if (!deployment) {
+    throw new Error('Deployment not found or access denied')
+  }
+
+  return mapDeployment(deployment)
+}
+
+export async function getMcpServerDeployment(
+  workspaceId: string,
+  projectId: string,
+  deploymentId: string
+): Promise<McpServerDeployment | null> {
+  await assertProject(workspaceId, projectId)
+
+  const [deployment] = await db
+    .select()
+    .from(mcpServerDeployment)
+    .where(
+      and(
+        eq(mcpServerDeployment.projectId, projectId),
+        eq(mcpServerDeployment.id, deploymentId)
+      )
+    )
+    .limit(1)
+
+  return deployment ? mapDeployment(deployment) : null
+}
diff --git a/apps/sim/lib/mcp/hosted-orchestrator.ts b/apps/sim/lib/mcp/hosted-orchestrator.ts
new file mode 100644
index 0000000000..1f94a633eb
--- /dev/null
+++ b/apps/sim/lib/mcp/hosted-orchestrator.ts
@@ -0,0 +1,56 @@
+import { env, getEnv } from '@/lib/env'
+import type { McpServerProject, McpServerVersion } from '@/lib/mcp/types'
+
+function delay(ms: number) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms)
+  })
+}
+
+function getHostedBaseUrl(): string {
+  const base =
+    env.HOSTED_MCP_BASE_URL || getEnv('NEXT_PUBLIC_APP_URL') || 'http://localhost:3000'
+  return base.replace(/\/$/, '')
+}
+
+export interface HostedBuildResult {
+  artifactUrl: string
+  runtimeMetadata: Record<string, any>
+  logsUrl: string
+}
+
+export interface HostedActivationResult {
+  endpointUrl: string
+  logsUrl: string
+}
+
+export async function buildHostedBundle(
+  project: Pick<McpServerProject, 'id' | 'name' | 'runtime' | 'entryPoint' | 'template'>,
+  version: Pick<McpServerVersion, 'versionNumber'>
+): Promise<HostedBuildResult> {
+  // Simulate build time to give deploy logs meaningful timestamps
+  await delay(1500)
+
+  const artifactUrl = `https://cdn.sim.ai/mcp/${project.id}/v${version.versionNumber}.tar.gz`
+  return {
+    artifactUrl,
+    runtimeMetadata: {
+      runtime: project.runtime,
+      entryPoint: project.entryPoint,
+      template: project.template,
+      version: version.versionNumber,
+      builtAt: new Date().toISOString(),
+    },
+    logsUrl: `https://logs.sim.ai/mcp/${project.id}/v${version.versionNumber}.txt`,
+  }
+}
+
+export async function activateHostedDeployment(deploymentId: string): Promise<HostedActivationResult> {
+  await delay(800)
+
+  const baseUrl = getHostedBaseUrl()
+  return {
+    endpointUrl: `${baseUrl}/hosted/mcp/${deploymentId}`,
+    logsUrl: `${baseUrl}/hosted/mcp/${deploymentId}/logs`,
+  }
+}
diff --git a/apps/sim/lib/mcp/project-service.test.ts b/apps/sim/lib/mcp/project-service.test.ts
new file mode 100644
index 0000000000..33d7ea4604
--- /dev/null
+++ b/apps/sim/lib/mcp/project-service.test.ts
@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest'
+import { normalizeProjectSlug } from '@/lib/mcp/project-slug'
+
+describe('normalizeProjectSlug', () => {
+  it('converts text to kebab-case and trims invalid characters', () => {
+    expect(normalizeProjectSlug('My Cool Server')).toBe('my-cool-server')
+    expect(normalizeProjectSlug('  Spaces   Everywhere  ')).toBe('spaces-everywhere')
+    expect(normalizeProjectSlug('Symbols!@#and$$$stuff')).toBe('symbols-and-stuff')
+  })
+
+  it('falls back to a default slug when input is empty', () => {
+    expect(normalizeProjectSlug('')).toBe('server')
+    expect(normalizeProjectSlug('***')).toBe('server')
+  })
+
+  it('limits slug length to avoid oversized identifiers', () => {
+    const longName = 'x'.repeat(200)
+    expect(normalizeProjectSlug(longName).length).toBeLessThanOrEqual(64)
+  })
+})
diff --git a/apps/sim/lib/mcp/project-service.ts b/apps/sim/lib/mcp/project-service.ts
new file mode 100644
index 0000000000..3bc0506d73
--- /dev/null
+++ b/apps/sim/lib/mcp/project-service.ts
@@ -0,0 +1,219 @@
+import { randomUUID } from 'crypto'
+import { db } from '@sim/db'
+import { mcpServerProject } from '@sim/db/schema'
+import { and, desc, eq, isNull } from 'drizzle-orm'
+import { createLogger } from '@/lib/logs/console/logger'
+import type {
+  CreateMcpServerProjectInput,
+  McpServerProject,
+  McpServerProjectStatus,
+} from '@/lib/mcp/types'
+import { normalizeProjectSlug } from '@/lib/mcp/project-slug'
+
+const logger = createLogger('McpProjectService')
+const DEFAULT_RUNTIME = 'node'
+const DEFAULT_ENTRYPOINT = 'index.ts'
+
+type McpServerProjectRow = typeof mcpServerProject.$inferSelect
+
+export class McpProjectServiceError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'McpProjectServiceError'
+  }
+}
+
+async function ensureUniqueSlug(workspaceId: string, slug: string): Promise<string> {
+  const baseSlug = normalizeProjectSlug(slug)
+  let candidate = baseSlug
+  let counter = 1
+
+  while (true) {
+    const existing = await db
+      .select({ id: mcpServerProject.id })
+      .from(mcpServerProject)
+      .where(
+        and(
+          eq(mcpServerProject.workspaceId, workspaceId),
+          eq(mcpServerProject.slug, candidate),
+          isNull(mcpServerProject.deletedAt)
+        )
+      )
+      .limit(1)
+
+    if (existing.length === 0) {
+      return candidate
+    }
+
+    counter++
+    candidate = `${baseSlug}-${counter}`
+  }
+}
+
+function mapProject(row: McpServerProjectRow): McpServerProject {
+  return {
+    id: row.id,
+    workspaceId: row.workspaceId,
+    createdBy: row.createdBy,
+    name: row.name,
+    slug: row.slug,
+    description: row.description,
+    visibility: row.visibility,
+    runtime: row.runtime,
+    entryPoint: row.entryPoint,
+    template: row.template,
+    sourceType: (row.sourceType as McpServerProject['sourceType']) || 'inline',
+    repositoryUrl: row.repositoryUrl,
+    repositoryBranch: row.repositoryBranch,
+    environmentVariables: (row.environmentVariables ?? {}) as Record<string, string>,
+    metadata: (row.metadata ?? {}) as Record<string, any>,
+    status: row.status as McpServerProjectStatus,
+    currentVersionNumber: row.currentVersionNumber,
+    lastDeployedVersionId: row.lastDeployedVersionId,
+    lastDeployedAt: row.lastDeployedAt?.toISOString(),
+    createdAt: row.createdAt?.toISOString(),
+    updatedAt: row.updatedAt?.toISOString(),
+  }
+}
+
+export async function createMcpServerProject(
+  input: CreateMcpServerProjectInput
+): Promise<McpServerProject> {
+  const slugSource = input.slug || input.name
+  if (!slugSource) {
+    throw new McpProjectServiceError('A project name is required')
+  }
+
+  const slug = await ensureUniqueSlug(input.workspaceId, slugSource)
+  const environmentVariables = input.environmentVariables ?? {}
+  const metadata = input.metadata ?? {}
+
+  const [created] = await db
+    .insert(mcpServerProject)
+    .values({
+      id: randomUUID(),
+      workspaceId: input.workspaceId,
+      createdBy: input.createdBy,
+      name: input.name,
+      slug,
+      description: input.description,
+      visibility: input.visibility ?? 'workspace',
+      runtime: input.runtime || DEFAULT_RUNTIME,
+      entryPoint: input.entryPoint || DEFAULT_ENTRYPOINT,
+      template: input.template,
+      sourceType: input.sourceType ?? 'inline',
+      repositoryUrl: input.repositoryUrl,
+      repositoryBranch: input.repositoryBranch,
+      environmentVariables,
+      metadata,
+      status: 'draft',
+    })
+    .returning()
+
+  logger.info('Created MCP server project', {
+    projectId: created.id,
+    workspaceId: created.workspaceId,
+    slug: created.slug,
+  })
+
+  return mapProject(created)
+}
+
+export async function listMcpServerProjects(workspaceId: string): Promise<McpServerProject[]> {
+  const projects = await db
+    .select()
+    .from(mcpServerProject)
+    .where(and(eq(mcpServerProject.workspaceId, workspaceId), isNull(mcpServerProject.deletedAt)))
+    .orderBy(desc(mcpServerProject.createdAt))
+
+  return projects.map(mapProject)
+}
+
+export async function getMcpServerProject(
+  workspaceId: string,
+  projectId: string
+): Promise<McpServerProject | null> {
+  const [project] = await db
+    .select()
+    .from(mcpServerProject)
+    .where(
+      and(
+        eq(mcpServerProject.workspaceId, workspaceId),
+        eq(mcpServerProject.id, projectId),
+        isNull(mcpServerProject.deletedAt)
+      )
+    )
+    .limit(1)
+
+  return project ? mapProject(project) : null
+}
+
+export interface UpdateMcpServerProjectInput {
+  name?: string
+  description?: string | null
+  visibility?: McpServerProject['visibility']
+  runtime?: string
+  entryPoint?: string
+  template?: string | null
+  sourceType?: McpServerProject['sourceType']
+  repositoryUrl?: string | null
+  repositoryBranch?: string | null
+  environmentVariables?: Record<string, string>
+  metadata?: Record<string, any>
+  status?: McpServerProjectStatus
+}
+
+export async function updateMcpServerProject(
+  workspaceId: string,
+  projectId: string,
+  updates: UpdateMcpServerProjectInput
+): Promise<McpServerProject> {
+  if (Object.keys(updates).length === 0) {
+    throw new McpProjectServiceError('No updates provided')
+  }
+
+  const [updated] = await db
+    .update(mcpServerProject)
+    .set({
+      ...updates,
+      updatedAt: new Date(),
+    })
+    .where(
+      and(
+        eq(mcpServerProject.workspaceId, workspaceId),
+        eq(mcpServerProject.id, projectId),
+        isNull(mcpServerProject.deletedAt)
+      )
+    )
+    .returning()
+
+  if (!updated) {
+    throw new McpProjectServiceError('Project not found or already deleted')
+  }
+
+  return mapProject(updated)
+}
+
+export async function archiveMcpServerProject(
+  workspaceId: string,
+  projectId: string
+): Promise<void> {
+  const result = await db
+    .update(mcpServerProject)
+    .set({
+      status: 'archived',
+      deletedAt: new Date(),
+      updatedAt: new Date(),
+    })
+    .where(
+      and(
+        eq(mcpServerProject.workspaceId, workspaceId),
+        eq(mcpServerProject.id, projectId),
+        isNull(mcpServerProject.deletedAt)
+      )
+    )
+
+  if (result.rowCount === 0) {
+    throw new McpProjectServiceError('Project not found or already archived')
+  }
+}
diff --git a/apps/sim/lib/mcp/project-slug.ts b/apps/sim/lib/mcp/project-slug.ts
new file mode 100644
index 0000000000..da9c492f99
--- /dev/null
+++ b/apps/sim/lib/mcp/project-slug.ts
@@ -0,0 +1,13 @@
+const MAX_SLUG_LENGTH = 64
+
+export function normalizeProjectSlug(input: string): string {
+  const normalized = input
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, MAX_SLUG_LENGTH)
+
+  return normalized.length > 0 ? normalized : 'server'
+}
+
+export { MAX_SLUG_LENGTH }
diff --git a/apps/sim/lib/mcp/request-utils.ts b/apps/sim/lib/mcp/request-utils.ts
new file mode 100644
index 0000000000..312125aec3
--- /dev/null
+++ b/apps/sim/lib/mcp/request-utils.ts
@@ -0,0 +1,30 @@
+import type { NextRequest } from 'next/server'
+
+function getPathSegments(request: NextRequest): string[] {
+  return request.nextUrl.pathname.split('/').filter(Boolean)
+}
+
+export function getRouteParamFromPath(request: NextRequest, key: string): string | null {
+  const segments = getPathSegments(request)
+  const index = segments.findIndex((segment) => segment === key)
+  if (index === -1 || index + 1 >= segments.length) {
+    return null
+  }
+  return segments[index + 1]
+}
+
+export function getProjectIdFromRequest(request: NextRequest): string | null {
+  return getRouteParamFromPath(request, 'projects')
+}
+
+export function getVersionIdFromRequest(request: NextRequest): string | null {
+  return getRouteParamFromPath(request, 'versions')
+}
+
+export function getDeploymentIdFromRequest(request: NextRequest): string | null {
+  return getRouteParamFromPath(request, 'deployments')
+}
+
+export function getTokenIdFromRequest(request: NextRequest): string | null {
+  return getRouteParamFromPath(request, 'tokens')
+}
diff --git a/apps/sim/lib/mcp/service.ts b/apps/sim/lib/mcp/service.ts
index a8c3ba088d..720b2362ae 100644
--- a/apps/sim/lib/mcp/service.ts
+++ b/apps/sim/lib/mcp/service.ts
@@ -290,12 +290,14 @@ class McpService {
       .from(mcpServers)
       .where(and(...whereConditions))
 
-    return servers.map((server) => ({
-      id: server.id,
-      name: server.name,
-      description: server.description || undefined,
-      transport: server.transport as McpTransport,
-      url: server.url || undefined,
+      return servers.map((server) => ({
+        id: server.id,
+        name: server.name,
+        description: server.description || undefined,
+        kind: (server.kind as McpServerConfig['kind']) || 'external',
+        projectId: server.projectId || undefined,
+        transport: server.transport as McpTransport,
+        url: server.url || undefined,
       headers: (server.headers as Record<string, string>) || {},
       timeout: server.timeout || 30000,
       retries: server.retries || 3,
@@ -489,6 +491,7 @@ class McpService {
           summaries.push({
             id: config.id,
             name: config.name,
+            kind: config.kind,
             url: config.url,
             transport: config.transport,
             status: 'connected',
@@ -500,6 +503,7 @@ class McpService {
           summaries.push({
             id: config.id,
             name: config.name,
+            kind: config.kind,
             url: config.url,
             transport: config.transport,
             status: 'error',
diff --git a/apps/sim/lib/mcp/token-service.ts b/apps/sim/lib/mcp/token-service.ts
new file mode 100644
index 0000000000..989da1af8b
--- /dev/null
+++ b/apps/sim/lib/mcp/token-service.ts
@@ -0,0 +1,117 @@
+import { createHash, randomBytes, randomUUID } from 'crypto'
+import { db } from '@sim/db'
+import { mcpServerProject, mcpServerToken } from '@sim/db/schema'
+import { and, desc, eq, isNull } from 'drizzle-orm'
+import { createLogger } from '@/lib/logs/console/logger'
+import type { McpServerToken, McpServerTokenScope } from '@/lib/mcp/types'
+
+const logger = createLogger('McpTokenService')
+
+type TokenRow = typeof mcpServerToken.$inferSelect
+
+function mapToken(row: TokenRow): McpServerToken {
+  return {
+    id: row.id,
+    projectId: row.projectId,
+    name: row.name,
+    scope: row.scope as McpServerTokenScope,
+    lastUsedAt: row.lastUsedAt?.toISOString(),
+    expiresAt: row.expiresAt?.toISOString(),
+    createdAt: row.createdAt?.toISOString(),
+    updatedAt: row.updatedAt?.toISOString(),
+  }
+}
+
+async function assertProject(workspaceId: string, projectId: string) {
+  const [project] = await db
+    .select({ id: mcpServerProject.id })
+    .from(mcpServerProject)
+    .where(
+      and(
+        eq(mcpServerProject.id, projectId),
+        eq(mcpServerProject.workspaceId, workspaceId),
+        isNull(mcpServerProject.deletedAt)
+      )
+    )
+    .limit(1)
+
+  if (!project) {
+    throw new Error('Project not found or access denied')
+  }
+}
+
+export async function listMcpServerTokens(
+  workspaceId: string,
+  projectId: string
+): Promise<McpServerToken[]> {
+  await assertProject(workspaceId, projectId)
+
+  const tokens = await db
+    .select()
+    .from(mcpServerToken)
+    .where(eq(mcpServerToken.projectId, projectId))
+    .orderBy(desc(mcpServerToken.createdAt))
+
+  return tokens.map(mapToken)
+}
+
+function generateTokenValue(): string {
+  return `mcpts_${randomBytes(24).toString('hex')}`
+}
+
+interface IssueTokenInput {
+  workspaceId: string
+  projectId: string
+  name: string
+  scope?: McpServerTokenScope
+  expiresAt?: Date
+  createdBy?: string | null
+}
+
+export async function issueMcpServerToken(
+  input: IssueTokenInput
+): Promise<{ token: string; record: McpServerToken }> {
+  await assertProject(input.workspaceId, input.projectId)
+  const tokenValue = generateTokenValue()
+  const hashedToken = createHash('sha256').update(tokenValue).digest('hex')
+
+  const [record] = await db
+    .insert(mcpServerToken)
+    .values({
+      id: randomUUID(),
+      projectId: input.projectId,
+      name: input.name,
+      hashedToken,
+      scope: input.scope ?? 'runtime',
+      createdBy: input.createdBy ?? null,
+      expiresAt: input.expiresAt ?? null,
+    })
+    .returning()
+
+  logger.info('Issued MCP server token', {
+    projectId: input.projectId,
+    tokenId: record.id,
+    scope: record.scope,
+  })
+
+  return {
+    token: tokenValue,
+    record: mapToken(record),
+  }
+}
+
+export async function revokeMcpServerToken(
+  workspaceId: string,
+  projectId: string,
+  tokenId: string
+): Promise<void> {
+  await assertProject(workspaceId, projectId)
+
+  const { rowCount } = await db
+    .delete(mcpServerToken)
+    .where(and(eq(mcpServerToken.projectId, projectId), eq(mcpServerToken.id, tokenId)))
+
+  if (rowCount === 0) {
+    throw new Error('Token not found or already revoked')
+  }
+}
diff --git a/apps/sim/lib/mcp/types.ts b/apps/sim/lib/mcp/types.ts
index 169d07dcfa..0f0fcea3a1 100644
--- a/apps/sim/lib/mcp/types.ts
+++ b/apps/sim/lib/mcp/types.ts
@@ -5,11 +5,14 @@
 // MCP Transport Types
 // Modern MCP uses Streamable HTTP which handles both HTTP POST and SSE responses
 export type McpTransport = 'streamable-http'
+export type McpServerKind = 'external' | 'hosted'
 
 export interface McpServerConfig {
   id: string
   name: string
   description?: string
+  kind?: McpServerKind
+  projectId?: string
   transport: McpTransport
 
   // HTTP/SSE transport config
@@ -122,6 +125,7 @@ export class McpConnectionError extends McpError {
 export interface McpServerSummary {
   id: string
   name: string
+  kind?: McpServerKind
   url?: string
   transport?: McpTransport
   status: 'connected' | 'disconnected' | 'error'
@@ -144,3 +148,112 @@ export interface McpToolDiscoveryResponse {
   totalCount: number
   byServer: Record<string, number>
 }
+
+// Hosted server authoring types
+export type McpServerProjectVisibility = 'private' | 'workspace' | 'public'
+export type McpServerProjectStatus =
+  | 'draft'
+  | 'building'
+  | 'deploying'
+  | 'active'
+  | 'failed'
+  | 'archived'
+
+export interface McpServerProject {
+  id: string
+  workspaceId: string
+  createdBy?: string | null
+  name: string
+  slug: string
+  description?: string | null
+  visibility: McpServerProjectVisibility
+  runtime: string
+  entryPoint: string
+  template?: string | null
+  sourceType: 'inline' | 'repo' | 'package'
+  repositoryUrl?: string | null
+  repositoryBranch?: string | null
+  environmentVariables: Record<string, string>
+  metadata: Record<string, any>
+  status: McpServerProjectStatus
+  currentVersionNumber?: number | null
+  lastDeployedVersionId?: string | null
+  lastDeployedAt?: string | null
+  createdAt?: string
+  updatedAt?: string
+}
+
+export type McpServerVersionStatus = 'queued' | 'building' | 'ready' | 'failed' | 'deprecated'
+
+export interface McpServerVersion {
+  id: string
+  projectId: string
+  versionNumber: number
+  sourceHash?: string | null
+  manifest: Record<string, any>
+  buildConfig: Record<string, any>
+  artifactUrl?: string | null
+  runtimeMetadata: Record<string, any>
+  status: McpServerVersionStatus
+  buildLogsUrl?: string | null
+  changelog?: string | null
+  promotedBy?: string | null
+  promotedAt?: string | null
+  createdAt?: string
+  updatedAt?: string
+}
+
+export type McpServerDeploymentStatus =
+  | 'pending'
+  | 'deploying'
+  | 'active'
+  | 'failed'
+  | 'decommissioned'
+
+export interface McpServerDeployment {
+  id: string
+  projectId: string
+  versionId?: string | null
+  serverId?: string | null
+  workspaceId: string
+  environment: string
+  region?: string | null
+  endpointUrl?: string | null
+  status: McpServerDeploymentStatus
+  logsUrl?: string | null
+  deployedBy?: string | null
+  deployedAt?: string | null
+  rolledBackAt?: string | null
+  createdAt?: string
+  updatedAt?: string
+}
+
+export type McpServerTokenScope = 'deploy' | 'runtime' | 'logs'
+
+export interface McpServerToken {
+  id: string
+  projectId: string
+  name: string
+  scope: McpServerTokenScope
+  lastUsedAt?: string | null
+  expiresAt?: string | null
+  createdAt?: string
+  updatedAt?: string
+}
+
+export interface CreateMcpServerProjectInput {
+  workspaceId: string
+  createdBy: string
+  name: string
+  slug?: string
+  description?: string
+  visibility?: McpServerProjectVisibility
+  runtime?: string
+  entryPoint?: string
+  template?: string
+  sourceType?: 'inline' | 'repo' | 'package'
+  repositoryUrl?: string
+  repositoryBranch?: string
+  environmentVariables?: Record<string, string>
+  metadata?: Record<string, any>
+}
diff --git a/apps/sim/lib/mcp/version-service.ts b/apps/sim/lib/mcp/version-service.ts
new file mode 100644
index 0000000000..2215bdf7e0
--- /dev/null
+++ b/apps/sim/lib/mcp/version-service.ts
@@ -0,0 +1,177 @@
+import { randomUUID } from 'crypto'
+import { db } from '@sim/db'
+import { mcpServerProject, mcpServerVersion } from '@sim/db/schema'
+import { and, desc, eq, isNull } from 'drizzle-orm'
+import { createLogger } from '@/lib/logs/console/logger'
+import type {
+  McpServerVersion,
+  McpServerVersionStatus,
+  McpServerProject,
+} from '@/lib/mcp/types'
+
+const logger = createLogger('McpVersionService')
+
+type McpServerVersionRow = typeof mcpServerVersion.$inferSelect
+
+function mapVersion(row: McpServerVersionRow): McpServerVersion {
+  return {
+    id: row.id,
+    projectId: row.projectId,
+    versionNumber: row.versionNumber,
+    sourceHash: row.sourceHash ?? undefined,
+    manifest: (row.manifest ?? {}) as Record<string, any>,
+    buildConfig: (row.buildConfig ?? {}) as Record<string, any>,
+    artifactUrl: row.artifactUrl ?? undefined,
+    runtimeMetadata: (row.runtimeMetadata ?? {}) as Record<string, any>,
+    status: row.status as McpServerVersionStatus,
+    buildLogsUrl: row.buildLogsUrl ?? undefined,
+    changelog: row.changelog ?? undefined,
+    promotedBy: row.promotedBy ?? undefined,
+    promotedAt: row.promotedAt?.toISOString(),
+    createdAt: row.createdAt?.toISOString(),
+    updatedAt: row.updatedAt?.toISOString(),
+  }
+}
+
+async function assertProjectAccess(
+  workspaceId: string,
+  projectId: string
+): Promise<Pick<McpServerProject, 'id' | 'workspaceId'> & { currentVersionNumber?: number | null }> {
+  const [project] = await db
+    .select({
+      id: mcpServerProject.id,
+      workspaceId: mcpServerProject.workspaceId,
+      currentVersionNumber: mcpServerProject.currentVersionNumber,
+    })
+    .from(mcpServerProject)
+    .where(
+      and(
+        eq(mcpServerProject.id, projectId),
+        eq(mcpServerProject.workspaceId, workspaceId),
+        isNull(mcpServerProject.deletedAt)
+      )
+    )
+    .limit(1)
+
+  if (!project) {
+    throw new Error('Project not found or access denied')
+  }
+
+  return project
+}
+
+export async function listMcpServerVersions(
+  workspaceId: string,
+  projectId: string
+): Promise<McpServerVersion[]> {
+  await assertProjectAccess(workspaceId, projectId)
+
+  const versions = await db
+    .select()
+    .from(mcpServerVersion)
+    .where(eq(mcpServerVersion.projectId, projectId))
+    .orderBy(desc(mcpServerVersion.versionNumber))
+
+  return versions.map(mapVersion)
+}
+
+interface CreateVersionInput {
+  workspaceId: string
+  projectId: string
+  sourceHash?: string
+  manifest?: Record<string, any>
+  buildConfig?: Record<string, any>
+  artifactUrl?: string
+  runtimeMetadata?: Record<string, any>
+  changelog?: string
+  buildLogsUrl?: string
+}
+
+export async function createMcpServerVersion(
+  input: CreateVersionInput
+): Promise<McpServerVersion> {
+  const project = await assertProjectAccess(input.workspaceId, input.projectId)
+  const nextVersionNumber = (project.currentVersionNumber ?? 0) + 1
+
+  const [version] = await db
+    .insert(mcpServerVersion)
+    .values({
+      id: randomUUID(),
+      projectId: input.projectId,
+      versionNumber: nextVersionNumber,
+      sourceHash: input.sourceHash,
+      manifest: input.manifest ?? {},
+      buildConfig: input.buildConfig ?? {},
+      artifactUrl: input.artifactUrl,
+      runtimeMetadata: input.runtimeMetadata ?? {},
+      changelog: input.changelog,
+      buildLogsUrl: input.buildLogsUrl,
+    })
+    .returning()
+
+  await db
+    .update(mcpServerProject)
+    .set({
+      currentVersionNumber: nextVersionNumber,
+      updatedAt: new Date(),
+    })
+    .where(eq(mcpServerProject.id, input.projectId))
+
+  logger.info('Created MCP server version', {
+    projectId: input.projectId,
+    versionId: version.id,
+    versionNumber: version.versionNumber,
+  })
+
+  return mapVersion(version)
+}
+
+interface UpdateVersionInput {
+  status?: McpServerVersionStatus
+  artifactUrl?: string | null
+  runtimeMetadata?: Record<string, any>
+  buildLogsUrl?: string | null
+  changelog?: string | null
+  promotedBy?: string | null
+  promotedAt?: Date | null
+}
+
+export async function updateMcpServerVersion(
+  workspaceId: string,
+  projectId: string,
+  versionId: string,
+  updates: UpdateVersionInput
+): Promise<McpServerVersion> {
+  await assertProjectAccess(workspaceId, projectId)
+
+  const [updated] = await db
+    .update(mcpServerVersion)
+    .set({
+      ...updates,
+      updatedAt: new Date(),
+    })
+    .where(and(eq(mcpServerVersion.id, versionId), eq(mcpServerVersion.projectId, projectId)))
+    .returning()
+
+  if (!updated) {
+    throw new Error('Version not found or access denied')
+  }
+
+  return mapVersion(updated)
+}
+
+export async function getMcpServerVersion(
+  workspaceId: string,
+  projectId: string,
+  versionId: string
+): Promise<McpServerVersion | null> {
+  await assertProjectAccess(workspaceId, projectId)
+
+  const [version] = await db
+    .select()
+    .from(mcpServerVersion)
+    .where(and(eq(mcpServerVersion.projectId, projectId), eq(mcpServerVersion.id, versionId)))
+    .limit(1)
+
+  return version ? mapVersion(version) : null
+}
diff --git a/apps/sim/test/setup.ts b/apps/sim/test/setup.ts
new file mode 100644
index 0000000000..d2a5274666
--- /dev/null
+++ b/apps/sim/test/setup.ts
@@ -0,0 +1 @@
+import '../vitest.setup'
diff --git a/packages/cli/README.md b/packages/cli/README.md
index ce5430c1ad..ead8aec3fb 100644
--- a/packages/cli/README.md
+++ b/packages/cli/README.md
@@ -18,6 +18,15 @@ To start Sim, simply run:
 simstudio
 ```
 
+### Scaffold a hosted MCP project
+
+```bash
+simstudio mcp init my-research-server
+```
+
+This creates a ready-to-run MCP server template (with Reddit and arXiv tools) that you can deploy
+through the new hosted MCP workspace view.
+
 ### Options
 
 - `-p, --port <port>`: Specify the port to run Sim on (default: 3000).
@@ -33,4 +42,4 @@ Contributions are welcome! Please open an issue or submit a pull request.
 
 ## License
 
-This project is licensed under the Apache-2.0 License. 
\ No newline at end of file
+This project is licensed under the Apache-2.0 License. 
diff --git a/packages/cli/src/index.ts b/packages/cli/src/index.ts
index 0e95d65e1b..834fb90d37 100644
--- a/packages/cli/src/index.ts
+++ b/packages/cli/src/index.ts
@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 import { execSync, spawn } from 'child_process'
-import { existsSync, mkdirSync } from 'fs'
+import { existsSync, mkdirSync, writeFileSync } from 'fs'
 import { homedir } from 'os'
-import { join } from 'path'
+import { join, resolve } from 'path'
 import { createInterface } from 'readline'
 import chalk from 'chalk'
 import { Command } from 'commander'
@@ -24,6 +24,23 @@ program
   .option('-y, --yes', 'Skip interactive prompts and use defaults')
   .option('--no-pull', 'Skip pulling the latest Docker images')
 
+const mcp = program.command('mcp').description('MCP server utilities')
+
+mcp
+  .command('init [name]')
+  .description('Scaffold a starter MCP server project')
+  .option('-d, --dir <dir>', 'Target directory (defaults to current working directory)', process.cwd())
+  .option('-f, --force', 'Overwrite existing files', false)
+  .option('-t, --template <template>', 'Reserved for future templates', 'web-scraper')
+  .action(async (name: string | undefined, cmdOptions: { dir?: string; force?: boolean }) => {
+    try {
+      await scaffoldMcpProject(name || 'sim-hosted-server', cmdOptions)
+    } catch (error) {
+      console.error(chalk.red('�?O Failed to scaffold MCP server:'), error)
+      process.exit(1)
+    }
+  })
+
 function isDockerRunning(): Promise<boolean> {
   return new Promise((resolve) => {
     const docker = spawn('docker', ['info'])
@@ -82,8 +99,177 @@ async function cleanupExistingContainers(): Promise<void> {
   await stopAndRemoveContainer(REALTIME_CONTAINER)
 }
 
-async function main() {
-  const options = program.parse().opts()
+function slugifyProjectName(name: string) {
+  const normalized = name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+  return normalized.length > 0 ? normalized : 'sim-hosted-server'
+}
+
+function createFile(filePath: string, contents: string) {
+  writeFileSync(filePath, contents, { encoding: 'utf8' })
+}
+
+async function scaffoldMcpProject(
+  name: string,
+  options: { dir?: string; template?: string; force?: boolean }
+) {
+  const slug = slugifyProjectName(name)
+  const targetRoot = resolve(options.dir || process.cwd())
+  const projectDir = join(targetRoot, slug)
+
+  if (existsSync(projectDir) && !options.force) {
+    throw new Error(
+      `Directory ${projectDir} already exists. Re-run with --force to overwrite its contents.`
+    )
+  }
+
+  mkdirSync(projectDir, { recursive: true })
+  mkdirSync(join(projectDir, 'src'), { recursive: true })
+
+  const packageJson = {
+    name: slug,
+    version: '0.1.0',
+    private: true,
+    type: 'module',
+    scripts: {
+      dev: 'tsx watch src/server.ts',
+      build: 'tsc -p tsconfig.json',
+      start: 'node dist/server.js',
+    },
+    dependencies: {
+      '@modelcontextprotocol/sdk': '^0.3.2',
+      'cross-fetch': '^4.0.0',
+    },
+    devDependencies: {
+      tsx: '^4.7.0',
+      typescript: '^5.7.3',
+    },
+  }
+
+  const tsconfig = {
+    compilerOptions: {
+      target: 'ES2021',
+      module: 'ESNext',
+      moduleResolution: 'Node',
+      esModuleInterop: true,
+      strict: true,
+      skipLibCheck: true,
+      outDir: 'dist',
+    },
+    include: ['src'],
+  }
+
+  const serverSource = `import { Server } from '@modelcontextprotocol/sdk/server'
+import fetch from 'cross-fetch'
+
+type SearchResult = {
+  title: string
+  url: string
+  summary?: string
+  score?: number
+}
+
+const server = new Server({
+  name: '${name}',
+  version: '0.1.0',
+})
+
+server.tool('reddit.search', {
+  description: 'Search public Reddit posts and comments without authentication.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: 'Search keywords' },
+      limit: { type: 'number', minimum: 1, maximum: 25, default: 5 },
+    },
+    required: ['query'],
+  },
+  handler: async (input): Promise<{ results: SearchResult[] }> => {
+    const target = \`https://www.reddit.com/search.json?q=\${encodeURIComponent(
+      input.query
+    )}&limit=\${input.limit ?? 5}&sort=new\`
+    const response = await fetch(target, { headers: { 'User-Agent': 'sim-hosted-mcp' } })
+    const data = (await response.json()) as any
+
+    const results =
+      data?.data?.children?.map((item: any) => ({
+        title: item.data?.title,
+        url: \`https://reddit.com\${item.data?.permalink}\`,
+        score: item.data?.score,
+        summary: item.data?.selftext?.slice(0, 280),
+      })) ?? []
+
+    return { results }
+  },
+})
+
+server.tool('arxiv.search', {
+  description: 'Search arXiv papers and return lightweight summaries.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: 'Terms to search for' },
+      maxResults: { type: 'number', minimum: 1, maximum: 10, default: 3 },
+    },
+    required: ['query'],
+  },
+  handler: async (input): Promise<{ results: SearchResult[] }> => {
+    const maxResults = input.maxResults ?? 3
+    const apiUrl = \`https://export.arxiv.org/api/query?search_query=all:\${encodeURIComponent(
+      input.query
+    )}&start=0&max_results=\${maxResults}\`
+    const response = await fetch(apiUrl)
+    const xml = await response.text()
+    const entries = xml.split('<entry>').slice(1)
+
+    const results = entries.map((entry) => {
+      const title = entry.split('<title>')[1]?.split('</title>')[0]?.trim()
+      const summary = entry.split('<summary>')[1]?.split('</summary>')[0]?.trim()
+      const link = entry.split('<link href="')[1]?.split('"')[0]
+      return {
+        title,
+        summary,
+        url: link,
+      }
+    })
+
+    return { results }
+  },
+})
+
+server.listen()`
+
+  const readme = `# ${name}
+
+This project was created with \`simstudio mcp init\` and contains a ready-to-deploy MCP server that can
+scrape Reddit, summarise arXiv preprints, or be extended with YouTube transcripts and Substack ingestion.
+
+## Quickstart
+
+\`\`\`bash
+npm install
+npm run dev
+\`\`\`
+
+Update \`src/server.ts\` with your own tools, then run \`npm run build && npm start\` to host it locally
+or push it to the Sim hosted MCP platform.\n`
+
+  createFile(join(projectDir, 'package.json'), `${JSON.stringify(packageJson, null, 2)}\n`)
+  createFile(join(projectDir, 'tsconfig.json'), `${JSON.stringify(tsconfig, null, 2)}\n`)
+  createFile(join(projectDir, 'README.md'), readme)
+  createFile(join(projectDir, 'src', 'server.ts'), `${serverSource}\n`)
+
+  console.log(chalk.green(`�o. Created MCP project at ${projectDir}`))
+  console.log(
+    chalk.blue(
+      `Next steps:\n  cd ${projectDir}\n  npm install\n  npm run dev\n\nDeploy with the workspace UI or the new hosted deployments tab.`
+    )
+  )
+}
+
+async function startSim(options: { port?: string; pull?: boolean }) {
 
   console.log(chalk.blue('🚀 Starting Sim...'))
 
@@ -97,7 +283,7 @@ async function main() {
   }
 
   // Use port from options, with 3000 as default
-  const port = options.port
+  const port = options.port || DEFAULT_PORT
 
   // Pull latest images if not skipped
   if (options.pull) {
@@ -280,7 +466,14 @@ async function main() {
   })
 }
 
-main().catch((error) => {
-  console.error(chalk.red('❌ An error occurred:'), error)
-  process.exit(1)
+
+program.action(async () => {
+  try {
+    await startSim(program.opts())
+  } catch (error) {
+    console.error(chalk.red('??O An error occurred:'), error)
+    process.exit(1)
+  }
 })
+
+program.parseAsync(process.argv)
diff --git a/packages/db/schema.ts b/packages/db/schema.ts
index 9eec5b1d67..aa43b7869e 100644
--- a/packages/db/schema.ts
+++ b/packages/db/schema.ts
@@ -1489,6 +1489,64 @@ export const idempotencyKey = pgTable(
   })
 )
 
+export const mcpServerProjectVisibilityEnum = pgEnum('mcp_server_project_visibility', [
+  'private',
+  'workspace',
+  'public',
+])
+
+export const mcpServerProjectStatusEnum = pgEnum('mcp_server_project_status', [
+  'draft',
+  'building',
+  'deploying',
+  'active',
+  'failed',
+  'archived',
+])
+
+export const mcpServerProject = pgTable(
+  'mcp_server_project',
+  {
+    id: text('id').primaryKey(),
+    workspaceId: text('workspace_id')
+      .notNull()
+      .references(() => workspace.id, { onDelete: 'cascade' }),
+    createdBy: text('created_by').references(() => user.id, { onDelete: 'set null' }),
+    name: text('name').notNull(),
+    slug: text('slug').notNull(),
+    description: text('description'),
+    visibility: mcpServerProjectVisibilityEnum('visibility').notNull().default('workspace'),
+    runtime: text('runtime').notNull().default('node'),
+    entryPoint: text('entry_point').notNull().default('index.ts'),
+    template: text('template'),
+    sourceType: text('source_type').notNull().default('inline'),
+    repositoryUrl: text('repository_url'),
+    repositoryBranch: text('repository_branch'),
+    environmentVariables: jsonb('environment_variables').notNull().default('{}'),
+    metadata: jsonb('metadata').notNull().default('{}'),
+    status: mcpServerProjectStatusEnum('status').notNull().default('draft'),
+    currentVersionNumber: integer('current_version_number'),
+    lastDeployedVersionId: text('last_deployed_version_id'),
+    lastDeployedAt: timestamp('last_deployed_at'),
+    deletedAt: timestamp('deleted_at'),
+    createdAt: timestamp('created_at').notNull().defaultNow(),
+    updatedAt: timestamp('updated_at').notNull().defaultNow(),
+  },
+  (table) => ({
+    workspaceSlugUnique: uniqueIndex('mcp_server_project_workspace_slug_unique').on(
+      table.workspaceId,
+      table.slug
+    ),
+    workspaceStatusIdx: index('mcp_server_project_workspace_status_idx').on(
+      table.workspaceId,
+      table.status
+    ),
+    visibilityIdx: index('mcp_server_project_visibility_idx').on(table.visibility),
+  })
+)
+
+export const mcpServerKindEnum = pgEnum('mcp_server_kind', ['external', 'hosted'])
+
 export const mcpServers = pgTable(
   'mcp_servers',
   {
@@ -1496,6 +1554,7 @@ export const mcpServers = pgTable(
     workspaceId: text('workspace_id')
       .notNull()
       .references(() => workspace.id, { onDelete: 'cascade' }),
+    projectId: text('project_id').references(() => mcpServerProject.id, { onDelete: 'set null' }),
 
     // Track who created the server, but workspace owns it
     createdBy: text('created_by').references(() => user.id, { onDelete: 'set null' }),
@@ -1520,6 +1579,8 @@ export const mcpServers = pgTable(
     totalRequests: integer('total_requests').default(0),
     lastUsed: timestamp('last_used'),
 
+    kind: mcpServerKindEnum('kind').notNull().default('external'),
+
     deletedAt: timestamp('deleted_at'),
 
     createdAt: timestamp('created_at').notNull().defaultNow(),
@@ -1540,6 +1601,118 @@ export const mcpServers = pgTable(
   })
 )
 
+export const mcpServerVersionStatusEnum = pgEnum('mcp_server_version_status', [
+  'queued',
+  'building',
+  'ready',
+  'failed',
+  'deprecated',
+])
+
+export const mcpServerVersion = pgTable(
+  'mcp_server_version',
+  {
+    id: text('id').primaryKey(),
+    projectId: text('project_id')
+      .notNull()
+      .references(() => mcpServerProject.id, { onDelete: 'cascade' }),
+    versionNumber: integer('version_number').notNull(),
+    sourceHash: text('source_hash'),
+    manifest: jsonb('manifest').notNull().default('{}'),
+    buildConfig: jsonb('build_config').notNull().default('{}'),
+    artifactUrl: text('artifact_url'),
+    runtimeMetadata: jsonb('runtime_metadata').notNull().default('{}'),
+    status: mcpServerVersionStatusEnum('status').notNull().default('queued'),
+    buildLogsUrl: text('build_logs_url'),
+    changelog: text('changelog'),
+    promotedBy: text('promoted_by').references(() => user.id, { onDelete: 'set null' }),
+    promotedAt: timestamp('promoted_at'),
+    createdAt: timestamp('created_at').notNull().defaultNow(),
+    updatedAt: timestamp('updated_at').notNull().defaultNow(),
+  },
+  (table) => ({
+    projectVersionUnique: uniqueIndex('mcp_server_version_project_version_unique').on(
+      table.projectId,
+      table.versionNumber
+    ),
+    projectStatusIdx: index('mcp_server_version_project_status_idx').on(
+      table.projectId,
+      table.status
+    ),
+  })
+)
+
+export const mcpServerDeploymentStatusEnum = pgEnum('mcp_server_deployment_status', [
+  'pending',
+  'deploying',
+  'active',
+  'failed',
+  'decommissioned',
+])
+
+export const mcpServerDeployment = pgTable(
+  'mcp_server_deployment',
+  {
+    id: text('id').primaryKey(),
+    projectId: text('project_id')
+      .notNull()
+      .references(() => mcpServerProject.id, { onDelete: 'cascade' }),
+    versionId: text('version_id').references(() => mcpServerVersion.id, { onDelete: 'set null' }),
+    serverId: text('server_id').references(() => mcpServers.id, { onDelete: 'set null' }),
+    workspaceId: text('workspace_id')
+      .notNull()
+      .references(() => workspace.id, { onDelete: 'cascade' }),
+    environment: text('environment').notNull().default('production'),
+    region: text('region'),
+    endpointUrl: text('endpoint_url'),
+    status: mcpServerDeploymentStatusEnum('status').notNull().default('pending'),
+    logsUrl: text('logs_url'),
+    deployedBy: text('deployed_by').references(() => user.id, { onDelete: 'set null' }),
+    deployedAt: timestamp('deployed_at'),
+    rolledBackAt: timestamp('rolled_back_at'),
+    createdAt: timestamp('created_at').notNull().defaultNow(),
+    updatedAt: timestamp('updated_at').notNull().defaultNow(),
+  },
+  (table) => ({
+    workspaceEnvironmentIdx: index('mcp_server_deployment_workspace_environment_idx').on(
+      table.workspaceId,
+      table.environment
+    ),
+    projectStatusIdx: index('mcp_server_deployment_project_status_idx').on(
+      table.projectId,
+      table.status
+    ),
+  })
+)
+
+export const mcpServerTokenScopeEnum = pgEnum('mcp_server_token_scope', [
+  'deploy',
+  'runtime',
+  'logs',
+])
+
+export const mcpServerToken = pgTable(
+  'mcp_server_token',
+  {
+    id: text('id').primaryKey(),
+    projectId: text('project_id')
+      .notNull()
+      .references(() => mcpServerProject.id, { onDelete: 'cascade' }),
+    name: text('name').notNull(),
+    hashedToken: text('hashed_token').notNull(),
+    scope: mcpServerTokenScopeEnum('scope').notNull().default('runtime'),
+    createdBy: text('created_by').references(() => user.id, { onDelete: 'set null' }),
+    lastUsedAt: timestamp('last_used_at'),
+    expiresAt: timestamp('expires_at'),
+    createdAt: timestamp('created_at').notNull().defaultNow(),
+    updatedAt: timestamp('updated_at').notNull().defaultNow(),
+  },
+  (table) => ({
+    projectScopeIdx: index('mcp_server_token_project_scope_idx').on(table.projectId, table.scope),
+    tokenLookupIdx: uniqueIndex('mcp_server_token_hash_unique').on(table.hashedToken),
+  })
+)
+
 // SSO Provider table
 export const ssoProvider = pgTable(
   'sso_provider',