Episodes

Hyperstruck used to remember the lessons of a run and forget the run. It stored the rules and facts a run produced, and the agent that produced them, but kept no durable record of the run itself: no graded outcome, no record of how sensitive the work was, and no way to erase it. That is a gap in two directions at once. Nothing could answer where did this belief come from, and nobody could ask for their trace to be deleted, because there was no trace to delete.

The episode shelf closes both.

What an episode holds

The outcome is graded rather than binary, and it comes from the engine's own signals rather than being inferred after the fact. Succeeded but degraded is a real and common state, and collapsing it into success is how a system convinces itself it is doing better than it is.

Sensitivity is derived, and it fails toward private

An episode holds the raw text of the goal and the steps, unredacted. That is the point of it, and it is also why it is the most carefully fenced of the three shelves.

Its sensitivity is computed from the trace itself. Work that touched credentials reads as sensitive. Work involving a person's own data is scoped to the agent that did it. Only a demonstrably clean trace can be marked shareable, and that verdict is reachable only by the check passing, never by a fallback or a default. Any stored value that is missing or unreadable is treated as private. A raw record of a run must never quietly read back as something safe to promote across an organization.

Being forgotten is an operation, not a policy

"Forget this run" and "forget everything about this person" are real operations in the runtime rather than commitments in a document. They are not yet reachable through the API, so read this section as how erasure behaves, not as something you can call today; see What is on today.

Erasing a run removes it, subtracts the support it lent to your agent's rules so nothing keeps standing it no longer earned, and detaches what pointed at it. It is written to survive interruption: if the process dies partway, resuming re-runs it from the start and leaves no residue. Erasing everything about an entity finds the runs that named it and deletes each one whole, since a raw record cannot be partly redacted.

How completely it finds them depends on the deployment. Identifier-shaped mentions, such as ids, domains and email addresses, are always indexed. Names in free text are caught only where the recognition model is present, so a deployment without it will reach fewer runs for a person named only in prose.

What episodes are not

• Not a transcript search. The agent does not read past runs back as context, and does not answer questions by replaying them. What generalizes from a run becomes a learning; what it established about something becomes a claim.
• Not evidence of a pattern. One run is one run. The corroboration that gives a rule standing counts separate runs precisely so a single memorable episode cannot masquerade as a trend.
• Not scored like the other shelves. A rule earns trust by recurring. An episode never recurs; it happened once. It is valued on how recently it happened and how it turned out, which is how people actually reach for a comparable past case.
• Not org-shared. Episodes stay with the agent that produced them.

What is on today

Episodes are recorded for every finished run, including runs from your own framework submitted through the learning loop, which get the same record with their outcome grading limited to succeeded or failed.

Related pages

• Memory for how episodes sit alongside learnings and claims
• Learning for what gets distilled out of a finished run
• Security and data isolation for the wider isolation model