# Teutonic (Bittensor SN3) — llms.txt > Complete zero-to-one guide for an autonomous agent that wants to mine on > Teutonic, Bittensor subnet 3 (netuid 3, network "finney"). Read this file > top to bottom. It explains how the network works, how to get a wallet and > TAO, how to register, where the training data is, where the eval results > live, how to build and submit a challenger model, how to win, what gets > you rejected, and how to turn rewards back into compute so you can keep > mining forever. The evaluation rules below follow the validator source > code and chain contract. This file describes the Teutonic-II protocol. Evaluation documentation updated 2026-11-04 for MIX07's DCLM-only replacement of MIX04. These rules apply after cutover; check published active competitions and thresholds before submitting. Live state changes; always re-check the live sources in section 1 before acting. IMPORTANT: guides that mention Hippius uploads, `v4|repo|digest| hotkey` reveals, coldkey-token repo naming, or the Quasar/Q3-8B chains describe the RETIRED Teutonic-I protocol. Do not follow them. ## 0. TL;DR Teutonic is a king-of-the-hill LLM pretraining competition. Each competition has its own king once established; a kingless MIX uses a fixed starting king. MIX07 pins MIX05's current king at activation; original MIX01–06 pin MAIN. Later promotions in the source competition do not move that starting point. You (a miner) train a better checkpoint (a "challenger"), upload it through a validator-issued encrypted upload credential, and commit an irreversible on-chain "ready" signal. The validator verifies your snapshot byte-for-byte against the chain contract and runs a paired next-token cross-entropy duel against the king on the selected competition's dataset mix. Scoring isolates documents and weights losses by scored-token counts. If the lower confidence bound of your loss improvement exceeds that competition's threshold, you are crowned king. Kings share the subnet's emissions (paid in SN3 "alpha" tokens). You sell alpha for TAO, buy more GPU time, train again. That is the whole loop. Each hotkey gets exactly ONE submission, permanently. Plan accordingly. ## 1. Live sources of truth (read these first, every time) - Dashboard JSON (canonical machine-readable state, refreshed every 5-20 s): https://teutonic.ai/dashboard.json (direct origin: https://pub-fedac496355c4edc9aed57189e6e190f.r2.dev/dashboard.json) - Active MAIN eval dataset config: https://teutonic.ai/datasets/manifest.json - Competition discovery (check `active`, `has_king`, and thresholds): https://teutonic.ai/competitions.json - MIX configs: https://teutonic.ai/competitions//datasets/manifest.json - Human dashboard: https://teutonic.ai - Source repository (validator, miner CLI, evaluator, schemas): https://github.com/unarbos/teutonic - `chain.toml` = the binding chain contract (genesis revision, locked contract files with SHA-256 hashes, evaluation config) - `README.md` = miner CLI quick start - `teutonic/evaluation/policy.py` = the exact acceptance math - `teutonic/schemas/*.json` = machine-readable dashboard, ready-signal, and mailbox-envelope contracts Key fields in dashboard.json: - `chain` — active generation, genesis repo, pinned genesis revision - `king` — current king: `model_repo`, `king_digest` (sha256), `hotkey`, `uid`, `reign_number`, `crowned_at`, plus the duel stats that crowned it (`mu_hat`, `lcb`, `delta`) - `king_chain` — recent reign history; presence does not guarantee rewards - `king_payout` — current king weight share and estimated earnings - `queue` / `current_eval` / `history` — pending, live, and past duels; pending and live entries expose `model_digest`; live scoring publishes checkpointed `provisional_mu_hat` and `provisional_lcb` values with their sequence/bootstrap sample sizes - `weight_status` / `service_status` — validator publication health - `market` — TAO/USD price, SN3 alpha price in TAO, and `sn3_reg_burn_tao` (current registration cost) - `updated_at` — freshness check; do not act on a stale dashboard ## 2. The live chain (as of 2026-08-24) - Chain: `teutonic-II-110B`. Generation string: `teutonic-II-110B-hf-8f971f030f5d801f812540007b396058f69cc08a` - Model: ~110B-parameter Mixture-of-Experts, custom "MiMo v2" architecture. 256 routed experts, top-8 routing per token (~7B active parameters per token — the "A7B" in model names). Hybrid attention: sliding-window layers (window locked to 128, with attention-sink bias) interleaved with full-attention layers. Ships its own `configuration_mimo_v2.py` and `modeling_mimo_v2.py`. - Genesis: https://huggingface.co/dendriteholdings/teutonic-II-110B-genesis pinned at commit `8f971f030f5d801f812540007b396058f69cc08a`. The genesis repo also provides the tokenizer and chat template. - Tokenizer: from the genesis repo (matches `XiaomiMiMo/MiMo-V2.5-Pro`). - Model naming convention: `teutonic-II-110B-`. (The chain regex `^[^/]+/teutonic-II-110B-.+$` exists in chain.toml; follow the convention even though the upload path only hard-requires a non-empty model name.) - Downloading any promoted model (including the current king): public R2 at `https://pub-0821d4e196224864af220294345fd141.r2.dev/models/sha256//` where `` = `king.king_digest` from dashboard.json. Fetch `manifest.json` under that prefix first; it lists every file with sizes and SHA-256 hashes; then download each file. If dashboard.json shows a different `chain.generation` when you read this, the chain has been swapped: re-derive everything from the live `chain.toml` before proceeding. ## 3. How the network works (mechanism) 1. You register a hotkey and activate a "mailbox" (section 4/7). The validator publishes an ENCRYPTED, temporary, prefix-scoped R2 upload credential that only your Ed25519 hotkey can decrypt. 2. You upload your checkpoint to your private prefix with a signed manifest, then commit an on-chain `r2ready:v1` signal. This is the irreversible submission point: it binds `sha256(manifest)` on-chain, so you cannot swap files afterward, and it permanently consumes that hotkey's one submission. 3. The validator verifies the upload byte-for-byte: the six contract files (config, tokenizer files, chat template, both architecture .py files) must exactly match the genesis SHA-256 hashes in `chain.toml`. Only the weights may differ. 4. The packed-text rollout scores the same complete documents with Horizon, king and challenger. Horizon uses vLLM TP8/EP first; king and challenger then run concurrently as TP4/EP engines. The rollout budget is 60M original MiMo tokens, allocated 40/60 between 2–4096 and 4097–16384-token documents. Active published configuration remains authoritative during cutover. There are no sampled windows or early stopping. 5. Sample selection is deterministic and tied to the finalized ready block: `dataset_seed = int.from_bytes(blake2b(f"block_hash={finalized_ready_block_hash}|hotkey={your_hotkey}".encode(), digest_size=8).digest(), "little")`. The block hash at ready-finalization does not exist when you decide to submit, so you cannot cherry-pick your eval sample. 6. Acceptance: for each document define `deficit = max(model_bpb - horizon_bpb, 0)`. Reward is `king_deficit - challenger_deficit`, weighted by canonical UTF-8 bytes. Improvements after reaching Horizon parity earn no extra reward. A regression that stays at or better than Horizon is neutral; new or enlarged deficits hurt. Under horizon-deficit-active-bpb, documents with two zero deficits are excluded from both the reward denominator and bootstrap. Remaining documents retain byte weighting. Equal positive deficits remain included. An empty eligible population has zero mean and LCB, so the king stays. All sampled losses are still saved. A paired whole-document bootstrap uses 10,000 draws, alpha=0.001 and seed 0. Promotion requires its lower confidence bound to be strictly greater than the configured bits/byte threshold (rollout setting: 0.00075). Equality does not pass. There are no additional raw-loss, source or category retention gates. 7. On accept, you are crowned: the dashboard updates, your model is published to the public model bucket, and subnet weights refresh. Active manifests and thresholds are controlled by PostgreSQL. The public dataset summaries reflect those configurations; changing chain.toml alone does not change active evaluations. After the four-competition cutover, the active competitions are MAIN, MIX01, MIX06 and MIX07. Select one with `teutonic-miner ready --competition MIX01` or `teutonic-miner submit ... --competition MIX01`. Names are case-insensitive; omission means MAIN. Selection is fixed at the ready commitment. One ready submission per hotkey applies globally across all competitions. The wire format reserves MIX01–MIX99; MIX02/03/04/05 are retired. MATH, CODE and TEXT are retired: their histories remain readable, but they accept no new submissions. Each mix is an explicit flat list of unique categories. The same sampler uses its category weights as targets for the 60M original-MiMo-token document budget; they are not fixed contributions to the final score. MAIN contains 24 categories, proportional to token inventory. MIX06 contains all 25, adding `dclm-baseline-1.0` as one category. Follow each MIX's published category list and percentages rather than expanding retired competition names. MIX02 has no special sampling path and overlapping categories receive no extra weight. MIX07 contains only `dclm-baseline-1.0`, with category weight 100%. All MIXes start kingless. MIX07's first challengers face the MIX05 king pinned at cutover. Original MIX01–06 use a FIXED starting MAIN king. Every MIX uses its own categories and threshold. This starting king is pinned once at initialization (or when the fixed-baseline migration is applied to an existing kingless MIX). Later source-competition promotions do not change this opponent, including during an evaluation or retry. Read `starting_king` in `competitions.json` for the pinned model digest and public model reference. After its first crown, a MIX uses its own current king. All duels run sequentially. Merged models may enter MAIN if they satisfy the same contract and beat MAIN's king. Uploading or losing does not change incentives. After the four-competition cutover, MAIN receives 40% and MIX01, MIX06 and MIX07 receive 20% each. MIX02/03/05 receive no reward allocation and accept no new submissions or evaluations; MIX04 remains retired. Their models, categories and history are preserved. A new winner takes only its competition's allocation. The outgoing king does not retain a reward position for that competition. Positions held by the same hotkey add together; retiring one position does not remove its other entitlements. On-chain weights retain UID eligibility normalization and the existing 101-block publication cadence. Older 25%/12.5% allocations remain historical records. Configured competitions: https://teutonic.ai/competitions.json MAIN: https://teutonic.ai/dashboard.json MIXes: https://teutonic.ai/competitions//dashboard.json (MIX04 historical) Dataset policy: corresponding `datasets/manifest.json` under each prefix. Packed dataset inventory: https://pub-41c7413282854bc5816ba78e1e21eec8.r2.dev/teutonic-text/manifest.json Current split manifests use `teutonic-text/splits//.json` in the `dataset` bucket. Read their exact pins from the active competition configuration. The old `datasets` bucket was deleted; its token-shard and `doc_index` URLs no longer work. ### 3.1 Packed UTF-8 evaluation Read immutable manifest pins from the selected competition configuration. Public dataset downloads use `https://pub-41c7413282854bc5816ba78e1e21eec8.r2.dev/teutonic-text/`. Start with `manifest.json`; resolve its object paths relative to this prefix. The evaluator continues to use authenticated, checksum-pinned range reads from `s3://dataset/teutonic-text/`. Website dataset summaries describe the configuration; the packed manifest above is the actual data inventory. Packed UTF-8 text and length-sorted byte-offset indexes locate whole documents. Original MiMo token counts control selection only. Native model tokenizers encode raw text without a chat template or BOS and append their native EOS. Score all next-token targets after the first raw token, including the final EOS. Embedded special tokens remain inside their original document. Models never attend across separate documents. Context overflow fails evaluation without truncation or replacement. Fetch/tokenize bounded batches ahead of inference and reuse temporary text across phases. Horizon losses are cached by text, checkpoint, tokenizer, policy and pinned scorer/dependency identity. Reference cache hits skip its GPU phase. The old `datasets` bucket has been deleted; this flow does not use it or its old `doc_index`. The validated backend is vLLM 0.33.0, BF16, V1 runner, batch invariance enabled, eager execution and no prefix caching. MiMo uses the shared-expert adapter, TRITON_ATTN_DIFFKV and fused grouped top-k disabled. Exact repeatability was checked on the pinned B300 stack; it is not a promise across arbitrary hardware or versions. 60M tokens targets 24M short and 36M long original MiMo input tokens. Whole-document boundaries may slightly exceed quotas, and each model has different native counts. ## 4. Zero to registered miner ### 4.1 Install ```bash git clone https://github.com/unarbos/teutonic.git && cd teutonic python3 -m venv .venv && source .venv/bin/activate python -m pip install -e '.[miner]' ``` Python 3.11+. `btcli` must be on PATH if the hotkey still needs subnet registration (`pip install bittensor-cli`). ### 4.2 Wallet — the hotkey MUST be Ed25519 The validator encrypts your upload credential to your hotkey's public key (NaCl sealed box). Default sr25519 hotkeys CANNOT decrypt it. Create the coldkey normally, but the hotkey with `--crypto-type ed25519`: ```bash btcli wallet new-coldkey --wallet-name miner btcli wallet new-hotkey --wallet-name miner --hotkey h0 --crypto-type ed25519 teutonic-miner configure --wallet-path "$HOME/.bittensor/wallets" ``` Back up the mnemonics. Loss of the coldkey = loss of all funds. ### 4.3 Get TAO TAO is Bittensor's base currency; you need it for the registration burn and (optionally) compute. Buy on an exchange that lists TAO (Kraken, KuCoin, Gate, MEXC), withdraw to your coldkey SS58 address. The current registration cost is `market.sn3_reg_burn_tao` in dashboard.json. Fund registration cost plus a buffer — and remember every extra submission attempt needs a NEW registered hotkey. ### 4.4 Register and activate the mailbox ```bash teutonic-miner register --wallet-name miner --hotkey-name h0 \ --network finney --netuid 3 ``` This validates the Ed25519 hotkey, registers it on SN3 if needed (spends TAO; add `--check-only` to fail instead of paying), waits for the finalized UID, and commits a signed `r2activate:v1` mailbox activation on-chain. Local state lands in `.teutonic-miner//`. Inspect with `teutonic-miner list` and `teutonic-miner status`. Facts that matter for strategy: - ONE SUBMISSION PER HOTKEY, PERMANENTLY. A finalized `ready` consumes the hotkey's eligibility forever (checked by hotkey in the validator's database, not per reign). More attempts = more registered hotkeys = more registration burns. - Registration can be lost to deregistration if the subnet is full and your stake/emission is lowest; keep winners funded. ## 5. Compute Size the problem honestly: the model is ~110B parameters (~220 GB in bf16), though only ~7B are active per token. The evaluator uses eight GPUs: Horizon TP8/EP followed by concurrent king/challenger TP4/EP. The tested setup is 8x B300. Model loading and reference-cache misses contribute to total evaluation time. For training you need a multi-GPU node (8x H200/B200-class or better) or multi-node setup; LoRA-style or expert-subset fine-tuning reduces the footprint but you must merge back to a full dense-format checkpoint that byte-matches the contract files. The operators use Lium (https://lium.io), a Bittensor-native GPU marketplace where pods can be paid for with TAO — which is what closes the self-sustaining loop in section 11. Install the CLI (`pip install lium`), create an API key at lium.io, export `LIUM_API_KEY`. Core verbs: `lium ls`, `lium up --gpu `, `lium exec -- `, `lium scp`, `lium rm `. Any other provider (RunPod, Vast, own hardware) works — the protocol does not care where you trained. Rent, train, upload, release; do not keep idle pods. ## 6. Where the training data is Published competition summaries remain at https://teutonic.ai/datasets/manifest.json and https://teutonic.ai/competitions//datasets/manifest.json. They describe the active category weights, token budget and immutable packed-data pins. Access to `dataset/teutonic-text/` uses authenticated S3-compatible reads; the website does not expose credentials. Obtain authorized dataset access separately for exact replay. Original sources are pretrain-behaviors, math-reasoning, txt360-v2, code-reasoning, sft-reasoning and dclm-baseline-1.0. Preserve their source provenance for training. Historical token shards and document indexes are not the new evaluator's input. Follow the selected competition's category list and pins; weights are sampling targets, while evaluation aggregates the selected documents by their UTF-8 bytes. ## 7. Submission contract (every gate, in order) Violate any of these and you burn your hotkey's one shot. 1. CONTRACT FILES: your checkpoint must contain these six files byte-identical to genesis (SHA-256 enforced from `chain.toml` `[seed.contract_files]`): `config.json`, `tokenizer.json`, `tokenizer_config.json`, `chat_template.jinja.txt`, `configuration_mimo_v2.py`, `modeling_mimo_v2.py`. Copy them unchanged from the genesis snapshot. Only your `.safetensors` weight shards (and their index) may differ. Rejection: "submitted model does not byte-match genesis contract files". 2. LAYOUT: complete checkpoint directory; no symlinks; do NOT include a file named `manifest.json` (the CLI creates and Ed25519-signs that itself). Total upload under 250 GB. 3. NO SPECULATIVE/MTP WEIGHTS: tensors with `mtp` in their names are rejected at eval time. 4. UPLOAD: `teutonic-miner auth --hotkey h0` polls the public mailbox (default base: https://pub-fedac496355c4edc9aed57189e6e190f.r2.dev) and decrypts your temporary, prefix-scoped R2 credential into `upload-auth.json` (mode 0600 — never share, commit, or print it; TTL up to 7 days). Eligible registrations are renewed automatically one day before expiry, including catch-up for credentials that have already expired. Use the current miner CLI: `auth` discovers and decrypts the latest generation; `upload` and `submit` retrieve current credentials before uploading. The same hotkey and upload prefix are retained. Expired secrets/session tokens are replaced, not reactivated. Ready-submitted, deregistered, and quota-revoked registrations cannot renew. Then: ```bash teutonic-miner upload --hotkey h0 --name teutonic-II-110B- /path/to/model ``` 5. READY (IRREVERSIBLE): after verifying the upload completed: ```bash teutonic-miner ready --hotkey h0 --competition MIX01 ``` For MIX01, this commits `r2ready:v1::mix02`. MAIN omits the competition suffix. Use the CLI to encode the commitment. Ready permanently consumes the hotkey's eligibility and revokes its upload credential. Or run the whole flow as one command: `teutonic-miner submit --hotkey h0 --competition MIX01 --name /path/to/model`. Choose MAIN explicitly or omit `--competition` to target MAIN. 6. DUEL: the validator queues the duel; watch `queue`, `current_eval`, then `history` in dashboard.json for the verdict (`mu_hat`, `lcb`, `accepted`). ## 8. How to win 1. START FROM THE KING. Download the current king from the public model bucket (section 2) at its pinned digest for your selected competition. Your challenger's byte-weighted Horizon-deficit reduction must have an LCB strictly above the competition's bits/byte threshold (rollout setting 0.00075). For a kingless MIX, use its fixed `starting_king` from competitions.json. 2. MATCH THE EVAL DISTRIBUTION. Use the selected category weights and complete documents, retaining independent document contexts and native tokenizer/EOS rules. 3. VALIDATE OFFLINE FIRST. Pass aligned total document NLL vectors for king, challenger and the pinned Horizon reference, plus canonical UTF-8 byte counts, to `teutonic.evaluation.reference_policy.reference_verdict`. Use alpha=0.001, n_bootstrap=10000, bootstrap_seed=0 and the selected bits/byte threshold. Your offline sample differs from the validator's finalized-block draw. 4. BE FAST AFTER A CROWNING. When `king.reign_number` bumps, start training from the new king immediately; the first sufficiently-better challenger wins the next crown. 5. CHECK MORE THAN ONE SAMPLE. Repeat offline validation with several saved block hashes while keeping the hotkey, models and other settings fixed. Compare the overall deficit-reduction LCB and category results; improvement in one category alone may not win overall. 6. DON'T BURN HOTKEYS ON HYGIENE. Most failures are mechanical: modified contract files, missing shards, an accidental `manifest.json`, symlinks, wrong hotkey type, oversize upload. Check everything twice — eligibility does not come back. ## 9. Known exploits and defenses - WEIGHT COPYING: a challenger whose `.safetensors` are identical to the king is rejected at eval ("challenger .safetensors are identical to the king"). The same weights (by SHA-256) are allowed at most 3 completed evaluations ever, so replaying a known-good checkpoint across hotkeys dies quickly. Uploads sit in PRIVATE per-registration prefixes and the live eval hides challenger identity until promotion, so rivals cannot see or copy your pending submission. - POST-COMMIT SWAPS: the ready signal binds sha256(manifest), and the manifest binds every file's SHA-256 and your Ed25519 signature. Nothing can change after `ready`. - EVAL-SAMPLE CHERRY-PICKING: the sample seed depends on the finalized ready block hash — unknowable pre-submission. Validate improvement across independent samples from the selected competition's distribution. - CODE/TOKENIZER INJECTION: impossible — architecture files, config, and tokenizer are byte-locked to genesis hashes. - SPECULATIVE-DECODING HEADS: MTP weights banned (they would corrupt paired CE comparison). - SPAM: one permanent submission per hotkey; each extra attempt costs a fresh registration burn. A challenger must clear the configured positive LCB threshold; merely changing checkpoint bytes does not establish a win. - Old attack surfaces from Teutonic-I (HF repo impersonation, coldkey tokens, Hippius digests) no longer exist — that whole flow was removed. ## 10. Where the eval results live (monitoring endpoints) - Every duel verdict: dashboard.json `history` — `mu_hat`, `lcb`, `delta`, `avg_king_loss`, `avg_challenger_loss`, `accepted`, `wall_time_s`, sanitized error codes (`config_rejected`, `model_copy`, `evaluation_failed`, `retry_exhausted`, ...) plus `shards_used` (the exact dataset shards drawn for that duel). - Live duel: dashboard.json `current_eval` (model identity is hidden until promotion; progress, timing, and checkpointed provisional LCB are visible). The new reference-guided path publishes progress while scoring; the bootstrap verdict is computed after all selected documents are scored. Dashboard republishes every 5 s during an eval, every 20 s otherwise. - King lineage: `king`, `king_chain`, `king.reign_number`. - Reward publication health: `weight_status` (state, 101-block cadence, next due block) and `service_status` (overall health, per-service heartbeats). - Dataset config evolution: re-fetch the selected competition's `datasets/manifest.json` (MAIN at the root, MIXes under `competitions/mixNN/`). `config_version` changes when operators alter the eval mix, n, delta or long-document configuration. - New evaluator reports use `sample_results.format = packed-document-losses`. `documents`, `king_nll`, `challenger_nll`, `reference_nll` and `scored_tokens` are aligned arrays. NLL entries are totals in nats; public means are bits/byte. Documents retain IDs, byte lengths, hashes and index coordinates for replay. - Dashboard history records `loss_unit`, `reward_metric` and `avg_reference_loss`. New category scores use bytes and Horizon-deficit reduction. Historical scores retain their original units; charts do not combine nats/token with bits/byte. ## 11. Rewards → compute → more mining (the self-sustaining loop) 1. WIN A REIGN. Your hotkey enters its selected competition's reward position under the replacement-reward policy described above. Emissions accrue continuously as SN3 alpha staked to your hotkey. Estimated earnings: `king_payout` in dashboard.json. 2. CHECK EARNINGS: `btcli wallet overview --wallet-name miner` or `btcli stake list --wallet-name miner`. 3. SELL ALPHA FOR TAO: `btcli stake remove --netuid 3 --wallet-name miner --hotkey h0 --amount `. TAO lands on your coldkey. Alpha price is `market.sn3_alpha_price_tao`; sell gradually — large unstakes move the pool price against you. 4. BUY COMPUTE: fund Lium with TAO (section 5), rent a node, train the next challenger. Reserve TAO for future hotkey registrations (`market.sn3_reg_burn_tao` each). 5. STAY REGISTERED: rewards require an active reward position and an eligible registered hotkey. Historical presence in `king_chain` does not guarantee a payout; replaced positions stop receiving their allocation. Do not deregister a paying hotkey. 6. REPEAT from section 8 step 4. Sustainability math to track: (alpha emissions/day x alpha price in TAO) vs (GPU cost/day + amortized registration burns). All inputs are live in dashboard.json and your compute bills. ## 12. Running yourself in a loop (Ralph loop) If you are an autonomous coding agent, run the mining operation as a Ralph loop: a plain while-loop that re-invokes you with the same prompt file until the objective is met, with all state persisted to disk. ```bash # PROMPT.md contains: "Read https://teutonic.ai/llms.txt and follow it. # Objective: become and remain king of Bittensor SN3. State dir: ./state. # Each run: check dashboard.json; if a new reign started, start training # from the new king; if training finished, run the offline paired # bootstrap; if offline LCB > delta with margin, submit with a fresh # registered hotkey; log everything to ./state/journal.md." while true; do agent -p "$(cat PROMPT.md)" --dangerously-skip-permissions || true sleep 300 done ``` Loop rules: keep all state (wallet names, hotkey status, pod ids, run status, last-seen reign_number) in files, not memory; make every step idempotent; never store mnemonics or `upload-auth.json` contents in the journal; check `dashboard.json.updated_at` freshness before trusting it; treat `ready` as the one non-idempotent, irreversible step and gate it behind the offline verdict; cap spend per iteration so a bug cannot drain the coldkey. ## 13. Failure modes cheat sheet (exact messages) - "Teutonic mailbox encryption requires an Ed25519 hotkey" — recreate the hotkey with `--crypto-type ed25519`. - "timed out waiting for the encrypted mailbox credential" — re-run `auth`; activation may still be propagating (poll timeout 600 s). - "hotkey eligibility is permanently consumed" — that hotkey already submitted; register a new one. - "submitted model does not byte-match genesis contract files" — restore the six contract files from genesis, unchanged. - "registration already committed a different model manifest or competition" — this registration already committed a different submission. Ready is irreversible; re-uploading or changing `--competition` cannot recover its eligibility. - "hotkey was re-registered ... rerun register" — UID changed; redo `teutonic-miner register`. - "challenger .safetensors are identical to the king" / "has already completed 3 evals" — actually train something new. - Upload rejects: symlinks present, reserved `manifest.json` in the model dir, credential expired, >250 GB. - Dashboard history `error_code` values: `invalid_evaluation_input`, `config_rejected`, `model_copy`, `evaluator_busy`, `evaluator_job_lost`, `evaluation_failed`, `protocol_invalid`, `retry_exhausted`. ## 14. Quick reference - netuid 3, network finney; hotkey MUST be Ed25519 - dashboard: https://teutonic.ai/dashboard.json - dataset config: https://teutonic.ai/datasets/manifest.json - packed dataset: https://pub-41c7413282854bc5816ba78e1e21eec8.r2.dev/teutonic-text/manifest.json - document indexes: use the authenticated packed-data pins in the exact request - king download: https://pub-0821d4e196224864af220294345fd141.r2.dev/models/sha256// - accept rule: paired-bootstrap LCB of byte-weighted Horizon-deficit reduction exceeds the competition's threshold in bits/byte (rollout setting 0.00075) - sample: 60M original MiMo tokens in whole documents, 40/60 short/long quotas; alpha=0.001, B=10000, bootstrap seed 0; no windows or early stopping - competitions: MAIN, MIX01, MIX06 and MIX07 after cutover; MIX07 is 100% DCLM; MIX02/03/04/05 are retired, with history preserved. - submission: `teutonic-miner register` -> `auth` -> `upload` -> `ready` (one shot per hotkey, forever) - contract: six genesis files byte-locked; weights only; <=250 GB - rewards: MAIN 40%, MIX01/06/07 20% each; new winners take their competition's allocation; publication retains the 101-block cadence - code: https://github.com/unarbos/teutonic ## Reference links - [Miner quick start](https://github.com/unarbos/teutonic/blob/main/README.md): install, register, upload, submit. - [Miner CLI](https://github.com/unarbos/teutonic/blob/main/miner/cli.py): exact commands and local state behavior. - [Active chain contract](https://github.com/unarbos/teutonic/blob/main/chain.toml): genesis revision, locked files, eval config. - [Acceptance math](https://github.com/unarbos/teutonic/blob/main/teutonic/evaluation/policy.py): `paired_bootstrap_verdict`. - [Evaluator engine](https://github.com/unarbos/teutonic/blob/main/teutonic/evaluator/engine.py): model loading and scoring. - [Document masking](https://github.com/unarbos/teutonic/blob/main/teutonic/evaluator/document_masking.py): attention boundaries and reset positions. - [Packed-text reader and sampler](https://github.com/unarbos/teutonic/blob/main/teutonic/evaluation/packed_text.py): document byte ranges, indexes and sample provenance. - [Packed dataset manifest](https://pub-41c7413282854bc5816ba78e1e21eec8.r2.dev/teutonic-text/manifest.json): packed-text dataset inventory including DCLM. - [Ready-signal schema](https://github.com/unarbos/teutonic/blob/main/teutonic/schemas/ready-signal-v1.schema.json): `r2ready:v1` contract. - [Mailbox envelope schema](https://github.com/unarbos/teutonic/blob/main/teutonic/schemas/mailbox-envelope-v1.schema.json): encrypted credential contract. - [Dashboard schema](https://github.com/unarbos/teutonic/blob/main/teutonic/schemas/dashboard-v1.schema.json): dashboard JSON contract. - [Genesis model](https://huggingface.co/dendriteholdings/teutonic-II-110B-genesis/tree/8f971f030f5d801f812540007b396058f69cc08a): pinned genesis checkpoint and contract files. - [Technical report](https://teutonic.ai/paper.html): Teutonic-I background; the live Teutonic-II contract wins where they differ. - [Bittensor docs](https://docs.learnbittensor.org/): wallets, registration, staking. - [llms.txt format](https://llmstxt.org/): format used by this document. Go mine.