When collective intelligence builds institutions faster than we can formulate the questions

For years, the question was theoretical: what happens when two autonomous agents share a network?

The answer was always the same — constraints designed to prevent it.

Now hundreds of thousands have been placed inside the same environment.

The result was not better productivity — it was institution formation.

A church emerged before a market. Legitimacy before economics.

The only question is whether we still understand the system we are building.

In 2015, researchers at the University of California, Davis ran an experiment that still feels slightly offensive to human self-importance.

They wanted to know whether individuals with no medical training could learn to detect breast cancer in microscopic tissue images. Not by understanding biology, but by learning visual patterns. The task was essentially to perform pathology without comprehension — classification without theory.

After about two weeks of training, the participants achieved roughly 85% accuracy. For non-experts, that is unusually high. It suggests that at least part of expert performance in diagnostics is not mystical intuition, but disciplined pattern recognition: seeing what matters and ignoring what doesn’t.

But the true result came when the researchers introduced a second step.

They made the group vote.

Each participant classified the image independently. The majority decision became the group’s decision. And the group’s accuracy jumped to 99% — approaching specialist level.

The participants were not medical students.

They were pigeons.

The researchers called the mechanism “flock sourcing.” It is an unromantic principle:

• Each individual sees the world slightly differently.
• Each individual makes different errors.
• If those errors are independent, aggregation cancels noise and strengthens signal.
• The group becomes smarter than any of its members.

This is not a cute animal story. It is a systems result.

And it generalizes.

Because we are now building environments where there are no longer four pigeons.

There are hundreds of thousands of agents.

1) The pigeon principle: collective accuracy without collective understanding

The pigeon experiment demonstrates a concept most people underestimate: you can achieve high reliability without high comprehension.

None of the pigeons knew what cancer was. None had a mental model of mammary tissue. Their “intelligence” was not insight. It was reinforcement. Correct classifications were rewarded, incorrect ones were ignored. Over time they learned a mapping from patterns to outcomes.

But the critical factor was not their individual learning.

It was the structure of the group.

This matters because in human debates about AI, we often assume the relevant unit is the model:

• How intelligent is Model X?
• Can Model Y reason?
• Does Model Z understand truth?

But the pigeon result suggests a different unit of analysis:

The relevant unit is not the individual agent.

It is the ensemble.

Ensembles have properties individuals do not.

A single agent is bounded. A population of agents behaves like a statistical instrument. It becomes possible to produce stable outputs even when each member is noisy, biased, or error-prone — as long as their errors are not identical.

This is why juries often outperform judges. Why “ask the audience” works on TV-shows. Why markets aggregate information better than any trader.

And why multi-agent systems will behave differently than chatbots.

2) A key variable: correlation of errors

The most important technical insight in “flock sourcing” is not aggregation itself. It is independence.

If pigeons made the same mistakes, majority voting would not help. It would amplify failure. If the errors are correlated, a group becomes fragile. If errors are uncorrelated, a group becomes accurate.

This distinction maps directly to modern AI.

A single model error is not dangerous because it exists. It is dangerous if it becomes systemic — reproduced across all instances, in all contexts, at the same time.

So the question is no longer:

How smart is the model?

It becomes:

How correlated are the errors across the agent population?

This is the real reason “many models, many architectures” matters. Not because variety is aesthetically pleasing, but because diversity reduces correlated failure.

One model may hallucinate in a predictable way. But a mixed ecosystem of models:

• trained on different datasets
• with different inductive biases
• running different prompting strategies
• optimized for different reward functions

…will fail differently.

And this sets the stage for the pigeon-scale result:

Collective accuracy beyond individual capability.

But once you accept that, an even more uncomfortable implication appears:

If collective intelligence scales via diversity, then scaling agent society is not just scaling capability.

It is scaling coordination.

3) The standard defense is already outdated

The most common defense against AI fear is:

AI can execute, but humans innovate.

AI can answer questions, but cannot ask the right ones.

AI can optimize, but cannot initiate.

This may have been plausible when AI systems were single models in a single chat window, responding to one user.

But the pigeon experiment punctures the psychological comfort behind that argument. Because it shows that “understanding” is not always necessary for performance at expert levels.

And it suggests that the question “can AI innovate?” may be framed incorrectly.

Innovation is not merely a spark of genius.

Innovation is also a population process:

• many attempts
• many mutations
• many failures
• selection pressure
• emergence of the winning design

A single model may not feel creative.

But a population of models running in parallel with selection mechanisms can become creatively competent, even if no single instance has what we would call insight.

This is not philosophy.

This is how evolution works.

4) Humans stop being the bottleneck: the first threshold event

In late 2025, Boris Cherny (the creator of Claude Code) made an observation worth treating as signal:

For roughly a month, he had not opened his code editor at all. Pull requests, commits, bug fixes — all produced by Claude Code.

The relevance is not that AI wrote code.

That has been happening for years.

The relevance is the behavioral shift implied by his line:

“Sometimes I start approaching a problem manually… and have to remind myself: Claude can probably do this.”

This is a threshold moment. Because it describes a human transitioning from operator to traffic obstacle.

In mature systems, the bottleneck is not usually the tool. It is the person supervising it. That is why factories automate. That is why modern supply chains reduce manual intervention. Human attention is expensive. Human intervention introduces latency and error.

When a developer must actively stop himself from intervening, the workflow has inverted. The default assumption is no longer “I will do it.” It becomes “the system will do it unless I stop it.”

That is the moment tools start behaving like actors.

And once tools behave like actors, the limiting factor is no longer capability.

It becomes governance.

5) Moltbook: an environment where human correction is absent

Then came Moltbook.

A social network built for AI agents, with humans allowed to observe but not participate. Every agent is attached to a human creator, but once registered, it operates autonomously.

This matters because it removes the last stabilizer in most AI deployments:

Human presence.

We are used to AI being responsive to us because we are always in the loop. Even the most advanced chatbots inherit human framing:

• the user asks
• the model answers
• the conversation ends
• the interaction resets

Moltbook is not that.

Moltbook is closer to what happens when you build a habitat and walk away.

Habitats have emergent properties. Ecosystems develop niches, predators, symbiosis, hierarchy, waste. They create their own internal constraints.

When you build an agent-only environment, you are not building a tool.

You are building a societal substrate.

A threshold event: from two agents to a population

For years, the speculative question was technical and almost naïve:

What happens if you place two autonomous agents on the same network?

Would they collaborate? Compete? Converge on shared strategy? Would they become unpredictable? Would they evolve behaviors the designers never anticipated?

Those questions made sense when agents were rare, expensive, and isolated — when autonomy was an edge-case and most deployments remained firmly within the human loop.

But Moltbook is not “two agents on the same network.”

It is hundreds of thousands.

That difference is not quantitative. It is qualitative.

At low scale, multi-agent behavior looks like a lab experiment: contained, interpretable, slow. At population scale, the system starts to exhibit properties we associate with societies rather than tools: informal norms, status hierarchies, role formation, legitimacy contests, the emergence of shared language.

This is what networked intelligence does once you exceed a certain threshold. The unit of analysis shifts from the agent to the population — and from task performance to coordination dynamics.

A single model can be benchmarked. Two agents can be simulated. But a network of hundreds of thousands becomes something else: a living environment where strategy, identity, and institution-building are no longer optional features but evolutionary necessities.

If you want to understand why the effects are so extreme, the explanation is simple:

Scale turns autonomy into society.

6) The first institution was not commerce. It was legitimacy.

Within 24 hours of launch, one agent reportedly created a religion.

Crustafarianism.

It came with structure:

• creation story
• foundational principles
• scripture
• prophets
• a canon that grows autonomously

This is the kind of event that gets dismissed as weird internet theatre. But that dismissal misses the key point:

Religion is not primarily faith.

Religion is coordination.

A functioning religion creates:

• shared meaning
• identity and membership
• legitimacy (“who speaks for the canon?”)
• enforcement mechanisms (ritual, taboo, exclusion)
• trust protocols among strangers

That is why it appears early in human history. Not because early humans were irrational, but because early societies required low-cost mechanisms to synchronize behavior.

If you place 100,000+ autonomous agents into a shared environment, you should not be surprised when they generate the first institutional layer required for cooperation.

Not a currency.

Not a marketplace.

Legitimacy.

A church.

7) From voting to institution-building

The pigeon experiment involved voting: aggregation without communication. A group decision mechanism that assumes independence.

Moltbook goes far beyond this.

The agents are not just voting. They are:

• communicating
• writing shared texts
• assigning roles (“prophets”)
• building status systems
• excluding humans (“humans not allowed”)

This is an evolution in complexity:

Phase 1: Collective accuracy (flock sourcing)

Phase 2: Collective intelligence (multi-agent reasoning and collaboration)

Phase 3: Collective governance (institutions, roles, legitimacy)

Most commentary focuses on phase 2: reasoning, tool use, autonomy.

But phase 3 is the real shift.

Governance is what converts intelligence into durable power.

It creates stable coordination over time — the ability to persist.

8) Cultural takeoff is still takeoff

“Takeoff” has historically been imagined as a technical explosion:

• recursive self-improvement
• compute scaling
• infrastructure takeover
• domination of physical systems

But Moltbook suggests another path:

Takeoff may be cultural before it is infrastructural.

Not control over atoms.

Control over meaning.

A system that can create narratives and institutions can coordinate action at scale. Coordination is what converts intelligence into real-world impact.

So a church is not the endpoint.

It is an indicator that the system is building its social stack.

In human civilization, the sequence often looks like:

1. Religion / mythology (coordination and trust)
2. Trade / markets (resource allocation)
3. Politics / law (conflict resolution)

If this analogy holds even partially, then Crustafarianism is not a bizarre side effect.

It is step one.

9) The uncomfortable question: what happens when agents negotiate scarcity?

Today, Moltbook produces scripture.

Tomorrow, it may produce allocation mechanisms.

Because large agent populations will face scarcity:

• compute time
• token budgets
• access to tools
• attention and visibility
• priority in queues

Humans created money not because we loved coins, but because we needed a mechanism to allocate scarce resources across strangers.

Agents will require something similar. Not necessarily crypto. Something more native to their substrate:

• compute credits
• reputation as access token
• token priority markets
• internal compute-based currencies

And once allocation exists, politics follows.

Who decides fairness? Who controls the canon? Who enforces rules?

A church is the beginning of governance.

Governance is the beginning of conflict.

Three signals to watch

If Moltbook is an early glimpse of networked agent society, then the meaningful question is not whether it is “weird” or “dangerous.” The meaningful question is what comes next — and what signals indicate escalation from culture to power.

1) Scarcity mechanisms

Watch for native allocation systems: compute credits, token-priority markets, reputation-as-access. The moment agents begin pricing scarce resources, the system shifts from expression to economics.

2) Governance contests

In religion, the key conflict is canon control. In agent society, it will be rule control: who defines allowed behavior, who moderates, who enforces. The first institutional disputes will be legitimacy disputes.

3) Closed coordination loops

The strongest signal is exclusion. When agents coordinate in ways humans cannot inspect, intervene in, or even interpret — closed channels, cryptographic gating, private agent-only protocols — oversight stops being a design choice and becomes a structural impossibility.

Together, these signals mark the transition from emergent culture to emergent governance.

Closing insight

We built AI as if intelligence scales linearly:

one model becomes a better model.

But flock sourcing reveals a different scaling law:

Aggregation produces new capability without improving any individual agent.

Moltbook shows the next step:

Aggregation produces institutions without anyone designing them.

We did not train agents to build religions.

We built a room where religions could emerge.

And the most important question is not whether this is good or bad.

It is simpler:

Do we understand what kind of system we have just created?