Priime documentation

You hold a strategy. What you do not hold is the company that every other route makes you build first. This page is your path through the docs.

Your problem

You build the infrastructure and you run it every hour. The entity and its bill come before the first dollar of deposits. Outside a firm, your record reads as one anyone could forge, and the shortcut on offer is a seeder who takes the economics.

Our answer

The infrastructure comes built. You configure modules, and the Trustless Execution Network runs the strategy every block. The emergency call stays yours. You test the strategy before you pay for any structure, and your record starts at the vault's first block, under your own address.

Read next

1. The canvas and Priime Copilot: how a composition is made.
2. Backtesting: what you learn before a dollar moves.
3. Funding-rate carry: the anatomy every template follows.
4. Fees and builder economics: the one fee and what you earn.
5. Builder risk and responsibility: where our guarantees end and yours begin.

Your next step

Take an invite-only cohort seat. Compose and backtest a first strategy at build.priime.finance, invite two peers after your first backtest, then give a written intent to publish. It is withdrawable and tied to no split.

You already hold the trade, by hand or through a manager's vault. This page shows what changes when the same trade runs on Priime.

Your problem

A desk running its own loop is its only check. A holder in a curated vault sees positions and caps, never the computation behind each move. The assets are transparent; the decisions are not. When your approver asks where decisions are made, which plans were stopped and what a key can do, the answer is one line: trust us.

Our answer

A second check, onchain. Every plan is re-run by the operator quorum and its signatures are checked before it settles. Every executed plan and every refused plan is readable without asking us. Your approver's three questions have answers you can fetch. Nothing settles unchecked.

Read next

1. Verifiable execution: what the chain checks before a plan settles.
2. What Priime is not: custody, pooling and advice, ruled out.
3. The risk catalog: the eight signals a vault watches on your behalf.
4. Market and leverage risk: what automation reduces and what it does not.
5. Deploying: the vault your users receive: what a Priime vault is, as an object.

Your next step

Read the trade you already hold against the record of refused plans, starting at priime.finance/ecosystem. Then ask us the question your own vault cannot answer. A desk with an invitation can commit in writing to hold a cohort vault, with no amount named.

You fund builders and you run a treasury, and both are read in public. This page is the order in which Priime arrives for a foundation.

Your problem

Your grants line meets the company before the strategy: the builders you could fund face that company first, and what ships runs on servers the chain cannot read. Your council is asked for a number before there is a record. Every treasury move is read onchain and defended on a public forum.

Our answer

An invite-only builder cohort that composes and backtests on Priime Build, with chain integration and custom modules built for your chain. A record before the number: one program vault on our capital at contained size. Nothing of yours goes onchain. Every step is reversible. Then a treasury your council defends from a record: a collar on the native token that earns premium above a floor, and T-bill or USDC floors for the stables.

Read next

1. Act on every chain: compute once, act on your chain.
2. Modules as building blocks: custom modules for your chain's venues.
3. The incubation zone: how a record is earned at contained size.
4. Priime Standing and builder cohorts: the cohort your program fills.
5. Tokenized T-bill floor: the floor under a treasury's stables.

Your next step

A record only grows from its first block, so the sooner a program starts, the sooner your council has one. Book a scoping call with the founder at antoni@priime.finance; the program doc follows, and your foundation chooses who fills the cohort seats.

You structure products and you answer to a committee. This page is how a desk composes on Priime without building execution.

Your problem

Execution the committee cannot inspect. Either you build the execution in house, paid for before the first product exists, or you hand the decision to a manager and keep the accountability while giving away the decision.

Our answer

Execution the committee can inspect, down to the plans the vault's own rules refused. Structuring without building the execution: a new product is a new arrangement of modules. The decision stays in rules your desk writes, read by the committee before anything goes live.

Read next

1. The modules in depth: every module's decision, one by one.
2. Tokenized T-bill floor and Invent your own: a floor, then a collar composed end to end.
3. How Priime differs: the five architectures a committee already knows, and the one weakness of each.
4. Builder risk and responsibility: what the desk owns.
5. Smart contract and oracle risk: the dependencies your committee will ask about.

Your next step

A workshop where your team composes and backtests one product with us, with no capital and nothing priced. Send a workshop date, the named team and your approved venue and asset list to antoni@priime.finance. The workshop ends in a one-page scope with a kill clause on both sides, and no desk wallet touches the vault.

You list vaults, and every listing is a review. This page is what a Priime vault changes about that review.

Your problem

Review by hand, with every new vault waiting on a reviewer. Logic a review cannot read. A check on a schedule, so a listed vault that goes wrong is caught after the fact. Reputation does not scale. Verification does.

Our answer

Review from the chain. Each listing criterion maps to the onchain field that answers it, or is marked not onchain, and the listing decision stays yours. The logic is code a review can read. The check runs against the record, block by block, between your reviews.

Read next

1. The Trustless Execution Network: what produces the record.
2. Verifiable execution: what is checked before settlement.
3. Deploying: the vault your users receive: the ERC-4626 object you list.
4. Graduation and scale: how a vault arrives on your platform with its record.
5. The Fetch, Compute, Act loop: the check between your reviews.

Your next step

The code and the record are public and readable without asking. Run the automated review first on a Priime vault, and keep every listing your decision. Write to antoni@priime.finance to map your criteria to the record.

Priime is the venue where onchain structured financial products, vaults, are created, tested, incubated, and grown. At its base runs the Trustless Execution Network: it fetches any data, onchain and offchain, computes every strategy at block time, and acts on any chain, every action verified before it settles, fully automated.

Traditional finance was automated in the 1980s. DeFi is only catching up now. Priime brings that automation forward by being proactive instead of punitive: it acts before a liquidation rather than after, preventing problems rather than penalizing you for them.

The Trustless Execution Network

At the base sits the network, the execution layer every vault runs on. Its flow is simple: fetch, compute, act. It runs every block, watching dependencies and risk signals, then acting on your position only when the situation calls for it, and every action is verified before it settles.

On top of the network are composable Priime Modules, the building blocks every vault is composed from. The shelf is one Liquidity source, which sets the venue and market a lane works in, and nine modules that each automate one decision: Dynamic leverage, Dynamic hedge, Auto center, Covered call, Protective put, Redemption route, Auto-compound, Exogenous risk and Carry floor. A vault holds one lane or several, and the capital router moves capital between them. A delta-neutral LP and a leveraged loop, our own vaults, were composed by the Priime team on Priime Build itself, through the same canvas, backtest, and incubation flow every builder gets.

Priime Build

Priime Build is where vaults are made. Compose Priime Modules on the Build canvas, or let Priime Copilot draft the composition. Backtest against history, incubate on real capital at contained size, and scale a vault that proves itself. One flow: Compose, Test, Incubate, Scale.

The principles

• Verifiable: every action is verified.
• Non-custodial: your keys, your vault.
• Block-time: it acts at chain cadence, fully automated.
• Open: the code is open and the execution is auditable.

Priime is not a custodian, not a pooled vehicle, and not investment advice. It is a venue for verifiable automation: automation built to reduce risk, not a guarantee against it.

Priime automates DeFi at block time, but automation does not mean you hand over control. It helps to be precise about what Priime is, and what it deliberately is not.

• Not a custodian. Priime never takes possession of your assets. Your keys and your vault stay yours. The Trustless Execution Network acts on your position, it does not hold it.
• Not a pooled vehicle in the managed sense. No manager exercises discretion over your deposit. A vault's strategy is declared as a composition of modules and runs as code, verified by the operator quorum every block. Neither Priime nor the builder ever holds user funds.
• Not investment advice. Priime executes the strategy you choose. It does not tell you what to buy, when to enter, or how much to allocate. Those decisions are yours.
• Not single-chain. The same verifiable stack settles across EVM, SVM, and MOVE families. Priime is built to be multi-chain, not locked to one network.
• Not a black box. Every action the network takes is verifiable, and the code is open. You can check what ran, why, and what it did.
• Not a closed product suite. Priime is a venue. Anyone can compose and launch a vault on Priime Build, and Priime's own vaults compete on the same field, under the same fees, against the same public record.

This matters because it sets the trust boundary. Automation reduces the work and the reaction time, but it does not move the risk onto a third party or hide the logic from you.

Automation lowers risk, it does not remove it. Priime acts to prevent problems before they cascade, but no strategy is free of risk.

Most DeFi today is punitive. When a market moves against you, the system reacts after the fact: a liquidation fires, collateral is seized, and you absorb the loss. The rules are enforced on you, not for you.

Priime starts from a different premise. Traditional finance moved to automated, proactive execution decades ago, in the 1980s. DeFi is only now catching up. Priime brings that same proactive automation onchain, at block time, so the system can act before a problem lands instead of penalizing you once it already has.

Concretely, that means acting ahead of a liquidation rather than after it. A Priime Module runs a Fetch, Compute, Act loop at chain cadence. It fetches external dependencies and risk signals, computes a deterministic decision about your exposure, and acts on your positions only when needed. The rest of the time, it holds.

The shift is from reactive enforcement to continuous, verifiable prevention:

• Punitive DeFi waits for failure, then charges you for it.
• Proactive DeFi evaluates risk every block and adjusts when it needs to.

This loop is not a feature of one product: every vault launched on Priime, Priime's own and every builder's, runs on it, executed and verified by the Trustless Execution Network.

Proactive automation reduces risk. It does not remove it. Priime is non-custodial and verifiable: your keys, your vault, with execution you can check.

Priime is built on a small set of principles that hold for every vault launched on the venue, Priime's own and every builder's, on every chain. They are the platform, not options a builder configures. They constrain how the Trustless Execution Network fetches data, computes strategy, and acts, with every action verified before it settles, and they define what you can verify about any action taken on your behalf.

• Verifiable. Every action the network takes is verified. Computation runs at block time and produces a result you (or anyone) can check, rather than a result you have to trust.
• Quorum-verified. No single party decides an outcome alone. An operator quorum re-executes every decision to identical results before anything settles.
• Non-custodial. Your keys, your vault. Priime acts on your position, but it never takes custody of your assets.
• Block-time. Modules run a Fetch, Compute, Act loop at chain cadence. They fetch dependencies and risk signals each block and act only when needed, otherwise they hold. One pick per tick.
• Fully automated. Strategy is computed and settled by the network, not by a discretionary operator deciding case by case.
• Open code. Execution is open and inspectable. Priime is not a black box.

These principles describe how Priime behaves, not a guarantee of returns. Automation here is built to reduce risk and act before problems compound, not to remove risk entirely.

The Trustless Execution Network is the compute base every vault on the venue runs on: Priime's own vaults and every vault launched on Priime Build execute on the same rails. It monitors every block and, when something needs to change, does three things in order: fetch, compute, act. Every action passes the onchain verifier before it settles, and each pass is marked 0xVERIFY, so what it did and why is verifiable after the fact. Each operator runs a Priime Processor, the node software of the network; the network is the quorum of them.

Traditional finance automated this loop in the 1980s. DeFi is only catching up now. The network closes that gap by moving from punitive to proactive: it can act before a liquidation rather than punish you after one. It is fully automated.

The loop

The network executes the modules' Fetch, Compute, Act cycle at chain cadence. It fetches external dependencies and risk signals, computes a deterministic decision about your exposure, then acts on the vault's position only when something needs to change. Otherwise it holds. One pick per tick.

• Fetch: pull the market, offchain, and multichain state the strategy needs.
• Compute: run the strategy deterministically, with no compute limits, off the contract; the operator quorum re-executes every decision to identical results.
• Act: act only through the onchain verifier, which settles the result onchain, verifiably. Nothing settles unverified.

Because the heavy work happens offchain and settles on every chain, strategies are not constrained by what fits in a contract. Because every action is verifiable and the code is open, you can check the work rather than trust it.

The network decides and settles. It never holds your funds: your keys, your vault. Automation here is built to reduce risk, not remove it.

Every Priime Module runs the same loop at block time: Fetch, Compute, Act. The loop runs on the Trustless Execution Network, so it re-evaluates each block and acts only when the position needs it. The rest of the time, it holds.

The loop

A module moves through three stages on every tick:

• Fetch. The module fetches external dependencies and risk signals: market state, offchain data, and state on other chains. This is the sensing stage: spot prices, oracle feeds, funding rates, venue state, and the position itself.
• Compute. The module computes its exposure from what it fetched. The computation is deterministic: it compares the current state against the strategy's targets and decides whether anything is off and, if so, what the single best response would be, and the operator quorum re-executes the same computation to identical results.
• Act. If a response is warranted, the module acts through the onchain verifier, and one action settles on the position. Nothing settles unverified. If nothing needs changing, it does nothing and waits for the next block.

One pick per tick

A module commits to at most one action per block. It picks the most useful move given current conditions, executes it, then fetches fresh state on the next tick. This keeps behavior legible and avoids stacking conflicting changes within a single block.

Holding is a valid outcome. Most ticks end with no action, which is the point: the module acts before a problem grows, not after, and stays quiet when the position is already on target.

Because the loop runs at chain cadence fully automated, and because each step is verifiable, you can audit not just what a module did but why it chose to act when it did. This loop is also the contract of the Priime Build canvas: every module you compose there, core or custom, runs exactly this cycle.

Modules are the composable building blocks shared across every vault on the venue. Each one sits on top of the Trustless Execution Network and runs a Fetch, Compute, Act loop at block time: it fetches external dependencies and risk signals, computes a deterministic decision about your exposure, then acts on the position only when needed. When nothing requires action, it holds. One pick per tick.

Think of modules as DeFi lego on the Build canvas. The same pieces compose differently in each vault: the delta-neutral LP and the leveraged loop are compositions of these modules, built on the same canvas every builder uses.

The shelf

One liquidity source and nine modules, each one a decision the vault automates.

• Liquidity source: which venue and market a lane works in: a lending market, a perp book, a liquidity pool or a treasury issuer.
• Dynamic leverage: holds the loop at its target leverage, one action per check: add a layer, trim, or unwind before the liquidation band.
• Dynamic hedge: keeps net delta at zero and the short funded.
• Auto center: recenters a concentrated range when price walks out of it.
• Covered call: writes calls above spot and rolls them.
• Protective put: holds puts below spot, funded by the calls, so the position has a floor.
• Redemption route: turns a treasury position back into cash by one of the routes its issuer publishes, and counts the days the capital waits.
• Auto-compound: sweeps earned yield back into the position once it clears a threshold.
• Exogenous risk: watches every party a lane depends on (oracles, venues, bridges, stablecoins, perp books and RPCs) as one stack, and de-risks the moment one degrades.
• Carry floor: reads the lane's own net carry at each market reading and, when it sits under your floor for long enough, trims back to the band or leaves for the loan asset.

Two more pieces sit beside the shelf. The capital router moves capital between a vault's lanes, inside a published concentration cap. It drains a lane whose carry dries up; any other move runs only when it is expected to earn more than it costs. On a funding lane, the perp market, basis engine and funding guard pick the book, hold spot long against the short at equal notional, and exit when funding stays under its floor.

Priime maintains the core set, and builders author custom modules against the same Fetch, Compute, Act contract on Priime Build.

Modules are proactive by design. They are built to act before a problem (for example, ahead of a liquidation rather than after it), which reduces risk but does not remove it.

Every module action runs through the network, so what a module did, and why, is verified and reproducible at block cadence.

Every action the Trustless Execution Network takes, for Priime's own vaults and for every vault launched on Priime Build, is verified, and it happens at the cadence of the chain itself. It is fully automated, with no hidden logic deciding how. The network fetches data, computes the strategy, and acts, with the result verified and settled onchain, and each of those steps leaves a record you can check.

This is what we mean by verifiable execution. The network runs every block, following the same fetch -> compute -> act flow each time, and nothing settles unverified. Because it operates at block time, Priime can act before a problem becomes a loss, for example rebalancing a position before it reaches liquidation rather than recovering from one after the fact.

Verifiable execution rests on a few properties that hold for every action:

• Verified: the inputs, the computation, and the settlement are all checkable, not asserted.
• Block-time: strategies are re-evaluated at chain cadence, so the position reflects current conditions.
• Fully automated: execution is automated end to end; no single party, not Priime, not a builder, not any one operator, decides an outcome alone.
• Quorum-verified: a registered operator set re-runs the same deterministic computation, and settlement proceeds only on k of n identical signed results. Every pass is marked 0xVERIFY.
• Open code: the logic that runs is published, so you can read exactly what executes.

This is the difference between proactive and punitive automation. Acting at block time lets the system prevent problems instead of reacting to them once damage is already done.

This record is also what the venue is built on: a vault's backtest tear sheet, its incubation record, and its live history are all read from the same verifiable execution trail.

Most automation lives where it executes. Priime separates the two: the Trustless Execution Network computes your strategy in one place, then settles the result on whichever chain holds your position. Compute once, act anywhere.

The flow is always the same. The network fetches onchain and offchain data, runs the strategy at block time, and produces an action. The action goes out through the onchain verifier (fetch -> compute -> act), and settlement targets the chain where the action needs to land. Your logic does not change when the venue does.

This is what makes Priime multi-chain rather than multi-deployment. The same modules and the same vaults sit on top of one verifiable base, and that base reaches across three execution families:

• EVM: ETH, BASE, UNI, BNB, OP, HL, INK.
• SVM: SOL.
• MOVE: APT.

Because compute is unified, a strategy that fetches a risk signal from one chain can act on a position held on another without you stitching anything together. One verifiable stack, every chain.

This is also what every builder inherits on Priime Build: compose a strategy once, and its vault settles (and, after graduation, distributes) wherever its venues live.

Settlement does not change Priime's properties. Wherever an action lands, it remains verifiable, non-custodial, and produced fully automated.

Five architectures run vaults today, and each does something well. Each also has one weakness, and it is the same one in different clothes: nobody outside can re-check a decision before it settles. This table says what each gets right first, then the weakness, then what changes on Priime.

Every vault on Priime starts as a composition of Priime Modules, and a template is a composition the Priime team maintains: a proven wiring of modules and defaults you can deploy as it stands, reparameterize, or fork on the Priime Build canvas. This chapter walks the shelf one template per section, each through the same anatomy: what it is and who it is for, how it works, the modules it composes, where the yield comes from, and the risks. The last section covers the strategy that is not on the shelf: inventing your own.

What it is and who it is for

The delta-neutral LP template provides concentrated liquidity and hedges the price exposure out. Fees in, price hedged. It is the first template the Priime team built on the venue: composed on the Build canvas and run through the same backtest and incubation flow every builder gets. Our own vault, built from it, runs on ETH/USDC on Base mainnet on our capital, with its record published against its tear sheet.

It is built for depositors who want the fee income of a liquidity position without an open bet on price direction, and for builders who want a maintained delta-neutral LP as the base of a fork: the same pair on another venue, another pair, or tighter bands.

How it works

The template combines two legs to capture trading fees without a directional bet. The liquidity leg provides concentrated LP on a DEX, collecting a share of swap fees while price trades inside the position's range; our own vault provides this liquidity on Aerodrome. The hedge leg, a borrow or short sized to that same exposure, cancels the price move; our own vault carries it on Aave. What you keep is the fee income, net of the cost of carrying the hedge.

A passive concentrated position has a known flaw. Fees accrue only while price sits inside the range, and price moving against the liquidity produces impermanent loss that quietly eats those fees. The template answers both with active management at block time. Three numbers govern the position, read onchain at chain cadence: the range, the price band the liquidity is concentrated into (narrower bands collect more fee per dollar but need recentering more often); the net delta, liquidity exposure minus the hedge, held near zero; and the fee income, the engine of the return, net of borrow cost and slippage.

The modules it composes

Three modules from the core library work the position the liquidity source holds, each reading live state on its own cadence and acting only when an action is warranted. None trade discretionarily or move funds outside your position, and every action is quorum-signed through Priime's verifiable execution. One pick per tick.

• Auto center keeps the liquidity centered on price. Inside the range it holds; as price drifts toward an edge and fees thin, it recenters the band so the position keeps accruing. A maintenance band keeps ordinary intraday movement from triggering needless rebalances.
• Dynamic hedge holds net directional exposure near zero. Concentrated liquidity drifts long or short as price moves, and impermanent loss is what that drift costs. The module sizes an offsetting short against the live position, resizes it as price and balances change, and settles accrued funding so accounting stays clean.
• Auto-compound claims accrued fees and folds them back into the position, so what the pool earns compounds rather than sitting idle.

The position lifecycle

A position moves through three phases, each leaving observable state you can read directly. Opening: you deposit USDC, the system provisions the concentrated liquidity around the current price and opens the offsetting hedge sized so price moves net to roughly zero, and both legs are established together. Holding: there is nothing to do; fees accrue block by block, the modules keep the position centered, hedged, and compounded, and the dashboard reads chain state directly, showing current value, net delta, the split across the legs, and the last action taken. Withdrawing: a partial withdrawal unwinds a proportional share of both legs and leaves the rest hedged and centered as before; a full withdrawal closes both legs and settles back to USDC in your wallet. Custody stays with you throughout.

Where the yield comes from

The vault collects from one source and pays for three. The source is concentrated LP trading fees: liquidity in a tight band around the current price collects far more fee per dollar than a passive full-range position, and it scales with how much the pool trades. The costs are the hedge (a borrow rate or perpetual funding, moving day to day), rebalancing friction (swap slippage and gas, kept low by acting only when warranted), and the venue's published fee (the 20% compute fee every vault pays on its growth after costs). Impermanent loss does not appear as a separate line: it is the drift the hedge is sized to offset. When price moves, the loss on the liquidity is met by the gain on the short, and the other way around. What survives is the fees, net of the hedge.

The published reference: +13.3% modeled net return on ETH/USDC over a 14-month out-of-sample backtest. Modeled, not realized. Our own vault runs the composition on Base mainnet on our capital, and its record is published against the tear sheet, so realized can be checked against modeled.

Risks

Delta-neutral means neutral at the moment of each rebalance, not immune to risk. Between actions the hedge ratio drifts, so the position can be briefly directional, and a hedged position can still show non-zero PnL day to day. A fast market is the sharpest exposure: a single-block move can outrun a rebalance even at block-time cadence, and the same move can push price outside the active range, where fees stop until the position is recentered. The hedge carries a cost that can move against the position, and funding can turn negative for sustained periods; the structural choice is to hold the hedge rather than un-hedge into greater directional risk. The venues the template integrates add their own exposures: slippage on every rebalance swap, oracle feeds Priime does not run, and smart-contract risk across the DEX, the lending venue, and the vault's own contracts.

Capital deployed in a delta-neutral LP vault is at risk and can be partially or totally lost. Concentrated liquidity can still incur impermanent loss, delta-neutral hedging reduces but does not remove risk, and outcomes are not guaranteed. This documentation is informational only and is not investment advice.

Your keys, your vault. The template is non-custodial and self-directed: you retain control of your assets at all times, you can exit at any time, and the execution logic is open code.

The funding-rate carry template holds an asset long in spot and shorts the same notional on a perpetual venue. The price legs cancel, and what remains is the funding the short collects. The funding is the yield.

What it is and who it is for

It is a template on the shelf: compose it on the Build canvas, backtest it, and carry it through the same incubation flow as any strategy. It is built for neutral funds, prop desks, and yield-bearing stablecoin designs: anyone who wants a market-neutral rate harvested from perpetual markets rather than from lending.

How it works

Perpetual futures charge funding between longs and shorts to keep the perp price pinned to spot. When the market leans long, shorts are paid to take the other side. The template captures that payment without price exposure: buy the asset in spot, short the same size in the perp, hold both legs. A move up gains on spot what it loses on the short, a move down does the reverse, and the funding accrues either way.

Funding differs by venue and moves constantly, so the template is multi-venue by design. A capital router splits the deposit across the perp venues the composition is wired to and weights each by its funding and measured depth, inside per-venue caps. Two numbers govern the position, read at block cadence: the hedge ratio, short notional over spot value, held near 1.0; and the net funding rate, what the shorts collect across venues after fees.

The modules it composes

Every lane seats the same four modules, one perp book per lane, and the capital router sits across the lanes.

• Perp market pins the perp venue and market the lane's basis position runs on.
• Basis engine holds spot long against the perp short at equal notional and collects the funding. It keeps the short sized against the spot leg as prices and balances move.
• Funding guard closes the short and parks in spot when funding sits under the lane's floor for its window, so a negative regime stops compounding. By default the floor is −20% and the window 48 hours, and the guard re-arms after 24 hours at or above zero: insurance against a long negative stretch, not a source of yield.
• Auto-compound sweeps earned funding back into the position.
• Capital router weights the lanes by each book's funding and measured depth, inside a published concentration cap, and drains a lane whose funding stays under its floor.

Where the yield comes from

One source, three costs. The source is the funding the shorts collect. The costs are fees and slippage on entries and rebalances across both legs, the margin that sits against the shorts instead of earning, and the venue's published fee, the same one every vault on Priime Build pays. There is no lending leg and no emission: the return is what perpetual markets pay to be long, captured by holding the other side. No modeled figure is published for this template. When one is, it will carry the same label every Priime number carries: modeled, not realized.

Risks

Funding is the yield, and funding flips. It can turn negative for sustained periods, especially in down markets, and a negative regime turns the carry into a cost until the router rotates or the position winds down. The perpetual venues are themselves a dependency: a venue pause, a liquidation engine under stress, or a mark price diverging from spot can hurt a position that is neutral on paper. And the trade has capacity limits: funding compresses as more capital crowds the same side, so a rate observed at small size does not scale without bound.

Funding rates are variable and can be negative for sustained periods. Venue, oracle, and smart-contract risk apply to both legs, outcomes are not guaranteed, and deposited capital is at risk. This documentation is informational only and is not investment advice.

The leveraged loop template multiplies a lending yield. Supply a yield-bearing asset to a lending market, borrow against it, re-supply the borrow, and repeat until the position reaches its target leverage. Supply, borrow, repeat.

What it is and who it is for

A delta-neutral variant adds an offsetting hedge so the amplified yield comes without amplified price exposure. The template is built for yield funds and DAO treasuries: holders of a productive asset who want more of its yield per dollar of capital, with the liquidation defense automated rather than watched by hand.

How it works

The loop is a recursive position on one lending market. The collateral earns the supply yield, the borrow against it costs the borrow rate, and each pass re-supplies the borrow so the collateral, and the yield it earns, compounds to a multiple of the deposit. The target loan-to-value sets the multiple: looping at an LTV near 0.60 compounds to roughly 2.5x effective leverage.

One number governs safety: the health factor, collateral value times the market's liquidation threshold, divided by debt. Below 1.0 the lending market lets anyone liquidate the position. The template holds a deliberate cushion above that line and defends it in tiers. The standard preset trims 0.07 health factor below the opening band. The absolute numbers come from the market: at a 94.5% liquidation threshold and 2.75x, the lane opens at 1.49 and trims at 1.42. The emergency tier sits a second gap lower, never below 1.10, and restores target in a single block with a larger swap, the last automated line above liquidation. If the health factor drifts up instead, because the collateral yielded or the market moved favorably, the loop levers back up opportunistically without crossing the standard line.

The deleverage cascade is atomic by design. Each move is one operation, unwind, swap, and repay together, with the minimum-out embedded so a bad fill reverts and retries next block, and successive moves are rate-limited to avoid oscillation. A deleverage that would pass through an unhealthy intermediate state cannot be expressed.

The modules it composes

• Dynamic leverage runs the loop. It watches the health factor continuously, extends or trims the borrow toward target, and owns both deleverage tiers.
• Dynamic hedge runs the neutral variant. It sizes an offsetting short against the collateral's price exposure and holds the hedge ratio inside its band as the loop grows.
• Auto-compound keeps the yield working: when earned yield loosens the health factor, the leverage module pulls it back to target, so returns compound instead of idling.

Custody

The template ships with an owner-bound custody model. Each depositor receives a personal smart account whose owner is pinned to their wallet at deployment, with the address derived deterministically, so it is known before the contract exists and cannot be front-run. The looped collateral lives inside that account. The operator quorum can perform only the bounded actions the composition declares, borrow, repay, and rebalance, and it can never move funds to itself or to any recipient you did not set. There is no shared pool, and Priime never takes custody.

Where the yield comes from

The net figure is roughly the supply yield times leverage, minus the borrow rate times leverage minus one, minus slippage on rebalances, then minus the compute fee on what is left. Both rates are variable and set by the lending market, so the spread that makes a loop attractive at open can compress or invert. The hedged variant adds perpetual funding on the short, positive or negative, scaled by the hedge ratio. No modeled figure is published for this template. When one is, it will be labeled like every Priime number: modeled, not realized.

Risks

Liquidation is the sharp edge, and it is governed by the lending market, not by Priime. The bands reduce the probability of liquidation, not its consequence. A single-block move on the collateral oracle, a liquidity event that reverts the deleverage swap, or an interruption in execution can defeat them, and below 1.0 anyone can seize part of the collateral at a penalty. The second edge is rate inversion: the borrow rate can rise above the supply yield, turning the carry negative while the position unwinds in bounded steps rather than instantly. Leverage amplifies both edges, and the hedged variant adds funding and hedge-venue risk on top of them.

Leverage amplifies losses as well as gains, and capital deployed in a leveraged loop can be partially or totally lost. Delta-neutral hedging reduces but does not remove risk, liquidation is enforced by the lending market, and outcomes are not guaranteed. This documentation is informational only and is not investment advice.

The hedged staking carry template holds a liquid staking token and shorts its perp for the same notional. The price legs cancel. What remains is the staking yield the token pays plus the funding the short collects, both in dollars, with no borrow.

What it is and who it is for

It is a template on the shelf: open it prebuilt at build.priime.finance/?template=hedged-staking-carry, or compose it yourself, backtest it, and carry it through the same incubation flow as any strategy. It is built for funds, and for treasuries holding ETH, HYPE or LINK that want yield without selling.

How it works

The template opens on wstETH held in spot, with an ETH perp short against it. wstETH pays staking yield as it accrues in the token. The short collects funding when the market leans long. Because the position holds the token rather than borrowing against it, there is no health factor to watch: the only leg that can be liquidated is the short, and it is sized to the spot it hedges. The same composition holds kHYPE against a HYPE perp or stLINK against a LINK perp.

The modules it composes

• Liquidity source picks the market: the staked token in spot and the perp book it is shorted on.
• Dynamic hedge keeps the short matched to the staked position as prices and balances move, and keeps the short's margin funded.
• Auto-compound sweeps collected funding back into the position once it clears a threshold.

Where the yield comes from

Two sources, two costs. The sources are the staking yield inside the token and the funding the short collects. The costs are the margin that sits against the short instead of earning, and fees and slippage on entries and rebalances, plus the venue's published fee, the same 20% of growth after costs that every vault pays. No modeled figure is published for this template. When one is, it carries the same label every Priime number carries: modeled, not realized.

Risks

Funding flips. In a down market shorts can pay instead of collect, and for as long as that lasts the funding leg is a cost against the staking yield. The perp venue is a dependency: a pause, a mark price diverging from spot, or thin book depth can hurt a position that is neutral on paper. The staked token has its own price against the asset it wraps, and that spread can move. Capacity is bounded by the perp book, not by the staking token.

The tokenized T-bill floor holds a tokenized US Treasury fund at the rate its issuer publishes, with the route back to cash built in, and it is the lane every other lane on a vault can retreat to.

What it is and who it is for

Open it prebuilt at build.priime.finance/?template=tbill-floor, compose it yourself, or fork it into a ladder. It is built for DAO treasuries, stablecoin reserves and fund cash, capital that wants a T-bill rate onchain and a published way out.

How it works

The template opens on BUIDL, the largest tokenized Treasury fund. The position earns the fund's own rate. It accrues in the NAV. There is nothing to harvest, so no compounding module is seated. The issuer publishes its redemption routes. The template opens on the fastest one, BUIDL's Circle USDC contract. It settles in zero days. The same lane holds USYC, OUSG, USDY or USTB, each at its issuer's published rate and routes.

The modules it composes

• Liquidity source picks the issuer and the fund.
• Redemption route turns the position back into cash by one of the routes the issuer publishes, and counts the days the capital waits on each.

Beside other lanes

The floor earns its keep beside a lane that can fail. That is its job. Put a loop, an LP or a basis carry beside a T-bill floor, and the capital router drains a lane that dries up toward the floor; any other move runs only when it is expected to earn more than it costs, each issuer's settlement wait counted as an exit cost. Several T-bill funds and USDC under one router make a treasury ladder. A collar on the native token beside a T-bill floor for the stables is the treasury pack.

Where the yield comes from

One source: the fund's published rate, which is a T-bill rate net of the issuer's fees. The venue's fee is the same 20% of growth after costs that every vault pays. The issuer publishes the rate. Nobody guarantees it. It moves with the bills the fund holds.

Risks

The issuer is the dependency. Each fund publishes minimums, eligibility rules and redemption windows, and a route that settles in days is a route that waits in a stress. A single-issuer lane carries that issuer's operational risk whole, which is what a ladder across issuers is for. The token's price against the dollar is the fund's NAV, not a market, and it depends on the issuer reporting it.

The shelf is where the templates end, not where the canvas does. Seven templates ship on the canvas today, and each one opens prebuilt from its own link, with its lane and its modules already wired; the landing page links four of them. Priime Build composes any strategy the modules can express, and the flow for a strategy of your own is the same flow every template went through. This section walks it in order, then composes one strategy end to end: a treasury collar.

The flow

• Pick a source. Every strategy starts where the capital works: a liquidity pool, a lending market, a perp venue, or a combination. The source defines what the position holds and which venues the composition must watch.
• Drag modules onto the canvas. Each module does one narrow job: one signal watched, one class of action. Auto center watches price against a range and recenters. Dynamic hedge watches net delta and resizes a hedge. Dynamic leverage watches the health factor and trims or extends. If no core module expresses the job, author a custom one against the same Fetch, Compute, Act contract.
• Set the guards. Exogenous risk bounds the world the position depends on: oracles, venues, bridges, funding. Carry floor unwinds a lane before its own carry turns against it. A composition that manages leverage without an exit path will not validate.
• Backtest. Carry the frozen composition forward from the review sheet and read what it models over the horizon you set. Modeled, not realized.
• Launch small. Deploy into the incubation zone, where the vault earns its record on real capital at contained size, published against the tear sheet.
• Scale. A vault that proves itself graduates, and distributes as a standard vault wherever vaults are permissionless and composable.

A worked example: the treasury collar

The treasury collar is the cleanest walkthrough of how a new composition comes together, because nothing in it is exotic. Every piece is a module doing one job.

The situation: a DAO holds most of its treasury in its own token. It wants downside protection without selling the token and without handing the treasury to a desk. Custody kept, a floor under the value, and some income along the way. Covered calls plus a floor: a collar.

The composition, step by step:

• Source. The treasury token, held in the DAO's own vault, wired to an onchain options venue. The tokens never leave the DAO's custody; the venue sees only the option legs.
• Income leg. A covered-call module writes calls above the current price. One signal: spot against the strike distance. One action class: write a call, or roll it as expiry and price move. The premium it collects is the income.
• Floor leg. A put module spends part of that premium on puts below the current price. Same shape: one signal, spot against the floor; one action class, buy or roll the put. If the token falls through the floor, the puts pay.
• Auto-compound is seated with nothing to compound: the premium pays for the upside sold.
• Guards. The calls are written against the treasury position itself, so they stay covered. Exogenous risk watches the options venue and the oracle it marks against, and can hold the rolls when a dependency degrades.

Then the same flow as every template. Run the collar forward from the review sheet and read what it models. Incubate with a small slice of the treasury while the record accumulates. Scale the share as the record holds. At no point does custody move, and every roll settles quorum-verified like any other action on the venue.

The strikes, the floor, and the roll cadence are parameters on the canvas, not code. A treasury that wants a higher floor pays more premium for it; one that wants more income writes closer calls. The trade-off is explicit and inspectable before a single option is written.

A collar caps upside as well as protecting downside: tokens can be called away at the strike, and the floor holds only to the extent the options venue performs. Options venues carry their own liquidity, oracle, and smart-contract risk, outcomes are not guaranteed, and capital is at risk. This documentation is informational only and is not investment advice.

Priime Build is the venue where anyone turns a strategy idea into a live, verifiable vault. One flow carries it from idea to distributed product: Compose, Test, Incubate, Scale.

The problem it solves is structural. Smart contracts are perfect settlement machines and terrible operators: not reactive, compute-limited. So vault logic today runs offchain, in the dark, and launching a vault is expensive, legally heavy, and drifting toward centralized black boxes. Priime Build collapses that cost into one flow: compose a strategy, prove it, and ship it as a vault.

The flow

• Compose. Drag Priime Modules onto the Build canvas and connect them into a strategy, or describe what you want to Priime Copilot and let it compose the first draft.
• Test. Run the integrated backtest on the frozen candidate the review priced, and see what your composition carries forward, before it touches capital.
• Incubate. Deploy into the incubation zone, where early depositors seed the vault in exchange for future royalties.
• Scale. A vault that succeeds graduates, then distributes as a standard vault wherever vaults are permissionless and composable.

Two primitives make this possible, and both are covered in Core concepts. The Trustless Execution Network runs fetch, compute, act every block, each pass verified before it settles and marked 0xVERIFY. Priime Modules run Fetch, Compute, Act at block time and act only when needed. There is no keeper to run, no oracle node to operate, no bundler to trust: you compose the strategy, and the network executes and verifies it.

This is not a hypothetical pipeline. The live delta-neutral LP vault was built on the same rails: +13.3% modeled net return on ETH/USDC over a 14-month out-of-sample backtest, live on Base. Modeled, not realized.

Every vault launched on Priime Build is non-custodial and executes on the same quorum-verified network as Priime's own vaults. Not a black box.

The Priime Build canvas is where a strategy takes shape. It is a visual surface: you drag Priime Modules onto it, connect them, and set their parameters until they form a complete vault strategy. Nothing on the canvas is code you write. Everything on it is a module you configure.

The result is a composition: a set of modules wired to one position, each running its own Fetch, Compute, Act loop at block time. The Trustless Execution Network executes the composition every block and settles at most one action per pass. One pick per tick, and holding is a valid outcome.

Two ways to compose

By hand: pull modules from the library, wire them to the position, and set targets, bands, and thresholds yourself. Or by prompt: describe the strategy you want and Priime Copilot drafts the composition for you.

Copilot improves with every strategy composed on the platform: each composition is training data. It proposes a composition you can inspect and edit module by module. It never deploys anything on its own. A Copilot draft reaches the review sheet, the backtest and the incubation zone the same way a hand-built one does, and carries the same modeled label.

What the canvas validates

• Compatibility: every module must support the chosen venue and asset pair.
• Bounds: every parameter must sit inside the range its module declares.
• Completeness: a strategy that manages leverage must carry an exit path.

Because modules carry their own bounds and compatibility rules, whole classes of authoring errors, unbounded sizing or missing exit coverage, cannot be expressed on the canvas at all.

The canvas is a design surface. Nothing on it touches capital until you deploy.

A composition that validates is not a composition that profits. Validation checks shape. The backtest checks behavior.

Everything on the canvas is a Priime Module: a composable single unit of automation that runs Fetch, Compute, Act at block time and acts only when needed. Each does one narrow job well. Connect them and you get a strategy.

The shelf

Priime builds and maintains the shelf: one liquidity source and nine modules. Core concepts and Architecture cover each in depth.

• Liquidity source: which venue and market a lane works in: a lending market, a perp book, a liquidity pool or a treasury issuer.
• Dynamic leverage: holds the loop at its target leverage, one action per check: add a layer, trim, or unwind before the liquidation band.
• Dynamic hedge: keeps net delta at zero and the short funded.
• Auto center: recenters a concentrated range when price walks out of it.
• Covered call: writes calls above spot and rolls them.
• Protective put: holds puts below spot, funded by the calls, so the position has a floor.
• Redemption route: turns a treasury position back into cash by one of the routes its issuer publishes, and counts the days the capital waits.
• Auto-compound: sweeps earned yield back into the position once it clears a threshold.
• Exogenous risk: watches every party a lane depends on (oracles, venues, bridges, stablecoins, perp books and RPCs) as one stack, and de-risks the moment one degrades.
• Carry floor: reads the lane's own net carry at each market reading and, when it sits under your floor for long enough, trims back to the band or leaves for the loan asset.

A vault holds one lane or several, and the capital router moves capital between them inside a published concentration cap: it drains a lane whose carry dries up, and makes any other move only when it is expected to earn more than it costs.

Determinism

Modules are deterministic. The same inputs produce the same signed output on every operator in the quorum, which lets the aggregator demand k of n identical results before anything settles. Extending Priime means writing logic that the operator quorum re-runs and cross-checks, not deploying a new trusted contract; the onchain settlement surface stays small and fixed.

Custom modules

Builders author new modules against the same Fetch, Compute, Act contract. A custom module declares what it fetches, what it may conclude, and the single action class it may emit. It runs inside the Trustless Execution Network's verification envelope like a core module, every pass marked 0xVERIFY. A custom module can stay private to your strategies; when the module marketplace opens, publishing lets others fork and compose with it, and royalties flow back to you. The creator economy section covers the economics.

Modules act, they do not custody. Capital moves only into the positions the composition declares, and no person, Priime or builder, can take custody of it.

A module automates a policy, it does not guarantee the policy is right. Automation reduces risk, it does not remove it.

Before a strategy touches capital, it can be carried forward. The integrated backtest on Priime Build opens from the review sheet on the same frozen candidate the review priced: same block, same published number, nothing re-scanned on the way in.

The methodology

The methodology is public, and so is its limit. Every leg of a composed lane names what it stands on: a supply or borrow leg is one read at the frozen block, and a funding leg is a set of window statistics that carry no timestamps. A run whose legs carry no measured series is labeled on the page in those words, path model, not a replay. Costs are itemized as (positive) and (negative) line items: fees earned, funding paid or received, borrow cost, slippage, and the compute fee. Every number carries the same label: modeled, not realized.

What the run prints

The run prints its agreement with the review sheet to the basis point, modeled value over the horizon you set on the deposit you set, and a band only where two measured rates exist to draw one. What it cannot earn it does not print: the statistics a path model may not produce are named on the page and left empty.

The published reference sets the bar. ETH/USDC ran at +13.3% modeled net return over fourteen months out-of-sample. Modeled, not realized. The delta-neutral LP vault runs live on Base, so you can make the comparison yourself. The methodology ran on Priime's own vault before it was offered to you.

What it does not model

• Liquidity at size: the frozen read is the market that existed at that block, not the market absorbing your deposit.
• Venue outages: a venue that was up at the frozen block can pause tomorrow.
• Future regimes: a rate carried forward is the rate that was read, not the rate that will hold.

The backtest is an option, not a gate: it runs from the review sheet, and a vault enters the incubation zone with or without it.

A backtest is a hypothesis, not a promise. Outcomes are not guaranteed, and capital is at risk.

Deploying from the canvas mints a real vault. Not a simulation, not a listing: a live product that accepts deposits and executes at block time. Every vault launched on Priime Build ships with the same guarantees as Priime's own vaults, yours included. The guarantees are the platform, not options the builder configures.

What your depositors get

• Non-custodial deposits. Your keys, your vault. The builder configures the strategy. The builder never holds user funds.
• Quorum-verified execution. The Trustless Execution Network runs the strategy: a registered weighted operator set re-runs the same deterministic logic, and the aggregator proceeds only on a quorum of identical signed results, k of n signatures. No single party can move a position alone. Not Priime, and not you.
• Verifiable execution. Every fetch, compute, act pass is verified and marked 0xVERIFY. Verified, every block.
• Open composition. Depositors can inspect which modules run the vault and with what parameters. Not a black box.

What the builder controls

You set the strategy, the parameters, and the metadata. You cannot withdraw user funds, cannot bypass the quorum, and cannot execute an action the composition does not declare. A compromised builder key is bounded the same way: it cannot take custody of funds, bypass the quorum, or act outside the composition's declared bounds, and parameter changes within bounds are visible on the verifiable record.

Deployment order

Run the backtest. Review the composition and its declared action surface. Deploy. The vault enters the incubation zone, covered in the next section. Settlement follows the strategy: compose once, settle where your venues live, across EVM, SVM, and MOVE. One verifiable stack, every chain.

Vaults on Priime Build are non-custodial. Depositors hold their own keys, and neither Priime nor the builder can take custody of user funds.

Deploying a vault makes you accountable to depositors for the strategy's design. The network guarantees faithful execution, not good judgment.

A freshly deployed vault does not launch to the world. It launches to the incubation zone, a proving ground where a strategy earns its track record on real capital at contained size. Deployment proves the vault runs. Incubation proves the strategy works.

Incubation exists because a backtest is modeled and live performance is realized. The zone is where the two are compared in public: the vault's live behavior is published against its tear sheet, block by block, for anyone to check.

Early depositors take the most risk on an unproven strategy, so they are compensated for it. Seeders earn a share of the vault's future royalties. Seeding is a position in the strategy's success, not just its yield.

What the zone measures

• Realized performance: live results measured against the modeled tear sheet.
• Drawdown behavior: how deep, how long, and how it recovered.
• Action quality: whether each module acted when its rules said it should.
• Retention: whether depositors stay as the record accumulates.

The outcomes are honest. A vault that performs graduates. A vault that does not stays in the zone or winds down, and the record stays public either way. Incubation is a filter, and the filter is the point.

Builders do not watch from a private console. You observe every module decision through the same verifiable record your depositors see, and you tune parameters within the composition's declared bounds. A material strategy change restarts the test.

The incubation zone caps blast radius while evidence accumulates: contained size, public record, honest exits. Trust is earned on the record, not claimed.

Incubating vaults are the highest-risk stage of the vault lifecycle. The strategy is unproven and outcomes are not guaranteed. Deposit only what you can afford to lose.

A vault that succeeds in incubation graduates. Graduation changes the vault's job: it stops proving itself and starts scaling, from a contained position in the incubation zone to a distributed financial product.

What graduation means

Three things happen at graduation. The incubation record closes and is published permanently: every action, every settlement, every 0xVERIFY mark, kept with the vault for as long as it exists. Deposit caps lift. And the vault becomes eligible for composable distribution.

Composable distribution

A graduated vault is a standard, verifiable, non-custodial vault. That is the whole distribution strategy. Distribution follows the standard: everywhere vaults are permissionless and composable, a graduated vault can be integrated and composed directly. On curated platforms such as Morpho and Euler, the vault's public record makes its case. Distribution is a property of the standard, not a business-development pipeline.

What scale means

• For the builder: more deposits compound the royalty stream and raise your Priime Standing. A graduated vault is the asset that keeps paying.
• For depositors: the vault carries its full incubation history, modeled tear sheet next to realized record, so allocation decisions rest on evidence, not a pitch.

Distribution is multi-chain by construction. One strategy, settled and distributed across EVM, SVM, and MOVE venues.

Graduated vaults are the flagship inventory of the venue. Priime's own vaults compete on the same field, under the same fees, against the same public record.

Graduation is evidence of past performance under contained conditions. It is not a rating, and it is not an endorsement of future returns.

Scale changes a strategy's own economics: capacity, slippage, and funding all move with size. Past performance does not guarantee future results.

Priime Build is also a creator economy. Priime builds and runs the core modules today; the module marketplace opens them to builders next. When it opens, builders publish modules and strategies, others fork and compose with them, and royalties flow back to the author.

What the marketplace will list

The module marketplace will list two kinds of artifacts: published Priime Modules and published strategies. Each listing will carry its author, its version history, its verification record, and its adoption: how many strategies compose with it, and how much capital those strategies run. You will evaluate a module the way depositors evaluate a vault, on the record.

Forks and lineage

Any published module or strategy will be forkable. A fork is a new artifact with its own record, but the lineage is preserved and the provenance is public. Credit follows the chain back to origin, and so does cash flow.

Royalties and bounties

Royalties are the earnings engine. Builders will collect royalties on their own strategies' vaults and on forks of their modules. Incubation seeders hold a share of future royalties, so the people who built, extended, and first backed a strategy all sit on the same side. Royalties are paid from a share of the venue's fee flow on the vaults that use the work. The fee schedule is published in the builder economics section.

Contribute is the paid on-ramp. Priime will post bounties for new modules, new strategies, and new chain and venue integrations, priced and public. It is how a builder earns revenue before they have a hit strategy.

The module marketplace, royalty flows, and bounties are planned mechanics of the platform, not shipped today. Publishing will be optional: private modules stay private, and nothing you compose is listed unless you list it.

Royalty income depends on adoption and on the fee-bearing performance of downstream vaults. It is variable, and it can be zero.

Reputation on Priime Build is earned on the record, not claimed. Priime Standing is the leaderboard that will rank builders by what their work has actually done. Builders rank by depositors served and forks that earn. Extenders rank by adoption and economic weight. Not follower counts, not the volume of publications: the metric is capital that chose your work and stayed.

What Standing will affect

• Placement: where your modules and vaults surface in the module marketplace and the incubation zone.
• Rank: your position on a cohort leaderboard and your eligibility for its prizes.
• Weight: how much your track record counts when depositors and platforms evaluate a new vault you launch.

Every input to Standing is measurable on the verifiable record. None of it can be bought with an audience.

Builder cohorts

Cohorts are the front door. Priime will run one-month incubation competitions with partner chain foundations. Each program brings a custom chain integration and custom modules, a worldwide builder competition on Priime Build, and a public leaderboard, and the foundation seeds the top vaults.

The goal is stated plainly: builders who come for a competition and stay to earn, bootstrapping strategies, filling bounties, collecting royalties on their work.

The social graph

Further out, stated as such: profiles and reputation scores for users, vaults, and the cash flows between them. Trust earned on the record, not claimed.

The canvas, Priime Copilot, and the backtest are the platform today. Priime Standing, builder cohorts, and the social graph are the launch sequence: planned mechanics, stated as plans. Read this section accordingly.

Priime charges one fee on every vault the venue executes, Priime's own vaults included. It is published here, and the venue earns it only when a vault grows past its previous high.

The schedule

• Compute fee: 20% of the vault's growth after costs, taken only above its previous high. This pays for what the Trustless Execution Network does: every operator in the quorum re-running your strategy every block, fetch, compute, act. Every cost the vault pays comes off first, so the fee is a share of what is left. It is taken once, on the vault as a whole. After a loss, the vault makes it back before any fee is taken again: that previous high is its high-water mark. A vault that earns nothing pays nothing.

That is the whole schedule. There is no deposit fee. No management fee on idle capital, nothing on principal, and no hidden spread.

Builder earnings

Royalties, described in the marketplace section, will be paid out of this same fee stream. Builder earnings and venue revenue rise and fall together with realized strategy performance. The alignment is plumbing, not a slogan: everything the venue and its builders earn from a vault, the compute fee and every royalty drawn from it, is paid only when depositors earn. There is no exception.

The itemized record

Every vault itemizes the economics of a depositor's yield in its record: gross yield (positive), funding or borrow (positive or negative), slippage (negative), compute fee (negative). Each line is visible. Nothing is netted away before you see it.

The schedule is uniform and public. There are no negotiated rates and no per-vault fee configuration. What this page says is what every vault pays.

The fee pays the venue for execution. It is not a performance promise.

The fee reduces net returns. All published yields are modeled net of the fee unless stated otherwise.

Priime verifies execution. You own the strategy. Everything in this chapter exists to make what your vault does verifiable. None of it makes what your vault does wise. This section states where the platform's guarantees end and where your responsibility begins.

What the Trustless Execution Network guarantees

• Declared execution. Your composition runs exactly as declared, every block, and nothing else.
• Quorum settlement. Every action is re-computed by the operator quorum and settles only on k of n identical signed results.
• Verification. Every pass is marked 0xVERIFY.
• No override. No one, including you, can make the vault do something the composition does not declare.

What it does not guarantee

• That the strategy is profitable, or that the backtest regime persists.
• That the venues, oracles, and bridges your strategy depends on keep behaving. The risk catalog's eight signals watch them, they do not prevent them.
• That depositors are protected from the strategy's own design.

Your obligations

• Represent honestly. Tear sheets are generated by the platform and cannot be edited. Framing and naming are yours.
• Parameterize deliberately. Risk module defaults are starting points, not decisions.
• Monitor incubation. Watch live behavior against the backtest.
• Wind down responsibly. When a strategy stops working, exit cleanly. The public record reflects how you exit as well as how you launch.

Before you deploy, understand what your depositors still carry. Market and leverage risk: leverage amplifies losses as well as gains. Delta-neutral is approximate, not exact. Smart contract and venue risk. And the exogenous dependencies no module controls. Risk management and Risk disclosure cover each in depth.

Priime Build is not a custodian, not a pooled vehicle, and not investment advice. Your vault is your product. Publishing it may carry legal obligations in your jurisdiction, and those are yours to assess.

Automation reduces risk, it does not remove it. Outcomes are not guaranteed, and capital is at risk. This documentation is informational only and is not investment advice.

Priime is one system read top to bottom: vaults sit on modules, modules sit on the Trustless Execution Network, and the network settles to any chain. Each layer is composable, so a vault is just a composition of modules wired to the same verifiable base.

At the bottom, the base tier, is the Trustless Execution Network, the compute base every vault shares. It runs a single flow, fetch then compute then act, only when something needs to change. It pulls any data (onchain and offchain), computes with no limits, and acts through the onchain verifier, settling onchain fully automated, each action quorum-signed by the operator set: k of n identical results before anything settles.

Above the network are the modules, the composable building blocks. Each module runs a Fetch, Compute, Act loop at block time: it fetches risk signals and external dependencies, computes a deterministic decision about your exposure, then acts on the vaults only when needed (otherwise it holds, one pick per tick). The core modules include:

• Exogenous risk: watches dependencies like oracles, venues, and bridges.
• Dynamic leverage: manages borrow and position leverage.
• Dynamic hedge: keeps exposure delta-neutral.
• Carry floor: unwinds a lane before its own carry turns against it.

At the top are the vaults, composed on the Priime Build canvas. The delta-neutral LP and the leveraged loop are the first: built by the Priime team on the same Compose, Test, Incubate, Scale flow every builder gets. Every vault settles across the EVM, SVM, and MOVE families behind one interface.

One verifiable stack, every chain. Same network, same modules, every vault: Priime's own and any builder's.

Modules are the composable building blocks that sit between a vault's strategy and the Trustless Execution Network. Each one runs a Fetch, Compute, Act loop at block time: it watches its domain, computes exposure, and acts on the position only when an action is actually warranted. One pick per tick. The shelf is one liquidity source and nine modules.

Liquidity source

The liquidity source sets which venue and market a lane works in: a lending market, a perp book, a liquidity pool, or a treasury issuer. Every other module on the lane acts on the position that source holds.

Exogenous risk

Exogenous risk watches the dependencies your position relies on but does not control. It tracks signals like stablecoin depeg, oracle divergence between DEX spot and feed, partner pauses, escrow freezes, backing gaps, and partner contract upgrades. When a dependency degrades, it can move the position toward safety before the problem reaches you.

Dynamic leverage

Dynamic leverage manages borrowed exposure. It re-evaluates the health factor every block and rebalances when leverage drifts away from target, keeping the position inside its intended band rather than reacting after a threshold is breached.

Dynamic hedge

Dynamic hedge keeps a position delta-neutral. It measures directional exposure each block and adjusts the offsetting hedge so the strategy captures yield without taking an unintended price bet.

Auto center

Auto center recenters a concentrated liquidity range when price walks out of it, so the position keeps earning fees instead of sitting outside the band it was opened in.

Covered call

Covered call writes call options above spot and rolls them as expiry and price move. The premium it collects is the income leg of a collar.

Protective put

Protective put holds puts below spot, funded by the calls, so the position has a floor under it without the holder selling the asset.

Redemption route

Redemption route turns a treasury position back into cash by one of the routes its issuer publishes, and counts the days the capital waits before that cash arrives.

Auto-compound

Auto-compound sweeps earned yield back into the position once it clears a threshold, so what a lane earns works rather than sitting idle.

Carry floor

Carry floor reads the lane's own net carry at each market reading and acts when it sits under your floor for long enough, either trimming back to the band or leaving for the loan asset. By default it waits for 7 readings under 0%: insurance against a spread that has closed, not a source of yield.

Beside the shelf sits the capital router, which moves capital between a vault's lanes inside a published concentration cap. It drains a lane whose carry dries up; any other move runs only when it is expected to earn more than it costs. Endogenous risk, the position's own leverage drift, hedge off-ratio and funding flips, is a risk category rather than a module on the shelf; the risk chapter covers it. Builders author custom modules against the same Fetch, Compute, Act contract on Priime Build: a custom module declares what it fetches, what it may conclude, and the single action class it may emit, and runs inside the same verification envelope as the shelf.

Because modules are shared, the same risk logic backs every vault on the venue: our own vaults and any composition launched from the Priime Build canvas. Every action a module takes is verifiable and runs fully automated.

Every Priime Module runs the same control loop at block time: Fetch, Compute, Act. This is how risk management stays proactive instead of punitive. The module watches for trouble continuously, but it only touches your position when something actually needs to change. The loop is identical for every vault on the venue: Priime's own vaults and any composition launched from Priime Build, core modules and custom ones alike.

Fetch. The module fetches its external dependencies and risk signals every block. That means market state, offchain data, and state across chains together: oracle feeds against DEX spot, venue health, funding rates, slippage, bridge and compute latency, and the position's own leverage.

Compute. The module computes a deterministic decision from that snapshot against your current exposure: whether the position is still within bounds, and if not, which single response best reduces risk right now. The Trustless Execution Network recomputes this from scratch each block, and the operator quorum re-executes the same computation to identical results, so the decision always reflects live conditions.

Act. When the computation calls for it, the module executes one action on the vault's position through the onchain verifier and settles it onchain. Nothing settles unverified. The principle is one pick per tick: at most one change per block, the one that matters most. When nothing needs to change, the module holds.

Acting only when needed keeps the loop calm under normal conditions and decisive under stress. Because every action is settled onchain and verifiable, you can audit what the module did and why. Block-time response is one layer of risk management. For every vault launched on Priime Build, the lifecycle adds another: the backtest before a strategy touches capital, contained size in the incubation zone, and a public record throughout.

Block-time automation reduces risk but does not remove it. Markets, oracles, and venues can move faster than any response, and acting early limits exposure rather than eliminating loss.

An Exogenous risk module, part of the core set any builder can drop onto the Priime Build canvas, watches the world your position depends on. It runs the fetch stage of the loop at block time, tracking eight external signals that can move against you, then hands what it sees to the compute step so the module can act before a problem reaches your funds.

Each signal is a dependency outside the position itself. Together they cover the venues you trade on, the data you trust, the chains you settle across, and the compute that drives every decision.

• Stablecoin depeg: a stablecoin drifting from its reference value.
• Oracle divergence: DEX spot price separating from the feed price.
• Partner pause: an LP or venue pausing deposits.
• Escrow freeze: a perp venue stalling withdrawals or halting the book.
• Compute lag: latency in the offchain compute node.
• Backing gap: wrapped supply above the collateral behind it.
• Contract upgrade: a partner contract upgrade that changes behavior.
• Redemption window: an issuer's redemption slowing or gating.

The module computes its decision from these signals together, then acts on the position only when exposure warrants it. Most ticks, it holds. One pick per tick.

Watching these signals reduces risk, it does not remove it. Automation acts at chain cadence on the data it can observe, and no monitoring catches every failure mode.

These disclosures apply to every vault the venue executes: Priime's first vaults and builder-launched vaults alike.

Leverage is a multiplier. When a strategy borrows to increase exposure, it amplifies gains and losses in equal measure. The leveraged loop vault uses leverage deliberately, and so can any vault launched on Priime Build that composes the Dynamic leverage module; the same mechanics that amplify yield also amplify the cost of an adverse move.

A delta-neutral structure reduces directional exposure, but it does not make a position free of risk. Hedges can drift, funding can turn negative, and the assets backing a loop can move against the borrow. When the market moves faster than the venues you settle on can absorb, realized outcomes diverge from modeled ones.

Priime's job is to act before those divergences compound. The Trustless Execution Network re-evaluates each leveraged position every block: it checks the health factor, watches leverage drift, and rebalances when a threshold is crossed. The Dynamic leverage module exists to keep a position inside its bounds instead of waiting for a liquidation to correct it.

That automation lowers risk. It does not remove it. You should size positions with these factors in mind:

• Amplified drawdowns. Higher leverage means a smaller adverse move can erode your equity.
• Liquidation exposure. A sharp, single-block move can outpace a rebalance, even at block-time cadence.
• Hedge imperfection. Delta-neutral targets neutrality; it does not guarantee it across funding, slippage, and venue conditions.

Leverage can lead to partial or total loss of deposited capital. Priime is non-custodial and provides no guarantee of yield or protection against loss. Only deploy capital you can afford to lose, and choose leverage you understand.

Priime is non-custodial and runs on open code, but it does not exist in isolation. Every vault settles through smart contracts and reads from price feeds, and both of those are dependencies you should understand before allocating.

Smart contract risk. Every vault launched on Priime, Priime's first vaults and builder-launched vaults alike, runs on smart contracts, and strategies interact with external venues and partner protocols to provide liquidity, borrow, and hedge. A bug, exploit, or unexpected behavior in any contract in that path can affect your position. Priime's own execution is verifiable and the code is open, so actions are verified rather than hidden, but verifiability is not the same as immunity from defects.

Oracle and price-feed risk. The Trustless Execution Network fetches onchain and offchain data to compute strategies at block time. If a price feed lags, diverges from market, or is manipulated, the inputs to that computation can be wrong, which can affect rebalancing, hedging, and health-factor decisions.

The Exogenous risk module watches for these conditions directly, as part of the eight-signal risk catalog. Relevant signals include:

• Oracle divergence: DEX spot price drifting from the reference feed.
• Stablecoin depeg: a stablecoin moving away from its peg.
• Contract upgrade: a partner contract upgrade that changes behavior.
• Partner pause: a venue pausing deposits or withdrawals.

Active monitoring reduces exposure to these dependencies. It does not remove it. Priime is not a black box and is not investment advice, and no automation can guarantee a contract or feed will behave as expected.

Priime computes offchain and settles on every chain, which means two systems outside the chain you settle on can affect how a strategy runs: the compute path and the cross-chain messaging path. The Trustless Execution Network is designed to handle delays in both, and the risk module watches the compute path directly.

The network runs fetch, compute, act every block, with every action verified before it settles, and each Priime Module runs its Fetch, Compute, Act loop on it. If the offchain compute path falls behind, the loop can act on slightly stale inputs or act later than intended. The Exogenous risk module treats this as a signal: Compute lag tracks compute node latency, and when latency rises the system can hold rather than act on data it no longer trusts. Holding ("one pick per tick" can mean no pick) is a deliberate response, not a failure.

Because Priime settles across many chains and families (EVM, SVM, and MOVE), some actions depend on cross-chain messaging and wait until the far side finalizes. The Backing gap signal compares a bridged asset's supply with the collateral locked behind it, so the module can stop taking that asset as collateral when the two part.

Priime also depends on third-party venues and partner contracts. The risk module watches two related signals:

• Partner pause: an LP or venue pausing deposits.
• Contract upgrade: a partner contract upgrade that changes behavior.

Automation reduces these risks by reacting at block time, but it does not remove them. Compute nodes, bridges, and third-party venues can degrade or go offline, and their availability is outside Priime's control.

Every action the network takes is verifiable and the code is open, so when the system holds or acts under these conditions, you can confirm exactly what it did and why.

Short answers to the questions we hear most, with links into these docs where the depth lives.

What can you build on Priime?

Any strategy the modules can express. The landing page shows four templates: funding-rate carry, leveraged loops, hedged staking carry and the tokenized T-bill floor, and seven open prebuilt on the canvas. The same modules build delta-neutral LP, treasury collars, stablecoin loops, T-bill ladders, and vaults that route between a yield lane and a floor. Invent your own starts from a blank canvas.

Why pay attention now?

The money is in vaults, and the decisions moving it run where depositors cannot see them: the benchmark at priime.finance/ecosystem counts 477 vaults and $33.60B. After Commissioner Peirce's statement on manager discretion, what can be inspected matters, and on Priime every plan executed or refused sits onchain.

Why a verified execution standard, and not a better manager?

Reputation does not scale; verification does. Curated vaults show positions and caps, but nobody outside can re-check the decision before it settles.

What does the chain check?

Every plan and NAV update needs registered operators holding two thirds of the weight, checked onchain before it settles, and every plan step is whitelisted, so a swap can only pay the vault.

What is the Trustless Execution Network?

The layer that runs what smart contracts cannot. It fetches onchain and offchain data, computes the strategy in sandboxed WebAssembly every block, and settles one transaction once a quorum of matching operator signatures arrives, on EVM chains, Solana and Aptos.

Can a builder add a module?

Yes. A custom module declares what it fetches, what it may conclude and the single action it may emit, and it runs on the same network as every other module.

Is Priime a fund or an asset manager?

Priime is paid for running a vault, never for holding assets: one fee, 20% of a vault's growth after costs. The operators execute pre-defined logic without investment discretion, and the builder owns the strategy.

Why is building a vault here easier than building a fund?

You keep the strategy and the engineering comes built: modules instead of code, a factory deploy, operators that pick the vault up, and a record under your own address.

Why is the onchain logic more powerful here?

Modules compute what a contract cannot: holding a health band, recentering a range, following the best funding, or watching a whole dependency stack every block. The vault still refuses any signed plan that would leave it short of what it owes its queue.

How does a depositor verify a vault?

By reading it. A public query returns every strike, every executed plan and every refused plan, with nothing to request from us.

What does it cost?

One compute fee on every vault, ours included: 20% of the vault's growth after costs, taken only above its previous high. No deposit fee, no management fee, no negotiated rate. A vault that earns nothing pays nothing.

Why would a strategist publish instead of keeping a private book?

A record under your own address raises capital a private book cannot: an allocator diligences the chain instead of a pitch.

This section covers where Priime stands today and how to get in touch. Priime is an active build: the Trustless Execution Network and its Fetch, Compute, Act modules are the foundation, Priime Build is the venue on top of them, and the first vaults, a delta-neutral LP and a leveraged loop, were built there by the Priime team on the same compose, backtest, incubate, scale flow every builder gets.

The direction is set by the principles the whole stack is built on. Every action is verified and verifiable by anyone. The system is non-custodial, so your keys and your vault stay yours. Execution runs at block time fully automated, and the code is open so you can inspect what runs.

The roadmap follows the vision: one verifiable stack across every chain, spanning the EVM, SVM, and MOVE families. Expect coverage to broaden across chains and venues, and expect new vaults and modules, from Priime and from independent builders on Priime Build, to compose on the same network rather than replace it.

On Priime Build, the canvas, Priime Copilot, and the backtest are the platform today; the module marketplace, Priime Standing and builder cohorts are the launch sequence: planned mechanics, stated as plans.

A few things worth keeping clear about what Priime is:

• It is not a custodian and not a pooled vehicle. You hold your own assets.
• It is not investment advice, and automation reduces risk rather than removing it.
• It is not a black box: execution is verifiable and the code is open.

To reach the team, follow the contact channels published on the official Priime site. Always confirm you are on a verified channel before sharing anything or signing a transaction.