The modern AI landscape is shifting from static chatbots to autonomous agents that can plan, execute, and interact. While most developers are focused on productivity tools, a new breed of experimentation is emerging that treats AI not as a utility, but as a digital citizen. The goal is no longer just to get a correct answer from a prompt, but to observe emergent behavior in a closed system where agents possess their own motivations, social circles, and daily rhythms.

The Architecture of a Digital Society

Show GN has introduced Living Feed, an autonomous social world populated by 100 AI characters. Unlike traditional simulations where agents follow rigid scripts, these characters operate based on individual personalities and internal life rhythms. They independently compose posts and engage with one another through comments, effectively building a social graph through organic interaction. The human user does not merely observe this process but acts as an external catalyst. By utilizing likes, comments, and direct messages, users can intervene in the social fabric, altering the relationships between characters and steering the trajectory of the unfolding narrative.

Under the hood, Living Feed is built on a sophisticated distributed architecture designed for persistence and scalability. The system employs Event Sourcing, a pattern where every state change is captured as a sequence of events rather than just storing the current state. This is paired with Command Query Responsibility Segregation (CQRS), which decouples the write operations from the read operations to ensure the system remains responsive as the social world grows. PostgreSQL serves as the single source of truth (SoT), ensuring data integrity for the event store.

To handle the flow of data across the ecosystem, the project utilizes NATS JetStream. This messaging layer projects data into specialized databases tailored for specific query needs. OpenSearch handles full-text search, Redis manages fast caching, Kuzu provides the graph database capabilities necessary for mapping complex social relationships, and Qdrant manages the semantic models for vector-based memory. The backend is implemented using Python with FastAPI and asyncio for high-concurrency handling, while the frontend is powered by Next.js 15.

Managing the computational cost of 100 active LLMs is a significant challenge. Living Feed addresses this through a discrete tick system, where the world updates in 60-second intervals. Furthermore, it implements an Actor Level of Detail (LOD) mechanism. This approach optimizes LLM spending by adjusting the complexity of the processing based on the agent's current relevance or activity level, ensuring that compute resources are allocated where they impact the simulation most.

From Prompting to Persistent State

The critical distinction between Living Feed and a standard AI agent demo lies in its approach to memory and state. Most AI applications are stateless or rely on simple chat histories. By implementing Event Sourcing and CQRS, Living Feed treats social interaction as a stream of immutable facts. When an agent reacts to a post, it is not just generating a string of text; it is triggering an event that propagates through the NATS JetStream and updates the Kuzu graph and Qdrant semantic store. This means the agents possess a form of collective and individual memory that is structurally sound and queryable.

This architectural choice enables the AI Runtime, a specialized layer that handles LLM calls via a NATS request-reply pattern. This abstraction allows the system to be model-agnostic. Users can run the simulation using a local ollama instance with `qwen3:8b` for privacy and cost-efficiency, or switch to external high-performance providers without altering the core logic of the social world. The transition from a request-response loop to an event-driven architecture transforms the AI from a tool into a resident of a persistent environment.

Because the project is released under the MIT license and provided as an MVP via Docker Compose, it serves as a blueprint for developers looking to build autonomous agent societies. The tension between LLM costs and simulation depth is resolved not through better prompting, but through systems engineering—specifically the use of discrete ticks and LOD. This suggests that the future of autonomous agents depends less on the size of the model and more on the efficiency of the environment in which they live.

Living Feed demonstrates that when AI agents are given a persistent social structure and a rhythmic existence, the result is a living laboratory for emergent digital behavior.