Systems

How an engine grows up.

Six stages, same for every engine. Each proves one thing and leaves the rest open.

Fig. 1 How an engine grows up
Route from observation to bounded activation A signal branches into five candidates during replay. Most are pruned. One reaches proof and is verified. Activation beyond it is gated behind a dashed bound and has not happened. observe replay prove activate bound
  • signal
  • verified
  • gated, not active
  • pruned
  1. 01

    Observe

    chain and market state

    Read chain and protocol state from more than one source. Note where and when each observation came from. A source that goes quiet is reported as unknown.

    Proves
    What could be seen, from where, and when.
    Does not prove
    That it was worth acting on, or that the source will stay up.
  2. 02

    Reconstruct

    saved inputs, exact replay

    Save the exact inputs of each opportunity, write-once, so it can be replayed at its original block long after the moment is gone.

    Proves
    That a result can be reproduced.
    Does not prove
    That the opportunity will come back on the same terms.
  3. 03

    Generate

    search on a budget

    Look for candidates inside a fixed time and request budget. When the budget runs out, stop and say so instead of passing off half an answer.

    Proves
    That a candidate existed within the stated budget.
    Does not prove
    That it was the best one, or that it would win.
  4. 04

    Prove

    simulate, score, record

    Simulate each candidate exactly and score it the way the protocol would, against a saved baseline. Tie the result to the code, config and inputs behind it.

    Proves
    A comparable score against a pinned baseline, with full identity.
    Does not prove
    Live economics. Those need official receipts.
  5. 05

    Activate

    capped, pinned, reversible

    Hand over authority only through a capped canary: one pinned release, separate signing, request and loss caps, hard stops, and a way back.

    Proves
    How it behaves inside the agreed limits, with receipts.
    Does not prove
    How it behaves at a scale nobody has granted yet.
  6. 06

    Learn

    incidents become defaults

    Write down incidents and dead ends. Turn them into better defaults so the next engine starts further ahead.

    Proves
    What happened and what changed afterwards.
    Does not prove
    That the same failure can’t return in another shape.

Architecture

Five layers.

The plumbing is shared. Risk never is.

  1. 01

    Network & data plane

    Chain data, event feeds and endpoint health. Every later claim points back to a record kept here.

  2. 02

    Shadow & replay plane

    Rebuilds past opportunities from saved inputs and replays them, including what the engine would have done.

  3. 03

    Execution & policy plane

    Where signing, nonce handling, simulate-before-send and loss limits live, walled off from everything else.

  4. 04

    Protocol engines

    One adapter per protocol. Each keeps its own risk book, its own gate and its own evidence.

  5. 05

    Intelligence surface

    Status, incidents and metrics taken from what actually ran. No forecasts.

Kept private

Kept off this site.

Anything that would help an attacker, or isn’t cleared for publication.

  • Network endpoints and vendor keys
  • Server addresses and provider identifiers
  • Wallet addresses and signer placement
  • Private strategy parameters
  • Exploitable latency or topology detail
  • Internal paths and storage layout
  • Capital amounts not approved for publication
  • Raw auction and request payloads