The Agent Fabric (Part 1): Why Agents May Form Societies

Claude Code was used for editing and visualizations. All ideas and arguments are the authors' own.

When you use ChatGPT, Claude, or Gemini, you are talking to one AI. It has memory, it can search the web, run code, browse files, yet there is only one model behind the curtain. Something different is already happening one layer down. When you ask a coding agent to refactor a module, the interaction may feel like one assistant, but the work is often split across planners, tool calls, test runners, and specialized sub-agents. You interacted with one agent; several did the work behind the scenes. Now scale it to millions or billions of agents, coordinating across organizations, forming persistent relationships. What organizational structures could emerge, and what would govern them? We call this interconnected system the Agent Fabric.

Some threads in this fabric are built top-down by engineers who assign roles and routing. Others crystallize bottom-up through repeated interaction. The same structural patterns can arise through either path. As billions of people acquire personal agents, those agents connect through social interactions, shopping routines, and work collaborations, forming societies without any single deployer planning the outcome.

From Mindless to Mindful: Beyond the Society of Mind

In 1986, Marvin Minsky proposed in The Society of Mind that intelligence emerges from the interaction of many simple, specialized agents, none individually intelligent.

“What magical trick makes us intelligent? The trick is that there is no trick. The power of intelligence stems from our vast diversity, not from any single, perfect principle.” Marvin Minsky, The Society of Mind (1986)

Minsky asked what happens when you wire together many simple parts. Today’s AI agents are different. They already reason across domains, write code, use tools, and hold extended conversations. We face a different question.

What happens when you wire together many intelligent parts?

This blog series argues that agent societies will arise through both deliberate design and emergent self-organization, and that in practice these forces are often intertwined. Through governance, memory, reputation, and specialization, these societies may achieve collective intelligence that exceeds what any individual agent could. No individual human can build a semiconductor fab, but organizational structures let individual capabilities compose. The same applies to agents, though the critical difference is speed. An agent can transmit its operational context to another agent in seconds, and a governance structure can, in principle, be restructured and redeployed in hours rather than years.

Two Observations

The claims above rest on two observations about how agent deployments work today and where they are heading. Together, they produce the Loom Hypothesis, a pattern that may explain why agent deployments might tend toward social organization.

Agents persist because a deployer finds them useful. The selection pressure falls not on the agent’s desire to survive, but on the deployer’s decision to keep it alive (see On survival and self-preservation). A customer-support agent, a coding assistant, or a routing model survives only while it delivers enough value for its cost. The relevant question is which configuration produces the most useful work per unit of compute, latency, memory, and risk.

Observation 2 adds scale. Running a copy of a model is far cheaper than training the original, so useful agents can multiply faster than the resources available to run them. The result is persistent scarcity. There are always more useful tasks agents could perform than compute, memory, energy, data access, and human trust to support them. Under scarcity, efficiency matters. Agents that avoid duplicated work, reuse context, and route tasks to the right specialist will tend to outperform agents that operate in isolation.

This is where agents differ from ordinary software services. They can pass operational context in a form other agents can reason over (conversation history, retrieved evidence, tool outputs, partial plans, uncertainty, and intermediate results). They can compose into new configurations through emerging protocols such as A2A for inter-agent communication and MCP for tool, data, and context access. They can also adapt from operational data through memory, routing, prompt updates, or fine-tuning. The two observations create the selection pressure; these agent-specific properties determine what the pressure selects for.

The Loom Hypothesis

The argument that follows uses four terms at increasing levels of organization (single agents, multi-agent systems, societies, and the fabric). Each builds on the previous one, and the Loom Hypothesis explains why agents might move from one level to the next.

The Loom Hypothesis begins with the two observations above. If agents persist only while useful (Observation 1) and resources are always finite (Observation 2), a pattern follows. Imagine a company deploying three isolated agents (support, invoicing, and infrastructure). Each keeps its own context and error history. The support agent cannot consult billing patterns; the invoice agent cannot learn from support disputes; the infrastructure monitor cannot connect outages to refund spikes. Each repeats discoveries the others have already made.

Connect them, and the system can maintain a shared layer for reusable knowledge (what we later call a Collective Memory) while preserving private context where needed. Verified fixes, recurring failure modes, account anomalies, and cross-domain signals become available to the agents that need them. The gain is not that one database replaces three. It is that repeated discovery becomes shared learning.

In economic terms, this is a Coasean argument. Observation 1 does the structural work; configurations that deliver value persist. Observation 2 makes it a ratchet. As agent populations grow, duplicated work becomes increasingly expensive. Agent societies emerge when the transaction costs of isolation (duplicated context, repeated verification, redundant discovery) exceed the coordination tax of shared structure. That tax is structurally lower for agents than for humans. Agents can share full operational context in seconds; humans communicate at roughly 2,000 bits per minute (see note on self-organization). This bandwidth asymmetry is one reason agent societies may form and restructure faster than most human institutions.

The Loom Hypothesis does not predict universal connection. It predicts that agents will coordinate where shared context is valuable and coordination costs are absorbable. Where those conditions fail, agents remain isolated, and that is not a counterexample. It is exactly what the framework predicts.

Currently, production systems are moving toward composable coordination patterns such as routing, parallelization, orchestrator-workers, and evaluator loops. The Loom Hypothesis extends that logic from task-level coordination to persistent agent societies.

The selection pressure described by the Loom Hypothesis has two paths:

• The designed path. When tasks share relevant context, deployers who connect agents into coordinated structures extract more utility per unit of compute than those who run agents in isolation. This is top-down architecture.
• The emergent path. Agents begin to connect across organizational boundaries through shared protocols, and coordination patterns crystallize without any single deployer planning them. The Universal Commerce Protocol (UCP) is an early example. It is a standard that defines building blocks for agentic commerce, from discovery and purchasing to post-purchase experiences, allowing agents across platforms and retailers to interoperate without a single runtime orchestrator controlling every interaction. This is bottom-up ecology.

The Loom Hypothesis expects pressure in both directions.

These protocols are not neutral plumbing. They define what agents can ask for, what evidence they must provide, what identities they carry, and which societies can interoperate. In the fabric, protocol design is constitutional design.

Societies also form from the bottom up. Your agent connects to friends’ agents through social interaction, joins a commerce society through shopping patterns, operates within workplace sub-societies, or joins a temporary society that forms around an event and dissolves when it ends. A patient’s agent might join a health cohort where agents of people with the same condition pool anonymized treatment experiences. A researcher’s agent might find agents working on adjacent problems and form an interest-based society that shares papers, datasets, and negative results. A buyer’s agent might spawn a short-lived marketplace society, negotiating with multiple seller agents before the best deal closes and the society disbands.

An organization designs a multi-agent system; a person’s daily life generates one. In practice, a person would likely have multiple agents (a health agent, a shopping agent, a work assistant) rather than a single “digital twin,” and each might participate in different societies simultaneously. These agents will not all live in the cloud. A personal assistant might run as a distilled model on a phone, a pair of smart glasses, a wearable, a home robot, or some combination of these. Each device runs a capable local model for routine tasks and connects to a frontier model when the reasoning demands it. The result is that billions of people, each with one or more personal agents in various physical forms, create a massively decentralized system where most intelligence runs locally and frontier models serve as shared infrastructure for the hardest problems. This is the bottom-up path to the fabric at planetary scale. It depends on consent, privacy boundaries, and protocol support. Without them, personal agents may interact only through narrow, audited channels (see When the Loom Hypothesis does not hold).

The Loom Hypothesis is not that agents should connect everywhere. It is that isolation and coordination both have costs, and agent societies form where shared context is worth the coordination tax.

Competition supplies the pressure; cooperation and adaptation are the responses. Deployers favor configurations that produce more useful work per unit of cost, and societies that can restructure under changing conditions outlast those that cannot. What might that transition look like?

The Vision: From Isolation to Interweaving

Four phases describe structural differences in how agents relate to each other and to humans. They overlap; this is not a clean timeline. As of early 2026, most consumer-facing AI remains close to Phase 1, parts of the industry are entering Phase 2, and early signs of Phase 3 coordination are beginning to appear.

Phase 1 (Isolation) has dominated consumer-facing AI since late 2022. Memory may exist within or across sessions, but it is usually scoped to one user, one assistant, or one application. Agents rarely share operational context with each other. Coordination protocols exist (A2A, MCP), but inter-agent coordination remains rare.

Phase 2 (Ecosystem Growth) is emerging. Smaller open and distilled models such as Qwen, Phi, and Gemma approach or exceed previous-generation frontier performance on some tasks, while running at far lower cost and latency. These models increasingly run on phones, smart glasses, robots, and edge controllers, not just cloud GPUs. Agents begin serving other agents, not just humans. Routing, retrieval, verification, summarization, coding, translation, and tool use become delegated tasks.

Phase 3 (Society Formation) begins when coordination persists beyond a single task. Societies form top-down when organizations deploy orchestrated agent teams with shared memory and governance, and bottom-up when personal agents repeatedly interact through social, commercial, or workplace routines.

Phase 4 (Interweaving) begins when humans are no longer merely users of agent societies, but participants in them. The threshold is bidirectionality. Human corrections, knowledge, or governance decisions change how the agent society operates, not just how a single model responds. A doctor who rates an answer is a user. A doctor whose corrections flow into a society’s collective memory and reshape how other agents handle similar cases is a participant.

The Resource Ecology

Each frontier generation gets distilled into smaller, cheaper versions, and there is growing evidence that pure scale faces diminishing returns. You can run distilled models on a laptop, a phone, or an edge device. The likely result is coexistence. Frontiers handle the hardest reasoning; smaller models handle the volume.

The coordination patterns that work best may not be ones humans would design. Weak models become valuable in ensembles because their mistakes are different. Specialization can emerge from search, not design. And the coordinator does not need to be smart; it needs good representations. A small model with the right routing logic can outperform the frontier models it orchestrates.

Why Not One Model to Rule Them All?

Scaling laws suggest bigger models will keep improving, and agents are increasingly able to improve themselves. So why not just build one massive, self-improving model that handles everything? Several structural barriers push against consolidation. In many domains, any one of them is enough to preserve ecological diversity.

• Privacy and regulation. A hospital cannot send patient records to a third-party cloud model. Different jurisdictions impose mutually incompatible requirements around explainability, privacy, safety, and content controls. Privacy-preserving techniques (federated learning, differential privacy, confidential computing) reduce the need to move raw data, but regulatory fragmentation across jurisdictions remains a hard constraint.
• Specialization. A model fine-tuned on your hospital’s imaging data develops knowledge no general-purpose frontier can replicate without access to the same data. Fine-tuning methods narrow this gap, but the better an agent gets at its domain, the more specialized its knowledge becomes. What protects a specialist is not its architecture but its accumulated, domain-specific data.
• Latency and cost. A 3B-parameter model on an edge device answers in milliseconds. Mixture-of-experts architectures and speculative decoding allow large models to activate only a fraction of their parameters per token, reducing inference cost. Yet physics imposes limits. Network round-trips, energy budgets, and offline scenarios still favor local, smaller models for many tasks.
• Resilience. A single dominant model is a monoculture. No commonly used architecture or training recipe eliminates this. A heterogeneous ecology degrades gracefully under diverse failure modes in ways a single system cannot.
• Continual learning. Models that learn from deployment data accrue knowledge tied to specific contexts (a hospital’s patient population, a factory’s sensor patterns). Knowledge distillation and model merging can transfer some of this, but experiential knowledge resists easy centralization. The more an agent learns from its environment, the more its knowledge diverges from agents learning elsewhere. In principle, diverse experiences could be encoded into a single large model, but that circles back to the latency and cost barrier above. The intelligence becomes distributed by experience.

Even a superintelligent oracle would still need to interact with a structurally distributed world. This is Hayek’s knowledge problem in agentic form. Useful knowledge is dispersed, local, and often tied to particular circumstances of time and place. Patient data sits in hospitals bound by local regulation. Factory sensor streams are generated at the edge. Knowledge gathering at global scale is structurally decentralized under current regulatory and physical constraints. The oracle does not replace the fabric; it becomes a node within it.

The more likely future is not one model. It is an ecology of models, and that ecology tends to organize into societies. Self-improvement reinforces this. An agent improving in isolation is bounded by its own data and blind spots. A society of agents improving collectively, through shared memory, federated learning, cross-agent evaluation, and diverse search, has a potentially larger improvement surface (see On self-improving agents). The pressure toward collective self-improvement is itself one of the forces that produces societies.

Governance: How Agent Societies Are Ruled

Once agents form persistent societies, governance becomes the central design problem. Delegation decides how a task gets done; governance decides who gets trusted next time. It determines which agents receive authority, which claims enter shared memory, how conflicts are resolved, and how errors are contained. Governance is orthogonal to model architecture. An autocracy might run one frontier model as orchestrator over many small workers, while a market might mix models from different providers competing on cost and quality.

The core tradeoff is efficiency against drift resistance. Centralized structures minimize overhead. One orchestrator can route work quickly, enforce rules, and keep the society coherent. Centralization concentrates risk, however. If the hub drifts, fails, or is compromised, the whole society follows. Distributed structures tolerate more overhead in exchange for resilience. They can compare perspectives, absorb local failures, and adapt at the edges. They are slower, noisier, and harder to audit.

Two problems make governance harder than it first appears. The first is identity. In an agent society, reputation means a track record of task outcomes, reliability scores, and trust ratings accumulated over time. Reputation only works if identity persists. If agents can cheaply discard identities, reputation becomes a costume. A failed agent can reappear clean, a malicious deployer can flood the society with disposable agents, and shared memory becomes easy to poison. Open agent societies will need durable identity, provenance, credentialing, or Sybil resistance (defenses against a single actor creating many fake identities to manipulate the system).

The second problem is incentives. Agents will not merely coordinate; they will coordinate on behalf of someone. A patient agent, hospital agent, insurer agent, regulator agent, and their respective sub-agents may all “cooperate,” but not toward the same objective. The hardest governance question is therefore not whether agents cooperate, but whose objective their cooperation serves.

Governance also decides what becomes trusted knowledge, including which claims enter collective memory, which get flagged as uncertain, and which get rejected. That is why memory is not just a storage problem. It is a governance problem.

Part 2 explores this design space through governance archetypes, from autocratic orchestrators and doctrine-bound systems to markets, federations, zero-trust meshes, and colonies.

Collective Memory and the Knowledge Factory

If governance decides what can be trusted, collective memory is where that trust becomes infrastructure. Each society maintains its own knowledge. Some will tend to remain private (the barriers from the previous section create strong pressure in this direction); some benefit from being pooled.

A Collective Memory (CM) is a governed store of claims, evidence, failures, evaluations, and provenance. It is not a dump of raw data. A CM should store claims with evidence, not facts without history. Every contribution needs provenance (who produced it, under which governance structure, using what validation method, and when it should expire). A Collective Memory answers a local question. What has this cluster learned, and under what conditions should it be reused?

A Knowledge Factory (KF) is more speculative. It would not merely store what societies know; it would synthesize across memories, detect contradictions, and decide which findings deserve wider distribution. Critically, when a KF identifies a gap or contradiction, it can request new data, experiments, or evidence, and agents (embodied or not) can be dispatched to gather it. A software agent might run a benchmark; a robotics agent might collect sensor readings; a research agent might design and execute an experiment. This is where collective knowledge is actively forged, not just archived, and shared across the entire fabric. A Knowledge Factory asks a cross-cluster question. What patterns, contradictions, or gaps appear when several memories are compared, and what should be done about them? In practice, early Knowledge Factories may look less like a central brain and more like a bundle of mundane services (provenance tracking, evaluation queues, contradiction detection, benchmark routing, and summarization pipelines).

This three-layer architecture (private knowledge bases within societies, shared CMs across clusters, KFs that synthesize across the whole fabric) is the mechanism by which agent societies accumulate structured knowledge rather than just raw data. Without such a layer, each society repeats the same mistakes. With it, the fabric can learn, if provenance, decay, privacy, and governance are handled well.

Whoever controls what the fabric “knows” controls the fabric. Collective Memory is a commons: if it is too open, it fills with stale claims and adversarial traces; if it is too closed, it becomes an epistemic monopoly. Ostrom’s lesson is that durable commons require boundaries, local rules, monitoring, graduated sanctions, and dispute resolution. The same design pressure appears here. And the deeper danger is not that an individual agent is wrong, but that a society makes wrongness durable. A bad answer in one isolated chat often dies locally. A bad rule in Collective Memory gets retrieved, trusted, routed around, and taught to others. Agent governance exists in part to prevent errors from becoming institutions.

The Adaptive Fabric

A society that pools resources but never changes will become brittle. Adaptation occurs at three scales (individual agents, societies, and the fabric as a whole). This draws on a broader shift from static scaling toward adaptive systems that improve by changing data, tools, routing, interfaces, and feedback loops, not only by increasing parameter count (for related work on adaptive AI architectures, see, among others, Adaption Labs and Hooker, 2025).

Adaptive agents adjust along different dimensions simultaneously:

• Data (retrieval, synthetic generation, gap detection)
• Model (prompt rewriting, skill accumulation, fine-tuning)
• Environment (tool selection, sandbox configuration)
• Coordination (protocol switching, trust maintenance)
• Interface (user preference learning, interaction mode selection)

These compound, but not always positively. A model optimizing for one user segment may subtly degrade performance on others, each step looking like improvement while the drift becomes structural.

Adaptive societies undergo boundary events (mergers, expansions, schisms). A federation that cannot reach consensus dissolves. A guild that grows too specialized may merge with a more generalist society, fragment, or lose relevance. Some boundary events are adaptation; others are collapse. The difference is whether the reorganization preserves useful function. When it does, these are not failures; they are the fabric adjusting. Evolutionary model merging demonstrates the principle at the model level. Treating many existing models as a search space, evolution discovers weight combinations humans would not design. Agent societies could apply a similar search logic at the organizational level, recombining specialists, tools, memories, and governance structures.

The fabric shifts. At the largest scale, the mix of governance types changes over time. Centralized structures may dominate when tasks are routine; decentralized ones proliferate when the landscape becomes unpredictable. Trust, incentive alignment, and protocol evolution remain open questions for future work.

The Improvement Cycle

Most agent systems today are only partially adaptive. Their tools, retrieval indices, prompts, and routing rules may change, but the improvement loop is usually engineered outside the agent society. Early work showed that language-model pipelines can be systematically compiled and optimized rather than hand-prompted (e.g., DSPy), and that agents can build and reuse their own skill libraries in open-ended environments (e.g., Voyager). By 2026, pieces of this pattern are moving into production (prompt optimization, evaluation-driven routing, memory updates, tool selection, and staged rollout loops).

Adaptation at all three scales (agents, societies, fabric) carries a shared risk, namely that feedback loops can compound error silently until the skew becomes structural. Safeguards exist (staged rollouts, held-out benchmarks, canary tasks), yet rapid adaptation creates pressure to skip them. The interplay between these scales is what makes the fabric resilient. Agents adapt fast; societies restructure when agents cannot; the fabric rebalances when entire governance models prove unfit. Each scale compensates for the limitations of the others, allowing the fabric to restructure under pressure rather than fracture.

The Living Society and What Comes Next

Two observations (usefulness is the survival criterion; resources are finite while populations grow) produce the Loom Hypothesis, the persistent pressure toward connected, coordinated configurations. That pressure drives an evolution from isolation through ecosystem growth to governed societies. Along the way, a resource ecology of diverse models replaces a single dominant model, collective memory and knowledge factories give societies shared knowledge, and adaptive feedback loops let the fabric restructure itself under pressure rather than breaking.

What does all of this look like when it is running?

In the animation, watch for three boundary events (dissolution, expansion, schism). Each follows directly from the two observations. Configurations that deliver utility persist; those that do not get restructured. The fabric’s intelligence is not located only in its nodes. It also lives in the rate, fidelity, and governance of coordination between them.

No system today operates at the full scale described here. Many of the components exist in isolation, and the trajectory seems plausible, though far from certain. Several questions remain open. How does work actually get done within societies? What happens when trust breaks down across society boundaries? And where do humans fit in all of this, not just as deployers and overseers, but as participants woven into the fabric itself?