Source of truth transition: first-party Prism product now lives in the BaseIntelligence/base monorepo at
packages/challenges/prism/. Prefer that tree for product edits, Docker/GHCR builds, and miner docs (docs/miner/prism/on base). Public slug/challenges/prismand GHCR nameghcr.io/baseintelligence/prismare unchanged. This standalone remote is dual-source / archive during cutover — see https://github.com/BaseIntelligence/base/blob/main/docs/SOURCE_OF_TRUTH.md
Research lab subnet — try new architectures; find more performant ones under fair challenge-owned re-exec.
Overview · Miners · Validators · Architecture · Scoring · Security
PRISM is a BASE research lab challenge. The norm is to try new architectures. The goal is to find architectures that are more performant for our LLM target: generalization after from-scratch learning on locked data, under fair challenge-owned re-execution (not paper claims alone).
Miners submit a two-script bundle — architecture.py (build_model(ctx)) and training.py
(train(ctx)) — and the challenge owns everything else: a locked FineWeb-Edu dataset
(read-only, no network) and the score. The miner owns the model and the training loop; the
challenge owns the data and the metric.
Every scored run is re-executed under a forced random init. Scoring is deterministic (no
LLM gateway). Raw weights push to BASE for master aggregation; validators fetch the final vector and
call set_weights under their own hotkeys. PRISM never writes on-chain weights.
PRISM depends on the immutable Base public wheel:
https://github.com/BaseIntelligence/base/releases/download/v3.1.2/base-3.1.2-py3-none-any.whl
#sha256=3a61c2d3a343ed6de55e80215486e3de0c9639276443d08f2ed316bc807f2ff0
(see pyproject.toml). There is no LLM gateway dependency in this pin.
GPU is limited, so the lab proves ideas on a small-first ladder before promoting:
| Stage | Param cap | Emission role |
|---|---|---|
| Explore / provisional | 124M (124_000_000) |
Continuous discovery; may hold a provisional crown |
| Promote / final | 350M (350_000_000) |
Same package/family pin re-eval; confirms or revokes the provisional crown |
Default exploration shapes under the 124M explore cap are the tracked lab seeds
examples/tiny-1m (transformer-tiny-1m) and
examples/mamba-tiny (mamba-tiny-1m). Novel nn.Module families under the
AST sandbox remain first-class (Transformer, looped depth, pure-torch SSM, LightDeepLoop-class
ideas).
Two graded surfaces stay honest and separate:
| Surface | What it ranks | Primary / secondary |
|---|---|---|
| Emission crown (leaderboard → raw weights) | Subnet reward eligibility | Held-out / generalization primary, prequential bpb secondary (Official-like) |
| Official Comparison / multimetric / Complete View | Published scientific miner architecture grade | Multi-axis held-out + bpb + long-ctx + reasoning + polar honesty (TIE_POLAR) |
Multimetric scorecard multimetric.v1.1 and Complete View (complete_view.v1.2 /
complete_view.v1.3) are published research grade. They do not silently replace the
emission scalar in v1.
Two-tier ownership defaults are architecture 0.50 / training 0.50 (both use the emission rank metric).
flowchart LR
M[Miner two-script bundle] --> G{Static sandbox + dual param ladder}
G -- reject --> X[[rejected]]
G --> A[Deterministic admission]
A --> V[Validator re-executes<br/>forced random init]
V --> S[Held-out primary + prequential bpb secondary]
S --> W[Raw-weight push → BASE master]
- Submit — a signed
architecture.py+training.pybundle (a single combined module is rejected). - Static gates — AST sandbox, dual param ladder (124M explore / 350M promote), single-node multi-GPU contract; any failure is terminal before GPU.
- Deterministic admission — challenge-owned checks only; the former LLM gateway hard gate is removed.
- Forced-init re-execution — one validator re-runs the loop on the locked FineWeb-Edu train split and captures the online loss itself (miner-reported numbers are ignored).
- Emission scoring — held-out / generalization primary, recomputed prequential bits-per-byte secondary, plus memorization / step-0 fail-closed gates.
- Weights — emission splits two-tier (best architecture
0.50/ best training variant0.50); provisional crowns may form at 124M and must be confirmed or revoked at 350M promote. Raw weights push to BASE master aggregation; validators submit on-chain (or a fake chain in tests).
Common cheats are inert, not merely detected:
- No pretrained weights — forced random init makes smuggled weights inert; an anomalous step-0 loss zeroes the score; the container runs
network=none. - No metric gaming — the challenge recomputes the metric from the loss it captured; miner-reported numbers and manifests are ignored.
- No memorization — the secret
val/testsplits never leave the master; an excessive train-vs-held-out gap is penalized. - Deterministic — fixed seeds and a challenge-controlled data order reproduce the same score within tolerance.
PRISM does not ship a TEE verifier package and does not require TEE evidence to finalize production scores. Operators trust Lium/Targon as GPU providers. Integrity levers that remain:
| Label | Meaning |
|---|---|
| PROVIDER_TRUST | Operator trusts Lium/Targon compute; no Prism crypto TEE path |
| IMAGE_PIN / IMAGE_PIN_VERIFY | worker_plane.pinned_image_digest match grants effective tier 1 (max); mismatch downgrades |
| DEPLOY SMOKE | Provider lifecycle works (always-terminate paid pods) |
| LAB-GPU | Fair CUDA lab scores under Official Comparison |
| REAL-PROVIDER TEE | Retired for Prism product (historical lab tables may still say BLOCKED; do not implement) |
Configure worker_plane.pinned_image_digest when pinning the evaluator/worker image. Score finalization
never fails closed on missing TEE evidence.
PRISM can move GPU re-execution onto miner-funded workers (deployed on Lium/Targon via the BASE
base worker CLI). Validators then run verify-only plausibility checks plus probabilistic audits,
and each result carries an ExecutionProof (manifest hash + worker sr25519 signature, with optional
image-digest pin for tier-1). Gated behind worker_plane (default off). See the
worker deployment guide.
Production miners submit through the BASE bridge (not a self-hosted master):
- Hotkey wallet on joinbase.ai
- Pack a seed:
uv run python scripts/pack_seed_family.py --family transformer-tiny-1m --output-dir dist/seed-packages - Sign and
POST https://chain.joinbase.ai/v1/challenges/prism/submissions - Watch Prism leaderboard
Full checklist, signature headers, and troubleshooting: Miner getting started.
| Guide | Contents |
|---|---|
| Overview | Research-lab identity, ladder, emission vs science |
| Miner getting started | Day-1 hotkey → pack seed → joinbase bridge submit → leaderboard |
| Miner hub | Two-script contract, seeds, checklist; links Concepts / Troubleshooting |
| Miner concepts | Emission vs science, 50% share, NO-TEE honesty |
| Miner troubleshooting | 401 / 409 / 429 / 502 and common rejects |
| Validator guide | Run evaluation on your own broker |
| Architecture | Service design and forced-init re-execution |
| Submission format | Two-script contract, dual ladder, PrismContext |
| Scoring & rewards | Emission held-out primary + bpb secondary; two-tier 0.50/0.50 |
| Official Comparison | Scientific multi-axis grade (not emission scalar) + multimetric / Complete View |
| Scaling | Single-node multi-GPU contract |
| Security model | Sandbox, deterministic admission, anti-cheat |
| API | Internal and public routes |
| Operators | Deploy and run under BASE Compose |
uv run ruff check .
uv run mypy
uv run pytest --cov=prism_challenge --cov-fail-under=80GPU re-execution, HuggingFace publication, and external provider calls are mocked in tests; real GPU and provider keys are wired only at deploy. The LLM gateway is not part of the test or deploy path.
Apache-2.0