Skip to main content
mcp-c is a fully managed runtime for MCP applications—whether that is a full mcp-agent workflow, a FastMCP server, or a custom ChatGPT App backend. You write agents using the same decorators you use locally—@app.tool, @app.async_tool, @app.workflow—and deploy them with a single CLI command. The platform bundles your code, provisions containerized MCP servers, executes workflows on Temporal, secures secrets, and streams telemetry to your dashboard or OTEL backend.

​
Key capabilities

  • Agents as MCP servers – every MCPApp is exposed as an MCP server with standard transports (SSE + streamable HTTP). Tools, resources, and prompts remain discoverable via the MCP APIs.
  • Temporal-backed durability – @app.async_tool and @app.workflow map to Temporal workflows with built-in retries, pause/resume, human input, and memoized state.
  • Automatic container orchestration – stdio MCP servers defined in mcp_agent.config.yaml run in hardened containers with lifecycle management, health checks, and auto-restarts.
  • Managed secrets – deployment secrets are encrypted at rest; per-user secrets are collected via mcp-agent cloud configure and scoped to that user’s execution.
  • Observability out-of-the-box – structured logs, traces, token counts, and workflow telemetry are available via the CLI or your own OTEL endpoint.
  • Simple client integration – mcp-agent install writes correct configs for Claude Desktop, Cursor, VS Code, and ChatGPT Apps.

​
Architecture at a glance

LayerWhat happens
Developer workstationmcp-agent deploy packages your project, transforms secrets, optionally tags the git commit, and uploads artefacts.
Deploy control planeValidates the bundle, builds container images, provisions or updates the MCP server, and wires secrets + environment variables.
Runtime planeA dedicated container hosts your main.py (MCPApp). Each stdio server (fetch, filesystem, custom tools) runs in its own container and communicates over local networking.
Temporal clusterDurable execution for workflows. Runs inside an internal multi-role Temporal deployment with service discovery and auth proxies.
Edge + observabilityEdge services expose HTTPS + SSE endpoints, enforce auth, forward telemetry to OTEL, and provide log streaming (mcp-agent cloud logger tail).

​
Deployment lifecycle

  1. Bundle – the CLI snapshots your directory, applying .mcpacignore and generating mcp_agent.deployed.secrets.yaml.
  2. Upload – artefacts are sent to the deployment service along with metadata (name, description, git commit, semantic version if provided).
  3. Build – containers are built for the application runtime and declared MCP stdio servers.
  4. Provision – infrastructure spins up in an isolated namespace; TLS certificates and routing are configured automatically.
  5. Health gate – Temporal workers and MCP endpoints must report healthy before the deployment is marked online.
  6. Operate – logs, traces, workflow state, and metrics become available through CLI and OTEL endpoints.

​
Execution model

  • Synchronous tools (@app.tool) run inline in the MCP server process and return results immediately. Use them for quick lookups or wrappers around MCP servers.
  • Asynchronous tools (@app.async_tool) enqueue a Temporal workflow and return {workflow_id, run_id}. Callers poll workflows-get_status until completion.
  • Workflow classes (@app.workflow, @app.workflow_run) define reusable long-running units. The platform generates the MCP tools (workflows-<Name>-run, workflows-cancel, etc.) automatically.
  • Human input & signals – workflows can pause on await context.request_human_input(...) or custom signals. Temporal keeps state durable during waits.
  • Multi-agent orchestration – routers, evaluator-optimizer loops, and deep orchestrator patterns are distributed across worker tasks but remain addressable through MCP tool APIs.

​
Security & authentication

  • Bearer tokens – default authentication mode. API keys created via mcp-agent login are scoped per user and can be rotated.
  • Unauthenticated mode – enable with mcp-agent deploy <name> --no-auth for public endpoints (required for ChatGPT Apps).
  • OAuth 2.1 (preview) – the platform’s authorization server follows the MCP OAuth specification, enabling end-to-end user authentication for enterprise scenarios. See Authentication →.
  • Downstream OAuth – use mcp_agent.config.yaml to configure client credentials for the agent’s outbound connections (e.g., Linear MCP server). Tokens are stored via the built-in token manager (token_store supports in-memory and Redis backends).

​
Observability

  • Logs – stream with mcp-agent cloud logger tail <identifier>; filter by time, severity, regex; export as JSON or YAML.
  • Traces – enable OpenTelemetry exporters in mcp_agent.config.yaml or forward to your collector via mcp-agent cloud logger configure.
  • Token accounting – the runtime counts prompt+completion tokens when using supported AugmentedLLM providers.
  • Workflow insights – inspect status, history, and memo data via CLI (mcp-agent cloud workflows describe) or Temporal Web UI (coming soon to the console).

​
Tooling surface

NeedCommand
Deploy or updatemcp-agent deploy <name>
Configure user secretsmcp-agent cloud configure --id <server-url>
Manage serversmcp-agent cloud servers list | describe | delete
Monitor logsmcp-agent cloud logger tail <id>
Manage workflowsmcp-agent cloud workflows list | runs | describe | suspend | resume | cancel
Install into clientsmcp-agent install --client <vscode|cursor|claude_desktop|chatgpt> <server-url>

​
When to use mcp-agent cloud

  • You want durable, resumable agents without operating Temporal or container infrastructure yourself.
  • You need to ship MCP servers to a broader audience (internal marketplace, customer-facing tools, ChatGPT Apps).
  • You require centralised observability and secrets management for all deployments.
  • You are ready to standardise on MCP for tool integration and agent orchestration.
If you need to run in regulated environments or on-premises, use the same app with your own Temporal cluster—see Durable agents →.

​
Next steps

⌘I