Priime documentation

Priime is the venue where on-chain structured financial products, vaults, are created, tested, incubated, and grown. At its base runs the verifiable Priime Processor: it fetches any data, on-chain and off-chain, computes every strategy at block time, and settles on any chain, provably, 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 Priime Processor

At the base sits the Processor, the compute layer every vault runs on. Its flow is simple: fetch, compute, settle. It runs every block, watching dependencies and risk signals, then acting on your position only when the situation calls for it.

On top of the Priime Processor are composable Priime Modules, the building blocks every vault is composed from: Exogenous Risk, Dynamic Leverage, Dynamic Hedge, and Endogenous Risk. Priime Pools and Priime 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 provable.
• 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 Priime Processor 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 Priime Processor 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, Pools and Loop, 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 an Observe, Reason, Act loop at chain cadence. It watches external dependencies and risk signals, reasons 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 Priime Processor.

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 Priime Processor fetches data, computes strategy, and settles, and they define what you can verify about any action taken on your behalf.

• Verifiable. Every action the Priime Processor takes is provable. Computation runs at block time and produces a result you (or anyone) can check, rather than a result you have to trust.
• Decentralized. No single party controls execution. The Priime Processor is the verifiable base every vault runs on, and it runs without a privileged operator in the path.
• Non-custodial. Your keys, your vault. Priime acts on your position, but it never takes custody of your assets.
• Block-time. Modules run an Observe, Reason, Act loop at chain cadence. They watch 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 Priime Processor, 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 Processor 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, settle. Each pass is marked 0xVERIFY, so what it did and why is provable after the fact.

Traditional finance automated this loop in the 1980s. DeFi is only catching up now. The Priime Processor 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 Priime Processor executes the modules' Observe, Reason, Act cycle at chain cadence. It observes external dependencies and risk signals, reasons 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 any data the strategy needs, on-chain and off-chain.
• Compute: run the strategy with unlimited compute, off the contract.
• Settle: write the result on-chain, verifiably.

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 Priime Processor 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: Observe, Reason, Act. The loop runs on the Priime Processor, 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:

• Observe. The module fetches external dependencies and risk signals, both on-chain and off-chain. This is the sensing stage: spot prices, oracle feeds, funding rates, venue state, and the position itself.
• Reason. The module computes its exposure from what it observed. 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.
• Act. If a response is warranted, the module settles one action on the position. 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 re-observes 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 Priime Processor and runs an Observe, Reason, Act loop at block time: it observes external dependencies and risk signals, reasons 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: Priime Pools and Priime 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 Pools-facing trio: recenter the range, maintain the hedge, reinvest the fees.

Priime maintains the core set, and builders author custom modules against the same Observe, Reason, 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 verifiable Priime Processor, so what a module did, and why, is provable and reproducible at block cadence.

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

This is what we mean by verifiable execution. The Priime Processor runs every block, following the same fetch -> compute -> settle flow each time. 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:

• Provable: 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 Processor computes your strategy in one place, then settles the result on whichever chain holds your position. Compute once, settle anywhere.

The flow is always the same. The Priime Processor fetches on-chain and off-chain data, runs the strategy at block time, and produces an action. Settlement is the final step (fetch -> compute -> settle), and it 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 observes a risk signal on 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.

Priime Pools (Priime Liquidity Pools) provides concentrated liquidity that the Priime Modules maintain under parameters the Priime team composed on the Build canvas, with ranges rebalanced at block time so your position keeps collecting fees instead of drifting out of range and going idle. Every module and parameter is open and inspectable, not a black box.

Priime Pools is the first vault built on Priime Build. The Priime team composed it from core Priime Modules on the Build canvas, ran it through the same backtest gate and the same incubation every builder's vault passes, and it now runs live on Base with its record published against its tear sheet.

Concentrated liquidity is capital-efficient but fragile: once price moves outside your range, the position stops collecting fees. Priime closes that gap. The Priime Processor observes price and the surrounding risk signals every block, reasons about where the active range should sit, and acts to re-center the position only when needed. Most ticks, it holds. One pick per tick.

The result is framed as liquidity pools turned delta-neutral. The Dynamic Hedge and risk modules work alongside the liquidity range to manage directional exposure, so the position aims to collect fees without taking an open bet on price direction.

Because the vault runs on the Priime Processor, you get:

• Verifiable accounting: every rebalance and fee movement is provable, not asserted.
• One interface across venues: pools on different chains and protocols sit behind a single surface.
• Block-time response: ranges follow the market at chain cadence, fully automated.

Active management reduces idle-range risk but does not remove market risk. Concentrated liquidity can still incur impermanent loss, outcomes are not guaranteed, and deposited capital is at risk.

Your keys, your vault. Priime 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.

Priime Pools combines two legs to capture trading fees without a directional bet on the underlying. The liquidity leg provides concentrated LP on a venue like Aerodrome (WETH/USDC on Base is live first), collecting a share of swap fees while price trades inside the position's range. The hedge leg, an Aave borrow or short sized to that same exposure, cancels the price move. What you keep is the fee income, net of the cost of carrying the hedge.

A passive concentrated position has a known flaw. Trading fees only accrue while price sits inside the range, and price moving against the liquidity produces impermanent loss that quietly eats those fees. Priime addresses both with active management: the Pools composition, three core Priime Modules from the same library builders compose on the Build canvas. Auto Center recenters the range on price so the position keeps collecting fees instead of drifting idle at an edge. Auto Hedge sizes and maintains the offsetting leg so the loss on the liquidity when price moves is met by a gain on the hedge, and the other way around. Auto Compound claims accrued fees and folds them back into the position.

A few numbers govern the whole position, read on-chain at block cadence:

• Range. The price band the liquidity is concentrated into. Narrower bands collect more fee per dollar but need recentering more often.
• Net delta. Liquidity exposure minus the hedge. Auto Hedge holds this near zero so the position stays delta-neutral as price and balances change.
• Fee income. The trading fees the position collects, the engine of the return, net of borrow cost and slippage.

The outcome is the fee income less the cost of the hedge. There is no fixed rate and no emission gimmick: whatever the market pays for liquidity is captured without the price risk, and the result depends on market conditions and user and partner decisions.

Delta-neutral is approximate, not exact. Net delta drifts between rebalances, impermanent loss is reduced rather than eliminated, and the hedge carries a borrow cost that can move against you. Outcomes are not guaranteed, yield varies with pool volume and rates, and deposited capital is at risk.

Providing the liquidity is the easy part. Keeping it productive, neutral, and inside its risk bounds block by block is the work, and that work is done by a set of always-on modules: core Priime Modules from the same library any builder composes on the Build canvas, together forming the Pools composition. Each one reads live on-chain state on its own cadence, decides whether an action is warranted, and acts only when it is. None of them trade discretionarily or move funds outside your own position. Range width, hedge ratio, and risk thresholds are on-chain bounds, and every action is quorum-signed through Priime's verifiable execution rather than issued by a single operator.

Auto Center keeps the concentrated position centered on price. While the position sits inside its range it collects full trading fees, so the module holds. As price drifts toward an edge, fees thin and then stop, and the module recenters the liquidity around the current price so it keeps accruing. It acts on price you can observe on-chain, not on a forecast, and 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 you. The module sizes an offsetting short against the live position so a move in the underlying is canceled by the hedge, leaving the fees. As the position and price change, it resizes the short to keep the hedge ratio inside its band, and settles accrued funding so accounting stays clean.

Auto Compound keeps the fees working. It claims the accrued trading fees and folds them back into the position, so what the pool earns compounds rather than sitting idle.

Finally, the Exogenous Risk module watches what the position depends on but does not control: the DEX, the price oracle, and the lending venue used for the hedge. It tracks signals from the ten-signal risk catalog, such as oracle divergence, stablecoin depeg, thinning liquidity, and venue pauses. When a dependency degrades, it can move the position toward safety before the problem reaches your funds, and it keeps leverage and range inside their safe bounds.

These modules respond to observable conditions at chain cadence; they reduce risk, they do not remove it. Concentrated liquidity can still incur impermanent loss, delta-neutral hedging nets out price moves only at the moment of rebalancing, and venues, oracles, and borrow markets can move faster than any response. Outcomes are not guaranteed.

A Priime Pools position moves through three phases: opening from a USDC deposit, holding while the modules run, and withdrawing in part or in full. Each phase leaves observable state you can read directly, and every action the Priime Processor takes on your behalf is quorum-signed by independent operators. Custody stays with you throughout. Priime never takes custody.

Opening. You deposit USDC into your position. From that deposit the system provisions concentrated liquidity on Aerodrome around the current price and opens an offsetting hedge on Aave, sized so that price moves on the underlying net to roughly zero. This is what lets the position collect LP fees without carrying the impermanent loss that an unhedged range would. You sign the authorizations the flow needs and confirm the deposit, and the legs are established together.

Holding. Once the position is open there is nothing to do. Fees accrue on the Aerodrome leg block by block, and the vault's composition keeps it in shape: Auto Center recenters the liquidity range as price drifts, Auto Hedge rebalances the Aave hedge against your live exposure, Auto Compound folds accrued fees back into the position, and the Exogenous Risk module watches the venues the position depends on. The dashboard reads chain state directly and shows current value, net delta, the capital split across the two legs, and the last action taken.

Withdrawing. You can withdraw part of your position or all of it. A withdrawal unwinds the proportional share of the Aerodrome liquidity, closes the matching portion of the Aave hedge, and returns the funds to you. A partial withdrawal leaves the remaining position hedged and centered as before. A full withdrawal closes both legs and settles back to USDC in your wallet.

Delta-neutral reduces directional exposure, it does not remove risk. Recentering, hedge rebalancing, and withdrawal all execute against live venues, so slippage, oracle moves, and venue conditions can affect the result. Outcomes are not guaranteed, and capital is at risk.

The vault collects from one source and pays for three. The source is the trading fees a concentrated liquidity position collects. The costs are holding the hedge, keeping the position centered, and the venue's fees. The headline yield is what is left after the costs are subtracted, which is why it moves with the market rather than sitting at a fixed rate. Published yields are modeled net of fees.

• Concentrated LP fees (positive). Liquidity placed in a tight band around the current price collects far more fees per dollar than a passive full-range position, because every dollar is working at the price where trades actually happen. This is the engine of the return, and it scales with how much the pool trades.
• Hedge cost (negative). Removing the price exposure is not free. A short sized to the position costs either a borrow rate (when collateral is borrowed against) or perpetual funding. This cost is netted out of the fees, and it varies day to day.
• Rebalancing and gas friction (negative). Keeping the band centered on price and re-sizing the hedge costs swap slippage and gas. The modules act only when an action is warranted, which keeps this friction as low as the strategy allows.
• Priime fees (negative). The venue's published schedule applies to Pools like every vault on Priime Build: a compute fee of 30% of yield charged at harvest, plus a one-time 2% settlement fee on deposits. No management fee on idle capital, no fee on principal at withdrawal.

Impermanent loss does not appear as a separate cost. It is the drift a liquidity position suffers when price moves against it, and the hedge is sized to offset it. When price moves, the loss on the liquidity is cancelled by the gain on the short, and the other way around. What survives is the fees, net of the hedge.

Concentrated liquidity collects more but demands active management, and that management is the point of the modules. A tight band drifts out of range as price moves, and an unmanaged position stops collecting fees the moment it does. Auto Center, Auto Hedge, and Auto Compound keep it centered, neutral, and reinvested every block. The live record is published against the vault's tear sheet, so realized yield can be checked against modeled.

Real yield depends on pool volume, borrow and funding rates, and slippage, all of which change. Strategies may produce outcomes depending on market conditions and user and partner decisions; nothing here is a guarantee. Capital is at risk.

A Priime Pool collects concentrated liquidity fees while hedging away the directional exposure, but delta-neutral means neutral at the moment of each rebalance, not immune to risk. The hedge module sizes an offsetting short against the position, and the modules evaluate the range and the hedge every block and act only when their bands call for it: at most one action settles per pass. Between actions the hedge ratio drifts, so a position can be briefly directional, and a hedged position can still show non-zero PnL day to day.

The sharpest exposure is a fast market. A single-block move can outrun a rebalance even at block-time cadence, leaving a residual delta until the next tick corrects it. The same move can push price outside the active range, where the liquidity stops collecting fees until it is re-centered. Active management reduces idle-range and drift risk, it does not eliminate the impermanent loss that concentrated liquidity carries when price travels through the range.

The hedge depends on venues Priime does not control. The borrow market or perpetual funding can move against the position: funding can turn negative for sustained periods, and the structural choice is to hold the hedge rather than un-hedge into greater directional risk.

Other exposures are inherent to the protocols a pool integrates (such as Aerodrome, Uniswap, and the lending venue behind the hedge):

• Liquidity and slippage. Each rebalance swaps through on-chain liquidity within a slippage cap. Thin books or a liquidity event can make a swap revert and retry, or settle worse than modeled.
• Oracle risk. Range, hedge, and health decisions read price feeds Priime does not run. A stale, divergent, or manipulated feed can trigger or suppress a rebalance incorrectly.
• Smart-contract risk. Bugs in the pool contracts, the upgradeable surface, or third-party protocols (the DEX, the lending venue) can impair operation even if Priime's own code is sound.

The operator quorum, the modules, and RPC providers are required for normal operation. None can move your funds, and your shares stay redeemable, but their downtime can prevent Priime from acting until the failed system recovers.

Priime is non-custodial software: you retain control of your assets at all times, positions are self-directed, and you can exit at any time. Capital deployed in a Priime Pool 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.

Priime Loop runs automated leverage loops that stay delta-neutral. You deposit, and the Priime Processor borrows, hedges, and compounds on your behalf, continuously re-evaluating the entire position at chain cadence (about every ten seconds).

Priime Loop is a vault, not an app: the Priime team composed it from Priime Modules on the Priime Build canvas and carried it through the same backtest, incubation, and scale flow every builder gets. It executes on the same quorum-verified Priime Processor as every vault on the venue.

The mechanics are familiar from manual leveraged farming, but the management is not. A loop borrows against your collateral, opens an offsetting hedge so price moves on the underlying net out to roughly zero, and recompounds yield back into the position. Where a manual loop drifts between the moments you check it, Priime Loop re-derives the right state at chain cadence.

Two modules do the work each tick. Dynamic Leverage watches the leverage ratio and trims or extends it back toward target. Dynamic Hedge keeps the hedge sized against your live exposure so the position stays delta-neutral as prices and balances change. The health factor is checked continuously (about every ten seconds) and rebalanced only when it drifts, which is what lets the loop act before a position drifts into trouble rather than after.

Every loop is yours:

• Self-custody. Your keys, your vault. Priime never takes custody, and you can close your position at any time.
• Open code. The strategy and execution are inspectable.
• Verifiable. Each rebalance is a provable action, settled on-chain where the vault's venues live.

Delta-neutral reduces directional exposure; it does not remove risk. Hedge venues, borrow markets, and oracles can move against a position, and automation responds to conditions rather than guaranteeing outcomes.

Priime Loop combines two positions to capture a rate spread without taking a directional bet on BERA. One leg builds leveraged collateral on Berachain. The other leg shorts the same exposure on Hyperliquid so price moves cancel. What you keep is the spread between lending yield, borrow cost, and funding.

The collateral leg is a recursive loop on Dolomite. Your USDC buys oriBGT (the canonical Berachain yield-bearing asset), the position borrows USDC against that collateral, swaps the borrow into more oriBGT, and re-deposits. The geometry compounds to roughly 2.5x effective leverage at a target loan-to-value near 0.60, held at a health factor around 1.25 at open. Kodiak handles the on-chain swaps along the way.

The hedge leg is a short BERA perpetual on Hyperliquid, sized so its notional matches the BERA notional of the collateral. It runs at isolated leverage funded by the portion of your deposit bridged to Hyperliquid at open. Orders are placed immediate-or-cancel inside a slippage budget you sign, with a hard cap enforced on-chain. Sized correctly, the two legs net to approximately zero first-order BERA exposure.

A handful of numbers govern the whole position, all read on-chain at block cadence:

• Health factor: collateral value times Dolomite's liquidation threshold, divided by debt. Below 1.0 a position is liquidatable.
• LTV and leverage: debt over collateral, and how far the loop is extended.
• Hedge ratio: short notional over collateral value, targeting roughly 1.0.

This is where continuously re-deriving state is the edge. A manual loop drifts between the moments you check it. Collateral accrues yield, BERA marks move, and funding flips, all continuously. Priime's Dynamic Leverage and Dynamic Hedge modules recompute the right state each tick and act only when a threshold is crossed, with the operator quorum producing a quorum-signed action through Priime's verifiable execution. The aim is to correct before a position drifts into trouble, not after.

The hedge is a discrete-time approximation, neutral on average rather than at every instant, so a small directional residual exists between rebalances. Leverage amplifies losses as well as gains, and a sustained negative funding regime can invert the hedge's contribution. Delta-neutral reduces directional risk, it does not remove it, and outcomes are not guaranteed.

Opening a loop is the easy part. Keeping it healthy block by block is the work, and that work is done by Loop's composition: the same always-on Priime Modules any builder wires on the Priime Build canvas (Dynamic Leverage, Dynamic Hedge), plus vault-specific modules like Scheduled Withdrawal. Each one reads live chain state on its own cadence, decides whether an action is warranted, and acts only when it is. None of them trade discretionarily, move funds outside your own accounts, or change strategy parameters. Health-factor targets, hedge ratio, and deleverage thresholds are on-chain constants, and every action is settled by Priime's verifiable execution rather than a single operator.

Dynamic Leverage watches the health factor continuously (about every ten seconds) and rebalances when it drifts. Below the standard threshold it brings the position back to target. If it falls toward liquidation, an emergency tier restores target in a single block with a larger swap. When the health factor drifts the other way (because the underlying rallied or collateral yielded), it levers up opportunistically, borrowing and re-depositing to restore capital efficiency without ever crossing back below the standard deleverage line. Each move is one atomic Dolomite operate (withdraw, swap on Kodiak, repay), with the minimum-out embedded so a bad fill reverts and retries next block. Successive moves are rate-limited to avoid oscillation.

Dynamic Hedge keeps the offsetting short sized against your live exposure. As collateral grows through yield, it tops up the Hyperliquid short to hold the hedge ratio inside its maintenance band, which is wide enough that ordinary intraday drift does not trigger a rebalance. It also settles accrued funding into the collateral leg so position accounting stays clean.

Scheduled Withdrawal handles closes large enough that a single market unwind would slip materially against on-pool liquidity. You queue a withdrawal, the shares burn immediately, and the position closes in slices over time, each bounded by a per-slice budget and slippage cap. You can cancel at any point, and the un-executed shares re-mint to you.

Finally, position monitoring covers the edge cases the risk modules do not: phantom loops where a deposit recorded off-chain has no live on-chain position, orphaned funds stranded on Hyperliquid, and hedge or drawdown drift. These surface to the dashboard for recovery rather than acting autonomously.

These modules respond to observable conditions at chain cadence; they reduce risk, they do not remove it. Leverage amplifies losses, delta-neutral hedging nets out price moves only at the moment of rebalancing, and venues, borrow markets, and oracles can move faster than any response.

When you deposit into Priime Loop, you receive a personal smart account on Berachain that only your wallet can own. It is an ERC-1271 contract whose owner is pinned to your wallet at deployment, and its address is derived deterministically, so it is known before the contract even exists and cannot be front-run by another deployer. Your leveraged Dolomite collateral position lives inside this vault. Your Hyperliquid hedge margin lives in your own Hyperliquid master account. There is no shared pool, and Priime never takes custody: the same non-custodial, quorum-verified guarantee every vault launched on Priime Build ships with.

The vault verifies signatures through isValidSignature: any signature it accepts is recovered and checked against your wallet, and no other authority can sign on its behalf. The Priime Processor and its independent operators can only perform bounded, pre-authorised actions inside the vault's isolated account, coordinated through the factory. They can borrow, hedge, and rebalance on your behalf, but they can never move funds to themselves or to any address other than the recipient you set. Each action is quorum-signed and verifiable.

Custody stays with you at every phase:

• Open position. Collateral sits in your vault (owned by your wallet); hedge margin sits in your Hyperliquid master account.
• Hyperliquid agent. You approve an agent that can place orders, but it cannot withdraw. Transfers and withdrawals require your master key.
• Close. USDC proceeds go to the recipient you authorise, and your master-key signatures release the hedge.

Gas is user-funded. At deposit, a small USDC amount is carved out into a per-user gas reserve tracked on-chain, and a small balance is routed to provision your own HYPE pocket on Hyperliquid. Sponsored transactions are reimbursed by debiting a few cents from your reserve at each close, and your HYPE pocket pays your Hyperliquid fees directly. Whatever remains is refunded (unspent USDC reserve and native HYPE) when you fully close. Separately from gas, the venue's published settlement fee (2% of deposits) is charged once at deposit, the same schedule every vault on Priime Build pays (see Fees and builder economics); gas itself is net-neutral, with no operator subsidy and no markup.

Non-custodial design protects ownership, not market outcomes. Leverage amplifies losses, delta-neutral structures reduce but do not remove risk, and modeled returns are not guarantees.

A Priime Loop position moves through four phases: opening from a USDC deposit, holding while the modules run, closing (in part or in full), and recovering if any step stalls midway. This is the day-to-day lifecycle of your position inside the vault, distinct from the vault's own compose, test, incubate, scale lifecycle on Priime Build. Each phase is built so that partial progress leaves observable state you can resume from, and every action the Priime Processor takes on your behalf is quorum-signed by independent operators.

Opening. A deposit is a fixed, resumable flow. You authorize a gasless permit on your USDC, your vault is deployed deterministically (idempotent, so it is reused if it already exists), funds are bridged to Hyperliquid in a single atomic batch (deposit, approval, and bridge together), and the offsetting short is placed once your operator agent is approved. In total you sign four typed-data authorizations and confirm two transactions. Every step detects whether it is already complete, so re-entering after an interrupted deposit is safe and never double-spends.

Holding. Once the position is open there is nothing to do. The modules run each block: Dynamic Leverage trims or extends the borrow as the health factor drifts, and Dynamic Hedge keeps the Hyperliquid short sized against your live exposure. The dashboard reads chain state directly and shows current value, health factor, hedge ratio, and the last action taken. It is the only surface, so integrators wanting their own alerts can subscribe to the on-chain events.

Closing. A partial close redeems a signed fraction of the position without touching the rest. Your vault unwinds the proportional collateral and debt through one Dolomite operation, swaps the released oriBGT or WBERA on Kodiak within your signed slippage cap, and sends USDC to your recipient. The hedge stays open at reduced coverage and the next hedge tick resizes it. A full close (fraction of 10^18) unwinds everything: a preflight gate verifies the position, agent, HYPE reserve, and bridge authorization before any irreversible step, then the Berachain loop unwinds, the short is closed, funds bridge home, and leftover HYPE and gas reserve refund to you as native HYPE and USDC.

Recovery. Every multi-step flow exposes a resume path. A timed-out deposit leaves a pending marker that completes on your next visit without a new signature. USDC stranded on Hyperliquid is flagged within minutes and cleared with one click, a stranded bridge leg re-runs from a resume endpoint, and a residual hedge clears on retry. The only fully irreversible step, the Berachain close, does not broadcast unless every prerequisite is verified first.

Leverage amplifies losses as well as gains. Delta-neutral hedging reduces directional exposure but does not remove risk: borrow markets, hedge venues, oracles, and bridges can all move against a position, and modeled returns are not guarantees.

Priime Loop draws its return from four distinct sources, less the venue compute fee. The headline number is a sum of parts rather than a single rate. Understanding each part is the only way to understand why a quoted yield can move from one day to the next.

• Boosted reward yield (positive). The collateral leg holds oriBGT, which accrues Berachain Boost rewards. This is the engine of the strategy, and leverage scales it: the loop accrues this yield on the full collateral balance, not just on your deposit.
• Borrowing cost (negative). The loop borrows USDC against that collateral on Dolomite at a variable rate. You pay this rate on the borrowed portion only, so it scales with leverage minus one.
• Hedge funding (positive or negative). The offsetting short on Hyperliquid pays or receives perpetual funding depending on the perp-versus-spot premium. In most regimes funding contributes positively, but it can invert.
• Trading and hedge slippage (negative). Each swap and re-hedge gives up a small amount to slippage, bounded by a configured cap.
• Compute fee (negative). 30% of yield, charged at harvest. It is the venue's published fee for quorum execution, the same schedule every vault on Priime Build pays (see Fees and builder economics).

The net figure is roughly the reward yield times leverage, minus the borrow rate times leverage minus one, plus or minus funding scaled by the hedge ratio, minus a slippage drag, minus the compute fee on the yield produced. The dashboard computes this live from the current rates, your effective leverage, and the live hedge ratio. It is a calculation against present inputs, not a forecast.

Loop ran the same integrated backtest every strategy on Priime Build runs: the composition replayed against historical price and funding data across many seeds, out-of-sample, producing a distribution of outcomes rather than a single line. The methodology is public and the tear sheet is published alongside the vault: modeled, not realized. Every input (reward yield, borrow rate, funding, order-book depth) is set by external markets; the compute fee is the venue's published schedule. History describes the past, not the future.

Modeled and backtested returns are estimates, not guarantees. Leverage amplifies losses as well as gains, and delta-neutral hedging reduces directional risk without removing it. The largest unmodeled risk is a sustained negative funding regime, which inverts the hedge's contribution and can turn a positive carry negative. Past performance does not indicate future results.

Priime Loop is delta-neutral with respect to BERA price at the moment of each rebalance, not immune to risk. The Berachain leg is leveraged roughly 2 to 3x, so adverse moves in oriBGT against USDC are amplified by that factor. Between rebalance ticks the hedge ratio drifts, which can leave a position briefly directional. Delta-neutrality is approximate, not exact, and a hedged position can still show non-zero PnL day to day. This page is Loop's vault-specific disclosure; the venue-wide framework in Risk Management and Risk Disclosure applies to it as to every vault on Priime Build, with Priime accountable as the builder of the strategy.

Liquidation is governed by Dolomite, not by Priime. If your health factor crosses 1.0, anyone can liquidate and seize part of the collateral. New positions open targeting a 1.25 health factor, a deliberate cushion above the liquidation line at 1.0; a standard deleverage trims exposure around 1.18, and an emergency deleverage acts below 1.10.0, a standard deleverage trims exposure around 1.18, and an emergency deleverage fires near 1.10 as the last automated line. These bounds reduce the probability of liquidation, not its consequence. A single-block flash move on the collateral oracle, a Kodiak liquidity event that reverts the deleverage swap, or an interruption in execution can still defeat them.

The hedge on Hyperliquid pays or receives funding. BERA-PERP funding has been mostly positive historically, but that is not a guarantee. Funding can flip negative for sustained periods, especially during selloffs, and the structural choice is to absorb it in either direction rather than un-hedge into greater risk.

Other exposures are inherent to the venues Priime Loop integrates:

• Slippage and bridge risk. Hedge fills use slippage caps and deleverage swaps carry a minimum-out, but thin order books, bridge outages, and validator-signing delays on the Hyperliquid bridge can stall actions. In-transit funds stay on the source chain until recovered.
• Oracle risk. Priime depends on Dolomite, Hyperliquid, and Kodiak price feeds it does not run. Stale or manipulated oracles can trigger or prevent liquidations incorrectly.
• Smart-contract risk. Code bugs, the factory's upgradeable surface, and third-party contracts (Dolomite, Kodiak, the bridges) can each impair operation even if Priime's own code is sound.
• Operational risk. The relayer, the modules, RPC providers, and the operator quorum are required for normal operation. None can move your funds, but their downtime can prevent Priime from acting on your behalf until the failed system recovers.

Priime is non-custodial software: you retain control of your assets at all times, positions are self-directed, and you can close your position at any time. Capital deployed in Priime Loop is at risk and can be partially or totally lost. Leverage amplifies losses as well as gains, delta-neutral hedging reduces but does not remove risk, and outcomes are not guaranteed. 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 against historical market data and see what your composition would have done, 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 Priime Processor runs fetch, compute, settle every block, provably, each pass marked 0xVERIFY. Priime Modules run Observe, Reason, 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 Processor executes and proves it.

This is not a hypothetical pipeline. Priime Pools was built on the same rails: 18% modeled net APY 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 Processor 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 Observe, Reason, Act loop at block time. The Priime Processor 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. Every Copilot draft passes through the same backtest and incubation gates as a hand-built one.

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 Observe, Reason, 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 Pools-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 independent operators re-run and cross-check, not deploying a new trusted contract; the on-chain settlement surface stays small and fixed.

Custom modules

Builders author new modules against the same Observe, Reason, Act contract. A custom module declares what it observes, what it may conclude, and the single action class it may emit. It runs inside the Priime Processor'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 runs against history. The integrated backtest on Priime Build replays your composition over historical market data and reports what it would have done, block by block. Not a summary curve: the actual decisions, in order.

The methodology

The methodology is public. Results are out-of-sample by construction: parameters are chosen on one window and judged on a held-out window the strategy never saw. 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.

The tear sheet

The output is a tear sheet: net APY, drawdown, hedge tracking, and action count, plus the exact decisions each module took. Every trigger is inspectable, so you can see why the strategy acted, not just that it did.

The published references set the bar. ETH/USDC ran at roughly 18% modeled net APY over fourteen months out-of-sample. cbBTC/USDC is the held-out pair: +27.6% over its 14-month out-of-sample window. Modeled, not realized. Priime Pools runs the same methodology live on Base, and its record is published against its tear sheet, 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: history shows the market that existed, not the market absorbing your deposit.
• Venue outages: a venue that stayed up in the window can pause tomorrow.
• Future regimes: history does not contain what has not happened yet.

The backtest is a gate: passing it is how a strategy enters the incubation zone. Its tear sheet is published alongside the vault, so depositors see the same evidence you saw.

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 Priime Processor 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, settle pass is provable and marked 0xVERIFY. Provable 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

Pass the backtest gate. 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 Processor 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 the same two fees on every vault the venue executes, Priime's own vaults included. Both are published here, and both are technical fees, not carry. The venue is paid for work performed, not for a share of the upside.

The schedule

• Compute fee: 30% of yield, charged at harvest. This pays for what the Priime Processor does: every operator in the quorum re-running your strategy every block, fetch, compute, settle. It is charged only when the strategy produces yield. A strategy that earns nothing pays nothing on yield.
• Settlement fee: 2% of deposits. This pays for verified onboarding of capital into the vault's positions.

That is the whole schedule. There is 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: all yield-linked revenue, the compute fee and every royalty drawn from it, is paid only when depositors earn. The settlement fee is the one exception, charged once at deposit for onboarding.

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.

Fees are charged by the venue for execution and settlement. They are not carry, and they are not a performance promise.

Fees reduce net returns. All published yields are modeled net of fees unless stated otherwise.

Priime verifies execution. You own the strategy. Everything in this chapter exists to make what your vault does provable. 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 Processor 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.
• Proof. 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 Processor, and the Processor 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 is the Priime Processor, the compute base every vault shares. It runs a single flow, fetch then compute then settle, only when something needs to change. It pulls any data (on-chain and off-chain), runs unlimited compute, and settles provably on-chain fully automated, each action quorum-signed by the operator set: k of n identical results before anything settles.

Above the Priime Processor are the modules, the composable building blocks. Each module runs an Observe, Reason, Act loop at block time: it observes risk signals and external dependencies, reasons 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. Priime Pools and Priime 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 Priime Processor, 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 Priime Processor. Each one runs an Observe, Reason, Act loop at block time: it watches its domain, reasons about 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 Pools-facing trio of Auto Center, Auto Hedge, and Auto Compound, covered in the Priime Pools sections. Builders author custom modules against the same Observe, Reason, Act contract on Priime Build: a custom module declares what it observes, 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: Priime Pools and Priime Loop, 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: Observe, Reason, 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.

Observe. The module reads its external dependencies and risk signals every block. That means on-chain state and off-chain data together: oracle feeds against DEX spot, venue health, funding rates, slippage, bridge and compute latency, and the position's own leverage.

Reason. The module evaluates that snapshot against your current exposure. It asks whether the position is still within bounds, and if not, which single response best reduces risk right now. The Priime Processor recomputes this from scratch each block, so the decision always reflects live conditions.

Act. When the reasoning calls for it, the module executes one action on the vault's position and settles it on-chain. 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 gate 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 an Observe loop at block time, tracking ten external signals that can move against you, then hands what it sees to the reasoning 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 reasons about 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. Priime Loop 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 Priime Processor 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 provable rather than hidden, but verifiability is not the same as immunity from defects.

Oracle and price-feed risk. The Priime Processor 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 Priime Processor is designed to handle delays in both, and the risk module watches for them directly.

The Priime Processor runs fetch, compute, settle every block, and each Priime Module runs its Observe, Reason, 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 Priime Processor 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 Priime Processor executes and verifies every vault: it fetches data on-chain and off-chain, computes at block time, and settles on any chain, provably, 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 Priime Processor 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 Priime Processor runs a fetch, compute, settle flow each block, and each step is provable.

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 Pools-facing trio (Auto Center, Auto Hedge, Auto Compound). Builders can author custom modules against the same Observe, Reason, Act contract.
• Vaults are the strategies launched on Priime Build. Priime Pools (concentrated, actively managed liquidity) and Priime Loop (delta-neutral leverage loops) 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?

Two published fees on every vault, Priime's own included: a 30% compute fee on yield, charged at harvest, and a 2% settlement fee on deposits. 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 Processor and its Observe, Reason, Act modules are the foundation, Priime Build is the venue on top of them, and the first vaults, Priime Pools and Priime 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 verifiable and provable. 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 Priime Processor 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.