Local vs. Global: What Emergence Tells You About Where a Decision Should Live

Every decision has to be made somewhere. The default instinct in most organizations is to push decisions upward, toward whoever has the most authority, the most context on paper, the most seniority. Emergence suggests a different question entirely: not "who is senior enough to decide this," but "does this decision belong to the system of local actors, or does it require a single point of view that no local actor has access to." 

The Distinction

A local decision is one where the person making it has full access to the information the decision actually depends on, and the consequence of getting it wrong is contained. An ant deciding which direction to turn based on the pheromone gradient right in front of it is a pure local decision.

A global decision is one where the relevant information is distributed across the system in a way no single local position can see, or where the consequence of a choice isn't contained to the person making it. Where to place the nest in the first place isn't a decision any single ant could make well, it requires information no one ant has (the whole terrain, where multiple future food sources are likely to be, the risk profile of different locations), and getting it wrong doesn't cost one ant a wasted step, it costs the colony its foundation.

Emergence produces excellent outcomes for the first category, but has very little useful to say about the second. The mistake is applying "push decisions down" uniformly, without checking which category a given decision actually falls into.

With only 8-10 agents, don't be surprised if some refreshes produce a messier or less obviously converged pattern than the full-colony version. It's a smaller-N system, closer to what a real small team's "aggregate of local decisions" actually looks like, noisier and less statistically reliable than a large colony.

When Local Decisions Aggregate Well

Three conditions have to hold, and they're the same three conditions from the colony, translated directly:

The information the decision depends on is actually present at the local level. 

This sounds obvious but is violated constantly. A support engineer deciding how to handle an individual customer issue has the information that decision needs — the specifics of that case. A support engineer deciding whether the team should change its escalation policy does not have that information at the local level; policy change requires seeing the pattern across hundreds of cases, which no single local position has visibility into. The first is a genuinely local decision. The second only looks local because it's being made by someone in a "local" role.

Feedback on the decision reaches the decision-maker fast enough to correct the course. 

A local decision that produces a bad outcome is only self-correcting if the person who made it finds out quickly. If feedback takes months to loop back — or gets aggregated into a report that reaches someone else entirely, the correction mechanism that makes decentralization safe simply isn't present, and you're accumulating local decisions with no error-correction, which is worse than not decentralizing at all.

The consequence of a wrong local decision stays contained. 

An ant's bad turn doesn't threaten the colony. A local pricing decision, a local commitment to a customer, a local architectural choice made without visibility into how it interacts with three other systems, these can each individually be "local" in terms of who has the relevant information, while still having consequences that propagate well beyond the local position. Decentralization is safe in proportion to how contained the blast radius actually is, not in proportion to how confident the local decision-maker feels.

When all three hold, pushing the decision down doesn't just feel more empowering, it produces a measurably better decision, because it's being made with better information, corrected faster, and safely bound if wrong. This is the real case for decentralization, and it's a stronger case than the usual motivational one ("people are happier when they have autonomy"), because it's about decision quality, not morale.

When Local Decisions Don't Aggregate Into a Good Global Outcome

Emergence itself contains the counterexample, and it's worth taking seriously rather than treating decentralization as costless. A real ant colony can march down a trail to a depleted food source because the local rule (follow the strongest pheromone signal) has no mechanism for incorporating information the individual ant can't see (that the source ran dry, that a better source exists elsewhere, that the colony's overall foraging effort would be better spent elsewhere entirely). Each ant is behaving perfectly rationally given what it can observe. The aggregate outcome is still wrong, because rationality at the local level doesn't automatically compose into rationality at the global level.

This happens in organizations in a specific, recognizable shape: many local decisions that are each individually defensible, that add up to a global outcome nobody would have chosen on purpose. A team optimizing its own local metric at the expense of a downstream team. Several product teams each making a locally reasonable call about which platform to build on, producing an incoherent overall architecture nobody designed. Local hiring decisions, each sensible in isolation, that produce an org structure with no one accountable for the seams between teams. None of these are failures of individual judgment, but rather failures of aggregation: the thing Emergence's colony model handles well only under specific conditions, and organizations routinely violate those conditions without noticing.

The tell that you're in this situation is that everyone involved can defend their own decision, and the aggregate outcome is still bad. If individual decisions were poor, you'd fix it by improving individual judgment. If the aggregation itself is the problem, improving individual judgment further won't help at all, you need either a different boundary condition (a shared constraint that wasn't there before) or you need to reclassify the decision as global and pull it up, not push it further down.

The Decision Rule

Given the above, the practical question for any specific decision isn't "should we empower people to decide this" as a general philosophy. 

Does the local position actually have the information this decision depends on, or does it only have information relevant to a narrower decision that's being conflated with this one? 

If the answer requires visibility across multiple local positions: pattern data, cross-team interaction effects, information that exists but isn't present at any single local vantage point, the decision is global regardless of who's nominally being asked to make it.

Will feedback on this decision reach the decision-maker fast enough to function as a correction mechanism, or will it arrive too late, too aggregated, or not at all? 

If the honest answer is "we'll find out in the next quarterly review, filtered through someone else's summary," decentralizing the decision doesn't get you the self-correcting property that makes decentralization safe.

If this specific local decision is wrong, does the cost stay with the person and context that made it, or does it propagate to people and systems who had no say in it? 

A wide blast radius is the single strongest argument for keeping a decision global even when the first two conditions are satisfied, good local information and fast feedback don't help if the downside lands somewhere the local decision-maker can't see or won't bear.

A decision that passes all three belongs local, and pushing it up will make it worse, not safer : you'll be substituting a slower, less informed decision for a faster, better-informed one, purely because it feels more controlled. A decision that fails any one of the three needs either a global decision-maker, or, maybethe better fix, a change to the boundary conditions (better data visibility, faster feedback loops, contained consequences) that could eventually convert it into a genuinely local decision rather than a permanently escalated one.

Where This Connects to Standard Decision Frameworks

This isn't a replacement for structured decision analysis: objective clarity, alternative generation, tradeoff weighing all still apply once you know who should be doing them. What it adds is a prior question those frameworks usually don't ask explicitly: before you run a rigorous process to make a good decision, you have to know whether the process should be running once, centrally, with full visibility, or many times, locally, with fast correction. Applying a single-decision-maker framework to something that's actually an aggregation problem produces a well-reasoned answer to the wrong question. Applying "push it down and trust the aggregate" to something that actually requires visibility no local position has produced the dead-trail failure mode: confident, coordinated, and wrong.

The colony doesn't get this right by being smart. It gets it right because the three conditions (local information, fast feedback, contained consequence) happen to hold for the specific decisions ants make. The organizational version should be about checking, decision by decision, whether those same three conditions actually hold before deciding where the decision should live.