MemoryGate

• 

  MemoryGate — Governed Memory Debugger for AI Agents | OpenAI Build Week

Inspiration

AI agents are increasingly able to remember users, but most memory systems still hide the decisions behind that memory.

Developers often cannot clearly answer:

• Where did this memory come from?
• Is it a verified fact, a preference, or a temporary state?
• Does it conflict with an existing memory?
• Is the system making an unsupported inference?
• Who authorized the memory to become persistent?

MemoryGate was created to make AI memory decisions visible, reviewable, and auditable.

What it does

MemoryGate turns raw conversations into structured memory candidates instead of writing directly into long-term memory.

For each candidate, it shows:

• the proposed memory
• its source evidence
• memory type and scope
• possible conflicts
• ambiguity or expiration risks
• the model's recommendation
• the final human decision

MemoryGate never silently overwrites an existing memory. A reviewer must explicitly Accept, Defer, or Reject the candidate before it can be treated as approved.

It can also export a structured audit record showing what was proposed, what evidence supported it, what conflicts were detected, and who made the final decision.

How we built it

MemoryGate was built during OpenAI Build Week with Codex and GPT-5.6.

Codex and GPT-5.6 were used to define the product scope, design the governance model, implement the Next.js application, write tests, debug issues, document the system, and verify the production build.

The submitted runtime uses a transparent deterministic local prototype engine. It does not invoke GPT-5.6 or any external AI API, and it does not write to a production memory backend.

The application uses a narrow, inspectable workflow:

1. Import conversation context
2. Generate a memory candidate
3. Inspect evidence and conflicts
4. Make a human decision
5. Export an audit record

Challenges we ran into

The hardest challenge is preventing the AI from acting beyond its authority.

A useful memory system must distinguish between analysis and authorization. The model may identify a conflict or recommend an action, but it must not pretend that the conflict has been resolved or that a memory has been approved.

Another challenge is keeping the experience simple. Memory governance can become highly complex, so MemoryGate focuses on one clear workflow rather than attempting to build an entire universal memory platform.

Background

MemoryGate is informed by the Civilization Core / Subspace Memory System, a broader research effort exploring governed long-term memory for AI systems.

For OpenAI Build Week, MemoryGate is being developed as a separate, focused, runnable product with its own repository, interface, tests, and demonstration workflow.

Accomplishments that we're proud of

We are proud of turning a broad research topic into a focused and understandable developer tool.

Instead of attempting to build an entire memory platform, we defined a narrow end-to-end workflow: extract a memory candidate, preserve its evidence, inspect conflicts and ambiguity, require a human decision, and produce an audit record.

We also established a strict authority boundary: the AI may analyze evidence and recommend an outcome, but it may not silently approve, overwrite, or delete persistent memory.

Finally, we separated MemoryGate from the larger Civilization Core research effort so that the Build Week contribution can be independently developed, tested, demonstrated, and evaluated.

What we learned

We learned that AI memory is not simply a storage problem. It is a decision problem involving evidence, scope, conflict, expiration, authority, and accountability.

We also learned that confidence scores alone are not enough. A highly confident model can still rely on incomplete context or make an unsupported inference. Reviewers need to see the source evidence and the reason behind each recommendation.

The most important lesson was that analysis and authorization must remain separate. An AI system can identify a likely conflict, but only an authorized human should decide whether a memory is accepted, deferred, rejected, or replaced.

We also learned that strong governance becomes useful only when it is presented through a simple product workflow rather than a large theoretical framework.

What's next for MemoryGate

Next, we plan to complete the runnable MemoryGate prototype and strengthen it through real-world testing.

Planned improvements include:

• support for multiple memory stores and agent frameworks
• configurable memory schemas and review policies
• expiration and supersession tracking
• side-by-side comparison of conflicting evidence
• team-based reviewer roles and approval history
• integrations with agent development and observability tools
• privacy controls for sensitive or inferred personal information

The longer-term goal is to make governed memory review a standard development layer for AI agents, similar to how version control, testing, and code review became standard layers for software engineering.

Built With

• codex
• gpt-5.6
• next.js
• typescript