Plan as Memory Asset

Strong models are often most valuable when they create the plan: they resolve design forks, name risks, define checks, and reject bad routes. Aionis turns that planning work into reusable execution memory.


planner plan -> Aionis observe -> governed context -> cheaper worker -> feedback -> measure -> replay

Your host can use Claude Code, GPT, a human reviewer, OpenRouter, or any other planner. Aionis owns what survives the next session: decisions, acceptance checks, failed branches, execution boundaries, and audit evidence.

What Becomes Memory

Plan artifact	Aionis role
Resolved decisions	Preserve as current execution evidence.
Acceptance checks	Carry the definition of done into the worker turn.
Failed or rejected branches	Keep as governed counter-evidence.
Active targets	Tell the worker where continuation belongs.
Execution boundaries	Prevent fallback to deprecated or blocked routes.
Raw traces	Keep behind rehydrate pointers when too large for prompt.

This is execution-state preservation rather than transcript summarization. The goal is to keep the executable state intact while removing prompt pollution.

Planner / Worker Split

A common loop looks like this:


1. Strong planner creates plan.md.
2. Aionis records the plan as execution evidence.
3. Worker starts later with no original context.
4. Worker asks Aionis for `guide`.
5. Aionis compiles only the state that can affect action.
6. Verifier/reviewer sends feedback.
7. Measure reports whether plan memory helped.

Planner and worker models provide evidence. Aionis applies lifecycle, authority, scope, source, suppression, and rehydrate gates before memory reaches the prompt.

SDK Shape

Use the SDK profile to map a plan into ordinary execution evidence:


import { createAionisClient, planAssetObserveEvents } from "@aionis/sdk";
 
const aionis = createAionisClient({
  baseUrl: "http://127.0.0.1:3001",
  scope: "checkout-migration",
});
 
const events = planAssetObserveEvents({
  run_id,
  task_signature: "checkout-migration",
  task_family: "coding",
  workflow_signature: "planner-worker",
  planner: {
    agent_id: "planner",
    model: "strong-planner",
  },
  plan: {
    title: "Checkout migration plan",
    summary: "Continue the scoped adapter route.",
    artifact_ref: "plan.md",
    decisions: [
      {
        decision_id: "decision:scoped-adapter",
        statement: "Patch packages/api/src/checkout.ts as the active target.",
        target_files: ["packages/api/src/checkout.ts"],
      },
    ],
    acceptance_checks: [
      "verifier accepts scoped checkout route",
      "legacy broad route remains reference-only",
    ],
    execution_boundaries: [
      "keep src/legacy/checkout.ts as reference-only evidence",
    ],
    failed_branches: [
      {
        branch_id: "failed:legacy-route",
        statement: "Legacy broad route failed verifier checks.",
        reason: "It touched unrelated checkout modules.",
        target_files: ["src/legacy/checkout.ts"],
      },
    ],
  },
});
 
for (const event of events) {
  await aionis.execution.observeStep(event);
}

Then compile context for the next worker:


const guide = await aionis.execution.guideForRole({
  agent_id: "worker",
  role: "worker",
  run_id,
  task_signature: "checkout-migration",
  query_text: "Continue from the accepted plan while avoiding the failed route.",
  context_mode: "compact_agent",
});

Proof Loop

Run the local product proof:


npm run -s runtime:e2e:plan-as-memory-asset

The demo verifies:

plan decisions enter governed context
acceptance checks are preserved
failed branches stay out of direct use
the simulated worker follows the plan target
feedback is attributed
/v1/measure reports changed future behavior
Flight Recorder excludes prompt payload and stays read-only

Example artifact: plan-as-memory-asset-result.json

Product Role

Aionis decides which plan evidence is safe and useful enough to affect the next Agent context. The host decides which model plans, which model executes, and how the loop runs.