Studio packages the infrastructure behind an internal AI rollout: model routing, MCP authentication, agent configuration, SSO, RBAC, audit logs, and usage accounting. Your teams get chat. You keep control.
Under the hood it's one control plane for your AI agents — one MCP endpoint for all your agents, tools, and models. Agents package context, tools, and policy into something you publish to the organization. Connections give them governed access to your systems — GitHub, Slack, Postgres, Sentry, anything that speaks MCP — with tokens stored in an encrypted vault. Models stay interchangeable: OpenRouter or direct providers, chosen per agent and per tool.
CLI for managing decocms.com apps & projects
2026-11-13
ดาว
—
เครื่องมือ
—
อัปไทม์
—
Start with one team. Standardize approved models, tools, and context. Expand across the organization without copying secrets or rebuilding the platform. Install locally and it stays private; sync to the cloud for remote access, team roles, and shared billing.
Install Docker with Compose, then run from source:
git clone https://github.com/decocms/studio.git
cd studio
docker compose up --build --watch
Open http://localhost:4000. Compose starts PostgreSQL,
NATS, object storage, migrations, and the hot-reloading API and web app.
See CONTRIBUTING.md for contributor setup and worktrees.
What you get
Agents
Package context, tools, and policy into an agent. Define instructions, add skills and files, grant approved MCP access, choose a model policy, then publish the agent to the organization. Each agent is its own MCP endpoint — callable from Cursor, Claude Desktop, your own code, or another agent. Agents compose, and every action is tracked with cost attribution.
Connections
Connect private systems once, securely. Register MCP servers at the organization level through a web UI with one-click OAuth — no JSON configs. Tokens live in the encrypted vault, and you grant tool-level access by organization, role, or agent. Share MCP capabilities — not credentials.
As tool surfaces grow, Studio exposes Virtual MCPs — one endpoint, different strategies for which tools to surface:
Full-context: expose everything (simple, deterministic, good for small toolsets)
Smart selection: narrow the toolset before execution
Code execution: load tools on demand in a sandbox
Models
Keep the AI layer interchangeable. Use OpenRouter or connect Anthropic, OpenAI, Google, or any compatible provider directly — the best model for each agent and tool, behind one router. For coding work, engineers can link their own Claude Code or Codex session and use the subscription already authenticated on their machine.
Projects
Projects bring agents and connections together around a goal. The project's UI adapts to what's inside — add a content agent and a CMS connection, the sidebar shows content management; add an analytics agent and a database, it shows dashboards and queries. The UI you see is the UI that's relevant for operating that project.
Observability
Account for every model and tool call. Trace the user, agent, model, tools, latency, errors, tokens, and cost for every thread. Break usage down by agent, connection, organization, or teammate — one dashboard.
From your desktop to your org
Local
Docker Compose on your laptop, including PostgreSQL, NATS, and object storage.
Cloud
Log in to studio.decocms.com. Control local projects from any browser.
Team
Invite people. SSO and role-based access. Shared connections. Cost attribution.
Enterprise
Self-hosted. Organization isolation, tool-scoped API keys, audit logs. Your infra, your rules.
Core Capabilities
Capability
What it does
Agents
Package context, tools, and policy into publishable agents with cost attribution
Connections
Route MCP traffic through one governed endpoint with auth, proxy, and encrypted token vault
Models
Interchangeable AI layer — OpenRouter or direct providers, model policy per agent
Projects
Organize agents and connections around goals with an adaptive UI
Virtual MCPs
Compose and expose governed toolsets as new MCP endpoints
Observability
Traces, costs, errors, and latency per user, agent, and connection — one dashboard
Access Control
SSO + RBAC via Better Auth — OAuth 2.1 and tool-scoped API keys per workspace/project
Multi-tenancy
Organization/project isolation for config, credentials, policies, and audit logs
Bindings
Capability contracts so tools target interfaces, not specific implementations
Every tool call gets input/output validation, access control, audit logging, and OpenTelemetry traces automatically.
Documentation
Studio documentation lives in
docs-tanstack, alongside the
Storefront documentation. Update public product guides and architecture there.
Workspace READMEs and engineering plans stay here with the implementation.
bun install # Install dependencies
bun run dev # Docker Compose Watch: dependencies, migrations, API + web
bun test # Run tests
bun run check # Type check
bun run lint # Lint
bun run fmt # Format
App-specific commands
bun run --cwd=apps/web dev # Vite dev server (port 4000)
bun run --cwd=apps/api dev:server # Hono server with hot reload
bun run --cwd=apps/api migrate # Run database migrations
For parallel worktrees, Compose lifecycle commands, and frontend-only work,
see CONTRIBUTING.md.
Deploy Anywhere
# Docker Compose: released Studio + PostgreSQL + NATS + object storage
docker compose -f selfhost/examples/docker-compose/compose.yaml up -d
# Kubernetes (Helm)
helm install deco-studio oci://ghcr.io/decocms/chart-deco-studio --version <version> -n deco-studio --create-namespace
Run Studio with Docker Compose or Kubernetes on your own infrastructure.
What you need to run it
Tier
Footprint
Laptop
Docker with Compose; the development stack includes its dependencies.
Docker
Published Studio image with configured PostgreSQL, NATS, and object storage.
Production (Helm)
PostgreSQL you bring, plus NATS for streaming and cross-pod coordination, ClickHouse + OTel Collector (traces and analytics), and the sandbox operator (isolated agent environments on Kubernetes). Your identity provider, your model keys, your storage.
Production topology
graph TB
clients["MCP clients — Cursor · Claude · VS Code · your code"]
clients -->|"one MCP endpoint · SSO · RBAC · audit"| api
subgraph k8s ["Kubernetes (Helm)"]
api["Studio API + Admin UI"]
api --> sandbox["Agent sandboxes<br/>(sandbox-operator)"]
api <-->|"streams and broadcasts"| nats["NATS"]
api -->|"traces · costs"| otel["OTel Collector"]
nats <-->|"streams and broadcasts"| worker["Workers<br/>DBOS runs"]
otel --> ch[("ClickHouse")]
end
pg[("PostgreSQL")]
api --> pg
worker <-->|"DBOS queues and journal"| pg
subgraph upstream ["Models & tools"]
models["Anthropic · OpenAI<br/>OpenRouter · Ollama"]
mcps["GitHub · Slack · Postgres<br/>your MCP servers"]
end
api -->|"model routing · vaulted credentials"| upstream
Every box is optional except Studio and PostgreSQL — start small, turn on the rest as the rollout grows.
Tech Stack
Layer
Tech
Runtime
Bun / Node
Language
TypeScript + Zod
Framework
Hono (API) + Vite + React 19
Database
Kysely → PostgreSQL
Auth
Better Auth (OAuth 2.1 + API keys)
Observability
OpenTelemetry
UI
React 19 + Tailwind v4 + shadcn
Protocol
Model Context Protocol (MCP)
Roadmap
Agent marketplace — discover, hire, and compose agents
