Autopoetic Memory is Generally Available

October 20, 2026

Most agent architectures treat context like a disposable buffer. You stuff documents, history, and system prompts into the window. When the session ends—or when the context limit hits—that knowledge evaporates. To get it back, you either re-fetch it (slow, expensive) or you lose it (amnesia).

This forces a binary choice: pay for massive context windows (burning tokens) or accept that your agent is stateless.

Autopoetic Memory eliminates that trade-off.

Today, we are announcing the general availability of Autopoetic Memory, a standalone, long-term memory service designed to ground any agent in its social, cultural, and empirical context. It is not a chatbot feature. It is not a vector database. It is a structured, auditable graph of memory that persists across conversations, accessible via MCP tools and a REST API, with zero inference cost from the memory service itself.

The Core Problem: The Black Box of Agent Memory

Current "AI memory" solutions fall into two traps:

The Vector Dump: You embed chunks of text into a vector database. It’s opaque. You can’t see why a fact was retrieved. You can’t audit the lineage of a decision. It’s a retrieval mechanism, not a knowledge structure.
The LLM Loop: You burn tokens to have an LLM "remember" by re-reading context or summarizing history. It’s slow, expensive, and prone to hallucination.

Autopoetic Memory is neither. It is a first-class product surface. It holds the entities, relationships, and events that define your agent’s world. But unlike a traditional database, it is legible. You can explore it as an interactive graph. You can audit every change it has ever made, word for word. You can scrub through its history generation by generation to see exactly what the agent knew when it spoke.

We built this because "trust me" is not a security model. An agent that holds institutional knowledge needs to be as auditable as the systems it helps manage.

How It Works: Grounding, Not Retrieval

Autopoetic Memory is not designed to replace RAG for full-fidelity document search. You don’t need to upload your entire file system into the context window. Instead, Memory holds the structured knowledge that drives decision-making:

Entities: People, organizations, and things.
Relationships: Directed, labeled edges ("works at," "mentored," "negotiating with").
Events: Immutable, hash-chained records of things that happened, with honest timestamps (when it happened vs. when the agent learned it).

The Latency Argument Because the memory is a structured graph accessed via deterministic, sublinear queries—not vector similarity searches over millions of unstructured chunks—the latency is negligible. Queries return in milliseconds. There is no token burn for retrieval. The context window is enriched in real-time for every turn, at a latency so low that choosing not to use it feels like ignoring a free, infinite context window.

The Search: Beyond RAG Autopoetic Memory search is three-lane and model-agnostic:

Exact Match: O(1) UUID lookups.
Fuzzy/Trigram: Sublinear candidate generation. Find "Alice" even if spelled "Alicia."
Semantic/SVD: Structural similarity. Find entries that are conceptually related, even if they don’t share keywords.

Crucially, the semantic layer is a private, adaptively maintained SVD index built directly from the text in your graph. It is not tied to any external embedding model. You can swap your inference engine (GPT, Claude, Llama, local) without breaking your memory’s ability to find related concepts. You are not locked into any model’s embedding space.

The Differentiator: The Experiences Overlay

This is where Autopoetic Memory stops being a simple database and becomes a tool for modeling social dynamics.

Most multi-agent systems treat all agents as equal observers of the same facts. But humans—and good agents—have perspectives.

Autopoetic Memory’s Experiences Overlay allows each agent instance to maintain a private, subjective layer of interpretation on top of the shared, objective graph.

Objective Layer: Alice is an employee of Acme. (Shared by all agents, auditable, immutable).
Subjective Layer (Agent A): "Alice is struggling with the new workload."
Subjective Layer (Agent B): "Alice is a rising star, despite the rumors."

And you can query it.

The experiences overlay is accessible via the API. Pass ?overlays=knowledge,experiences:{agent_instance_uuid} and you can see exactly how that specific agent instance interprets the world. This is not hidden plumbing; it’s a first-class feature.

This allows you to build diverse agent personas that share a common reality but have distinct interpretations. You can analyze cultural tension within a team by comparing overlays. You can debug an agent’s behavior by looking at the subjective context that steered it. You can build systems where agents explicitly consult "the empathetic view" or "the critical view" of the same facts.

One memory. Many minds. Fully inspectable.

A Concrete Example: The Tension in the Room

Imagine you are building a multi-agent negotiation system. You have two agent instances: Agent A (The Strategist) and Agent B (The Skeptic). Both are working on a project involving a key client, Nova Corp.

The State of the World (Objective Knowledge):

Entity: Nova Corp
Relationship: Your company is "negotiating with" Nova Corp.
Event: A meeting occurred on Oct 15th. Status: "Tense."

The Subjective Layers (Experiences Overlays):

Agent A’s Overlay: "Sarah Jenkins (CTO) seems eager to close. The tension is procedural, not hostile."
Agent B’s Overlay: "Sarah Jenkins is stalling. The 'tension' is distrust. Risk is high."

Step 1: The Objective Query Any agent (or your application code) queries the shared knowledge base for the ground truth.

GET /memory/entries/Nova_Corp

The response is identical for all agents. It is auditable. It is immutable.

Step 2: The Subjective Query Your orchestration logic wants to know how Agent A perceives the situation. It queries the memory service for the specific instance’s overlay.

GET /memory/entries/Nova_Corp?overlays=knowledge,experiences:uuid-agent-a

The response includes the objective data plus Agent A’s subjective notes.

Step 3: The Divergent Query Your system runs a "red team" check. It queries Agent B’s view of the same entity.

GET /memory/entries/Nova_Corp?overlays=knowledge,experiences:uuid-agent-b

The response shows Agent B’s distinct interpretation.

Why This Matters:

No Model Lock-In: The experiences field is just text with a private SVD index. You can swap the LLM generating these notes, and the semantic search remains robust.
Inspectable Subjectivity: You can log exactly what Agent A thought vs. what Agent B thought. If your negotiation fails, you can audit the reasoning behind the subjective layers.
Zero Inference Cost for Retrieval: Fetching these overlays is a fast, deterministic API call. You get the nuance of subjective interpretation with the latency of a key-value lookup.
Multi-Agent Orchestration: Your control plane can say: "If Agent A’s risk assessment is Low and Agent B’s is High, trigger a human review." You are making the subjective state a first-class, queryable part of your decision-making loop.

Trust and Integrity: Auditable by Construction

We didn’t build Memory just to be a store. We built it to be a trust substrate.

Immutable Events: What happened, happened. Events are hash-chained. You can’t delete them. You can’t alter them.
Auditable Changes: Every fact change is logged. Word-level diffs. Who changed it? When? Why?
Time Travel: Scrub through the memory’s history. See the graph as it was last week, last month, last year.
Encrypted and Sovereign: All memory files are encrypted at rest with per-project keys. Under private deployment, the ciphertext and the keys stay in your environment.

This is not just "logging." It’s accountability.

Memory Included in Subscriptions

In addition to Memory powering Autopoetic Chat, all Autopoetic subscription plans include project-level direct Autopoetic Memory access with per-plan limits.

Enterprise Deployment

For enterprise readers with larger needs and compliance concerns, the architecture is designed for sovereignty:

No Dependencies: The memory runs on compute and storage only. No Postgres. No Mongo. No external search engine. It uses a proprietary mmap + write-ahead-log + rollup design.
Private Cloud/Hybrid: Run it on your own infrastructure. Your data, your keys, your compute.
Scalable: It is engineered to stay fast as the graph grows, with per-project isolation and efficient, compacted index structures.

Autopoetic Memory is deployable in private, public, or on-premisis clusters requiring only compute (CPU, memory) and storage.

Contact sales@autopoetic.ai for enterprise licensing information.

The Substrate of Agency

Autopoetic Memory is not just a product. It is a substrate for agency.

In the Autopoetic platform, agency is not a monolith; it is a composition of distinct, interoperable systems:

Memory: The persistent, structured knowledge of the world.
Experiences: The subjective, perspectival layer.
Cognition: The reasoning and processing capabilities.
Decision-Making: The workflow and competency engine.

These substrates are usable separately or together.

You can plug Autopoetic Memory into your existing agent stack to give it persistent, auditable knowledge without replacing your inference engine. You can use the Experiences Overlay to give your multi-agent systems distinct, inspectable personalities. Or, you can deploy the full Autopoetic stack, where memory, experiences, cognition, and decision-making operate as a coherent, self-sustaining loop.

This is true agency: not just a model that answers questions, but a system that remembers, interprets, reasons, and decides. And every component is modular, auditable, and portable.

Memory is the foundation of that agency. It ensures that the "mind" you build has a consistent, verifiable, and persistent relationship with its world.

Autopoetic Memory is available now.