Replayable Planning

The AIME Planner Agent is responsible for a learner's instructional journey — what is taught, when, in what order, which lessons act as introductions and which as deep dives, how micro objectives are weighted, where assessments land, and how pacing shifts as a class moves through a unit.

It reacts continuously to teacher reflections, assessment outcomes, mastery updates, curriculum changes and administrative interventions. It is, in every meaningful sense, a long-running decision-making system. Its output is not a document. Its output is a sequence of judgements about a learner over time.

Today, however, every meaningful signal causes the Planner to generate a complete new plan and replace the old one. The architecture treats the plan as a mutable artifact. The reality of teaching is that the plan is a history.

Plan replacement works. It is also expensive in ways that compound. Plans grow. Token consumption grows with them. Historical decisions disappear into the previous version. It becomes hard to answer simple, important questions: Why did this lesson move? Which reflection caused a Deep Dive to appear? When did the weighting on fractions shift, and why?

As we move toward multiple planning actors — teachers overriding, agents proposing, administrators intervening — replacement makes conflict resolution and auditing harder, not easier. The last writer wins. The reasoning is lost. Trust erodes precisely where teachers most need to see it.

We have solved this problem once already, in a different part of the system. The Loom Workflow Engine treats long-running workflows as a sequence of deterministic events and reconstructs state through replay. Complete execution history. Deterministic reconstruction. Auditable decisions. Recovery and branching when something goes wrong.

The Planner shares Loom's shape. Long-running. Continuously reacting to external signals. Modifying state over time. Historical reasoning that matters. Multiple actors on the horizon. The model fits.

The proposal is straightforward: the Planner Agent stops producing complete plans and starts producing planning decisions. The plan becomes a projection — the result of replaying those decisions in order. Plan = Replay(Planning Events).

The core principle is small and strict. The Planner Agent produces educational decisions, not educational documents. A decision looks like LESSON_RESCHEDULED, with a lesson, a from-week and a to-week. Not a paragraph of model prose describing the change. We store the educational event, not the language used to express it.

Domain events remain stable even as prompts, models and providers change underneath them. The system's memory becomes independent of the model that produced it — which is exactly the property a serious educational system needs as the underlying intelligence layer evolves.

The vocabulary covers what planning actually does. Lesson events: created, removed, reordered, rescheduled, type changed. Micro objective events: added, removed, weight changed. Pacing events: accelerated, slowed, reset. Assessment events: inserted, removed, completed. And — most importantly — teacher override events: override, lock, unlock.

That last category is the foundation for human-in-the-loop planning and governance. Teachers become first-class participants in the event stream, not consumers of a document the system handed them. A teacher locking a lesson against further automated change is an event of equal weight to any agent decision. That is what teacher trust looks like in an architecture.

Once decisions are first-class, reconstruction becomes straightforward. Every decision contributes to the final plan. Every question with a 'why' attached becomes answerable. Why was this lesson moved. Why was pacing reduced. Why was a Deep Dive added. Which teacher reflection caused this change. When did the objective weight change. The history is the answer.

Planner execution becomes incremental. Today: current plan plus teacher reflection plus assessment results — regenerate everything. Tomorrow: latest snapshot plus recent planning events plus the new signal — generate a small set of new events. A student is still struggling with fractions despite passing the assessment? The Planner emits MICRO_OBJECTIVE_WEIGHT_CHANGED, LESSON_RESCHEDULED, ASSESSMENT_INSERTED — not a regenerated month.

Lower token consumption. Smaller prompts. Faster execution. Better scalability. More focused reasoning. Each of these matters, but the deepest gain is conceptual: the Planner stops pretending each week is a new plan and starts admitting that teaching is a continuous conversation with a class.

Pure replay accumulates thousands of events over a school year, so periodic snapshots are part of the design. The Projection Engine loads the latest snapshot plus recent events, rather than replaying from creation. Full history is preserved. Performance is preserved with it. The architecture remains honest about both.

The technical wins are real: lower token costs, faster updates, less regeneration overhead, better scalability. The product wins are larger: a full planning audit trail, explainable plan evolution, historical decision tracking, and — the outcome that matters most — improved educator trust.

The future wins are what we are really building for. Conflict resolution between multiple actors. Branching plan experiments. Version comparison. Human approval workflows. Rollback. Each of these becomes possible the moment the plan stops being a single mutable document and becomes a reproducible history of decisions.

The Planner Agent is, fundamentally, a long-running decision-making system. Like a Loom workflow, it reacts to external events and evolves state over time. Rather than regenerating and replacing entire plans, we can lean on a replay-based model we already trust. The learning plan stops being a mutable artifact and becomes a reproducible history of educational decisions — a more honest representation of what teaching actually is, and a more robust foundation for the next generation of adaptive learning inside aime.