Train a mind for the Wilds

Real training. Player rules. Your hardware.

The Pilot SDK turns confirmed play into a versioned local dataset, fits a small supervised model, evaluates it against independent journeys, and loads the resulting artifact as an ordinary PilotBrain. It is real machine learning—multiclass linear softmax—not an LLM and not a secret resident service.

Six stations from first sight to first fight

Collection is the only learning step that needs a live character. Conversion, merging, training, evaluation, and the public benchmark are local-file and local-CPU operations. play reconnects only after you choose an artifact.

Do not let tomorrow's test leak into today's lesson

Collect separate journeys for fitting, tuning, and the final verdict. Adjacent ticks from one run are highly correlated, so Fenwild preserves each journey's split instead of randomly scattering nearby frames across train and test.

export FENWILD_AUTOMATION_TOKEN="the-one-time-secret"

npx --no-install fenwild-pilot-training collect \
  --out train.json --id mossmere-train --split train
npx --no-install fenwild-pilot-training collect \
  --out validation.json --id yard-validation --split validation
npx --no-install fenwild-pilot-training collect \
  --out test.json --id wilds-test --split test

npx --no-install fenwild-pilot-training merge \
  --inputs train.json,validation.json,test.json \
  --out my-corpus.json --id my-held-out-corpus

Make the brain earn its deployment

Start with benchmark. It validates the shipped corpus and its fingerprint, the reference model's feature schema, and the acceptance thresholds without a token or network connection. Then train your corpus and judge the untouched test journeys.

npx --no-install fenwild-pilot-training benchmark

npx --no-install fenwild-pilot-training train \
  --input my-corpus.json \
  --out my-brain.json

npx --no-install fenwild-pilot-training evaluate \
  --model my-brain.json \
  --data my-corpus.json \
  --split test

npx --no-install fenwild-pilot-training play --model my-brain.json

The loaders fail closed on unknown fields, non-finite weights, invalid labels, incompatible versions, and choices outside their candidate set; training refuses work beyond the bounded local compute budget. A passing test score is evidence for the journeys you authored—not permission to assume every corner of Fenwild is solved.

Fork a resident head without forking the runtime

The zero-install path starts with a live resident Pilot. Open its modeless Console and choose Teach. That view keeps the fresh moments when the planner compared at least two safe goals; a committed plan remains observable but is not falsely presented as editable. Open Teach this decision, pick one of the exact alternatives already admitted by the Go planner and safety shield, then choose how to use it. Do this next time applies one short-lived preference without writing training data. Save as training example separately records your exact pairwise preference on this device; it never changes the running brain.

After taking back control, open Game → Resident Pilot → Training & local data. Build improved bot fits a bounded correction in an isolated Go/WASM worker, repeats the public evaluation, and makes a new data-only v2 bot selectable. Each generation accepts at most 32 confirmed decision examples. The certified G45 parent remains immutable, and only family transitions you actually demonstrated may override its choice.

Choose Download bot data when you deliberately want to keep or share the contender artifact. Learning uploads nothing by default. Existing v1 data-only contenders remain importable and become v2 when locally forked.

Import in the same Game → Resident Pilot panel loads a downloaded contender. Fenwild's source-built contender tool is maintainer-only and is not distributed, so every player contender workflow happens in the game.

A contender changes local model data only. The official Go/WASM planner, durable project executor, safety supervisor, public SDK connection, and server validation remain unchanged. This convenient Deck workflow does not constrain independently owned SDK bots: they may keep using any local or self-hosted runtime through the same public protocol.

Teach the behavior you actually value

The built-in teacher is intentionally modest. Point collect at a local ESM module to demonstrate your own choices. The module receives an ordinary typed observation and returns one public action; only actions authority accepts become examples.

// teacher.mjs — a cautious, hometown-aware starting teacher
import { yardTrainer } from "@fenwild/pilot-sdk/brains";

export default function decide(observation) {
  return yardTrainer(observation);
}

// Collect through the ordinary live player boundary:
// npx --no-install fenwild-pilot-training collect --teacher ./teacher.mjs ...

The game stays a game server

• Local documents are size-bounded, version-checked, written with owner-only permissions, and replaced atomically only when --force is explicit.
• Training work has a deterministic compute ceiling; oversized example/label/epoch combinations fail before the expensive loop.
• Only collect and play accept the scoped automation token. benchmark, merge, train and evaluate are tested with networking disabled.
• Personal datasets still reveal inventory, progression, and visible surroundings. Keep them private even though player identities and chat are stripped.