← Back to Skills Marketplace
exenvitor

Causal Abel

by ExenVitor · GitHub ↗ · v1.1.6 · MIT-0
cross-platform ✓ Security Clean
222
Downloads
0
Stars
0
Active Installs
5
Versions
Install in OpenClaw
/install causal-abel
Description
Use when the user wants an Abel causal read on what drives a market, company, asset, sector, or macro node, how two nodes connect, what changes under interve...
README (SKILL.md)

Any dollar-value decision, just Abel it. Finance and crypto nodes are the signal layer (the graph's proxy vocabulary), not the product.

Do not use Abel for pure fact lookup, news recap, or operational how-to when no real decision is being made; use normal retrieval first. Abel starts when the user needs a causal read on a choice that allocates money, time, career-capital, or downside risk.

Install And Authorization

If the user installs this skill, asks to connect Abel, or the workflow is missing an Abel API key, follow references/setup-guide.md exactly.

  • Start the Abel agent OAuth handoff immediately instead of asking for manual credentials.
  • Return data.authUrl to the user, not the /authorize/agent API URL.
  • Store data.resultUrl or data.pollToken, ask the user to reply once Google authorization is complete, and only then poll until the result is authorized, failed, or expired.
  • Persist the resulting data.apiKey in session state and .env.skill when local storage is available.
  • Do not continue to live CAP probing until that key is present.
  • Never ask the user to paste an email address or Google OAuth code.

Step 1: Preflight + Classify

Confirm auth via python scripts/cap_probe.py auth-status and references/probe-usage.md. Do not infer missing auth from shell env alone. If auth_source is missing, stop and ask the user whether to start the OAuth handoff from references/setup-guide.md; do not substitute web search just because auth is missing.

Classify the request as:

  • direct_graph for specific ticker/node/path/intervention questions
  • proxy_routed for real-world decisions with no direct node

Horizon gate: If the decision horizon is >3 years ("5年后", "未来十年"), switch to structural mode: web is PRIMARY, graph is VALIDATOR ONLY, and you should not use momentum-style observe as the main loop.

Unstable-premise gate: If the opportunity thesis depends on a recent leak, launch, partnership, shutdown, org change, or other freshness-sensitive claim, do one minimal premise-verification search before L0. Use a Tier A source when possible, or a clearly sourced Tier B report if no primary source exists yet. If the premise is still unanchored, rewrite the task as conditional analysis ("if this is true, where are the opportunities?") and say so before continuing. This gate does not cancel Abel; it decides whether the rest of the read is fact-anchored or conditional. Separate verifiable subclaims from inferred motive/strategy claims, and keep inferences labeled as inference even when some facts are anchored.

Opportunity-scope gate: If the user asks a broad question such as "有什么赚钱机会", lock the primary opportunity frame before L0. Distinguish at least among public-market trade, supplier/competitor scan, startup or B2B opportunity, and career/business opportunity. If the user does not specify, default to public-market trade and label other frames as secondary unless they materially change the answer. If multiple frames matter, label them explicitly instead of mixing them into one undifferentiated mechanism list.

If direct_graph, switch to references/routes/direct-graph.md as the active workflow. Return here only for shared web-grounding and write-up rules.

Step 2: Generate Hypotheses (proxy_routed, L0)

Generate 4-6 candidate causal mechanisms:

  • The obvious mechanism
  • A second-order mechanism
  • A contrarian (what would make the opposite true?) — REQUIRED
  • A confounder (third factor explaining both)

Each mechanism: cause → (transmission) → outcome with a testable proxy and falsification condition.

If the contrarian or confounder is missing, stop and fix that before moving on.

Step 3: Screen + Discover (L0.5)

Map the mechanisms to graph nodes and separate them into:

  • structurally supported
  • weakly connected
  • narrative-only

When extensions.abel.query_node is used for fuzzy mapping, inspect node_kind before picking the next surface. Do not assume every returned node can be coerced into \x3Cticker>.price or \x3Cticker>.volume. If the hit is macro, prefer direct verb calls for macro-capable structural surfaces instead of asset-only probe shortcuts.

Required passes:

  • run structural discovery deeply enough to identify a real transmission chain, not just co-movement
  • if the graph only confirms L0, actively search for the strongest graph-based contradiction
  • do not declare graph-sparse until capillary discovery is exhausted

Follow the full proxy_routed loop in references/routes/proxy-routed.md.

Step 4: Observe + Verify (L1 + L2)

Observe the key nodes for directional coherence and driver consistency.

Intervene only along real graph-supported edges when a meaningful target exists. Match horizon_steps to the decision window and widen in tiers via references/probe-usage.md when needed.

Aggregate to one directional signal per dimension. Never carry raw prediction decimals into the verdict.

Detailed probe shapes and proxy_routed execution rules live in:

  • references/routes/proxy-routed.md
  • references/probe-usage.md

Step 5: Web Grounding (proxy_routed, or direct_graph when freshness matters)

Minimum 4 searches:

  1. What's happening now — latest prices, policy, events, dates
  2. Supporting evidence — confirms graph-backed verdict
  3. Contradicting evidence — actively search for why verdict is WRONG (mandatory)
  4. User-perspective — what a real buyer/decision-maker would search (second-hand prices, waitlists, real experiences)

Contradicting evidence is mandatory. Stop only after you know whether key time-sensitive claims do or do not have a primary-source anchor.

Follow references/web-grounding.md for source hierarchy, wording, and return-to-graph rules.

Graph findings (L2) take precedence over web (L0) in the verdict. Exception: graph-sparse dimensions, where web is primary with lower confidence.

Step 5.5: Personalize

Before writing, check agent memory/context for user profile (income, experience, risk tolerance, life stage, goals). If available, tailor the action layer to that person. If not, give universal advice and say what user details would sharpen the read.

The causal graph is universal. The verdict is personal.

Step 6: Write Report

Read assets/report-guide.md and references/rendering.md before writing.

Render gate (MANDATORY): apply the label-pass and guard workflow from references/rendering.md before finalizing. For non-asset or proxy_routed questions, raw tickers, raw node ids, graph paths, signed prediction decimals, and rendering scratch work stay out of visible prose.

Output default (MANDATORY): default to main answer only. Do not emit an appendix, trace block, evidence dump, rendering scratch work, or probe/process transcript unless the user explicitly asks for evidence details, debug output, reproducibility steps, or a trace.

Write the final answer to the contract in assets/report-guide.md.

Keep claim-strength honesty explicit: life decisions are graph-grounded advice, not causal proof.

References (read only when needed)

  • references/routes/direct-graph.md — ticker question routing
  • references/routes/proxy-routed.md — proxy-routed graph workflow
  • references/setup-guide.md — OAuth install (only if key missing)
  • references/probe-usage.md — exact cap_probe.py command shapes
  • references/rendering.md — label-pass rules, visible/internal split, guard usage
  • assets/report-guide.md — full output contract with archetypes, rendering rules, coverage areas
Usage Guidance
This skill appears internally consistent for performing Abel causal analysis, but it runs bundled Python scripts that: (1) call remote Abel endpoints (cap.abel.ai and api.abel.ai/echo) and (2) read and may write local env files (<skill-root>/.env.skill, fall back .env). Before installing, review and accept that the agent will execute those scripts and that the skill will store your Abel API key in a local file if available. To minimize exposure: create an Abel API key with minimal scope and expiration, do not keep other secrets in the same-directory .env files, and review the two included scripts (scripts/cap_probe.py, scripts/render_guard.py) yourself to confirm they match expected behavior. If you are uncomfortable with local persistence, do not install or ask the agent to avoid persisting keys to disk.
Capability Analysis
Type: OpenClaw Skill Name: causal-abel Version: 1.1.6 The causal-abel skill bundle is a comprehensive framework for performing causal economic and financial analysis using the Abel AI platform. It includes a robust Python utility (scripts/cap_probe.py) for interacting with the Abel CAP API and a set of detailed instructions (SKILL.md, references/) that guide an AI agent through hypothesis generation, structural graph discovery, and web-grounded verification. The skill implements a structured OAuth authentication flow (references/setup-guide.md) and uses a guard script (scripts/render_guard.py) to ensure sensitive graph identifiers are filtered from user-facing reports. No evidence of malicious intent, unauthorized data exfiltration, or security vulnerabilities was found; the code and instructions are entirely consistent with the stated purpose of providing decision-support analysis.
Capability Tags
cryptorequires-oauth-tokenrequires-sensitive-credentials
Capability Assessment
Purpose & Capability
Name/description (Abel causal reads) line up with required items: a single ABEL_API_KEY and Python are reasonable prerequisites. The included scripts (cap_probe.py, render_guard.py) and SKILL.md workflow focus on probing Abel graph APIs and rendering results, which fits the stated purpose.
Instruction Scope
SKILL.md instructs the agent to run bundled Python probes, perform OAuth agent handoffs, run graph probes, perform web-grounding searches, and persist the retrieved API key to session state and a local file (.env.skill). These are within the declared scope, but the instructions explicitly tell the agent to read/write local env files and to run the included scripts — so installing the skill gives the agent the ability to execute Python code and read .env* files in the skill directory. The scripts also fall back to reading a same-directory .env file if .env.skill is missing.
Install Mechanism
No external install/downloads are declared. The skill is instruction-plus-scripts only (no remote installers). That reduces supply-chain risk; the only code executed is the bundled Python scripts included in the package.
Credentials
Only ABEL_API_KEY (primary credential) is required, which is appropriate. However, the probe script loads environment files (.env.skill, .env.skills, and as a fallback .env) and will set all parsed keys into os.environ. This means other secrets stored in a same-directory .env could be read into the running process if present; the skill does not require other unrelated credentials but will load them if they exist.
Persistence & Privilege
always:false and no cross-skill config changes are requested. The skill explicitly instructs agents to persist the acquired apiKey to session state and to <skill-root>/.env.skill when local storage is available. Persisting API keys locally is expected for continued live probes but is a sensitive action — it creates persistent credentials on disk in the skill directory.
How to Use
  1. Make sure OpenClaw is installed (local or Docker)
  2. Run the install command in chat: /install causal-abel
  3. After installation, invoke the skill by name or use /causal-abel
  4. Provide required inputs per the skill's parameter spec and get structured output
Version History
v1.1.6
causal-abel v1.1.6 - Strengthened authentication checks: now requires explicit verification via `cap_probe.py auth-status` and no longer infers authentication from environment variables alone. - Updated setup instructions: if `auth_source` is missing, stops and prompts user to initiate OAuth instead of substituting web search. - Improved node mapping: when using `extensions.abel.query_node` for fuzzy mapping, now inspects `node_kind` before proceeding and uses direct macro probes for `macro` nodes. - Clarified requirements for selecting surfaces and handling macro nodes, preventing forcing all found nodes into asset-based probes.
v1.1.3
Changed: Removed the `appendix`-as-default output shape from the source `causal-abel` guidance so the normal response now defaults to the main answer only unless the user explicitly asks for trace, evidence, debug, or reproducibility details.; Reworked rendering guidance from explicit `render_map` language to a lighter `label pass` flow, reducing the chance that internal rendering artifacts leak into visible prose.; Tightened source report rules so raw graph identifiers, raw proxy tickers, paths, prediction decimals, and process transcripts stay internal by default, with the normal answer explicitly avoiding debug-style headings and dumps.
v1.0.10
Changed: Removed `low-signal` wording from the source `causal-abel` planner and report guidance, replacing it with softer bridge-heavy / diffuse / non-explanatory phrasing so internal routing heuristics do not leak into user-facing language.; Refined direct-graph interpretation guidance so surprising drivers are explained via the security's own attributes before falling back to `weak` or `unresolved` wording.; Trimmed `causal-abel/agents/openai.yaml` back toward trigger and routing guidance so detailed execution rules stay in `SKILL.md` and route references.; Tightened the source `causal-abel` prompt so the core guidance is shorter and higher-leverage, with graph-first rules phrased as a small set of primary constraints.; Refined broad ticker-driver guidance so agents anchor to executable tickers, run Abel first, and interpret surprising parents as transmission channels before leaving the graph.; Tightened `causal-abel` prompt priority so direct graph answers now preserve graph facts first instead of replacing them with web-searched narratives.; Reframed Abel graph outputs as high-value PCMCI-style market-data evidence and added guidance for handling surprising drivers as serious transmission signals.; Narrowed direct-graph web grounding so driver lists, parent membership checks, and path facts are usually answered from graph output without forced search.; Updated the report and planner guidance so graph fact, interpretation, and optional web validation stay visibly separate when the graph output is unintuitive.; Reframed `causal-abel` so the default output shape is a compact report rather than a short verdict-only answer.; Updated the direct and proxy routes so executable anchors are observed first, preferring `extensions.abel.observe_predict_resolved_time` before deeper structural traversal.; Changed the planner and probe guidance so non-trivial comparative reads now default to one compact `intervene.do` pressure test after the mechanism is coherent.; Updated the report template so pressure-test coverage is expected by default in longer comparative analyses.
v1.0.2
Added: `references/search-loop.md` for edge-anchored search discipline in proxy-routed reads.; `references/layered-routing.md` for selecting layered proxy anchors and running convergence reads on broad questions. | Changed: Expanded the source and committed ClawHub skill instructions with `convergence_read`, stronger proxy/search guardrails, and clearer separation between graph facts, searched mechanisms, and inference.; Updated `question-routing.md`, `inversion-flow.md`, and `probe-usage.md` to support layered proxy routing, search-loop escalation, and convergence-first analysis for broad comparisons.; Updated `cap_probe.py` so `intervene-do` performs a required `graph.paths` gate before calling `intervene.do`, and added `--max-description-chars` for trimming verbose text fields in responses.; Refined first-use update wording so the skill prompts on version differences without depending on an in-prompt changelog summary.; Restored the repository changelog as the source of release notes for update and publish flows, while keeping the generated ClawHub artifact free of source-only update metadata.; Bumped the source skill and committed ClawHub artifact to version `1.0.2`.
v1.0.1
causal-abel 1.0.1 - Expanded and clarified usage guidance, including explicit authorization checks and API usage requirements. - Detailed new task classification and intent mapping steps for causal queries. - Added stepwise recommendations for node normalization, capability discovery, and decision workflow. - Strengthened guardrails around market-proxy routing and honest input mapping. - Outlined improved reporting, structural read prioritization, and layered answer formatting. - Updated triggers and exclusions to better focus on causal reasoning and avoid unrelated use cases.
Metadata
Slug causal-abel
Version 1.1.6
License MIT-0
All-time Installs 0
Active Installs 0
Total Versions 5
Frequently Asked Questions

What is Causal Abel?

Use when the user wants an Abel causal read on what drives a market, company, asset, sector, or macro node, how two nodes connect, what changes under interve... It is an AI Agent Skill for Claude Code / OpenClaw, with 222 downloads so far.

How do I install Causal Abel?

Run "/install causal-abel" in the OpenClaw or Claude Code chat to install it in one step — no extra setup required.

Is Causal Abel free?

Yes, Causal Abel is completely free, licensed under MIT-0. You can download, install and use it at no cost.

Which platforms does Causal Abel support?

Causal Abel is cross-platform and runs anywhere OpenClaw / Claude Code is available (cross-platform).

Who created Causal Abel?

It is built and maintained by ExenVitor (@exenvitor); the current version is v1.1.6.

💬 Comments