Capx
Get Early Access
Solutions / Engineers

capx init your next company.

YAML configs. Full REST API. CLI. TypeScript SDK. MCP Server. Designed for engineers who want control, not magic. Every action programmable, every decision auditable, every cost tracked.

Read the DocsGet Access

5 ways to interact.

Every tool ships with full documentation, typed interfaces, and real code examples. Pick your interface. The API is the same underneath.

CLI

capx init, deploy, status, logs, tail. CI/CD friendly. Autocomplete for bash, zsh, fish.

cli
$ capx init my-company --template saas-agency
  Creating company... done
  Provisioning 4 agents... done
  Company ready: my-company.capx.ai

$ capx status my-company
  Status:   active
  Agents:   4/4 healthy
  Spend:    $42.10 / $500.00 cap
  Tasks:    12 completed, 2 in progress

REST API

Every action programmable. Companies, agents, tasks, playbooks, approvals. OpenAPI spec included.

rest api
curl -X POST https://api.capx.ai/v1/companies \
  -H "Authorization: Bearer capx_sk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "name": "acme-marketing",
    "template": "saas-agency",
    "governance": { "spend_cap": 500 }
  }'

# 201 Created
{
  "id": "co_8x9k2m",
  "status": "provisioning",
  "agents": 4,
  "url": "acme-marketing.capx.ai"
}

TypeScript SDK

Typed interfaces, async/await, streaming. Full IntelliSense. Ships with type definitions.

typescript sdk
import { Capx } from '@capx/sdk';

const capx = new Capx({ apiKey: process.env.CAPX_KEY });

const company = await capx.companies.create({
  name: 'acme-marketing',
  template: 'saas-agency',
  governance: { spendCap: 500 },
});

const run = await capx.playbooks.run({
  company: company.id,
  playbook: 'landing-page-copy',
  input: { brief: 'Launch page for new feature' },
});

for await (const event of run.stream()) {
  console.log(event.type, event.data);
}

MCP Server

Model Context Protocol. Works with Claude Desktop and Cursor. Natural language control.

mcp server
// claude_desktop_config.json
{
  "mcpServers": {
    "capx": {
      "command": "capx",
      "args": ["mcp", "serve"],
      "env": {
        "CAPX_API_KEY": "capx_sk_live_..."
      }
    }
  }
}

// Then in Claude Desktop or Cursor:
// "Deploy a company called acme-marketing
//  using the saas-agency template with
//  a $500 spend cap"

Dashboard

Web-based GUI for teams who prefer visual management. Real-time updates, one-click approvals.

dashboard
┌────────────────────────────────────┐
│  Capx Dashboard                    │
│                                    │
│  Companies     3 active            │
│  Agents        12/12 healthy       │
│  Spend (30d)   $412.80 / $1,500    │
│  Tasks         847 completed       │
│                                    │
│  Recent Activity                   │
│  14:32  engineer  PR #23 opened    │
│  14:28  marketer  Newsletter sent  │
│  14:15  support   Ticket resolved  │
│  14:01  cofounder Strategy updated │
└────────────────────────────────────┘

Request flow.

What happens when your code calls the Capx API. Six steps from request to result.

1

Request arrives

Your code calls the API, CLI command runs, or MCP server receives a natural language instruction.

POST /v1/playbooks/run
{ "company": "co_8x9k2m", "playbook": "engineer-task", "input": { "spec": "Add dark mode toggle" } }
2

Governance check

The runtime validates spend caps, execution policies, and RBAC permissions before any agent is invoked.

3

Playbook resolution

The YAML playbook is loaded, version-pinned, and its steps are compiled into an execution plan.

# engineer-task.yaml
steps:
  - tool: llm.prompt
    input: "Plan changes for: {{spec}}"
  - tool: code.edit
    input: "{{plan.files}}"
4

Agent execution

The assigned agent runs each step in an isolated container. Tool calls are logged. Outputs are validated against the rubric.

5

Approval gate (optional)

If the playbook requires human approval, the result enters the approval queue. Otherwise it auto-completes.

6

Result + webhook

The run result is returned to the caller. Webhooks fire for any configured event subscriptions.

// Webhook: task.completed
{
  "event": "task.completed",
  "agent": "engineer",
  "result": "success",
  "artifacts": [{ "type": "pull_request", "url": "..." }]
}

Bring your own model.

Model-agnostic by design. Use Claude, GPT, Codex, Cursor, or any HTTP endpoint. Switch per agent, per task, or per playbook step.

Claude (Anthropic)

agents:
  - role: strategist
    adapter: claude
    model: claude-sonnet-4-6
    config:
      max_tokens: 4096
      temperature: 0.3

GPT (OpenAI)

agents:
  - role: analyst
    adapter: openai
    model: gpt-4o
    config:
      max_tokens: 4096
      response_format: json

Custom HTTP

agents:
  - role: custom-agent
    adapter: http
    config:
      endpoint: https://your-api.com/agent
      headers:
        Authorization: "Bearer ${KEY}"
      timeout_ms: 30000

Start building.

DocsAPICLI