CortexRails is the deterministic policy layer that decides whether a borrow, withdrawal, transfer, or liquidation is actually safe -- before it executes. Live on Robinhood Chain against real TSLA stock tokens and real USDG, with every liquidation threshold checked against 14 years of real price history, not assumptions.
Proven, not asserted
CortexRails' live risk formulas were run against 14 years of real TSLA price history (2010-2024) -- not a synthetic backtest, not a cherry-picked window.
The result is a provable, closed-form finding: at the testnet's live parameters, a full-capacity borrower becomes liquidatable the instant the asset falls exactly 20% below the price they borrowed at -- no more, no less. Full methodology and data in docs/ANALYSIS.md.
Autonomous agents
Autonomous agents can determine what they want to do. Financial protocols still need a deterministic boundary that decides what they are actually allowed to do.
CortexRails evaluates the requested action against the current asset, position, lifecycle, and policy state before execution.
No model sits in the decision path. The agent layer only translates units and enum names, and the authoritative answer is the onchain canExecute() result. Every adapter calls canExecute() again at execution time, so a stale or skipped evaluation can't bypass policy.
The policy primitive
Every consumer asks the same question through the same function. The same policy surface is called before different financial actions.
canExecute() is a view function. It never moves funds or enforces anything itself; the calling contract does both.
ILedgerLinePolicy
function canExecute(
uint256 assetId,
uint256 positionId,
Action action, // BORROW | WITHDRAW | TRANSFER | ...
uint256 amount // 18-decimal internal units
) external view returns (PolicyResponse memory);
struct PolicyResponse {
Decision decision; // ALLOW | LIMIT | REVIEW | BLOCK
uint256 permittedAmount; // the maximum permitted, never the request
bytes32 reason; // "OK", "EXCEEDS_CAPACITY", "RESTRICTED", ...
}A consumer enforcing it · LendingAdapter.borrow()
PolicyResponse memory response =
policy.canExecute(assetId, positionId, Action.BORROW, amount);
if (response.decision == Decision.BLOCK) revert PolicyBlocked(response.reason);
uint256 wouldOweTotal = debt[msg.sender] + amount;
if (wouldOweTotal > response.permittedAmount)
revert ExceedsPermittedAmount(wouldOweTotal, response.permittedAmount);Reuse
Three independent adapter contracts call the same, unmodified Registry, Stylus engines, and Policy. Adding WITHDRAW and then TRANSFER needed no change to the Registry or either engine, just one new Policy branch each.
CortexRails evaluates borrowing capacity and risk before a lending action executes: position value × collateral factor × risk adjustment, computed by the Stylus engines.
LedgerLineLendingAdapter
CortexRails evaluates lifecycle conditions before collateral leaves the vault. The adapter then applies debt safety: remaining capacity must still cover outstanding debt.
LedgerLineVaultAdapter
CortexRails evaluates lifecycle conditions before collateral changes owner. Ownership is reassigned in custody; no tokens move.
LedgerLineTransferAdapter
CortexRails evaluates whether a position's real, live debt has crossed the Stylus RiskEngine's maintenance threshold. Policy stays debt-agnostic by design -- the adapter supplies the borrower's actual debt from LendingAdapter as the request amount.
LedgerLineLiquidationAdapter
Decision model
The same state and the same request always produce the same response. LIMIT returns the maximum permitted amount, and CortexRails never quietly reduces the request. The caller decides whether to resubmit.
The action satisfies policy.
The requested amount exceeds the permitted amount. The response carries the maximum permitted.
Reserved in the Decision enum for a manual-review path. No policy branch returns it today.
The action violates policy, for example a non-ACTIVE lifecycle or zero capacity.
Same rules and reason codes as LedgerLinePolicy.canExecute() for BORROW, applied to an illustrative $200,000 position. The policy engine at /app reads the deployed contract live.
Policy inputs
A balance and a price are not the whole story. Tokenized assets carry lifecycle state that can change whether an action should execute at all.
Agent intent / policy evaluation
An illustrative $200,000 TSLA position under the testnet configuration (70% collateral factor, 80% risk adjustment) has $112,000 of borrowing capacity.
This walkthrough is illustrative. The policy engine at /app runs the same flow against the deployed contract with your connected wallet's real position.
“Borrow 120,000 USDG against TSLA.”
“Borrow 112,000 USDG.”
LendingAdapter.borrow() re-evaluates policy, checks existing debt, then transfers USDG.
Live deployment
Chain ID 46630. The current testnet deployment demonstrates CortexRails against the real TSLA Stock Token and USDG contracts, while policy state and reference pricing remain operator-configured in the test environment.
| Contract | Role | Address |
|---|---|---|
| LedgerLineRegistry | State store | 0x8850…907c ↗ |
| LedgerLinePolicy | canExecute() | 0xD6EC…5460 ↗ |
| PositionEngine | Stylus (Rust/WASM) | 0xde83…Ff0F ↗ |
| RiskEngine | Stylus (Rust/WASM) · isLiquidatable() | 0x1024…C2bc ↗ |
| LedgerLineLendingAdapter | BORROW/repay()/liquidate() consumer | 0x5e55…560d ↗ |
| LedgerLineVaultAdapter | WITHDRAW consumer | 0x4E94…9C43 ↗ |
| LedgerLineTransferAdapter | TRANSFER consumer | 0x32D4…D4f1 ↗ |
| LedgerLineLiquidationAdapter | LIQUIDATE consumer | 0xB24A…a97d ↗ |
| RobinhoodStockTokenAdapter | Asset adapter · not wired into Registry | 0x3A1B…dfb9 ↗ |
| TSLA Stock Token | Collateral · 18 decimals | 0xC9f9…Bd4E ↗ |
| USDG | Borrow asset · 6 decimals | 0x7E95…802F ↗ |
Every address above has live bytecode on Robinhood Chain testnet. Block numbers, deploy transactions, and the VaultAdapter redeploy history are in DEPLOYMENTS.md.
Architecture
The Registry holds state. Two stateless Stylus contracts compute position value and capacity. Policy turns that into a decision. Adapters custody funds and enforce the decision. The agent layer sits outside this deterministic core.
Developers
Applications and autonomous agents can submit structured action intents to CortexRails and receive the authoritative policy result before execution.
Intent → SDK → CortexRails Policy → Decision
Solidity consumers call canExecute() directly. Offchain code uses @ledgerline/core, a typed viem client in this repo's sdk/ directory. It is not yet published to npm.
TypeScript · sdk/src/agent.ts
import { LedgerLineClient, evaluateAgentIntent, suggestRetryIntent } from "@ledgerline/core";
const client = new LedgerLineClient({ rpcUrl }); // defaults to the testnet deployment
const intent = {
asset: "TSLA",
positionId: agentWallet, // address or raw positionId
action: "BORROW", // "BORROW" | "WITHDRAW" | "TRANSFER"
amount: "120000", // human units; the SDK scales to 18 decimals
};
const result = await evaluateAgentIntent(client, intent);
// e.g. { decision: "LIMIT", permittedAmount: "112000", reason: "EXCEEDS_CAPACITY", raw, ... }
const retry = suggestRetryIntent(intent, result); // amount = permittedAmount, only on LIMITAgents propose. CortexRails decides. Adapters execute.