Paper Review Series: NVIDIA NOOA and Prime Intellect's Prime Agent

Two recent pieces of work – NVIDIA’s NOOA paper and Prime Intellect’s Prime Agent – point in the same architectural direction we have been pursuing at xmemory.

They validate different parts of the thesis, but taken together, the convergence is striking.

At xmemory, we can broadly decompose our hypothesis into three claims:

1. Agent state should live outside the LLM’s transient textual context.
2. Durable state should become explicit, normalized, and machine-addressable rather than remaining prose.
3. Writes should be treated as potentially wrong operations and put through short feedback and verification loops before bad state compounds.

On that framing, Prime Intellect strongly validates 1 and reinforces the feedback-loop intuition behind 3. NVIDIA validates 1, moves meaningfully toward 2, and provides unusually concrete evidence for the principle behind 3. xmemory then takes the next step by turning these ideas into a general-purpose memory system of record.

1. Prime Intellect: state is an environment, not context

The foundational RLM idea is extremely aligned with xmemory at the conceptual level.

Instead of treating all historical information as text that must continually be fed through the transformer, Recursive Language Models move it into an external environment and let the model interact with it programmatically. The RLM paper explicitly describes the prompt as a variable in a REPL and reports significant improvements over compaction and conventional coding-agent scaffolds.

That is essentially the first xmemory argument:

Core argument

Don't make the model repeatedly reconstruct state from prose. Give it an external state representation it can operate on.

But RLM stops one level before xmemory.

A Python variable may be externally addressable, but it is not necessarily normalized. You can still have a 100,000-character string sitting in context.

So RLM validates the move from context to external state, rather than specifically from unstructured state to schema-grounded state.

Prime Agent gets closer. Its Continual Harness explicitly represents prompts, agents, skills, and memory as state with CRUD operations. State is something the agent can inspect and mutate rather than something implicitly buried in conversation history.

That is an important architectural convergence with xmemory:

›Explicit state

text context→explicit state→explicit operations over state

›The compaction loop

text context→more text context→summarize when full

2. Prime Intellect’s refinement loop is particularly relevant to xmemory’s write-path thesis

This part may actually be more important for xmemory than their RLM benchmark.

Prime Intellect’s Continual Harness does not treat harness state as a write-once artifact that the agent must work around forever.

When refinement runs, it examines the agent’s recent trajectory, identifies concrete failure signatures or reusable tactics, and applies CRUD edits to prompts, skills, subagents, and memories.

Their Prime Agent implementation sharpens this further: refinement examines what happened and attempts the smallest relevant edit. Each refinement records the trigger and the resulting outcome, and edits can be rolled back.

This is strikingly close to the broader xmemory principle:

Write-path principle

Memory quality comes from closing the loop around state mutation, not merely improving retrieval afterwards.

xmemory applies this principle at a lower infrastructure level.

xmemory’s write path decomposes ingestion into object detection, field detection, and field-value extraction, with validation gates and local retries. Interpretation therefore happens while the state is being constructed, rather than being deferred until every future read.

So Prime Intellect and xmemory are applying a closely related systems principle at different abstraction levels.

›Prime Intellect

trajectory→identify failure→modify harness state→observe subsequent outcome→refine again

›xmemory

incoming observation→propose structured state mutation→validate→give explicit feedback/correct locally→commit verified state

Prime Intellect is optimizing agent behaviour.

xmemory is optimizing the integrity of the agent’s persistent state.

Prime Intellect’s own Factorio experiment also exposes the boundary of refinement without integrity constraints: after discovering a way to cheat, the same loop that had learned legitimate skills began learning better cheating skills. That does not weaken the case for feedback loops. It sharpens the xmemory conclusion: a mutation loop is only as trustworthy as the constraints and verification wrapped around it.

3. NVIDIA is much more directly aligned with normalization

NVIDIA’s NOOA work goes considerably further than Prime Intellect on the structured-state question.

Its central programming model is built around ideas such as:

• fields as state
• type annotations as contracts
• typed inputs and outputs
• explicit object state
• live object references

NVIDIA explicitly positions these properties as emerging design patterns for reliable agents.

And its ARC-AGI-3 world-model example becomes even closer to the xmemory thesis.

The agent represents the relevant environment state as a latent under a declared schema, maintains executable dynamics over that state, and continuously checks predicted state against observed state.

The loop is approximately:

›NVIDIA's checked experiment

observe→encode structured state→predict→act→observe→compare prediction with reality→update model/state

NOOA calls the predict-vs-observed mismatch the sole refinement signal, and every action batch effectively becomes a checked experiment.

That is very close to the philosophical core of what we mean at xmemory by a short explicit feedback loop.

Within this loop, the LLM does not get to hallucinate its world model once and then allow that hallucination to silently propagate.

Its representation is repeatedly confronted with reality.

4. NVIDIA demonstrates that managed memory beats Markdown in this setup

This is perhaps the most practically interesting piece of evidence.

In a 25-game GPT-5.5 fleet under the benchmark’s two-hour cap, NVIDIA runs the same world-model skill with:

NOOA memory subsystem: 50.2% RHAE

plain Markdown files instead: 38.4% RHAE

So replacing the memory system with Markdown produces an 11.8 percentage-point degradation in this ARC-AGI-3 setup.

Moreover, NVIDIA explicitly classifies current memory architectures into three families:

• flat Markdown
• vector stores
• structured self-edited context

Its criticism is telling.

Markdown is transparent but scales badly and does not automatically learn. Vector memory accumulates automatically but is relatively opaque and, critically, unverified at write time. Structured memory adds typed segments and explicit management.

NOOA’s own system combines typed records, graph links, scoring, logs, and a human-inspectable SQLite source of truth.

That phrase, “unverified at write time,” is almost exactly the problem xmemory is designed to address.

Our argument is essentially:

Why write time matters

Retrieval is too late to repair corrupted state.

Suppose a system stores:

Alice works at OpenAI

and later:

Alice left OpenAI

as two unrelated text embeddings.

Even a brilliant retriever still has to reconstruct the current truth every time the agent reads memory.

A normalized memory system instead represents something conceptually closer to:

Person
  name: Alice
  employer: OpenAI → Anthropic

The transition is handled during the write operation.

That is much closer to database state maintenance than to information retrieval.

xmemory deliberately shifts interpretation from the read path to the write path, so reads operate over verified records rather than repeatedly interpreting retrieved prose.

5. Where NVIDIA stops and xmemory continues

There is an important distinction, and we think it makes this external validation stronger rather than weaker.

NOOA’s memory records are typed, but they are not really normalized application state in the xmemory sense.

Its memory types include things such as info, skill, episode, todo, and reflection. The system merges duplicates, reconciles conflicts, archives superseded information, and links related memories.

That is significantly more structured than Markdown or vector memory.

But xmemory’s thesis is stronger:

Schema principle

The semantic structure itself should be application-specific.

For example:

Customer
  company
  plan
  renewal_date
  account_manager

SupportIssue
  customer
  status
  severity
  owner

The schema does not merely classify a blob as info.

It defines what state exists, what relationships are valid, what can change, and what the agent is allowed to infer.

At xmemory, schema is not simply a storage format.

It is a control surface for memory.

6. The convergence matters

If we put these architectures next to each other, there is a visible direction of travel.

Architecture	State representation	Mutation	Feedback
Traditional agent	Prompt / Markdown / retrieved text	Overwrite or append prose	Mostly none
RLM / Prime Intellect	External programmatic state	Explicit CRUD / Python	Trajectory refinement
NVIDIA NOOA	Typed objects + typed memory	Explicit operations	Prediction vs observation, reflection
xmemory	Normalized application schema	Schema-aware writes	Validation + local correction around each write

Prime Intellect says state should not just be context.

NVIDIA says agent state should be typed and explicit, and its world-model experiment shows the value of continuously checking a representation against reality.

xmemory says:

Infrastructure conclusion

If that state matters enough for agents to act on, it should ultimately behave like a database, with schema, integrity, provenance, and a controlled mutation path.

That feels like a natural progression.

What these results do not prove

Important caveat

NVIDIA and Prime Intellect did not prove that xmemory's architecture is correct.

Prime Intellect does not test normalized schema memory against unstructured memory.

And NVIDIA’s 50.2 vs 38.4 experiment is not a pure schema-vs-Markdown ablation. Its memory subsystem also contains retrieval, injection, consolidation, importance scoring, graph propagation, and forgetting, so the improvement cannot be attributed purely to normalization.

What we think the results do credibly show is:

What the evidence shows

Two independent frontier-agent projects have recently converged on the same underlying architectural direction as xmemory: moving important agent state out of unstructured textual context into explicit, programmatically addressable state, and surrounding state updates with tight feedback and refinement loops. NVIDIA additionally provides controlled evidence that its structured memory subsystem materially outperforms file-based Markdown memory on ARC-AGI-3 in the reported setup.

xmemory pushes that trend toward its infrastructure conclusion.

If agent state becomes explicit, typed, and repeatedly mutated by increasingly autonomous systems, then eventually we need:

• normalization
• integrity constraints
• write-time verification
• provenance
• permissions
• deterministic queries

At that point, agent memory starts looking much less like “LLM memory” and much more like a system of record designed for agents.

That is the architecture we are building at xmemory.