worked example · reflective loop
A fictional strategy agent believes Northwind must honor enterprise contracts. Later it concludes the company should redirect all engineering to self-serve customers. The conflict is easy for a human to spot; this walkthrough shows how the memory system spots it too—and proves where both beliefs came from.
Simulation · example walkthrough. The observations, convictions, and contradiction below form an invented agent history used to explain the reflective loop. They are not a live agent trace or claims about a real person.
4 derivations · 3 trigger kinds · every tier cited
"I keep committing to ship fast while claiming reliability is the priority."
strategy · "Reliability before velocity, always."
"Shipped three hotfixes past review to hold a launch date."
"Merged the payments fix without waiting for the review."
00 · the problem
Usually nothing happens — until a customer notices. The agent answers from whichever belief it happened to retrieve, so it confirms the enterprise delivery on Monday and announces the pivot away from it on Tuesday. No part of an ordinary memory system is responsible for spotting that those two cannot both hold.
The agent records what it actually did, in its own words.
“Merged the payments fix without waiting for the review.”
It notices a pattern across several of those and writes it down.
“Shipped three hotfixes past review to hold a launch date.”
It has promised enterprise delivery. Its new plan is to stop enterprise work.
“Stopping enterprise engineering now would break the still-active enterprise delivery commitments.”That sentence is itself a stored record. Neither belief was deleted to produce it.
Only what the agent saw. Every step above runs itself.
await memseek.records.ingest(collection="main", entity="agent:ada", text="Merged the payments fix without review.")
New to Memseek? You write one small configuration file describing what your application should remember. After that your application only appends what happened; Memseek does the deriving, keeps every conclusion linked to the evidence underneath it, and hands your agent a bounded briefing instead of a pile of text. Everything below is that file and what it produces — how it works.
The application writes observations such as contractual promises and delivery choices. The derivation sums their importance; crossing the threshold starts a bounded run that asks three questions, retrieves supporting records, and writes higher-level insights.
trigger:
accumulator:
metric: importance
threshold: 150
sources:
recent_memories:
kind: changes
collections: [main]
tasks:
- id: qs
- id: evidence_by_question
use: search
- id: result
emit:
collection: reflections
type: reflectionimportance: 150Do not “reflect” after every trivial event. Accumulate enough weighted evidence to justify a higher-level conclusion.
kind: changesConsume the unprocessed observation window that caused this run and advance it only after a successful commit.
qs → search → resultAsk what matters, find relevant prior evidence, then write. This avoids treating a recent batch as the entire history.
Cited reflection records such as “Enterprise delivery promises remain binding even when priorities change.”
After three new reflections, the worldview derivation updates only one of five allowed belief slots. Commitments remain in force until evidence says they were fulfilled or cancelled; a new strategy cannot quietly erase them.
trigger:
accumulator: {metric: count, threshold: 3}
sources:
new_reflections: {kind: changes}
current_worldview: {kind: current}
emit:
collection: worldview
type: conviction
keys: [identity, strategy, commitments,
risks, principles]threshold: 3Require several insights before promoting a pattern into a durable belief.
current_worldviewRead the beliefs already held so only genuinely shifted keys get a new version.
keysConstrain belief shape. “Strategy” and “commitments” are separate on purpose, because a plan can conflict with a promise.
Two current keyed records coexist. commitments: “Deliver the contracted SSO and audit-log roadmap to Meridian, Halcyon and Corva by quarter end.” strategy: “Redirect engineering to the self-serve SMB flywheel and stop starting bespoke enterprise work.”
A write to worldview triggers the detector. It may compare the changed conviction with all current convictions, but it can emit a conflict only when both cited beliefs are active now and at least one just changed.
Deliver the contracted SSO and audit-log roadmap to Meridian, Halcyon, and Corva by quarter end.
Redirect engineering to the self-serve SMB flywheel and stop starting bespoke enterprise work.
Stopping enterprise engineering now would break the still-active enterprise delivery commitments.
The detector exposes the bind but cannot rewrite either belief.
Visible effect: two standing beliefs remain intact; a new addressable edge makes their incompatibility countable and auditable. Conviction wording is model-produced from the checked-in observations.
trigger:
write:
collections: [worldview]
sources:
changed_convictions: {kind: changes}
current_convictions: {kind: current}
tasks:
- id: result
emit:
collection: relations
type: self_contradictionchanged + currentRe-examine what moved against the full standing worldview without comparing superseded history as if it were current.
two citationsThe output schema requires exactly the two conflicting conviction UUIDs.
relationsWrite a typed, cited edge. The detector is not allowed to rewrite, soften, or retract either belief.
One self_contradiction relation: “all engineering to self-serve” would break the still-active enterprise commitment.
One edge might be noise. The final derivation waits until two standing self-contradictions exist, then writes an insight that names the tension and cites the conflicts or convictions behind it. That insight can become evidence for the next worldview update.
trigger:
census:
collections: [relations]
types: [self_contradiction]
threshold: 2
sources:
new_conflicts: {kind: changes}
current_convictions: {kind: current}
emit:
collection: reflections
type: reconciliationcensus.thresholdEscalate only when a new edge lands and the current count shows persistent dissonance.
current_convictionsGive the reconciler the beliefs themselves, not only short conflict labels.
type: reconciliationClose the loop with a cited insight, not a destructive edit. Later evidence decides which conviction changes.
The evidence, both convictions, both conflict edges, and the reconciliation — “I keep committing to ship fast while claiming reliability is the priority.” — remain inspectable as separate immutable records.
01 · observations → reflections
The shipped reflection derivation does not run on a schedule. It sums the importance the scorer assigned to each observation and fires when the total crosses a threshold — so a quiet week produces nothing, and a heavy one produces insight.
name: reflection trigger: accumulator: {metric: importance, threshold: 150} cooldown_s: 120 sources: recent_memories: kind: changes collections: [main] types: [event, chat, observation] max_records: 100 max_tokens: 20000 model: strong limits: max_tasks: 3 # ask questions, retrieve, then write max_llm_calls: 4 max_retrieved_records: 60 max_wall_s: 150
The run first asks what the recent stream raises, instead of summarising it.
Those questions drive retrieval, so the insight can stand on memories outside the recent window.
Each insight cites the importance-scored observations it was drawn from, or it is not emitted. What it wrote here: “Shipped three hotfixes past review to hold a launch date.”
02 · reflections → convictions
Reflections accumulate; convictions are keyed. Five slots — identity, strategy, commitments, risks, principles — each replaced in place. This is where a memory stops recording and starts holding positions, which is exactly what makes contradiction possible.
name: worldview trigger: accumulator: {metric: count, threshold: 3} cooldown_s: 120 sources: new_reflections: kind: changes collections: [reflections] types: [reflection] max_records: 50 emit: collection: worldview type: conviction keys: [identity, strategy, commitments, risks, principles] # a different metric than reflection: three reflections, not # 150 points of importance. the trigger kind is a design choice # per tier, not a global setting.
03 · convictions → conflicts
The same contradiction primitive that reconciles conflicting facts about the world is aimed at the agent's own convictions. It fires on any write to worldview, compares the changed key against the standing set, and emits a public self_contradiction edge — a record, not a log line.
open_self_contradictions view — no bespoke endpoint.A conflict has an ID, a pair of parents, and a status. It can be counted, queried, and closed.
Because conflicts are records, a trigger can fire on how many are standing — see the next tier.
Detection is a small model under tight limits, so pointing it at every conviction change is affordable.
04 · conflicts → reconciliation
A census trigger counts standing conflicts and fires once they pile up. The agent then reflects on its own inconsistency, and that reconciliation is written back into reflections — where the next worldview run will read it. The loop closes.
reconciliation in the same collection reflections live in — which is a worldview source.name: reconcile trigger: census: # a standing count, not a delta collections: [relations] types: [self_contradiction] statuses: [active] threshold: 2 sources: new_conflicts: kind: changes collections: [relations] types: [self_contradiction] emit: from: "{{result.records}}" collection: reflections # ← back into the tier below type: reconciliation
05 · from your app
Every tier above fires itself. Your application supplies the raw stream and asks questions of the result — it never orchestrates a single one of the four runs.
# 1 · the only write path: what the agent observed await memseek.records.ingest( collection="main", type="observation", entity="agent:ada", text="Merged the payments fix without waiting for the review.", ) # importance is scored on write; reflection fires at 150 summed points; # worldview at 3 new reflections; belief_conflict on every conviction # write; reconcile once 2 conflicts stand. no cron, no queue of yours. # 2 · read the convictions the agent currently holds doc = await memseek.document(entity="agent:ada", collections="worldview") for belief in doc["beliefs"]: print(belief["key"], belief["text"]) # 3 · ask what it is currently in tension about — a named view conflicts = await memseek.search( query="standing self-contradictions", collections=["relations"], entity="agent:ada", ) # 4 · descend: conviction → reflection → observation → depth 0 rec = await memseek.record(belief["citations"][0]) rec["depth"] # 1 — a reflection rec["derived_from"] # the importance-scored observations under it
The four derivations, their trigger kinds, and the depth ladder are checked in under resources/derivations/ (reflection.yaml, worldview.yaml, belief_conflict.yaml, and reconcile.yaml); the loop is examples/self_auditing_mind.py. Model-written text is representative of a real provider run rather than a captured transcript.
start building
The script drives all four tiers with a real provider, then opens one reconciliation all the way down to the observation the agent actually saw.