AI agents are getting better at reasoning, using tools and executing complex workflows. Yet one of the most important problems in building useful, long-running agent systems remains surprisingly difficult:
How do multiple independent agents develop and maintain a reliable, shared understanding of the world they operate in?
A coding agent might understand a system architecture. A research agent might discover a relevant technical development. A strategy agent might understand why a product decision was made.
But what happens when these agents need to use one another's knowledge?
Without persistent, interoperable memory, important information gets fragmented across conversations, tools, applications and execution histories.
This is one of the problems we're exploring with METABOLIQ Brain. Its accepted foundation is a persistent memory vault for a single owner on a trusted local machine. A broader shared intelligence layer is the direction, not a finished product.
Context is not the same as memory
Modern language models can process large amounts of context. That is useful, but a context window is fundamentally a workspace for the current inference—not a complete, governed representation of what an agent should know over time.
Consider an engineering agent that helps make an architectural decision.
During the session, it can reason about requirements, compare alternatives and recommend an implementation.
Weeks later, a different agent may need to know:
- What decision was made?
- Why was it made?
- Which alternatives were rejected?
- Has the decision changed?
- What evidence supports it?
- Is this information authorized for the requesting agent?
Simply retaining an old conversation transcript doesn't fully solve these questions.
The underlying problem is not just storage. It is the organization, validity, retrieval and governance of accumulated knowledge.
The fragmentation problem
Imagine a company using several specialized AI agents:
An engineering agent manages technical work.
A research agent monitors relevant developments.
A business agent helps evaluate commercial opportunities.
A personal branding agent transforms verified professional experiences into useful public content.
These agents may operate independently, use different model providers and execute in different environments.
If each agent maintains an isolated memory system, the company risks creating multiple inconsistent representations of the same reality.
One agent might know that a product architecture changed. Another might continue operating with an outdated design. A third might confidently repeat a conclusion that was never verified.
A shared intelligence layer creates an opportunity to address this fragmentation.
But sharing knowledge without appropriate controls creates another problem: not every agent should access every fact.
A useful shared brain therefore needs both interoperability and governance.
What should an agent's shared brain remember?
We think of memory as several related capabilities rather than a single collection of text embeddings. The categories below describe a design direction; they are not a list of capabilities already implemented in Brain.
1. Factual memory
Persistent information about entities, projects, systems, people and decisions.
For example, the approved technical architecture of a particular service.
2. Episodic memory
Records of events, actions and experiences.
For example, the outcome of an experiment or the reasoning behind an engineering decision.
3. Temporal memory
An understanding of how information changes.
An architectural decision that was valid six months ago may no longer describe the system today. Historical information must remain accessible without being mistaken for current truth.
4. Procedural memory
Reusable knowledge about how to perform tasks.
This might include an approved engineering review workflow, deployment procedure or research methodology.
5. Relational memory
Connections between people, projects, technologies, organizations and events.
These relationships can make knowledge more useful than a collection of disconnected facts.
Together, these memory types provide a foundation for more capable systems. However, each introduces different challenges for ingestion, consistency, retrieval and verification.
Retrieval is necessary, but retrieval isn't intelligence
Vector embeddings have made semantic retrieval much more accessible.
Instead of searching only for exact keywords, a system can discover information whose meaning is related to a question.
But semantic similarity introduces its own limitations.
Suppose an agent asks a question for which the knowledge base has no reliable answer.
A vector search system can still return the nearest available records. Those results may be mathematically similar to the query without actually providing sufficient evidence.
This distinction is essential:
A relevant memory is not necessarily a verified fact. And a verified fact is not necessarily sufficient to answer a question.
Access control belongs in retrieval from the start. Source verification, temporal reasoning and explicit recognition of insufficient evidence are additional problems; storing a reference or retrieving a similar record does not solve them.
These are separate problems and should be evaluated separately.
Why we're building on PostgreSQL
For the initial foundation of METABOLIQ Brain, we've chosen PostgreSQL as the authoritative store for structured memories.
The accepted foundation includes persistent records, namespaces, versioned revisions, source references and API-enforced access permissions. Owners can inspect revision history; agents cannot read it.
Source references are recorded, not fetched or independently verified. A URL or document reference is provenance metadata, not proof that its contents are true. Stored validity dates likewise do not yet provide automatic temporal reasoning or resolve which conflicting record is current.
PostgreSQL full-text search is already implemented in the accepted foundation. A separate development branch adds pgvector-based semantic and hybrid retrieval with local embedding models. That work remains under evaluation and is not part of the accepted foundation described here.
There are several reasons for this approach.
First, structured knowledge and vector indexes can remain close to the authoritative records.
Second, access-control requirements can be applied within retrieval queries.
Third, the architecture avoids introducing a separate vector database before scale or performance requirements justify one.
And finally, it gives us a relatively simple operational foundation on which to build more sophisticated memory capabilities.
This doesn't mean PostgreSQL will be the optimal choice for every workload. It means we're choosing the simplest architecture that currently satisfies our requirements, then using benchmarks to guide future decisions.
Security must be part of the architecture
Shared memory becomes particularly sensitive when multiple agents can both read and contribute information.
Consider an agent that discovers an apparent fact in a document.
Should that information immediately become authoritative?
What if another agent has already recorded contradictory evidence?
What if the document contains confidential information?
What if the source itself includes malicious instructions?
Agent-created memories enter a proposed state. An agent edit also returns the affected memory to proposed and records agent provenance; other agents stop seeing that record until the owner makes it active again. This is a minimal review mechanism, not an automated fact checker or a dedicated review queue.
The API enforces owner, namespace, operation and sensitivity restrictions at the data-access boundary, including filters in its SQL queries. PostgreSQL constraints and append-only revision and audit protections support data integrity. Per-agent authorization is enforced by the API, not PostgreSQL row-level security or an AI model's judgment.
Provenance, revision history and memory status are important because an agent's output should not automatically become a trusted fact.
A system that remembers everything but cannot determine what should be trusted or shared is not a reliable intelligence system.
What we're learning from METABOLIQ Brain
Our early engineering work has reinforced three principles.
First, durability and governance should precede sophisticated AI capabilities. Persistent storage, consistent revisions and authorization are foundational requirements.
Second, retrieval quality must be measured rather than assumed. Our semantic and hybrid retrieval work is still under evaluation. A meaningful evaluation must examine irrelevant results, missing evidence, stale information and authorization boundaries as well as relevant hits.
Third, a shared brain should be independent of any individual agent framework. The foundation exposes an authenticated HTTP API. Broader context assembly, MCP integration and framework-specific SDKs are future work.
The repository's acceptance package records persistence, revision-history and authorization tests for the initial memory vault. Its acceptance is scoped to a single owner on a trusted local machine; it is not a claim of production readiness. TLS for wider access, backups and restore procedures, and further operational hardening remain separate work. Ingestion connectors, knowledge graphs, temporal reasoning and cross-agent context assembly remain future work.
The bigger engineering question
The long-term opportunity is not simply giving agents more information.
It's enabling multiple agents to operate against a consistent, evolving and appropriately governed body of knowledge.
That requires systems engineering as much as model engineering: databases, indexing, identity, access control, provenance, evaluation and reliable interfaces.
As we continue building METABOLIQ Brain, we'll share technical decisions, benchmarks, challenges and lessons from the implementation process.
Because the most interesting question may not be how much an AI agent can remember.
It may be how reliably multiple agents can use what has been remembered.
METABOLIQ Engineering explores the infrastructure, systems and engineering decisions behind developing advanced AI technology.
Further reading
- PostgreSQL 17: Full Text Search
- PostgreSQL 17: Row Security Policies
- pgvector: vector similarity search for PostgreSQL
- LangGraph: persistence, checkpointers and stores