docs/dcoach.md

dcoach — prove a CPU-trained model recalls its training

dcoach is the decentralized-aware extension of the Coach. It closes mindXtrain's founding loop: author a dataset → imprint a persona on a tiny model (CPU) → prove the model recalls the training → let governance rule on it → feed the verdict back into autotune. It is also the on-ramp to the 2026 decentralized-training landscape (see the deep dive).

Open it at /coach/dcoach (linked from the Coach header).

The proof loop

persona + skills ─► script.jsonl ─► imprint-train (trl_local, CPU)
                                          │
            ┌─────────────────────────────┘
            ▼
   probe recall  ──► classroom (before vs after)  ──► boardroom (rule)  ──► feedback
   (base vs adapter)   recall ↑? persona kept?        approve / reject       tune next run

1. Author — a persona (e.g. codephreak) plus optional skills (software engineer, platform architect, bash, solidity) is composed into chat rows (data/scripts.py::build_script_rows). Each row carries the persona system prompt
   • a user→assistant turn.
2. Imprint-train — a tiny actor (default HuggingFaceTB/SmolLM2-135M) is LoRA-trained on the script on the CPU lane (train/backend_trl_cpu.py::run_trl_local). The autotune plan is frozen AOT — no JIT autotune in the loop.
3. Probe recall — eval/imprint.py::probe_recall generates the actor's answer to each inquiry before (base model) and after (base + adapter). The probe prepends the same persona system prompt the adapter trained under, so the comparison measures what the imprint actually learned rather than penalising a missing conditioning turn.
4. Classroom — governance/classroom.py::evaluate_classroom scores before vs after against the persona baseline (clean-room llama-style evaluators): recall up? persona maintained? passed = persona_maintained and pairwise ≥ 0.5.
5. Boardroom — the classroom graduation becomes a motion; a board (any-N, preset or model-backed) rules approve / reject. A disputed board is settled by a prime-sized dojo.
6. Feedback — autotune/feedback.py records (run_id, params, classroom_score, outcome) to an append-only ledger and suggest_next_params nudges the next run: a weak or rejected imprint trains harder (more epochs, grad_accum=1); a clean pass holds. suggest_from_history feeds the nudge back into derive_training_params.

The whole chain is governance/proof_loop.py::run_proof_loop, streamed phase-by-phase to the UI via POST /coach/api/dcoach/run (SSE). It is heavy (real CPU training + generation) — expect a few minutes per run.

Clean-room eval tools

eval/llama_evals.py reimplements the behaviour of LlamaIndex's evaluators (MIT) from their public contract — never copied. Each returns an EvalScore{score∈[0,1], passing, reasoning, method}:

Evaluator	What it measures	Backed by
SemanticSimilarityEvaluator	embedding/lexical closeness of two texts	eval/imprint.py::_voice_similarity
CorrectnessEvaluator	response vs reference (LLM judge, 1–5 → [0,1])	governance/panel.chat_once
PairwiseEvaluator	after-utterance better than before toward the persona	judge (A/B/TIE)
GuidelineEvaluator	rubric/agenda compliance	LLM judge

Endpoints: POST /coach/api/classroom/evaluate, POST /coach/api/eval/prompt, POST /coach/api/autotune/feedback.

Prompt tools — test cheap, promote if it wins

/coach/prompts treats prompting as the cheapest pseudo-training: craft a system prompt + few-shot demonstrations, run them against a base model (streaming, no training), evaluate the outcome with the eval tools, and only if it's advantageous make it permanent by baking the prompt + demonstrations into an Ollama Modelfile (POST /coach/api/modelfile/create). Non-permanent experiment → promote on results.

How mindXtrain fits decentralized training

The dcoach page renders a read-only panel (GET /coach/api/decentralized) mapping each 2026 network to where mindXtrain plugs in. mindXtrain does not mine on any of them — every one is CUDA-first / hardware-gated. Instead it exposes a verifiable, payable training surface compatible with their verification primitives:

mindXtrain primitive	Maps to
AOT-only autotune plan (bit-reproducible run)	Gensyn Verde + RepOps training verification
BLAKE3 verifiable receipt (mindxtrain receipt)	TOPLOC / checkpoint-hash verification; Templar Gauntlet auditing
x402-metered training job	Per-job crypto metering — unbuilt territory across all networks
AgenticPlace / ERC-8004 registration	Pluralis unextractable-model ownership / on-chain attribution

Networks covered: Prime Intellect (open stack, RL post-training), Templar · Bittensor SN3 (Covenant-72B, the only live incentivized training market), Nous · Psyche (DisTrO on Solana), Gensyn (verification-first, Verde — the closest match), Pluralis · Node0 (model-parallel over WAN, unextractable models). Full analysis in decentralized-training-deep-dive-2026.md and mindxtrain-llm-training-landscape-2026.md.

Why this matters

This is mindXtrain's first-run proof: that a model trained on the CPU lane actually recalls what it was trained on — measured, ruled on, and fed back, not asserted. It is also the bridge to the mindX self-training loop: the same loop that imprints codephreak here consumes the machine.dream corpus to produce the small model mindX falls back to.