Remnic Relay

When stale memory teaches an AI agent the wrong thing, Remnic Relay exposes the belief & the failure it caused, puts the correction behind human approval, and proves a brand-new agent learned the fix.

Comment

The problem

Git keeps a team’s code in sync. It does not keep a team of AI agents’ beliefs in sync.

An agent can retrieve an old decision, confidently change working code, and pass that mistake to every agent that follows. The dangerous part is not only that memory can be wrong. It is that the wrong belief is usually invisible: you cannot see why the agent believed it, approve a correction, or verify that the next agent actually learned.

Remnic is shared memory for AI agents. For Build Week, I built Remnic Relay: a human-governed correction loop that makes shared memory inspectable, reviewable, and testable.

Why it matters

As agents move from individual assistants to persistent teammates, shared memory becomes infrastructure. A stale deployment rule, security policy, API contract, or customer decision can quietly multiply across an entire agent team. Remnic Relay introduces the missing controls: provenance, human authority, versioned correction, and downstream verification.

This is bigger than better retrieval. It is a way for organizations to trust that when one agent learns an important correction, the whole team can inherit it without losing accountability.

What Remnic Relay does

Relay closes the loop from a bad belief to a verified recovery:

  1. Detect the conflict. Relay puts the current source-of-truth contract beside the stale memory an agent recalled.
  2. Open the X-Ray. It connects the exact memory, its provenance, the agent action, and the test failure that action caused.
  3. Review the correction. A separate Codex agent proposes a clear before-and-after diff. Shared memory does not change until a human reviews the evidence and explicitly approves it.
  4. Preserve the lineage. Relay marks the old belief as superseded instead of silently erasing history, then activates the approved replacement.
  5. Prove propagation. A brand-new Codex agent joins with no handoff, recalls the corrected rule, updates the implementation, and runs the same test. The incident is resolved only when that test turns green.

That is why I describe Relay as a pull request for team memory: inspect the cause, review the diff, approve the change, and require proof from a fresh consumer.

The demo story

The demo starts with a concrete online-payment outage during a customer purchase. The payment service should reuse one temporary access key while it remains valid and replace it once after it expires. One agent reads that current rule. Another remembers the stale rule “replace the key on every retry” and implements the wrong retry logic. The same repository now contains opposite beliefs, and the automated payment test fails.

Relay opens the evidence X-Ray, shows the causal chain, presents the proposed memory diff, and waits for human approval. After approval, the old belief remains visible as superseded. A fresh agent then recalls the replacement, fixes the retry behavior, and turns the same contract test green.

The demonstration uses a dedicated Remnic instance and a synthetic payment fixture created for the competition. It never touches your production Remnic data.

How we used Codex and GPT-5.6

GPT-5.6 powered four isolated Codex agents in the demonstrated mission: the agent that reads the current contract, the agent influenced by stale memory, the correction agent, and the fresh agent that must prove the fix propagated. Their separation is essential to the product claim: the final agent succeeds from approved shared memory, not from an earlier agent’s handoff.

Codex also helped us build Remnic Relay during Build Week: the correction engine, versioned lineage and evidence contracts, Mission Control interface, human approval gate, fresh-agent verification flow, and end-to-end test. We used Codex throughout implementation, adversarial review, testing, and demo production while keeping the product’s authority boundary explicit: agents may propose; a human approves; a test proves.

What is new for Build Week

Remnic existed before Build Week. Relay is the new extension built for this event. The eligible work includes:

  • a versioned contract for conflicts, evidence, corrections, lineage, and fresh-agent verification;
  • the human-gated correction engine and append-only supersession flow;
  • Mission Control, including the conflict view, evidence X-Ray, approval diff, propagation view, and verified mission receipt;
  • a bounded GPT-5.6 Codex mission runner with isolated roles and a dedicated synthetic Remnic instance; and
  • an end-to-end judge package that verifies the recorded causal chain and lets judges inspect the complete product flow.

The existing Remnic memory engine and host integrations are the foundation, not work claimed as new for this entry. The repository’s Build Week notes and claim ledger identify the new Relay work and its dates.

Challenges

The hardest design question was deciding what should count as “fixed.” Updating a memory record was not enough. Relay had to show that the wrong belief caused a real behavior change, that the correction was source-grounded and human-approved, and that an agent with no prior handoff could use it to produce the right outcome.

That led us to model the full causal chain instead of building a conflict dashboard: belief, provenance, agent action, failure, proposed diff, approval, supersession, fresh recall, and the same test passing.

What we learned

Agent memory needs the equivalent of code review and continuous integration. Retrieval answers “what does the team remember?” Remnic Relay adds the harder questions: “why does it believe that, who can change it, and did the next agent behave differently?”

What’s next

The online-payment incident is deliberately small enough to understand in seconds, but the protocol generalizes to deployment runbooks, dependency migrations, security guidance, customer constraints, and cross-tool agent teams. The next step is to let Relay watch real team workflows for belief-to-outcome conflicts while preserving the same human approval and fresh-agent proof requirements.

Built with

  • OpenAI Codex CLI
  • GPT-5.6
  • Remnic
  • Model Context Protocol (MCP)
  • TypeScript and Node.js
  • HTML, CSS, and JavaScript

Built With

  • chatgpt
  • chatgpt-5.6
  • codex
  • openclaw
  • remnic
Share this project:

Updates