Dissecting AI
From the paper: Memento 3: Model-Based Recursive Self-Improvement through Reflective Rulebooks

Population-Based Exploration with Competing World Models

A single plausible world model can steer an agent into self-confirming behavior; Memento 3 retains competing models that share evidence and samples distinct plans to broaden exploration.

Read the paper ↗
The short version

What it is

  • Competing world models The agent keeps several candidate explanations of the same environment instead of committing to only one.
  • Shared evidence Every candidate is checked against the same interaction history, so one real observation can rule out or repair multiple candidates.
  • Distinct plans Candidates that currently predict the same actions count as one behavioral alternative; sampling favors differences in what the agent will actually do.

Why it matters

A single model can keep choosing actions that never reveal its own mistakes. Competing models can propose different routes through the environment, letting the agent gather evidence that one narrow plan would miss.

Before I get into the mechanics, here is the short version: instead of trusting one guess about how an environment works, the agent keeps several guesses around. They all learn from the same interaction history, and the agent chooses among the different action plans those guesses currently suggest. That matters because a model can look right for a long time if it only takes actions that avoid testing its mistakes.

  1. Avoid self-confirming behavior: A model may be wrong about an action it never chooses. The canonical example is a hidden door: one model predicts that a nearby object opens it, another predicts that the object is decorative. If the first model’s plan never interacts with the object, its error stays invisible. More generally, each model’s own plan determines which predictions get tested. What if a different plausible model would take the agent somewhere else?

  2. Keep one evidence trail: The models do not get separate copies of the environment. Every real action adds an observation to a shared history, and each candidate is checked against that same record. Think of several investigators reading one notebook, not each running a separate experiment. The analogy is limited: models do not merely interpret the notes; their executable predictions can be contradicted by them. If everyone sees the same evidence, how can the agent keep alternatives from being redundant?

  3. Choose behavioral differences: The useful distinction is not whether two programs look different, but whether they currently tell the agent to do different things. For example, two models may encode a game differently yet both predict “move east, then interact”; for exploration now, that is one plan. Models with different nonempty action sequences form separate behavioral alternatives, and the agent samples among those classes. This is a way to spend choices on different possible experiments, not a claim that every alternative is equally good. What happens when no candidate offers a plan?

The system can explore or revise before plan sampling resumes. When a plan is selected, the selected model stays active while it is followed, until success, a falsifying observation, or replanning. Each observation still joins the common record, so the other models get to learn from the same trip. I like this separation: the population creates options, while the shared history keeps those options accountable. The cost is maintaining and checking multiple candidates, and diversity helps only when it produces actions that expose useful disagreements. Can a population broaden exploration without pretending uncertainty has disappeared?

Read the deep dive

Why People Wanted It

A single model can be internally consistent and still be wrong. Worse, if its chosen actions never expose the mistake, its predictions may remain unchallenged while the agent follows a narrow path. The practical question is: can the agent preserve alternatives long enough for their different plans to reveal different evidence?

Memento 3 answers by keeping multiple rulebook–executable hypotheses, checking them against one shared interaction history, and choosing among behaviorally different plans. The other module on reflective rulebook-guided model construction covers how each individual model is built and repaired.

The Core Move

Keep several candidate world models against the same history, then sample among the distinct nonempty action plans they predict. The population is written as Φt\Phi_t; the learning state is the shared history and that population, (Ht,Φt)(H_t,\Phi_t). The history is shared, not replayed in separate environment copies.

Quiz
In the population extension, what is shared across retained world models?
Only the most recent observation, with earlier history discarded
A separate environment instance for each model
One identical executable and reconstructed state
The interaction history and observed trajectories

Why Multiple Models Can Reveal Different Evidence

Now the version for readers who want more of the machinery: the population addresses a specific failure mode of single-model control—self-confirming behavior. For a fixed model, imagine following only the actions its own plan selects. The paper defines R(θ)R(\theta) as the histories reached under that model’s plan-induced policy. A model can be wrong on actions it never chooses yet remain unfalsified along its own path. Retaining alternatives matters because their plans can take the agent to different histories, where those hidden disagreements become observable.

The population contains NN retained hypotheses; N=1N=1 recovers the single-model case. Each member has its own rulebook and executable, but every real observation extends the same HtH_t. This is not a set of parallel environment runs: it is a set of competing explanations tested against one record. What prevents the population from merely keeping many textual variants of the same behavior?

Why Verification Uses the Common History

Here is the part that gets technical: each real interaction is checked against every member using the accumulated trajectories, not just the newest frame in isolation. A prediction that contradicts an observation falsifies that executable; affected members then undergo the reflective update. Members that have not contradicted the record remain candidates. The population therefore filters by shared evidence while preserving multiple survivors when the record does not distinguish them.

The source describes proposal, repair, and plan/act as the population loop: proposals are retained when admissible; falsified members are repaired; and action outcomes are added to the common history. The important population-level constraint is that no member gets a private evidence stream. How should the surviving candidates be made useful for action selection?

Why Plans, Not Programs, Define the Alternatives

Now the deeper selection rule: at a shared history, each model reconstructs its own internal state and supplies a plan if it has a nonempty one. Two members count as behaviorally equivalent when their action sequences are identical. The system samples uniformly over distinct nonempty plan classes for each planning episode, then follows a representative plan until success, falsification, or replanning.

This distinction avoids spending exploration opportunities on different programs that prescribe the same actions right now. It also does not promise that every sampled plan is correct: the point is to give retained behavioral alternatives opportunities to produce new evidence. If no member has a nonempty plan and the task remains unfinished, the control operator explores or revises before sampling resumes. Which tradeoff does this design make between diversity and commitment?

Minimal Causal Code

This plain loop makes the shared record and plan-class choice visible; it omits proposal and repair internals.

history = []
models = initial_models

while not finished:
    for model in models:
        if model.contradicts(history):
            model.repair_from(history)

    classes = {}
    for model in models:
        plan = model.plan(history)
        if plan:
            classes.setdefault(tuple(plan), []).append(model)

    if not classes:
        models = explore_or_revise(models, history)
        continue

    plan, representatives = choose_uniformly(list(classes.items()))
    model = choose_representative(representatives)
    for action in plan:
        observation = environment_step(action)
        history.append((action, observation))
        if model.contradicts(history) or is_success(observation):
            break

What You Gain, and What You Lose

The gain is broader model-guided exploration: distinct surviving plans can produce distinct histories, reducing dependence on one early model choice. Shared-history checks also let every retained member be tested by the same accumulated interactions.

The cost is maintaining and checking a population, and the population is not a guarantee of correctness. If candidates agree on a plan, or their chosen actions fail to expose their disagreements, the agent can still miss important errors. Sampling distinct plans trades commitment to one model’s route for opportunities to test alternatives; it does not make each action safer or each hypothesis equally plausible.

Quiz
When does the population treat two models as behaviorally equivalent for plan sampling?
When they have equal numbers of parameters
When their rulebooks use the same words
When their nonempty predicted action sequences are identical
Whenever both models have survived verification
Core Takeaway

Keep competing explanations, share the evidence, and spend exploration on plans that actually differ.