Liquidations shouldn't be a guess. CortexRails is an onchain policy layer returning deterministic ALLOW, LIMIT, REVIEW, or BLOCK decisions for financial actions before execution.
CortexRails Protocol is an onchain policy layer for tokenized-asset finance.
Financial protocols and autonomous agents increasingly need to make decisions before executing actions such as borrowing, withdrawing, transferring, or increasing leverage. Today, policy and execution are often tightly coupled inside individual applications — and liquidation thresholds in particular are usually implicit, buried in application code rather than enforced as an explicit, checkable rule.
That gap is real, not theoretical. A position entered on 2021-11-04 at $409.97 was liquidatable once TSLA fell to $327.98. It actually crossed that price on 2021-12-13 — 26 trading days later. Across 14 years of TSLA price history, 70% of entry points eventually crossed their liquidation trigger, with a median of 72 trading days and a fastest case of just 1 day. Every one of those crossings is a moment where a lending protocol needs a deterministic, enforceable answer — not a guess.
CortexRails separates policy from execution. An application or agent submits a structured financial intent. CortexRails evaluates the request against asset state, position state, risk parameters, lifecycle conditions, and action-specific rules, then returns a deterministic decision:
ALLOW — LIMIT — REVIEW — BLOCK
If an action exceeds its permitted amount, CortexRails returns the permitted amount rather than silently changing the request. The caller can then adjust and resubmit the intent before execution.
The architecture is:
Agent / Protocol → Intent → CortexRails Policy → Decision → Financial Adapter → Onchain Execution
CortexRails currently runs on Robinhood Chain testnet using Arbitrum Stylus/Rust and Solidity contracts. The deployment demonstrates policy-controlled interactions involving real tokenized TSLA and Paxos USDG, with adapters for lending (borrow/repay/deposit), vault withdrawals, transfers, and permissionless liquidation.
The system is designed as reusable infrastructure: applications can call the policy layer without having to rebuild the same risk and lifecycle decision logic inside every financial protocol.
Agents propose. CortexRails decides. Adapters execute.
During the hackathon, CortexRails evolved from an initial financial execution architecture into a reusable policy layer between financial intent and execution.
We implemented and deployed the core policy infrastructure using Arbitrum Stylus/Rust and Solidity, including PositionEngine, RiskEngine, the Policy and Registry contracts, and four financial adapters covering lending, vault withdrawals, transfers, and permissionless liquidation.
We deployed CortexRails to Robinhood Chain testnet and integrated real TSLA and Paxos USDG testnet assets. We implemented deterministic ALLOW, LIMIT, REVIEW and BLOCK decisions, lifecycle controls, risk-based borrowing capacity, action-specific policies, and an SDK/agent intent layer connecting structured intents to live onchain policy evaluation.
We also ran a 14-year historical backtest against real TSLA price data to validate the liquidation logic against actual market behavior rather than synthetic assumptions, confirming the deterministic trigger point algebraically and empirically.
The current MVP is backed by 66 passing Solidity contract tests and 33 passing SDK tests, and demonstrates live borrowing, withdrawal, transfer, and liquidation flows — showing how an agent can receive a policy decision, adjust an intent when limited, and proceed to onchain execution.
Pre-revenue / self-funded. Currently focused on product development and ecosystem validation.