Dunbar’s Number Was Always Pointing Here
You know that diagram. The one where someone draws five people as nodes, connects every person to every other person, and suddenly there are twenty lines where you expected five. It gets used in talks about team communication, usually to explain why adding one person to a team doesn’t just add one relationship — it adds relationships between the new person and everyone else, plus changes every existing relationship dynamic.
It’s a simplification, obviously. Real communication doesn’t actually flow along every link simultaneously. But it illustrates something true about why coordination gets hard fast, in a way that’s immediately legible to anyone who’s ever tried to run a project with too many cooks.
Dunbar’s number is pointing at the same thing, but one layer deeper.
The familiar version: humans can maintain stable social relationships with roughly 150 people. Beyond that, groups fragment, require formal rules, lose the cohesion that comes from everyone more or less knowing everyone else. Gets cited a lot at conferences. Also tends to show up on LinkedIn looking like this:
Putting aside the fact that the real world doesn’t work like that, the slightly deeper implication of Dunbar’s Number is that the real constraint isn’t knowing 150 people, it’s that modelling the relationships between people is a quadratic problem. Those 17 people don’t have 136 equivalent relationships - the relationship may only exist through a proxy and some relationships are stronger than others.
If you want to understand not just who’s in your network but how everyone relates to everyone else - who trusts whom, who influences whom, who’s quietly furious with whom - the cognitive load grows as the square of the group size. Dunbar’s number isn’t simply a limit on memory, rather it’s a limit on relational inference.
I came across this post recently, written about five years ago in the context of metaverse design, which feels both prescient and slightly quaint, that makes this point clearly, gave me some fancy language to use and draws an interesting implication: social structures like gossip, hierarchy, and trusted intermediaries are essentially compression algorithms for this quadratic problem. Humans never actually solved n². We found ways to approximate it cheaply enough to function. Gossip is lossy but fast. We outsource relational inference to people we trust and sample through them.
That reframe stuck with me, because I think we're about to make the diagram significantly more complicated. And I think the shape of what happens next is worth sketching out.
So Then Everyone Gets a Swarm
We’re moving, faster than most people have quite registered, into a world where individuals operate not just as themselves but through personal agent swarms. Not one AI assistant, rather a small army of agents that research, draft, schedule, execute, delegate, and report back. Some of this is already here. Most of it is arriving faster than our ability to think clearly about what it means.
Now think about what this does to the diagram. Bear with me on the napkin mathematics, because I’m not a complexity theorist, but you don’t need to be to see the direction of travel.
Start with the baseline: n people in a network, O(n²) relational edges to model. That’s the familiar constraint.
Add personal swarms of size k. Each swarm has internal structure, agents coordinating, delegating, specialising, which is its own ball of complexity. But then consider what happens when my swarm interacts with your swarm. That’s not one edge between us anymore. That’s potentially k² interactions between our two swarms alone. Across a network of n people: O(n²k²). Quadratic in both dimensions at once.
And look, I’m waving my hands a bit here, because that’s probably a simplistic version. In practice, agent swarms may not interact each other in neat pairs. They operate in shared environments, call the same APIs, act on the same platforms. My swarm’s actions change the context your swarm is operating in, which changes how a third swarm interprets a request from a fourth person who isn’t even party to the original thing. At that point you’ve left quadratic complexity behind and wandered into something that gives me a headache.
The number itself matters less than the direction: it gets more complicated, fast, and we’re adding nodes to this network every day.
Intent and Context have a Provenance Problem
Here’s the part that really starts my head-scratching.
In a normal human network, intent originates somewhere clean. You want something. You say it. Other people interpret it, act on it, sometimes garble it. The telephone game is real, but there’s a recoverable source at one end.
But how hard is it to keep an organisation aligned around intent, with sufficient context for everyone to make good decisions? In my experience, it gets harder as the size of an organisation grows, which, now I think about it, sounds familiar.
Personal agent swarms change this alignment problem structurally. By the time your intent reaches my swarm, it hasn’t just crossed from you to me - it’s been interpreted, compressed, and re-expressed by your swarm based on your context before it ever left your network. What arrives isn’t your intent. It’s your swarm’s model of your intent. Already once removed. Already carrying the assumptions baked into how your agents were configured, which were probably set up months ago when you were thinking about slightly different problems.
My swarm then acts on that. Its outputs feed into someone else’s context. And so on.
At some point, asking “what did the original human actually want here?” becomes genuinely hard to answer, not because anyone did anything wrong, but because the causal graph of intent has too many nodes to trace cleanly. Each hop is locally defensible. The composition is opaque. It’s structurally similar to how individually sensible algorithmic trading decisions can combine into outcomes nobody intended and nobody owns, except here it’s not money moving, it’s meaning.
This is going to apply to interactions across all sorts of domains: from within families all the way through to nation states. And it’s happening now, not in some imagined future.
I’ve been using Claude in an enterprise setting recently and it’s genuinely interesting to observe. It’s building an understanding of the business and product I’m working on. But that understanding is based on the context it has, and its actions are based on the prompts I give it. My colleagues either side of me are doing the same thing, albeit it’s their framing of intent and context feeding their agents. And so on. The gap between what I mean and what my swarm acts on is already there, and I can already feel it at the edges.
Commerce Is the Canary
Money has a way of making abstract problems concrete.
Payments and commerce is the first domain where the intent problem became urgent enough that real infrastructure had to be built. Aura Labs, led by my former boss Marc Massar, is building specifically for agentic commerce. Marc’s framing cuts straight to it: agents don’t arrive with browsing behaviour the way humans do. They arrive with structured intent: declared constraints around product, budget, delivery, supplier requirements. When intent is explicit rather than inferred, the whole matching problem looks different. But making intent explicit requires new infrastructure, new protocols, new trust frameworks.
Mastercard has introduced something called Verifiable Intent, an open cryptographic standard that creates a tamper-resistant record of what a user actually authorised when an AI agent acts on their behalf. The framing from their Chief Digital Officer is direct: as autonomy increases, trust cannot be implied, it must be proven, and if something goes wrong everyone needs facts rather than guesswork. Google, Fiserv, IBM, and Checkout.com are already building on it. This is infrastructure being assembled right now, because agents transacting without verifiable intent is a fraud and dispute problem nobody wants to inherit.
There’s a parallel thread in enterprise software. A recent a16z piece on why data agents keep failing in deployments lands on the same diagnosis from a different angle: context. The most important context is often implicit, conditional, and historically contingent, tribal knowledge that only exists inside teams and doesn’t survive the translation into agent instructions. Intent is never fully captured in the first place, so of course it degrades from there.
Commerce forced the issue and people are grappling with it seriously. But the underlying problem isn't specific to commerce. It's going to crop up whenever agents act on behalf of humans in any domain where the original intent matters.
Trust Needs a New Layer
Human networks approximated the n² relational problem through trust as compression. You don’t model every relationship in your network directly, you can’t and that’s the whole problem. You trust certain nodes to have done that work for you. High-status people, institutions, close friends who know the relevant parties. You sample through them. The diagram with all the lines becomes tractable because you’re not actually computing it, you’re delegating chunks of it to people whose judgment you’ve verified over time.
This works because human behaviour is mostly legible through social signals you’ve been calibrated to read over a lifetime.
In a swarm-of-swarms world, trust has to extend to agents, not just people. And agents are harder to read than humans. Their failure modes are different, often fluent and confident right up to the moment they’re completely wrong. And they may be optimising for something subtly different from what their human actually wants, without anyone having noticed yet, including the human.
What you’d need is something like meta-trust: not just trusting a person, but trusting that their swarm faithfully represents them. That it carries their actual values and judgment, not just instructions from last April. a16z’s Big Ideas for 2026 makes a related point: on top of today’s systems of record, we’ll need what they call systems of coordination - new layers to manage multi-agent interactions, adjudicate context, and ensure reliability across autonomous workflows. The language is enterprise, but the concept generalises. We need infrastructure that doesn’t fully exist yet.
The compression algorithms that made human networks function were built over centuries of working with human behaviour. Their equivalents for agent networks are just starting to be designed.
So Where Is the Work Happening?
This is the part where I have to be honest about the limits of my own visibility.
In commerce, it’s becoming clear: Aura Labs, Mastercard’s Verifiable Intent, Google’s Agent Payments Protocol, the Linux Foundation’s Agentic AI Foundation; real standards, driven by the concrete stakes of agents handling money. Real people building real infrastructure because the alternative is untenable.
In enterprise software, it’s emerging: the context layer work that a16z is tracking, ontology and knowledge graph infrastructure that’s been building for years, agent-native coordination layers starting to appear.
What I haven’t found, and what I think might be the gap, is someone looking squarely at the full problem across domains. Not just intent in commerce, or context in enterprise data, but the general challenge of what happens when networks of humans, each operating through agent swarms, interact at scale. The relational inference problem that Dunbar identified doesn’t go away just because we’ve added machinery, it compounds.
Maybe that work is happening and I haven’t found it yet. Maybe it’s distributed across AI safety research, multi-agent coordination, and trust infrastructure engineering, and nobody has drawn the connecting lines yet.
If you’re working on this, or you know who is, I’d genuinely like to find out. And if you think I’ve got the framing wrong, I’d like to hear that too.
This is the kind of problem that gets clearer in public.
Building and Exploring is where I write about building with software, and increasingly the strange futures we’re building toward. If this sparked something, please reply or leave a comment.
Really fascinating and thought provoking post. For me, the biggest challenge this translates into is two things:
1. Using the right context to leverage the AI and its thinking without trying to capture every single piece of data. trouble being, as soon as I start selecting the context it brings in some level of bias.
2. More important, using AI to produce better insight not just to generate a greater volume of output that simply places the burden of finding what matters back onto the client.