Atrium — Cross-Venue Portfolio Margin for the EVM

One deposit. Every venue. One unified buying-power number, computed and enforced on-chain.

Materials

Please start with the Notion judge brief. It is the complete Atrium dossier and contains the full product explanation, buildathon progress, architecture, deployments, verification links, proof materials, and judge-facing context in one place.

The Notion brief is the main source of truth for judges. It includes everything needed to understand, verify, and evaluate Atrium properly.

The Problem

On-chain trading is still capital-fragmented.

Today, every venue margins collateral in isolation. A trader with positions across Hyperliquid, Aave, Pendle, and other venues often has to post full collateral separately in each place, even when those positions hedge each other and the true portfolio risk is much lower than the gross exposure.

Traditional finance solved this decades ago through prime brokerage and portfolio margin. Crypto has never had an equivalent on-chain layer because full portfolio risk computation is too expensive to run inside a normal smart contract.

The Product

Atrium is the on-chain prime-brokerage layer for EVM markets.

Users deposit collateral once into an ERC-4626 vault, and that collateral backs positions across every connected venue as one unified book. Instead of treating each venue separately, Atrium calculates portfolio risk across the full account and produces a single margin requirement.

At the core is Plinth, a SPAN-style scenario risk engine written in Rust and deployed on Arbitrum Stylus. Plinth revalues the full portfolio per block, nets offsetting exposure, and computes the required margin on-chain.

In the live worked example, a hedged book requires 51% less collateral than the same positions margined in isolation.

Stylus is the unlock. It allows Atrium to run this kind of computation at a fraction of Solidity’s cost, which is exactly why this has not been shipped on-chain before.

Delegation Without Trust

Atrium also treats AI agents as first-class users, but without giving them unchecked control.

A user signs one EIP-712 mandate that defines:

• Per-action cap

• Total cap

• Expiry

• Venue allowlist

Every agent action is validated directly by the contract.

An in-scope trade executes.
An over-cap trade reverts with NotionalExceeded.
Any action after revocation reverts with MandateRevoked.

Revocation is a single transaction.

The agent never custodies user funds and never receives authority beyond the signed scope. The full lifecycle is recorded on-chain.

Engineering You Can Verify

Atrium is built to be verifiable, not just described.

• The same Rust margin engine runs on-chain, is checked by a Kani formal proof of the core netting invariant, and is mirrored line-for-line in a TypeScript parity port that powers the interface. The chain, the prover, and the UI all share one definition of margin.

• The full stack is deployed on two testnets: Arbitrum Sepolia and Robinhood Chain. Solidity contracts are verified on Sourcify.

• 792 tests pass across the Rust, Solidity, and TypeScript layers.

• Proof of reserves is handled through a signed Merkle attestation published on-chain. Anyone can build an inclusion proof for a balance directly in the browser.

• Every flow shown in the product is backed by a transaction hash, a live RPC read, or a file in the repository. Where data is pending, the product clearly says pending.

Honest Scope

Atrium is live on testnet today.

There are no real funds involved, and every current limitation is clearly labeled inside the product instead of being hidden behind polished language.

Today, one venue, Aave V3, is fillable end to end through an Atrium mock. This is intentional. Most real venues are not deployed on public testnets, so there is no live testnet venue to fill against. Instead of faking execution, Atrium proves the full open-to-close path on one venue and clearly labels the remaining venues as deployed but scaffolded.

The core protocol is still real on-chain, even on testnet:

• The margin engine runs on-chain.

• The vault handles deposits and withdrawals.

• Agent mandates are enforced by contracts.

• Proof of reserves is attested and verifiable.

The mainnet path is direct and practical, not speculative. Six of the nine target venues are native to Arbitrum One and can become real adapters without a bridge: Aave V3, GMX, Curve, Pendle, Morpho, and Synthetix V3.

On mainnet, the mock Aave pool becomes the live Aave V3 pool, and the mock price feed becomes the real Chainlink feed.

The remaining three venues connect cross-chain:

• Hyperliquid through validator attestation

• Polymarket through Chainlink CCIP

• Trade.xyz through the same attestation path as Hyperliquid

Atrium is honest about where it is today and clear about how it reaches production. The testnet version proves the core system: unified margin, vault custody, contract-enforced agent limits, and verifiable reserves.

Full mainnet plan: https://useatrium.me/docs/mainnet

Progress During the Buildathon

During the buildathon, Atrium evolved from a margin-engine concept into a fully deployed, end-to-end verifiable product running on two testnets.

The work covered the contract layer, margin engine, off-chain infrastructure, product interface, agent enforcement system, proof-of-reserves flow, QA process, and judge-facing verification materials.

Contracts and Margin Engine

We shipped Plinth, a SPAN-style scenario risk engine written in Rust and deployed on Arbitrum Stylus. To fit the 24 KB activation cap, the engine was split across Plinth, Plinth-Math, and Plinth-Oracle.

We also built and deployed the surrounding contract stack:

• Coffer — ERC-4626 vault

• AtriumRouter — single-transaction orchestration

• Sigil — EIP-712 agent mandates

• Vigil — liquidation keeper

• Lantern — proof of reserves

• Aqueduct — Chainlink CCIP integration

• Portico — nine venue adapters

The full stack was deployed on both Arbitrum Sepolia and Robinhood Chain testnet, with every Solidity contract verified on Sourcify.

Provability

We proved the core netting invariant in Kani: a hedged book should never require more margin than the sum of its isolated legs.

The same Rust margin engine was also ported line-for-line into TypeScript, so the on-chain contract, the formal proof system, and the UI all share one definition of margin.

We also drove and recorded real on-chain transactions for the key product flows:

• Money path: approve, deposit, open, withdraw

• Agent lifecycle: in-scope action allowed, over-cap action blocked, kill switch, post-revoke action blocked

This means the core claims are not just described. They are backed by live transactions and reproducible proof artifacts.

Product and Infrastructure

We built the full product surface, including:

• Landing page

• Authenticated app

• Onboarding

• Vault

• Trade

• Reserves

• Agents

• Architecture page

• Self-verifying proof deck

• Pitch deck

• Brand Kit

Every screen was wired to real on-chain reads, with honest pending states, empty states, SIWE per-user authentication, and per-surface chain guards.

We also deployed supporting infrastructure, including a self-hosted indexer to reduce third-party dependency, an x402-payable read API through Codex, and the on-chain proof-of-reserves attestor through Lantern.

Quality and Judge Materials

We ran a full real-wallet QA sweep across every page, state, and viewport. Bugs were fixed and re-tested on the live site.

Across the Rust, Solidity, and TypeScript layers, 792 tests pass.

We also produced the full judge dossier:

• Notion judge brief

• Self-verifying proof deck

• Recorded demo video

• Recorded pitch video

Final Result

By the end of the buildathon, Atrium was no longer just a concept. It became a deployed, testable, and verifiable cross-venue portfolio margin system for the EVM.

Every major milestone is backed by a transaction hash, a live RPC read, or a file in the open-source repository.

Nothing is claimed without a way to verify it.

Bootstrapped. Three founders, $0 outside capital, testnet-first by choice.

We have not raised and are not currently running a round; the focus is shipping a provable testnet product and turning it into a real company out of the buildathon. Open to conversations with aligned partners and grant programs.