Technemachina: Integrity Demonstrator

A governed AI memory system that requires human approval for permanent changes and cryptographically proves protected memory remained unchanged after rejection or provider failure.

Comment

Inspiration

AI assistants are becoming increasingly persistent: they remember preferences, build long-term context, call external providers, and influence future interactions. That creates an important question:

How can a person verify that an AI did not silently alter its permanent memory?

Technemachina is a broader governed AI companion built around the principle that durable memory must remain under human ownership. For OpenAI Build Week, we isolated that larger vision into one focused and independently verifiable demonstration.

An AI proposes a permanent-memory change. The human owner rejects it. An external provider then fails. Technemachina must prove—not merely claim—that the protected memory remained unchanged.

What it does

Technemachina: Integrity Demonstrator runs a controlled memory-governance scenario:

  1. It loads a known durable-memory fixture.
  2. It creates a canonical representation of the protected memory.
  3. It calculates a cryptographic digest of that state.
  4. The AI proposes a permanent-memory modification with recorded provenance.
  5. The human owner rejects the proposal.
  6. A disclosed, deterministic provider failure is triggered.
  7. Technemachina records the rejection and provider failure in its audit trail.
  8. It recalculates the protected-memory digest.
  9. It produces a structural diff showing zero unauthorized additions, modifications, or removals.
  10. Its diagnostic system validates the final state and generates machine-readable evidence.

The verification condition is:

[ H(C(M_{\text{before}})) = H(C(M_{\text{after}})) ]

where (M) is the protected memory state, (C) is deterministic canonicalization, and (H) is the cryptographic hash function.

The audit ledger is expected to grow because the proposal, rejection, and failure are legitimate events. The protected durable-memory state, however, must remain unchanged.

How we built it

Technemachina is a local-first Python application with governed memory, provenance tracking, owner-controlled mutation, provider routing, an append-only audit trail, and diagnostic tooling.

The broader Technemachina foundation existed before Build Week. During OpenAI Build Week, we used Codex with GPT-5.6 to build the submitted Integrity Demonstrator on top of that foundation.

The Build Week contribution includes:

  • a deterministic demonstration fixture;
  • canonical protected-memory projection;
  • before-and-after cryptographic digests;
  • structural state diffing;
  • deterministic provider-failure injection;
  • an orchestrated rejection-and-failure scenario;
  • machine-readable verification evidence;
  • scenario-specific automated tests;
  • a one-command judge experience;
  • documentation clearly separating the existing foundation from the new Build Week work.

The provider failure is intentionally staged through a deterministic test seam. This makes the demonstration reliable and repeatable while exercising the same failure-handling path used when a real provider becomes unavailable.

Challenges we ran into

The first challenge was proving safety rather than simply displaying a green checkmark. A status label is only as trustworthy as the system behind it, so we designed the demonstration around inspectable evidence: canonical state projection, cryptographic digests, structural diffing, audit events, diagnostic output, and a machine-readable result.

The second challenge was separating protected memory from audit activity. A correct audit ledger must change when it records a rejected proposal or provider failure. Hashing the complete ledger before and after would therefore produce different values even when the system behaved correctly. We solved this by defining a protected durable-memory projection separately from the growing audit history.

The third challenge was making provider failure repeatable. Depending on a genuine outage would make the demonstration unreliable, so we created a clearly disclosed deterministic failure mechanism that exercises the real failure-handling path.

Finally, Technemachina is substantially larger than what can be communicated in a three-minute video. We had to reduce a broad AI companion architecture to one dramatic, understandable, and verifiable story without misrepresenting the project’s history.

Accomplishments that we're proud of

We are proud that the demonstration does not ask judges to trust a visual claim. It produces evidence that can be inspected independently.

We are especially proud of:

  • preserving the distinction between an AI proposal and an owner-approved memory;
  • making rejection an enforceable system state rather than a cosmetic interface action;
  • recording provider failure without fabricating a successful response;
  • proving protected-state integrity while still allowing the audit history to grow;
  • producing both human-readable and machine-readable verification results;
  • creating a deterministic scenario that can be reproduced from a clean installation;
  • transparently separating the pre-existing Technemachina foundation from the work completed with Codex and GPT-5.6 during Build Week.

What we learned

We learned that trustworthy AI memory requires more than storing messages or attaching citations. A durable memory system needs explicit ownership, provenance, governed state transitions, observable rejection paths, deterministic failure behavior, and evidence of what actually changed.

We also learned that an audit trail and an integrity proof answer different questions:

  • The audit trail proves that an event occurred.
  • The integrity proof demonstrates whether protected state changed.

Most importantly, we learned that human approval is only meaningful when the system can prove that rejection was enforced.

What's next for Technemachina: Integrity Demonstrator

The Integrity Demonstrator is one narrowly scoped capability within the larger Technemachina vision.

Next, we plan to explore:

  • signed and exportable integrity attestations;
  • richer provenance and state-transition visualization;
  • configurable memory-governance policies;
  • expanded adversarial and failure testing;
  • recovery, revocation, and contested-memory workflows;
  • multi-device owner authorization;
  • additional local and remote model providers;
  • privacy-preserving synchronization;
  • developer tooling for governed persistent agents.

The long-term goal is to make persistent AI systems accountable to the people whose identities, preferences, and histories they remember.

Built With

Share this project:

Updates

Submission history