Getting Started

Abel CAP is the fastest way to start exploring Abel’s causal surface. A simple way to begin is to type Abel it plus the question you actually care about, and let the skill route the CAP work underneath. You do not need to send raw CAP requests on day one.

Start In Three Steps

Install the skill. Let the agent handle setup and routing.
Get an API key. Create an Abel API key via Open Abel Skill, or let the agent complete OAuth for you.
Ask one real question. Start in chat with Abel it and your actual question.

Install The Abel Skill

Codex

Tell Codex:

Fetch and follow instructions from https://raw.githubusercontent.com/Abel-ai-causality/Abel-skills/refs/heads/main/.codex/INSTALL.md

Claude Code

Tell Claude Code:

Fetch and follow instructions from https://raw.githubusercontent.com/Abel-ai-causality/Abel-skills/refs/heads/main/.claude/INSTALL.md

OpenCode

Tell OpenCode:

Fetch and follow instructions from https://raw.githubusercontent.com/Abel-ai-causality/Abel-skills/refs/heads/main/.opencode/INSTALL.md

That gives your agent a ready-made flow for:

first-use setup
API key handoff
CAP capability inspection
choosing the right CAP verb for the question
moving to an Abel extension when needed

Good first prompts:

Abel it: how might faster AI adoption ripple into everyday jobs, wages, and household pressure? Map it to the right market proxies, show me the likely chain, and tell me what to try next.

Abel it: what is really driving NVDA right now, and which upstream nodes matter most if I care about the next 1 to 3 months?

Get An API Key

If you already have an Abel API key, use it.

If you do not, either create one on the Abel website or let your agent handle the Google OAuth handoff.

When the agent does the handoff:

the agent requests an authorization link
you approve the login in the browser
the agent polls for completion and retrieves the key automatically

You should not need to paste an email address, OAuth code, or callback URL back into chat.

Keep It In Chat First

You can stay in agent mode for a while:

lead with Abel it when you want the agent to take the question and route it for you
ask a broader real-world question and let the skill map it to market proxies
ask what is driving a node
ask whether two nodes are connected
ask which Abel extension is worth trying next

You do not need raw CAP requests on day one.

Send Requests Directly

Public endpoint: POST https://cap.abel.ai/api/cap

Start with capability discovery:

curl -s -X POST https://cap.abel.ai/api/cap \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_ABEL_API_KEY' \
  -d '{
    "cap_version": "0.2.2",
    "request_id": "req-capabilities-1",
    "verb": "meta.capabilities"
  }'

Then ask the server for machine-readable method metadata before choosing between CAP core and an Abel extension:

curl -s -X POST https://cap.abel.ai/api/cap \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_ABEL_API_KEY' \
  -d '{
    "cap_version": "0.2.2",
    "request_id": "req-methods-1",
    "verb": "meta.methods",
    "params": {
      "detail": "compact",
      "include_examples": false
    }
  }'

That gives you the active verb list plus method-level argument summaries for this server, including the mounted extensions.abel.* surface.

Two quick public-surface rules to remember:

canonical Abel public node ids use <ticker>.price or <ticker>.volume; legacy <ticker>_close and <ticker>_volume inputs may still be accepted and normalized by the current server
if you send context.graph_ref, use graph_id="abel-main" and graph_version="CausalNodeV2"

Once you know the shape you want, call a task-specific verb. For example, ask for parents around a node:

curl -s -X POST https://cap.abel.ai/api/cap \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_ABEL_API_KEY' \
  -d '{
    "cap_version": "0.2.2",
    "request_id": "req-parents-1",
    "verb": "traverse.parents",
    "params": {
      "node_id": "NVDA.price",
      "top_k": 5
    }
  }'