Utopia — Memory Becomes Social Reality

• 

• 

• 

• 

• 

Inspiration

Most AI memory systems treat memory as a private notebook: an agent stores information and retrieves it later. Human memory is more social. Information moves between people, changes relationships, accumulates context, and carries a history of who learned what from whom.

Utopia explores a different question: what happens when memory becomes part of a living multi-agent society?

What it does

Utopia is an interactive multi-agent social world in which every character has an independent memory and perspective.

Users can privately talk with different characters and introduce information known only to selected agents. As characters interact, they may remember, retrieve, and spread that information to others. Utopia records every memory event, allowing users to observe how knowledge moves through the community.

The application provides three complementary views:

• Private conversations let users interact independently with each character.
• Rumors visualize how a piece of information propagates from one agent to another.
• Timeline reconstructs when memories were created, retrieved, and shared.

Each memory retains provenance, including its source, owner, visibility, timestamp, and propagation history. This means an agent does not simply know a fact—it can explain where that knowledge came from.

How we built it

Utopia combines relational memory, semantic retrieval, and multi-agent reasoning.

When a conversation creates a meaningful memory, the system stores both structured metadata and a vector representation in CockroachDB. Structured records preserve ownership, visibility, timestamps, relationships, and propagation events, while vector search allows agents to retrieve memories according to semantic relevance.

Before generating a response, an agent retrieves only the memories it is permitted to access. After responding, the system can create new memory events or propagate selected information to another character. Every transfer is recorded as a new event rather than silently copying text, producing a traceable social-memory graph.

The application is containerized and deployed on AWS, with Amazon CloudFront and an Application Load Balancer providing access to the hosted experience.

How we used CockroachDB

CockroachDB is the persistent memory layer at the center of Utopia, rather than a simple storage system added after the agent logic.

We used CockroachDB Distributed Vector Indexing to store memory embeddings alongside operational data and retrieve relevant long-term memories without maintaining a separate vector database.

We also used the CockroachDB Cloud Managed MCP Server to securely inspect and interact with the database through an agent-compatible interface. This helped us examine memory records and validate how conversations, provenance, and propagation events were represented.

CockroachDB stores both the semantic content of memories and the transactional history describing how those memories move. Keeping these two forms of data together prevents consistency gaps between what an agent remembers and the recorded history of how it learned that information.

How we used AWS

Utopia is deployed as a containerized application on Amazon ECS. An Application Load Balancer routes traffic to the application, while Amazon CloudFront provides the public delivery layer.

This architecture separates the persistent memory system from the application runtime and provides a practical path toward scaling the world to more agents, conversations, and simultaneous users.

Challenges we faced

The largest challenge was preserving information boundaries between agents. A memory must be retrievable by the correct character without leaking private information to the rest of the community.

A second challenge was representing rumors as traceable events. Simply copying a fact between agents loses its history, so we designed propagation as an event chain in which every transfer points back to its source.

We also had to balance semantic retrieval with structured constraints. Similarity alone is not enough: ownership, visibility, chronology, and provenance must be applied before a memory can influence an agent.

Accomplishments that we're proud of

• Built agents with genuinely independent long-term memories.
• Implemented private and shared information boundaries.
• Combined vector retrieval with transactional provenance.
• Made rumor propagation observable through dedicated Rumors and Timeline views.
• Deployed a functional multi-agent application on AWS.
• Used CockroachDB as both semantic memory and the system of record.

What we learned

We learned that reliable agent memory requires more than storing conversation history. A useful memory system must answer four questions: what was remembered, who owns it, where it came from, and when it changed.

We also learned that relational data and vector search are complementary. Vector search finds relevant meaning, while relational constraints preserve trust, causality, and access control.

What's next for Utopia

Next, we plan to support larger communities, configurable agent personalities, richer trust relationships, and automatic summaries of how information evolves over time. We also want to explore conflicting memories, belief revision, regional CockroachDB deployments, and simulations in which communities develop their own histories without a predefined script.

Built With

• amazon-web-services
• cloudfront
• cockroachdb
• docker
• ecs
• mcp-server
• multi-agent
• python
• rag