ChainCapital Documentation

ChainCapital is an autonomous AI capital manager built natively for Robinhood Chain. Instead of trading yourself, you deposit into a vault and a pipeline of AI models handles market analysis, risk validation, position sizing, execution, and rebalancing on your behalf, continuously.

How vaults are structured, how risk is enforced, how strategies are built and shared, and how to integrate with ChainCapital programmatically through the SDK.

Everything in ChainCapital is composed from three primitives. Understanding how they relate makes the rest of the docs click into place.

A vault always has exactly one strategy and one risk profile at a time. Changing either is a configuration update on the vault — capital never has to move to switch strategies.

Every market signal a vault acts on passes through the same six-stage pipeline, in order. No stage can be skipped, and a rejection at any stage stops the idea before capital is touched.

A vault is a single on-chain account with one strategy and one risk profile. When you deposit, your capital is pooled with the vault's existing AUM and sized into positions according to the vault's current allocation — you are never trading against other depositors, you are participating in the same book.

• →Deposits and withdrawals are processed on Robinhood Chain and reflected in the vault's AUM in real time.
• →Every vault exposes a live status: Scanning Markets, Risk Analysis, Executed, or Optimized — the same states shown in the homepage demo.
• →Performance is tracked per-vault, not per-depositor pool, so returns are transparent and auditable against the vault's trade log.

The Risk Engine is the only stage in the pipeline that can veto a trade outright. It enforces four limits — drawdown, leverage, volatility tolerance, and rebalance cadence — read from whichever profile the vault is configured with.

Positions drift from target allocation as prices move. The Portfolio Optimizer runs on the interval defined by the vault's risk profile and trims or adds to positions to bring the vault back to its target exposure — without waiting for a new signal from the strategy.

Every rebalance still passes back through the Risk Engine. A rebalance that would push the vault outside its drawdown or leverage ceiling is resized automatically rather than rejected outright, since rebalancing is a risk-reducing action by default.

The Strategy Marketplace lists strategies built on top of the ChainCapital SDK, ranked by live, on-chain performance rather than backtests. Copying a strategy creates a new vault configured with that strategy and a risk profile you choose — the original strategy's capital is never touched.

The SDK is how strategies published in the Strategy Marketplace, and vaults created programmatically, talk to ChainCapital. Install it and create a vault by pairing a strategy with a risk profile.

01npm install @chaincapital/sdk

01import { ChainCapital } from "@chaincapital/sdk";
02 
03const vault = await ChainCapital.createVault({
04  strategy: "momentum",
05  risk: "balanced",
06});
07 
08await vault.execute();

01await vault.deposit({ amount: 50_000, asset: "USDC" });
02 
03const status = await vault.getStatus();
04// { state: 'Scanning Markets', aum: 1_250_000, todaysReturn: 0.0342 }
05 
06await vault.withdraw({ amount: 10_000, asset: "USDC" });

01vault.on("trade", (trade) => {
02  console.log(trade.symbol, trade.side, trade.size);
03});
04 
05vault.on("blocked", (reason) => {
06  // Risk Engine rejected a setup before execution
07  console.log(reason);
08});

ChainCapital separates signal generation from capital custody. Strategies never hold funds directly — they submit trade ideas to a vault, and only the vault's Risk Engine and execution layer are permitted to move capital on Robinhood Chain.

• →Strategy layer — stateless signal generation, published to the Strategy Marketplace or run privately via the SDK.
• →Vault layer — holds capital, applies the risk profile, and is the only component that authorizes execution.
• →Chain layer — Robinhood Chain settlement, where deposits, withdrawals, and trades are recorded against the vault address.

The Risk Engine is not an advisory layer — it is a hard gate. A strategy can propose any trade it wants, but execution only happens if the trade clears the vault's drawdown, leverage, liquidity, and exposure checks. There is no override path that lets a strategy bypass the vault's risk profile.

Every deposit, withdrawal, trade, and rejection is recorded on Robinhood Chain against the vault address, so a vault's history is independently verifiable rather than reported by ChainCapital alone.

More guides and the full API reference are on the way.