Cordum

AI Agent Governance Platform
Deploy autonomous agents with built-in safety, observability, and control.

The Problem

AI agents are powerful. They're also unpredictable.

Teams deploying agents in production face the Trust Gap: the distance between what an agent can do and what you're confident letting it do unsupervised.

Without governance, you're flying blind:
- No visibility into what agents are doing
- No safety rails before dangerous actions
- No audit trail when things go wrong
- No way to require human approval for sensitive operations

The Solution

Cordum is a control plane for AI agents that closes the Trust Gap.

┌─────────────────────────────────────────────────────────────────┐
│                         Cordum                                  │
│                                                                 │
│  ┌──────────┐   ┌──────────┐   ┌──────────┐   ┌──────────────┐ │
│  │   API    │──▶│ Scheduler│──▶│  Safety  │──▶│ Worker Pools │ │
│  │ Gateway  │   │          │   │  Kernel  │   │              │ │
│  └──────────┘   └──────────┘   └──────────┘   └──────────────┘ │
│       │              │              │                │         │
│       ▼              ▼              ▼                ▼         │
│  [Dashboard]    [Workflows]    [Policies]      [Your Agents]   │
└─────────────────────────────────────────────────────────────────┘

What Cordum does:

• Safety Kernel — Policy checks (allow/deny/throttle/human-approve) before any job runs
• Workflow Engine — Orchestrate multi-step agent workflows with retries, approvals, and timeouts
• Job Routing — Distribute work across agent pools with capability-based routing
• Observability — Full audit trail, traces, and real-time dashboard
• Human-in-the-Loop — Require approval for sensitive operations

Quickstart

Prerequisites: Docker, Docker Compose

# Clone the repo
git clone https://github.com/cordum-io/cordum.git
cd cordum

# Start everything
docker compose up -d

# Open dashboard
open http://localhost:8082

Run the smoke test:

./tools/scripts/platform_smoke.sh

That's it. You have a running Cordum instance with API, scheduler, safety kernel, and dashboard.

How It Works

Cordum uses CAP (Cordum Agent Protocol) for all agent communication:

1. Submit — Client submits a job via API
2. Safety Check — Scheduler asks Safety Kernel: allow, deny, throttle, or require approval?
3. Dispatch — Approved jobs route to the right worker pool via NATS
4. Execute — Your agent runs the job (using MCP, LangChain, whatever)
5. Result — Agent returns result; Cordum updates state and notifies client

Client ──▶ API ──▶ Scheduler ──▶ Safety Kernel ──▶ NATS ──▶ Agent Pool
                       │                              │
                       ▼                              ▼
                  [Redis State]                 [Your Agents]

Key design choices:
- Payloads stay off the bus — context_ptr and result_ptr reference Redis/S3, keeping the message bus lean
- Protocol-first — CAP is an independent spec; Cordum is the reference implementation
- Workers are external — Cordum is the control plane; your agents run wherever you want

Key Features

Architecture

cordum/
├── cmd/                    # Service entrypoints
│   ├── cordum-api/         # API gateway (HTTP/WS + gRPC)
│   ├── cordum-scheduler/   # Job routing + safety + state
│   └── cordum-context/     # Optional context/memory service
├── core/                   # Shared libraries
│   ├── safety/             # Safety kernel implementation
│   ├── workflow/           # Workflow engine
│   ├── scheduler/          # Scheduler logic
│   └── protocol/           # CAP type aliases + API protos
├── dashboard/              # React UI
├── sdk/                    # Go SDK + worker runtime
├── deploy/k8s/             # Kubernetes manifests
└── docs/                   # Documentation

Documentation

Protocol: CAP

Cordum implements CAP (Cordum Agent Protocol) — an open protocol for distributed AI agent orchestration.

CAP vs MCP:
- MCP = tool-calling protocol for a single model
- CAP = job protocol for distributed agent clusters

They're complementary. Use CAP for orchestration, MCP inside your agents for tools.

Read more: MCP vs CAP: Why Your AI Agents Need Both Protocols

SDK

The Go SDK makes it easy to build CAP-compatible workers:

import "github.com/cordum-io/cordum/sdk/runtime"

func main() {
    worker := runtime.NewWorker("my-agent", "job.my-pool")

    worker.Handle(func(ctx context.Context, job *runtime.Job) (*runtime.Result, error) {
        // Your agent logic here
        return &runtime.Result{Status: runtime.Succeeded}, nil
    })

    worker.Run()
}

SDKs: Go (stable) | Python (coming soon) | Node (coming soon)

Community

• Discord: Join the conversation
• GitHub Discussions: Ask questions
• Twitter/X: @coraboratedai
• Email: admin@cordum.io

Enterprise

Cordum Enterprise adds:
- SSO/SAML integration
- Advanced RBAC
- SIEM export
- Priority support

Contact us for pricing.

Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

License

Licensed under Business Source License 1.1 (BUSL-1.1).

Free for self-hosted and internal use. Not permitted for competing hosted/managed offerings. See LICENSE for details and Change Date.

Ready to govern your AI agents?
cordum.io · CAP Protocol · Discord

⭐ Star this repo if Cordum helps you deploy agents safely