One verifiable stack, from the metal up.
Priime is a stack: the Processor at the base, composable modules above it, and the apps you use on top. This page is how each layer works, and why every action it takes is provable, not something you have to trust.
A Processor you do not have to trust.
The Priime Processor runs your strategy off-chain and brings the result on-chain, provably. It monitors every block and acts only when something needs to change, doing three things: fetch, compute, settle. The difference from a trading bot is one word: verifiable. A set of distributed operators each run it, and the chain only accepts a result a quorum of them produced, matched, and signed.
ETH
BASE
UNI
BNB
OP
HL
INK
SOL
APTETHBASEUNIBNBOPHLINKSOLAPTEvery action, provable by design.
A registered, weighted set of operators each re-runs the same deterministic logic on the same inputs. The aggregator only proceeds when enough produce identical results and sign them. The on-chain verifier checks those signatures against the operator set. An insufficient quorum is rejected by design, so no single party can move your position.
A module is one Observe, Reason, Act loop.
A module is one unit of automation: a trigger, a piece of sandboxed WebAssembly, and a submission. Something to watch, logic to run, an action to take. Modules are composable, so an app is just a set of modules running together, and because a module can return nothing, it acts only when its condition is met.
A trigger watches for the condition that matters: an on-chain event, a cron schedule, every block, or an off-chain feed.
The module logic runs off-chain as sandboxed WebAssembly. Deterministic, so the same inputs always produce the same result.
If action is needed, operators sign the result and a quorum settles one verified transaction. If not, the module returns nothing and holds.
Each module watches one signal, and acts only when it must.
A strategy is an arrangement of these. The screen is what a module sees; the keys are what it can do, lit the moment it fires. They patch into one another, and into the Priime Processor.
Off-chain speed. On-chain trust. Priime Processor.
Priime is verifiable off-chain compute. Your code runs in fast WASM sandboxes across a set of distributed operators, each re-runs the exact same deterministic logic and signs the result. A thin on-chain contract accepts it only when a quorum agrees. The verifiability of a distributed operator set, settled with the trust and finality of the chain, without paying to run your logic on-chain.
Off-chain speed, on-chain trust, no compromise: distributed operators in WASM sandboxes agree, and a quorum of their signatures settles on-chain.
Same modules, assembled differently.
Priime Pools and Priime Loop are different combinations of the same modules, running on the same Priime Processor. A new app is a new arrangement of modules, not new infrastructure.