Passa al contenuto principale

Agent Briefs — Batch 1

How to use this page

Each brief below is written to be handed to an agent (Claude session, OpenClaw worker, or deep-research run) as-is, together with the linked context pages. Rules inherited from the Delegation Plan: no dispatch until the Inputs row is satisfied; the acceptance test is the definition of done; escalation triggers mean stop and ask a human, not improvise. Batch 1 is chosen so that B-01/B-02/B-03 have no dependencies and can start immediately in parallel; B-04 depends on B-02; the rest are independent.

B-01 · EULA & policy audit, first pass​

Tier 2 · Executor: deep-research agent · Unblocks: Phase 0.4, 0.7, 0.8

RETURNED 2026-07-07 — awaiting counsel review

Executed same day via 5 parallel agents. Result: 0 GREEN / 4 AMBER (Minecraft Java & Bedrock, BG3, Elden Ring) / 15 RED, including five explicit AI/TDM prohibitions (Take-Two, Epic ×2, WB, CDPR ×2) all added in 2024–2026 terms, and five recordings-ownership claims (Riot, Blizzard, Krafton, Take-Two, ZeniMax). Deliverable: ec-workspace/research/world-model-data-flywheel/b01-eula-audit-2026-07-07.md. Key corrections: Valve's video policy covers Valve titles only; the "3–5 green titles" assumption in Phase 0.8 is falsified — AMBER titles support internal R&D/services only, and the FPS/driving domains are partnership targets, not unilateral-capture targets. Klindt POC (Minecraft Java, internal R&D) unaffected.

  • Objective: classify every enabled title green/amber/red for recording, AI-training use, and data sale.
  • Inputs: title list from playroll-cpp/res/games.json; each title's current EULA/ToS + creator-content policy (live web).
  • Steps: for each title — locate the governing documents; extract and quote verbatim any clause touching recording, streaming/monetization, data harvesting/automation, ML/AI use, UGC ownership; note storefront-level policies that apply (Steam video policy); note anti-cheat stack; classify per the 0.4 rubric; snapshot each document (archive URL + retrieval date).
  • Deliverables: one table (title | tier | governing clauses quoted | doc URLs + dates | anti-cheat stack | ML-license availability) + per-title notes file.
  • Acceptance test: 100% of enabled titles covered; every classification supported by a verbatim quote a reviewer can check in ≤1 minute; zero paraphrase-only justifications.
  • Out of scope: legal conclusions — the output is counsel's reading packet, and the red/green calls are provisional until counsel signs.
  • Escalate when: a EULA is region-gated or paywalled; two governing documents conflict; a title has an explicit AI/ML clause (flag immediately — it may need same-day removal from capture).

B-02 · Klindt POC eval harness​

Tier 1 · Executor: OpenClaw on dfgpu · Unblocks: Track A0 steps 2–3, B-04

  • Objective: stand up an open Minecraft world model and reproduce one published evaluation number, giving the POC a working base + eval loop.
  • Inputs: dfgpu access (agent-scoped env); candidate weights in priority order — MineWorld, open Oasis 500M, Matrix-Game Minecraft slice; each repo's published eval protocol.
  • Steps: environment build (pinned, reproducible); inference smoke test; implement/adapt the eval loop; reproduce one published metric; document VRAM/runtime envelope (this bounds POC fine-tune cost); wrap in a one-command entry point.
  • Deliverables: repo/branch with env spec, run_eval.sh, README (hardware envelope, tolerance notes), reproduction report.
  • Acceptance test: published metric reproduced within stated tolerance on dfgpu, twice (determinism check); a teammate reproduces it from the README alone.
  • Out of scope: fine-tuning; benchmark design; touching any Playroll recording data.
  • Escalate when: no candidate model reproduces within tolerance after honest effort (report the gaps — this changes POC model choice); license terms of weights restrict our use.

B-03 · Coverage atlas v1 prototype​

Tier 1 · Executor: OpenClaw (GPU for embedding) · Unblocks: Founding Experiment step 1, C2, C5

  • Objective: first embedding-space density map of the existing corpus; output the ranked thin-cell list.
  • Inputs: corpus sample (≥50 h video + _input.csv, ≥3 titles, PII-safe — Vincenzo cuts it, see the data inventory); an off-the-shelf video encoder.
  • Steps: window the sessions (fixed length, video+action features); embed; fit density (kNN-distance baseline, flow optional); cluster into cells; rank by density; visualize per-title and pooled maps; stability check (re-run with different encoder seed / window offset — cell ranking should be broadly stable).
  • Deliverables: atlas artifact (embeddings + cells + densities), thin-cell report with example clips per cell, atlas README, stability analysis.
  • Acceptance test: pipeline runs end-to-end on the sample by one command; thin-cell ranking Spearman ≥ agreed threshold across the two stability runs; a human spot-check confirms ≥7/10 sampled "thin" cells are genuinely unusual gameplay (not artifacts like loading screens — those must be caught by the quality filter and reported separately). Design note (2026-07-08): cell priority must expose a learnability-weight hook, not ship raw density as the ranking (Klindt's broken-TV caveat — the C5 annealing loop will supply the weight; v1 stubs it at 1.0 but the interface exists from day one).
  • Out of scope: quest generation from cells; production deployment.
  • Escalate when: thin cells are dominated by junk (menus, crashes) even after basic filtering — that's a curation-ordering finding for B-05, not something to silently patch.

B-04 · Benchmark probe candidates (for Antonio to pick)​

Tier 2 · Executor: Claude/deep-research · Depends on: B-02 · Feeds: A0 step 3

PARTIALLY RETURNED 2026-07-07 — literature half done, demonstrations await B-02

8 probe candidates designed (P1 persistence, P2 permanence, P6 inventory as headline trio; P8 linear-decodability as the Klindt-bespoke analysis), with metrics, RCON ground-truth plans, documented-failure citations, and a pre-registration template. Model recommendation: open Oasis 500M via WorldMem's training pipeline (MineWorld secondary pending checkpoint availability — verify HF download). Deliverable: ec-workspace/research/world-model-data-flywheel/b04-probe-survey-2026-07-07.md. Companion drafts (A0 step 4 + Phase 0.1) in poc-quest-drafts-2026-07-07.md — quests "Raise the Wall" + "Quarry Run" with verifiers, and the capture-spec ADR draft. Remaining for B-02's harness: base-model failure demonstrations per probe.

  • Objective: ≥5 candidate dynamics probes on which the B-02 base model plausibly fails, each ready for pre-registration.
  • Inputs: B-02 harness + model behavior notes; David's shared papers/links (from the team channel); prototypes/minecraft-spatial-tracer (RCON ground-truth positions — the cheap source of authoritative state for probe evaluation).
  • Steps: survey Minecraft world-model eval literature; enumerate dynamics families (block place/destroy consistency, displacement coherence, object permanence, gravity/water, action-effect latency); for each candidate: metric definition, ground-truth source (spatial-tracer RCON vs pixel-only), expected-failure rationale with a demonstration attempt on the B-02 model, implementation sketch, collection implication (what quest data would fix it).
  • Deliverables: probe-candidate memo, one page per probe, with demonstrated base-model behavior where obtainable.
  • Acceptance test: ≥5 probes; ≥3 with demonstrated (not hypothesized) base-model failure; each implementable in ≤1 week per the sketch; Antonio can pick and pre-register without further research.
  • Escalate when: the base model fails at nothing meaningful (pick harder probes or weaker model — human call); RCON state proves unreliable.

B-05 · Curation pipeline v1​

Tier 1 · Executor: OpenClaw in data-filtering · Unblocks: C3, all training briefs

  • Objective: extend data-filtering/pipeline into the v1 curation stack: spec-conformance, quality filtering, semantic dedup, tiering.
  • Inputs: data-filtering repo (existing pipeline + tests as the base); corpus sample (same as B-03); ~50 team-labeled quality examples (good / menu-idle / crash / broken-sync).
  • Steps: conformance checks (resolution, fps, _input.csv sync metric, completeness); quality classifiers (menu/idle/crash detection — heuristics before models); embedding near-duplicate detection (share B-03's embeddings); tier assignment; per-decision provenance events (schema from B-07); throughput measurement.
  • Deliverables: pipeline branch + tests; evaluation report (precision/recall per filter on the labeled set); survival-rate breakdown on the corpus sample.
  • Acceptance test: each filter's precision/recall ≥ agreed bar on labeled examples; end-to-end run on the sample produces tiered shards + provenance log; no PII-flagged clip reaches a sellable tier.
  • Escalate when: survival rate below 1% or above 50% on the sample (both smell like filter miscalibration); sync metrics reveal a systematic capture bug (report to the capture team — that's a 0.1 finding).

B-06 · Unified event format + IDM training scaffold​

Tier 1 · Executor: OpenClaw on dfgpu · Unblocks: Track B

  • Objective: the data plumbing and model skeleton for IDM v1 — not the full training run.
  • Inputs: corpus sample with _input.csv per title; D2E's OWA event format and VPT's IDM architecture as published references.
  • Steps: unified event schema + per-title adapters (round-trip tested); windowed dataset builder with contributor-split train/val enforced in code; non-causal video→action model skeleton (keypress heads, quantized mouse head per VPT); training loop with the standard sanity ladder (overfit 1 clip → overfit tiny set → loss curves on the sample); eval metrics (keypress accuracy, mouse R²) matching the VPT bar definitions.
  • Deliverables: repo/branch with schema docs, loaders + tests, model + training + eval code, sanity-ladder report.
  • Acceptance test: round-trip tests pass on every title in the sample; model overfits a tiny batch (loss → ~0); full-sample short run shows learning (val accuracy > majority-class baseline); contributor-split verified by test.
  • Out of scope: the real training run, cross-game protocol, any accuracy claims.
  • Escalate when: _input.csv semantics differ across titles in ways the schema can't unify cleanly (needs a human data-format decision).

B-07 · Provenance ledger schema + manifest generator​

Tier 1 · Executor: OpenClaw (staging Supabase branch) · Unblocks: Phase 0.5, B-05, every delivery

  • Objective: the per-clip provenance schema and the export-manifest generator.
  • Inputs: current Supabase schema (data model, recording spine, consent-versioning tables); the 0.5 field list (consent version, whitelist tier at capture, spec version + sync metric, quest attribution, lineage, delivery record).
  • Steps: schema design as timestamped migrations on a staging branch (migration-first per workspace DB rules — canonical home playroll-cpp/supabase/migrations, idempotent where practical); lineage event API for pipeline stages; manifest generator (machine-readable, one manifest per export); withdrawal propagation (mark → exclude from all future exports); tests for every path.
  • Deliverables: migration files (staging), event-emitter library used by B-05, manifest generator + JSON schema, withdrawal test suite.
  • Acceptance test: on staging with synthetic data — export produces a manifest tracing every clip to contributor/consent/title/tier/spec; withdrawal test shows the clip absent from the next export; migrations re-run cleanly on a reset branch.
  • Escalate when: schema conflicts with live tables (human migration review); anything requires touching prod.

B-08 · Input-stream forensics features (fraud v1 groundwork)​

Tier 1 · Executor: OpenClaw · Unblocks: C4

  • Objective: the feature extractors and baseline detectors that make botted/replayed/scripted sessions distinguishable from honest play.
  • Inputs: honest input-stream corpus (from the corpus sample); synthetic fraud set — 2–3 team members spend ~a day fabricating cheats: macro scripts, replayed sessions (identical + slightly perturbed), input smoothing/injection (data inventory action).
  • Steps: feature library over _input.csv streams (inter-key timing distributions, mouse micro-jitter spectra, pause structure, fatigue drift, per-session self-similarity); near-duplicate session detection (reuse B-03/B-05 embeddings); baseline classifier honest-vs-fabricated; calibration report emphasizing false-positive cost (a falsely accused contributor is a product failure — C4 treats trust as a product surface).
  • Deliverables: feature library + tests; detector + ROC/calibration report; "evasion notes" — what the detector would miss, written adversarially.
  • Acceptance test: catches ≥90% of the fabricated set at a false-positive rate ≤ agreed budget on honest holdout; replay detection flags exact and perturbed duplicates; evasion notes reviewed by the team red-teamer.
  • Out of scope: enforcement/quarantine logic (human-gated); payout integration.
  • Escalate when: honest operator sessions cluster with fraud (features are capturing operator style, not honesty — needs fleet-diverse data before proceeding).

Dispatch order & dependencies​

B-01, B-02, B-03, B-06, B-07 dispatch now (their inputs exist or need only the corpus-sample cut); B-04 follows B-02; B-05 follows B-03+B-07; B-08 follows the fraud-set fabrication day. When a brief returns, the Delegation Plan's iteration loop re-grades the map and cuts Batch 2 — expected candidates: probe implementation, quest compiler v1 input adapter, PII pipeline, coverage signatures, annealing harness.