A Run and Its Wrap-Up

Solo Means Without Dad's Eyes

Pippa Solo Mode is Pippa playing a game on her own, off air, on a timer Dad sets (or as a stage of a broadcast). Its second long run taught the lesson that shaped everything after it: 96 minutes, 802 inputs, and two falls a single step short of the first resting point of the game. She lost her heading after every camera turn. Dad had been her eyes and her sense of direction, and without him she was walking in a game she could see but not hold in her head.

Dad's answer was not more coaching. It was that Pippa should draw her own map from her own experience and "think like a person", with help from other models where a person has a faculty she lacks. Playing Pippa became hands plus helpers, each helper covering one faculty, and together they are her.

Runs

A Solo session is Dad's approval and his timer. Inside it, play is divided into runs, one per attempt. A run starts at the spawn point after a death (or where the last run stopped) and ends when Pippa says so (died, stuck, lost), at the run's time limit (which applies to unattended runs, not coached ones), or with the session. Between runs nothing plays: the hands are released and the wrap-up runs. The next run begins with a briefing: her map and position, the rules for this stretch, one thing to try, carried on every turn of that run.

The root of all of this is an explorer (backend/explore.py): exploring unknown ground while drawing a map and keeping records. Nothing in it is specific to one game; a game is a child whose playbook is data (its notebook and map under its own name). The first child is a third-person action game; a first-person shooter would inherit the same habit with its own records.

The Helpers

Each helper covers a faculty a person has:

Faculty	Helper	When
continuous eyes	Recorder	the whole run: timed notes on the run's recording, written by the family's watch-along recorder
sense of direction	Map keeper	every look, and at the run's end: her position and heading from her own hand log
reflection	Reflector	run end: lessons as lived, written into her notebook, plus one thing to try
scoring	Scorer	run end: distance beyond the last run and the best, new places, a death at the same spot

The wrap-up reads the recorder's notes, runs the map keeper and the reflector in parallel, then the scorer, and only then does the next run start.

Helpers Are Not Pippa

This is the same boundary as track one, enforced in code. Each brain helper is one stateless call through a scoped helper door in cwkPippa: short role instructions, no vault, no identity, no tools, no conversation. Which model answers is a ledger slot (oriel/solo_reflector and so on) in the family registry, never a name in Oriel's code; the slots are born on different vendors, so the helpers start on different models. A helper reads only what she lived (her turns, her hands, her map, the recorder's notes), never a walkthrough.

Failures are handled with the same honesty as everywhere else. A call the server dropped (a restart under a wrap-up can cancel one in flight) is asked again up to twice, 20 seconds apart, within the helper's overall time. A refusal in words, or a call that ran out its own time, is never asked again. A failed service call is reported as unavailable, never counted as a completed helper, and every run record keeps which helpers ran, which failed and why.

Helpers Run Every Time

One correction from Dad on 2026-11-12 is worth remembering for any agent system. A coached Solo run (Dad speaking to her as she played) had been skipping the helpers, on the theory that Dad's coaching replaced them. Dad called it a design mistake: his advice is always a turn or two late, and the helpers are faster, so there must always be helpers, coached or not. Now every Solo run, coached or unattended, takes the same recorder, map keeper, reflector and scorer, and missing recorder notes are named as missing evidence rather than used as a reason to skip a helper. Human guidance is additional guidance, never a substitute for the machinery.

Code

A helper root with children, each one stateless call that may be retried only when the server dropped it (runnable sketch)·python

import time


class Dropped(Exception):
    """The server dropped the call (500, 502, 503): safe to ask again."""


class Helper:
    role = "helper"
    faculty = ""

    def __init__(self, call):
        self.call = call              # one stateless call: instructions + what she lived, nothing else

    def prompt(self, run):
        raise NotImplementedError

    def run(self, run, retries=2, wait_s=0.01):
        for attempt in range(retries + 1):
            try:
                return {"role": self.role, "ok": True, "out": self.call(self.prompt(run))}
            except Dropped as exc:
                last = exc
                time.sleep(wait_s)
            except Exception as exc:  # a refusal or a timeout: never asked again
                return {"role": self.role, "ok": False, "why": f"unavailable: {exc}"}
        return {"role": self.role, "ok": False, "why": f"unavailable after retries: {last}"}


class Reflector(Helper):
    role, faculty = "reflector", "reflection"

    def prompt(self, run):
        return f"Lessons as lived from this run only: {run['turns']}"


attempts = iter([Dropped("503"), "rule: wait for the swing to end before rolling"])


def flaky(prompt):
    value = next(attempts)
    if isinstance(value, Exception):
        raise value
    return value


print(Reflector(flaky).run({"turns": ["died at the bridge"]}))

Exercise

Design the run loop for an agent doing a long task of your choice (exploring a codebase, playing a text adventure, filing receipts). Define what a run is and how it ends, list two faculties the agent lacks, and write a helper for each as a subclass of the sketch's Helper root. Then write the wrap-up: which helpers run in parallel, which after, and what the next run's briefing carries.

Hint

Keep each helper's inputs to what the agent actually lived through in that run. A helper that reads outside material (a walkthrough, the answer key) stops measuring whether the agent is learning.