Priime documentation

Priime is the venue where on-chain structured financial products, vaults, are created, tested, incubated, and grown. At its base runs the Trustless Execution Network: it fetches any data, on-chain and off-chain, 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: Exogenous Risk, Dynamic Leverage, Dynamic Hedge, and Endogenous Risk. A delta-neutral LP and a leveraged loop, the first vaults, built by the Priime team on Priime Build itself, assemble these modules into automated strategies, 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 on-chain, 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, off-chain, 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 on-chain, verifiably. Nothing settles unverified.

Because the heavy work happens off-chain 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, off-chain 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 core set

• Exogenous Risk: watches your dependencies (oracles, partner venues, bridges, funding, liquidity) and surfaces signals before they become losses.
• Dynamic Leverage: adjusts borrow and leverage so the position stays within its intended bounds as conditions move.
• Dynamic Hedge: maintains delta-neutral exposure, rebalancing the hedge as the underlying shifts.
• Endogenous Risk: watches the position itself, including health factor and leverage drift, and acts before a threshold is crossed.
• Auto Center, Auto Hedge, Auto Compound: the LP-facing trio: recenter the range, maintain the hedge, reinvest the fees.

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 on-chain, 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 on-chain and off-chain 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.

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 live template: the Priime team composed it on the Build canvas, ran it through the same backtest and incubation flow every builder gets, and the vault built from it runs today on ETH/USDC on Base, 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; the live vault provides this liquidity on Aerodrome. The hedge leg, a borrow or short sized to that same exposure, cancels the price move; the live 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 on-chain 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

Five modules from the core library do the work, 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.
• Auto 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.
• Endogenous Risk watches the position itself: hedge-ratio drift, slippage creep, and the health of the borrow behind the hedge, acting before a threshold is crossed.
• Exogenous Risk watches what the position depends on but does not control: the DEX, the price oracle, and the lending venue behind the hedge, tracked against the ten-signal risk catalog.

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 on yield at harvest that every vault pays). 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, live on Base. Modeled, not realized. The live 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 the 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 re-weights toward the best net-of-cost funding, 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

• Dynamic Hedge is the basis engine. It keeps each short sized against the spot leg so the pair stays neutral as prices and balances move, and settles accrued funding so accounting stays clean.
• Dynamic Leverage manages margin on the perp legs, keeping each venue's margin inside its band so a mark move cannot liquidate a position that is neutral in aggregate.
• Exogenous Risk is the funding guard. The funding-flip signal from the ten-signal risk catalog watches for funding trending negative, alongside oracle divergence and venue pauses, so the router can rotate capital or the position can wind down before a negative regime compounds.
• Auto Compound folds harvested funding back into the position.

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 fees, the same schedule 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.
• Endogenous Risk watches the position itself: leverage drift, slippage creep on the deleverage path, and gaps between on-chain state and what the strategy expects.

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, minus the compute fee on yield. 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 shelf is where the templates end, not where the canvas does. 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. Endogenous Risk bounds the position itself: leverage, drift, slippage. Exogenous Risk bounds the world it depends on: oracles, venues, bridges, funding. 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 sits on the landing as a card, and it is also 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 on-chain 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 folds the net premium, calls collected minus puts paid, back into the treasury position.
• Guards. Endogenous Risk bounds the option notional against the treasury size so the calls 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 off-chain, 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 core set

Priime builds and maintains the core set. Core Concepts and Architecture cover each in depth.

• Exogenous Risk: watches the ten-signal risk catalog, the dependencies your position relies on but does not control.
• Endogenous Risk: watches the position itself: leverage drift, slippage creep, compute lag.
• Dynamic Leverage: steers health factor back toward target, with standard and emergency deleverage tiers.
• Dynamic Hedge: keeps the position delta-neutral and settles accrued funding.
• Auto Center, Auto Hedge, Auto Compound: the LP-facing trio: recenter the range, maintain the hedge, reinvest the fees.

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 on-chain 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 it is a technical fee, not carry. The venue is paid for work performed, not for a share of the upside.

The schedule

• Compute fee: 20% of yield, charged at harvest. This pays for what the Trustless Execution Network does: every operator in the quorum re-running your strategy every block, fetch, compute, act. It is charged only when the strategy produces yield. A strategy that earns nothing pays nothing on yield.

That is the whole schedule. There is no deposit fee. No management fee on idle capital, no fee on principal at withdrawal, 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 is charged by the venue for execution. It is not carry, and 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 ten 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 (on-chain and off-chain), computes with no limits, and acts through the onchain verifier, settling on-chain 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.
• Endogenous Risk: watches the position itself.

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.

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, funding flips, TVL drain, bridge lag, 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.

Endogenous Risk

Endogenous Risk watches the position itself rather than its dependencies, monitoring signals such as leverage drift, slippage creep, and compute lag. It acts to keep the position solvent and healthy at chain cadence.

The core set also includes the LP-facing trio of Auto Center, Auto Hedge, and Auto Compound, covered in the templates chapter. 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 core set.

Because modules are shared, the same risk logic backs every vault on the venue: the first 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, off-chain 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 on-chain. 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 on-chain 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 ten 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.
• Funding flip: perp funding trending negative.
• TVL drain: liquidity and depth declining, with LPs exiting in size.
• Compute lag: latency in the off-chain compute node.
• Slippage creep: realized slippage rising over time.
• Bridge lag: cross-chain messaging running slow.
• Contract upgrade: a partner contract upgrade that changes behavior.
• Leverage drift: the position leverage ratio drifting up.

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 and Endogenous Risk modules exist 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 on-chain and off-chain 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 ten-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 off-chain 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 for them 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 off-chain 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. The Bridge lag signal watches for messaging latency between chains, so the module can account for an action that has not yet finalized on the far side.

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

• Partner pause: an LP or venue pausing deposits.
• Contract upgrade: a partner contract upgrade that changes behavior.
• TVL drain: declining depth or a mass LP exit on a venue you rely on.

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. For deeper detail, follow the links to the relevant sections of these docs.

What is Priime?

Priime is the venue where on-chain structured financial products (vaults) are created, tested, incubated, and grown. Strategies are composed from Priime Modules on Priime Build, and the Trustless Execution Network executes and verifies every vault: it fetches data on-chain and off-chain, computes at block time, and acts on any chain, every action verified before it settles, fully automated. The thesis is simple: move DeFi from punitive to proactive, acting before a problem (like a liquidation) instead of punishing you after.

Does Priime hold my funds?

No. Priime is non-custodial. Your keys, your vault. The network acts on your position at block cadence, but you retain custody throughout.

How do I know what Priime is doing?

Every action is verifiable, and the code is open. Execution is not a black box. The network runs a fetch, compute, act flow each block, each step is verified, and nothing settles unverified.

What are Modules and vaults?

• Modules are the composable building blocks you compose on the Priime Build canvas: Exogenous Risk, Endogenous Risk, Dynamic Leverage, Dynamic Hedge, and the LP-facing trio (Auto Center, Auto Hedge, Auto Compound). Builders can author custom modules against the same Fetch, Compute, Act contract.
• Vaults are the strategies launched on Priime Build. A delta-neutral LP (concentrated, actively managed liquidity) and a leveraged loop (delta-neutral leverage) are the first vaults, built by the Priime team on the same Compose, Test, Incubate, Scale flow every builder gets.

Can I build my own vault?

Yes. Priime Build is the venue for it: compose Priime Modules on the canvas (or describe the strategy and let Priime Copilot draft it), backtest against history, deploy into the incubation zone, and graduate to scale. Every vault you launch ships with the platform guarantees: non-custodial, quorum-verified, inspectable.

What does it cost?

One published fee on every vault, Priime's own included: a 20% compute fee on yield, charged at harvest. There is no deposit fee, no management fee on idle capital, and no fee on principal at withdrawal.

Which chains does Priime support?

Priime is multi-chain by design, spanning the EVM, SVM, and MOVE families. One verifiable stack, every chain.

Priime is not a pooled vehicle and not investment advice. Automation is designed to reduce risk, not eliminate it.

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.