Ava Wants to Build Digital Societies, One Async Tick at a Time

The Cat, the Bag, and a Token

The README opens with a warning: “The cat is out the bag.” Fundamental Research Labs, the team behind the repository, declares it is building “the next frontier of digital beings”—autonomous agents that think, remember, form relationships, and act. Not chatbots. Not assistants. Beings. The page also prominently displays a contract address for a token called $AVA, linked to pump.fun, alongside badges for Python 3.11 and an Apache 2.0 license. The juxtaposition is arresting: a research-grade async Python framework for multi-agent simulation, paired with the memecoin infrastructure of 2025. That tension is arguably the source of the repo’s current buzz. It arrives at a moment when the AI agent market is projected to reach $236 billion by 2034, with incumbents like Salesforce, Google, and Microsoft racing to productize agentic workflows for enterprises. Ava, by contrast, asks a more academic question: what happens when you run large populations of simple agents in a shared environment and refuse to tell them what to do?

Concurrency as a First-Class Citizen

Most multi-agent demonstrations collapse under their own weight once the population grows past a dinner party. The typical scheduler was never meant to juggle thousands of coroutines, and one slow agent can stall the entire tick. Ava’s first architectural bet is that concurrency must be structural, not decorative. The execution engine uses Python’s TaskGroup—available only in 3.11 and later—to step populations in parallel, bounded by a Semaphore. A single unhandled exception in one agent cannot silently corrupt the rest of the run. On commodity hardware, the framework reports throughput in the neighborhood of twenty-five thousand agent-ticks per second for no-op agents, with mean tick times scaling from roughly five milliseconds for a hundred agents to two hundred milliseconds for five thousand. Those numbers are synthetic—no-op agents do not call LLM backends—but they demonstrate that the event loop itself is not the bottleneck. The boring part here is the semaphore, and that is precisely where the value lies. If you actually deploy five thousand agents that each deliberate by calling an external model, the framework becomes a backpressure mechanism, preventing you from accidentally overwhelming both your own process and your inference provider.

Memory That Forgets on Purpose

Each agent carries a tiered MemoryStore that separates what happened from what it means. Episodic memory records events with a tick timestamp and fades over time. Semantic memory distills high-importance episodes into durable facts through a reflection process. Procedural memory reinforces successful action sequences independently of any single episode, so an agent that repeatedly forages in forest biomes gradually converges on that skill without a hand-tuned policy. Retrieval blends recency, importance, and embedding relevance. The design is a direct descendant of the memory architectures seen in Stanford’s generative agents and the thousand-agent societies studied by the AI Digital Human Group’s Project SID, both cited in the documentation as intellectual lineage. Where a flat log would drown an agent in its own history, the tiered store attempts to mimic the way human memory compresses experience into competence. In a field where most LLM-based agents simply dump an ever-growing message history into a prompt, this structural separation is a genuine architectural difference.

Governance by Quorum

Ava’s agents do not merely coexist; they legislate. The GovernanceSystem allows agents to propose laws, cast votes, and ratify rules with quorum and majority thresholds that scale with population size. For decisions that must survive adversarial or faulty participants, the communication layer implements a three-phase PBFT-style protocol—PROPOSE, PREPARE, COMMIT—that commits once two-thirds plus one of a Byzantine-tolerant set agree. It is a toy model of a very real problem. A recent white paper from the Institute for Security and Technology notes that legal doctrine and identity frameworks must evolve to account for persistent, cross-system agents whose actions do not map cleanly onto individual human principals. The IST argues that authorization should be treated as a dynamic, revocable process based on observed behavior and risk signals. Ava’s voting and consensus mechanisms are far simpler than the policy challenges the IST describes, but they surface the same core tension: when software acts autonomously, authority must be collectively verifiable. The agents are simultaneously the citizens and the legislature, which raises questions of liability that the framework does not yet answer.

Emergence with a P-Value

The project’s most distinctive feature may be its refusal to trust its own eyes. The analysis layer runs change-point detection—Mann-Whitney U tests over rolling windows—against population metrics like specialization and wealth distribution. A claim such as “agents formed distinct roles” is expected to arrive with a p-value, not a hunch. The repository includes a reference experiment in which sixty agents, given only a reinforcement rule over three possible actions, sort themselves into statistically significant roles. This is the opposite of the anecdotal emergent behavior that floods social media whenever two LLMs argue in a sandbox. Whether the statistical rigor holds up under the weight of LLM stochasticity is an open question—the README does not discuss false positives or the power of the test—but the ambition is clear. Ava wants to be a laboratory, not a demo.

Research Code in a Gold Rush

The repository is candid about its status. APIs in the agent and civilization modules are described as reasonably stable, while the analysis layer is still evolving as more detectors are added beyond specialization and stratification. It is research infrastructure, not a consumer product. That honesty is refreshing, because the surrounding market is not modest. According to industry analysis, Big Tech is pushing hard into agentic ecosystems, with Salesforce’s Agentforce, Google’s Agent2Agent protocol, Microsoft’s Azure-embedded agents, and OpenAI’s Operator platform all competing to define the enterprise stack. One overview notes that early adopters are reporting productivity improvements of thirty to forty percent, and that the technology has moved beyond theoretical discussion into practical implementation. Ava occupies a narrower niche—population-scale simulation for researchers studying social emergence—but it shares the same cultural momentum. The $AVA token, however, complicates the narrative. An open-source Apache 2.0 project does not need a memecoin to compile, and the pump.fun link in the header suggests a financialization of the “digital being” concept that the code itself does not yet justify. It is a rough edge, visible in the source, that readers should notice.

Outlook

Ava’s future depends on whether it can resist two gravitational pulls. The first is the temptation to become yet another enterprise automation framework, a space already crowded by platforms with billion-dollar marketing budgets. The second is the gravitational well of its own tokenomics, which may attract speculation rather than contributors. If the project can keep its focus on scalable, measurable emergence—refining the analysis layer, hardening the consensus protocols, and proving that its async engine can carry real cognitive loads—it could become a standard substrate for computational sociology. The question is not whether the cat is out of the bag, but whether the bag was ever the right container.