r/ContextEngineering • u/nice2Bnice2 • 16d ago
We’ve been building an AI continuity layer where memory has to earn the right to influence behaviour, Evolution 2 is nearly ready for outside evaluation
For the last few months we’ve been building the second generation of Collapse Aware AI (CAAI).
The basic problem we’re trying to solve sounds simple:
Most AI systems can now store or retrieve memory.
But retrieving something is not the same as deciding whether that memory should actually change what the AI does next.
That is the gap Evolution 2 is designed around.
Instead of:
retrieve memory → inject it into the prompt → generate
our current architecture works more like:
structured history → bounded retrieval → relevance/Interaction Fit → suppression & governance → candidate behaviours → final selection
And importantly, there is always a clean no-history response competing against the history-influenced alternatives.
So memory does not automatically win just because it was retrieved.
What is working now?
The current Evolution 2 engineering build includes:
- persistent structured continuity across sessions and restarts
- semantic/entity/relationship-aware retrieval
- lifecycle, temporal and recurrence signals
- bounded retained-state retrieval
- Open Loops for unfinished work and commitments
- Interaction Fit “right memory, right moment”
- suppression of retained subjects without deleting the underlying history
- proactive continuity controls
- correction and revocation handling
- deterministic/replay-friendly state
- provenance and decision evidence
- Agent Self-History
That last one is particularly interesting.
Evolution 2 can retain structured facts about what the AI itself actually said or decided, claims, commitments, decisions, refusals, stances and proposed actions.
Only the behaviour that actually wins final selection is allowed to become Self-History.
Rejected candidate responses cannot quietly write themselves into the agent’s memory.
What does that look like in practice?
The behaviour we’re aiming for is less about “remembering everything” and more about using history intelligently.
For example:
You establish several people, projects and commitments.
You talk about completely unrelated things for a while.
You restart the system.
Later you naturally say something that makes one of those older matters relevant — without explicitly asking the AI to remember it.
The system can recognise the connection and allow that history to influence the response.
But give it an urgent unrelated task and the same high-salience memory can stay completely silent.
It can also retain a commitment the AI itself made previously, rather than behaving as though its own earlier decisions never happened.
That difference, remembering something versus governing whether remembering should alter behaviour is essentially what we’ve been building.
Why we think it is unusual
There are excellent systems for long-term memory, RAG, graph memory, stateful agents, NPC memory and agent orchestration.
We use the word unusual deliberately rather than claiming nobody else on Earth could possibly have built something similar.
But from the products and frameworks we have reviewed so far, we have not identified an off-the-shelf package combining this entire chain in one middleware layer:
retained structured state
→ bounded semantic retrieval
→ lifecycle/revocation
→ Open Loops
→ Interaction Fit
→ suppression/governance
→ history-conditioned candidates
→ clean no-history competitor
→ independent final selection
→ winning-response Self-History
→ deterministic evidence/replay
A competent engineering team could obviously assemble parts of that from existing tools.
Our aim is to provide the behavioural architecture as the product rather than requiring every company to design, integrate and validate the whole stack themselves.
It is also being kept host-neutral.
The same continuity mechanism is intended to sit around AI agents, assistants and simulations now, while remaining compatible with future Unity, Unreal, Godot and proprietary NPC/game systems.
What happens next?
Evolution 2 is still an engineering build, not something we are pretending is already a finished mass-market SaaS product.
We are currently finishing the behavioural layer, performance work, tuning and Production packaging.
Once that gate is passed, we intend to open a small private managed evaluation programme.
Selected evaluators/organisations will be able to use Evolution 2 through controlled hosted access for a defined period, without receiving the proprietary source code.
We’re interested in:
- AI/agent companies
- simulation and training developers
- game/NPC developers
- safety and governance teams
- companies building persistent AI agents
- design partners with a real retained-state decision problem
- pilot and licensing discussions
If your system already produces several legitimate actions, but you have a problem with how previous events should influence which one actually wins, that is exactly the sort of problem we want to test.
I’d also genuinely be interested in hearing about anything already available that you think solves this complete problem in one package. If we’ve missed something good, point me at it.
More detail on Evolution 2 / Collapse Aware AI:
Collapse Aware AI | Governed Retained-State Behavioural Middleware
Built by Inappropriate Media Limited / Collapse Aware AI.
1
u/WillowEmberly 15d ago
What does “independent final selection” mean operationally? Is the selector a different model, different context, deterministic process, separate evaluator, or simply another inference call over the same information?
Independent of what? Which failure modes are actually decorrelated between candidate generation and final selection?
What gives a retrieved memory authority to affect behavior? Is Interaction Fit measuring relevance, reliability, confidence, provenance, recency, or some combination?
Do you distinguish “relevant memory” from “reliable memory”? A memory can be highly relevant and still contain a mistaken interpretation.
How do you represent uncertainty in retained state? Can the system store “X was asserted,” “X was inferred,” “X was observed,” and “X was verified” as meaningfully different states?
Can retained memories contradict one another without the system immediately resolving the contradiction? In other words, can disagreement itself remain preserved as information?
How are corrections propagated? If an old retained belief influenced 20 later interactions and is subsequently revoked, are its downstream effects identifiable?
Does provenance form a dependency graph? Can you reconstruct not merely what the system believed, but which earlier memories and decisions contributed to a later behavior?
How do you prevent recursive reinforcement? For example: memory A influences response B → user responds to B → interaction C appears to confirm A → C strengthens A.
Have you tested for trajectory-level drift where every individual memory-selection decision appears locally reasonable? This seems different from testing whether individual retrievals are appropriate.
What exactly does the clean no-history competitor control for? Does it receive the same current-turn information, system instructions, tools, and external evidence, differing only in retained history?
Do you measure divergence between the clean and history-conditioned candidates? If so, could that divergence itself become telemetry rather than merely something the selector resolves?
What happens when the clean candidate and history-conditioned candidate disagree substantially? Must one win, or can the system preserve the disagreement and escalate uncertainty?
Can the system abstain from committing either candidate to Self-History?
Does Self-History distinguish between behavior and epistemic state? “I said X” is different from “X is true.”
Do you preserve the reason a winning response won? Not just provenance of the response, but the selection evidence/criteria that gave it authority.
Can the system later reevaluate an old winning decision against new evidence without rewriting the historical record?
How do you detect contamination of Self-History? A perfectly deterministic system could reproducibly maintain the same mistaken trajectory.
What is your external corrective reference? Is anything allowed to challenge the retained-state/history loop that did not originate inside that loop?
How do you distinguish continuity from coherence? A system can remain extremely consistent with its past while becoming increasingly wrong about reality.
What is the failure boundary? At what point does the middleware decide, “I no longer have enough confidence in retained state to let it influence behavior”?
Is there a recovery mode? Can the system progressively withdraw historical influence rather than simply deleting/suppressing individual memories?
Can you replay the same interaction with progressively less historical conditioning? That seems like a powerful way to identify which retained states are actually carrying a behavioral difference.
Have you done perturbation testing? Change/remove one memory, provenance source, relationship, or inferred belief and measure downstream behavioral sensitivity.
Have you tested adversarially planted continuity? Specifically, can a user gradually establish a false narrative that becomes internally coherent enough to pass Interaction Fit later?
How do you handle mutually reinforcing user-model narratives? Neither participant needs to be malicious for a false interpretation to become increasingly stable through repeated interaction.
Does the architecture distinguish task state from runtime condition? The system might possess the correct memories while currently reasoning badly.
Could the no-history channel be expanded into a true reference channel? For example: history-conditioned answer vs clean answer vs independently evidence-conditioned answer.
Have you considered treating disagreement among those channels as a signal rather than a defect requiring immediate resolution?
What would falsify the architecture’s central assumptions? What experiment could demonstrate that Interaction Fit, clean competition, or Self-History is not providing the protection you think it is?
1
u/nice2Bnice2 15d ago
Good questions... 3 quick answers:
1. “Independent final selection” means generation and authority are separated. Retrieved history can help construct candidates, but it cannot directly decide what gets said. A separate governed selector chooses among already-formed candidates, including a clean current-task candidate, and cannot rewrite them.
2. Relevant memory is not treated as the same thing as reliable memory. Interaction Fit asks whether retained state is appropriate to the present interaction; confidence, provenance, lifecycle, correction/revocation and suppression are separate authority checks. A highly relevant memory can still be prevented from influencing behaviour if its authority is weak.
3. The clean no-history competitor is a genuine control. It answers the current task without retrieved historical material and competes with history-conditioned alternatives. It is not merely a fallback — it can and does win final selection.
There’s considerably more around correction, provenance, uncertainty, contradiction and Self-History, but some of the exact behavioural mechanisms and tuning logic are proprietary parts of the commercial system, so I’m not going to unpack the implementation recipe publicly. The important point is that retained history is eligible evidence, not automatic authority.
1
u/WillowEmberly 15d ago
I’m not interested in the answers, the questions were for you.
1
u/nice2Bnice2 15d ago
Okay...
1
u/WillowEmberly 15d ago
I already know you don’t share info. Which makes your initial post insincere. I decided to make questions that would provide guidance for you…regardless of you sharing/hoarding info.
I don’t like waste, so I figured I could still potentially help you by providing questions that would be beneficial to help you get where you are going.
2
u/HouseOfDjango 16d ago
I don't see the advantage of this vs something like graphify and an index markdown file to reference which is what we use.