The first truly decentralized AI lives on Genesis L1.

Open gl1f.com → Create → Dataset. Drop a CSV with hourly BTC candles plus engineered features. The studio parses it in your browser, infers numeric vs categorical columns, and lets you click to mark feature columns and the label column. Pick the task — binary_classification — and choose which label value is "pump" (class 1).

The Data Galaxy sub-panel shows a live 3D PCA projection of your data so you can spot leakage or cluster structure before training. Walk-forward, not random split — for time-indexed crypto data the studio defaults to chronological train/val/test partitioning so the model never peeks at the future.

The Training tab exposes the hyperparameters that matter — number of trees, depth, learning rate, min-leaf, bins, seed — with sane defaults for crypto. Training runs in a Web Worker (UI stays smooth); validation log-loss streams live as each tree is added.

Click Heuristic search and the studio runs bounded random mutation around your config to find a better one. Click Refit on train+val at the end and it retrains using the best tree count on the union. All of this is point-and-click in the browser.

⚠ More than ~100k rows? Switch the Compute backend selector from WASM to PYTHON :8088 or C++ :8089. The supplied local server runs on your own machine; the studio sends it the dataset over localhost. The training UI stays exactly the same. Your data never leaves the device.

The Local preview tab decodes the just-trained model bytes locally, replays predictions row-by-row in chronological order, and shows feature importances (split-usage + permutation), per-tree metric curves, and a per-row playground for sanity checks. Time series leak past into future under random splits — GL1F enforces walk-forward by default, so the metrics you see here are the ones you'll get in production.

→ Everything in this tab runs locally against the binary .gl1f file the studio just produced. It is the same decoder the on-chain runtime uses, so what you see here is what the chain will return.

The Mint tab packages your trained .gl1f bytes, splits them into GL1C chunks (≤24,572 B each, the EIP-170 code-size limit minus a 4-byte magic prefix), and deploys each chunk as a tiny pointer contract using ModelStore.write(). A pointer-table contract follows; then ModelRegistry.registerModel() mints the NFT and binds the model.

You fill out: a 128×128 PNG icon, a name, a description, a pricing mode (free / tips / paid-required), a fee, and an owner API access key. You agree to the active license (default CC BY-SA 4.0) and the on-chain Terms version. Click mint. N + 2 transactions later, your model is live on GenesisL1.

For very large models (millions of bytes, tens of chunks), GL1F also supplies an optional Python minter (gl1f-mint) so you can deploy chunks from your terminal in parallel. Same ABIs, same network, same end result. The browser path remains the default and works for the overwhelming majority of models.

✓ Once mined, the model is a transferable ERC-721. Its tokenId is human-facing; its modelId = keccak256(bytes) is content-addressed. Anyone can re-derive that hash from the on-chain bytes — your training is its own witness.

The model lives on GenesisL1 and is queryable by any wallet, any contract, any chain client. This is the only step in the tutorial where code appears — because it's how other dapps consume your model. From the studio side, you've already shipped.

// Any contract on GenesisL1 (chainId 29) can call your model.
// No oracle middleman. The prediction is part of the same atomic tx as the trade.

interface IForestRuntime {
    function predictView(bytes32 modelId, bytes calldata packedFeaturesQ)
        external view returns (int256 scoreQ);
}

contract PumpStrategy {
    IForestRuntime public immutable runtime;
    bytes32  public immutable modelId;        // 0x9af3…7c2d
    uint32   public immutable scaleQ;         // 1_000_000

    function isPump(int32[7] calldata q) external view returns (bool) {
        bytes memory packed = _packLE(q);                // int32 LE per feature
        int256 scoreQ = runtime.predictView(modelId, packed);
        // score is logit · scaleQ; >0 means P(pump) > 0.5
        return scoreQ > 0;
    }
}

import { JsonRpcProvider, Contract } from "ethers";
import { RUNTIME_ADDR, RUNTIME_ABI, packFeatures } from "./gl1f";

const rpc     = new JsonRpcProvider("https://rpc.genesisl1.org");
const runtime = new Contract(RUNTIME_ADDR, RUNTIME_ABI, rpc);

const packed = packFeatures([-0.0023, -0.0140, 28.4, 0.0180,
                              -0.0110, -0.0340, -0.0270], 1_000_000);

const scoreQ = await runtime.predictView("0x9af3…7c2d", packed);
const p      = sigmoid(Number(scoreQ) / 1_000_000);
console.log(p);   // 0.866 — strong pump signal