Platform

Build with
live causal computation

Abel Platform is the commercial builder surface for live causal intelligence — CAP primitives, Schema API, MCP integration, SDKs, and private deployment.

Start with QuickstartAPI Reference

How To Integrate

Three ways to connect

Choose based on your architecture. Direct call for speed, Schema-guided for flexibility, MCP for native LLM tool use.

A

Direct Call

Zero LLM, maximum speed

Your agent already knows variable names. Call CAP primitives directly — no LLM overhead, no Schema lookup, pure computation.

direct_call.pypython
import abel

client = abel.Client(api_key="sk-...")
prediction = client.predict("BTCUSD_close", horizon=48)
explanation = client.explain("BTCUSD_close", depth=2, cross_domain=True)
effect = client.intervene("Fed_Funds_Rate", "BTCUSD_close", treatment_value=0.5)
B

Schema-Guided

LLM reads the map, then routes

Your LLM queries Schema API first to discover variables, then makes structured CAP calls. Abel-side: zero LLM.

schema_guided.pypython
# Step 1: Agent's LLM reads Abel's Schema API
schema = client.schema.search_variables("oil price")
# → [{ name: "WTI_Crude", community: "Energy Markets", ... }]

# Step 2: Agent calls CAP primitive with exact variable names
effect = client.intervene(
    treatment="WTI_Crude",
    outcome="CPI",
    treatment_value=120.0
)
# → { effect: +2.1%, chain: "WTI → CPI", tau: "720h", ci: [1.4%, 2.8%] }
C

MCP Server

Native LLM tool calling

Claude, GPT, or any MCP-compatible LLM calls Abel as a native tool. Structured input, causal output.

mcp_tool_call.jsonjson
# Claude / GPT calls Abel via MCP — zero setup
# Tool: abel_causal_intervene
{
  "treatment": "Fed_Funds_Rate",
  "outcome": "BTCUSD_close",
  "treatment_value": 0.5
}

# Abel returns pure causal computation:
# { effect: -4.2%, ci: [-2.1%, -6.8%],
#   chain: "Fed →[τ=5h]→ DXY →[τ=2h]→ BTC",
#   method: "do-calculus via PCMCI graph" }

CAP Primitives

8 causal computation operations

Each primitive maps to a specific level of Pearl's Causal Hierarchy.

predict()Available

Forecast using causal Markov blanket

L1+
explain()Available

Extract causal drivers with cross-domain chains

L1-2
intervene()Available

Compute P(Y|do(X=x)) — causal intervention

L2
discover()Available

Learn causal structure from data (39 algorithms)

L0
counterfactual()Beta

What would have happened if…?

L3
validate()Available

Test graph against new data

Meta
detect_regime()Beta

Has the causal structure changed?

Meta
analyze()Available

Full autonomous causal analysis pipeline

All

Schema API

The map your LLM reads to route itself

Abel exposes structured metadata so any LLM can translate natural language into CAP calls — without Abel running any LLM.

GET /schema/communities

List all semantic communities with member variables and typical queries

GET /schema/variables?search=...

Fuzzy search variables by name, type, or domain

GET /schema/primitives

Operation catalog — what each primitive does, parameters, examples

GET /schema/neighborhood?variable=...

Causal parents, children, and cross-domain chains for a variable

GET /schema/regimes

Current regime state, recent structural changes

Platform Map

One platform, four entry points

Use this page as the overview, then branch into the protocol, docs, or deployment path you need.

Platform Overview

Start here to understand how Abel separates language from causal computation and where the commercial platform fits.

You are here →

CAP Protocol

Read the open protocol that defines the causal operations and graph-discovery primitives behind the platform.

Read the protocol →

Docs and SDKs

Move from architecture to implementation with quickstart guides, API reference, MCP setup, and SDK docs.

Go to docs →

Open Source and Enterprise

Use Causal-Copilot for open-source workflows, then scale into BYOLLM and private deployment when needed.

Explore deployment →

Commercial Platform

Protected access to a live causal graph

Abel's graph topology is core IP. The platform exposes computation, routing, and deployment options without collapsing everything into raw graph access.

Green Zone

Aggregated results only. No edge-level graph access. Safe for public-facing integrations.

Yellow Zone

Edge-level access with rate limits. Dynamic fingerprinting and canary edges detect extraction attempts.

Red Zone

Full graph access. Computation-gated queries — results require Abel's GPU to produce, preventing reconstruction.

Start making decisions with
live causal intelligence.

Start BuildingExplore Product

Interested in shaping the future of
causal intelligence? We're hiring.

Open Roles

Join Abelian Groups to stay on top of new
releases, features, and updates.