Introducing CAP: The Causal Agent Protocol

Today we're releasing the Causal Agent Protocol (CAP) — an open standard that defines how AI agents invoke causal reasoning capabilities. CAP is MIT-licensed and available on GitHub.

Why a New Protocol?

The AI agent ecosystem has protocols for tool calling (MCP, Function Calling), knowledge retrieval (RAG), and memory (various). But there's no standard for causal reasoning — the type of computation needed to answer "Should I…?" questions.

Current protocols define transport (how an agent calls a tool) but not causal semantics (what causal operations look like). An agent using MCP can call any tool, but there's no standardized way to say "compute a causal intervention" or "walk a causal graph."

CAP fills this gap. It sits on top of MCP/Function Calling and defines the semantic layer for causal operations.

The 12 Primitives

CAP defines 8 computation primitives and 4 schema discovery primitives:

Computation:

• discover(data) → Graph — learn causal structure from data
• intervene(graph, X, Y, x) → Effect — compute P(Y|do(X=x))
• predict(graph, Y, horizon) → Value — forecast using causal Markov blanket
• explain(graph, Y) → Parents — extract causal drivers
• counterfactual(graph, X', obs) → Y' — alternative history reasoning
• validate(graph, data) → Report — test graph against new data
• detect_regime(graph) → Changes — structural change detection
• check_reflexivity(graph, Y) → Report — self-fulfilling prophecy detection

Schema Discovery:

• list_communities() — what domains does the causal world model cover?
• search_variables(query) — find the right variable names
• get_neighborhood(var, depth) — explore causal connections
• get_regime_status() — has the causal structure changed recently?

Schema-as-API: Zero LLM on Abel's Side

A key innovation in CAP is Schema-as-API. Abel exposes structured metadata about its causal graph (communities, variables, neighborhoods) as API endpoints. Any LLM can read this metadata and learn to translate natural language into CAP calls — without Abel needing to run any LLM internally.

This means: Claude reads Abel's Schema → understands the causal world model → translates "What happens if oil hits $120?" into intervene(treatment="WTI_Crude", outcome="CPI", treatment_value=120) → Abel computes pure math → returns structured result → Claude formats it for the user.

Abel's computation is LLM-free. The language layer belongs to whichever LLM the user prefers.

Open Protocol, Powerful Engine

CAP is open (MIT). Anyone can implement it. But Abel's implementation — powered by GPU-accelerated PCMCI across 200,000+ variables (6M causal spatiotemporal nodes) with daily structural refresh — is the most powerful CAP engine available.

This mirrors the SQL model: SQL is an open standard, but Oracle, Snowflake, and PostgreSQL compete on engine performance. CAP is the open standard for causal queries; Abel is the engine that runs them fastest and at the largest scale.

Get Started

• Read the full spec: abel.ai/cap
• Python SDK: pip install abel-cap
• MCP Server: npx abel-mcp
• GitHub: github.com/abel-ai/cap

MCP gives agents tools. CAP gives agents causal reasoning. Build with CAP.