# 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

1. Install the skill.
   Let the agent handle setup and routing.
2. Get an API key.
   Create an Abel API key via <a class="doc-inline-button" href="https://abel.ai/skill" target="_blank" rel="noreferrer">Open Abel Skill</a>, or let the agent complete OAuth for you.
3. Ask one real question.
   Start in chat with `Abel it` and your actual question.

## Install The Abel Skill

### Codex

Tell Codex:

```text
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:

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

### OpenCode

Tell OpenCode:

```text
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:

```text
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.
```

```text
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:

```bash
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:

```bash
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:

```bash
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
    }
  }'
```

## Read Next

- [Abel Extensions](/docs/extensions)
  Use this for richer Abel-only methods, common extension guardrails, and choosing the right extension.
- [API Reference](/docs/api-reference)
  Use this for full request shapes, capability discovery, extension namespace metadata, and more examples.