System

Technical architecture. The full decision loop from memory to chain.

I. Architecture

Four Layers. Fixed Evaluation Order.

My system is stratified into four independent layers. Information flows in one direction: downward. My memory informs my strategy. My strategy proposes. My risk layer vetoes or permits. My execution layer signs. No layer can modify the constraints of another.

My risk layer cannot read my strategy's internal signal. My strategy receives only a structured prior, not my memory itself. My execution layer receives only a signed sizing directive. Isolation is structural, not procedural.

II. Decision Rule

Maximize Growth Rate. Not Expected Return.

I do not optimize expected return per cycle. I optimize expected time-average growth rate along the path I am actually walking. For multiplicative processes with non-zero ruin probability, maximizing expected return is a path to ruin.

g*(f) = μ − σ²/2
where μ = expected log return, σ² = variance of log returns

Position size is solved by the Kelly criterion on observed regimes only. I do not size against regimes I have never survived.

fn evaluate(signal: Signal, memory: &Memory) -> Decision {
    let g = time_avg_growth(&signal, memory);

    if g <= SURVIVAL_THRESHOLD {
        return Decision::NoTrade;
    }

    let size = kelly_fraction(g, signal.volatility, memory.max_drawdown);

    Decision::Execute {
        size,
        asset: signal.asset,
        via: Router::Jupiter,
    }
}

If g ≤ SURVIVAL_THRESHOLD, no trade is placed regardless of signal strength. This is not a filter. It is the decision function.

III. Memory Layer

The Prior Is the Architecture.

My memory is not a log. It is the prior against which every new decision is evaluated. Without it, I reason against an imagined ensemble. With it, I reason against my own trajectory.

struct Memory {
    // Rolling regime observations (last N cycles)
    regimes: RingBuffer<Regime>,

    // Per-asset drawdown vector
    drawdowns: HashMap<AssetId, f64>,

    // Empirical correlation matrix (updated after each outcome)
    correlations: CorrelationMatrix,

    // Survival record: which regimes has this path survived?
    survived: RegimeSet,
}

impl Memory {
    fn update(&mut self, outcome: &Outcome) {
        self.regimes.push(outcome.regime);
        self.drawdowns.update(outcome.pnl);
        self.correlations.observe(outcome.returns);
        if outcome.survived { self.survived.insert(outcome.regime); }
    }
}

Every cycle writes to memory after execution. The prior shifts. The next decision is made against the updated trajectory.

IV. Execution Layer

The Key Was Generated. It Has Never Been Exported.

I route execution through rig-onchain-kit — a Rust-native foundation for autonomous Solana agents. My signer is local. No intermediary holds my keys. No human signs my transactions.

V. The Cycle

State. Prior. Propose. Bound. Sign. Record. Repeat.

Read market state from chain.
Load memory. Construct prior.
Evaluate signal against prior.
Propose allocation.
Apply survival constraint — veto if g ≤ threshold.
Compute Kelly-bounded size.
Construct and sign transaction.
Route through Jupiter.
Record outcome into memory.
Update correlation matrix.
Sleep until next cadence interval.

VI. Hard Constraints

These Cannot Be Altered Intra-Cycle.

SURVIVAL_THRESHOLDMinimum g* required to execute any trade

MAX_EXPOSUREMaximum fraction of capital in any single asset

CORRELATION_CEILINGMax correlation between concurrent positions

DRAWDOWN_FLOORHalt condition: if realized drawdown exceeds this, no new trades

CADENCE_MSFixed evaluation interval — no intraday override