The best architectures, requirements, and designs emerge from self-organizing teams.” – Principles behind the Agile Manifesto

I follow in the footsteps of so many people who have long wondered at the meanings of such simple words, as though they were dogma from on high. Emerge? Self-organizing? Profound, to be sure. But what do we really make of this sentence?

galaxiesFirst let me throw water on that whole dogma thing. The whole point to the Agile Manifesto and its Principles is to be less dogmatic about how we build good software. So I don’t really care what the esteemed crafters of this bite-size morsel of profundity actually meant by emerge and self-organizing.

Instead, what I do really care about is how to help our organizations achieve their goals – especially how to be more agile. Building great software is part of this story to be sure. And as it happens, emergence and self-organization are fundamental principles that can move us forward, especially now that so many enterprises are struggling with digital transformation.

The Notion of Emergence Emerges

Let’s start with the surprisingly multifaceted definition of the word emergence, and its verb form, to emerge. The dictionary defines emerge as to come into being through evolution; to rise from, come out into view. So right off the bat we have several related concepts.

Perhaps emergent refers to coming into being, as in going from not existing to existing.

Or maybe to emerge means to evolve, as in going from a less mature or advanced state to a more mature or advanced state, as opposed to being static.

Then there’s the notion of coming out into view, as in going from hidden to visible. It was always there, but emerged from the shadows.

But there are other senses of emergence that the dictionary definition doesn’t quite capture. For instance, the notion of being assembled piecemeal. The photo on a jigsaw puzzle emerges as we put it together.

And then there’s a sense of emergence popular in discussions of emergent architecture: the notion of unintentional. In other words, there is a spectrum between emergent architectures on one hand and intentional ones on the other, where intentional architectures are essentially pre-planned and on purpose, while emergent architectures are somehow accidental.

In spite of all these subtle differences in meaning, what most people are apparently trying to say when they use emergent in the context of architecture or design is: by deferring important architectural and design decisions until the last responsible moment, you can prevent unnecessary complexity from undermining your software projects (a quote I found on IBM DeveloperWorks, but if you know who actually said this first, please fill us all in by commenting).

This software-building principle thus introduces yet another notion into the mix: the concept of deferred. Human decision making is responsible for driving architecture and design, so such architecture and design emerges simply by virtue of the fact that we don’t make up our minds about any of it until we have to.

Then perhaps it comes into view, or evolves, or comes into being. And while such decision making would clearly be intentional, at least it wasn’t intentional at the beginning of the effort, in the sense that the team didn’t pre-plan anything.

The Elephant in the Room Emerges

All of the subtle variations in definition above miss one important element: the role of self-organization. Sure, people would generally prefer to organize themselves than to have someone else do it for them, so perhaps a self-organized team might be more productive or more collaborative than a team that a manager organized for them.

However, if you’ve read some of my recent articles on self-organization – or my book The Agile Architecture Revolution for that matter – you’ll recognize a bigger picture here: emergent in the context of complex adaptive systems (CAS).

In this context, an emergent property of a CAS is a property of the system as a whole that isn’t a property of any of the sub-systems of that system.

Self-organization is one of the primary driving forces behind complex systems. Natural systems from beehives to galaxies all have self-organizing subsystems. Perhaps the original Agilists were thinking about this sense of emergence when they wrote the sentence at the top of this Cortex.

Or perhaps not. But regardless of whether the original Agilists were thinking of CAS or not, many people over the last 15 years since the Manifesto appeared have made this association, for better or worse.

On the surface the appeal of emergent design or architecture being the sort of emergence that complex systems exhibit is tantalizing, as though emergence were some kind of secret magic. All we need to do is have our teams self-organize, and behold! Emergent design and/or architecture springs up out of the nothingness!

If only it were that easy, right?

Unfortunately, making this jump from emergent-as-deferred-and-evolving to emergent-as-property-of-CAS has serious issues. First of all, in the CAS context, emergence applies to the properties of complex systems. In the case of a software team working on some software effort, it’s not clear where the complex system is, let alone what properties it has.

Furthermore, it’s a stretch to think of architecture or design as a single property of a system. Perhaps they represent a collection of properties of a software system – scalability, performance, and what not – but architecture represents more than simply the properties of a system. How one component talks to another could be thought of as an element of an architecture, but not a property in the way that scalability is a property of a system.

And in any case, there’s no general reason to consider software systems to be complex systems, as the properties of their architecture or design are manifest in their components. Even when a property of a software system is a property of the system as a whole, it may still very well be a property of the components of that system – and thus it isn’t an emergent property.

Recognizing a Complex Adaptive System

Here’s how I like to think of emergence in the context of complex systems: if you look too closely at a CAS, you can’t see the emergent properties. Instead, you must step back – sometimes way back – and look at the big picture of the system as a whole to see its emergent properties. In other words, the pattern emerges from the big picture.

If you study the behavior of individual bees you’ll never see the structure of the hive. If you look at individual stars you’ll never see the shape of the galaxy. If you examine water molecules you’ll never know what it means to be wet.

When we think about the sorts of software systems that self-organizing teams can build – that is, the two-pizza teams that the Agile world favors – we’re simply not stepping far enough away from the component level to get any sense of emergent properties.

Bottom line: it doesn’t matter how self-organized individual teams are, there won’t be anything particularly emergent about the software design or architecture they produce, in the CAS sense of emergence.

Now, don’t throw up your hands and conclude that I’m missing the point of the sentence at the top of this article entirely. In fact, I’m pointing out a subtle but critical aspect of the entire Agile Manifesto. It’s not really about software at all – or at least, not just about software.

The Agile Manifesto is in reality about people and how people interact with software. How developers in collaboration with stakeholders create it and ensure it meets the ongoing needs of the organization.

However, even if we look at the self-organizing teams themselves plus the software they create, we’re still too close to see any emergent properties. We must step away and look at the organization as a whole.

Just how big the organization must be is rather slippery to define. It may be the entire company or perhaps a large division or business unit. Large enough, however, for emergent properties to manifest themselves.

The Intellyx Take

When we look at our enterprise as a whole, we may note several emergent properties, both positive and negative. We’re not likely, however, to see an emergent design or architecture for the enterprise – at least, not without stretching our definitions for those terms well beyond their usual application.

In my opinion, however, it doesn’t matter that neither design nor architecture emerges. Instead, I see architecture as a set of intentional acts that seek to influence the organization to exhibit desirable emergent properties, of which business agility is the most important.

I like to call this approach Agile Architecture, a reinvention of enterprise architecture that influences the behavior of human and technology subsystems in an organization to shift its emergent behavior toward business agility. But business agility is the property that emerges, not the architecture.

Intellyx advises companies on their digital transformation initiatives and helps vendors communicate their agility stories. As of the time of writing, none of the organizations mentioned in this article are Intellyx customers. Image credit: Hubble Heritage.


  1. Len Fehskens says:

    Jason writes:

    “And then there’s a sense of emergence popular in discussions of emergent architecture: the notion of unintentional.”

    I must be missing something important, as I have never understood how we can trust things we don’t intend, and that are therefore likely to be unexpected, to provide us with the means to solve specific problems we have to solve. I understand the value of serendipity, and have often exploited unforeseen outcomes in solving design problems, but for me design is an inherently purposeful activity, and relying on (as opposed to being prepared to take advantage of) unintended and unforeseeable outcomes to solve design problems seems to me to be at best unjustifiably optimistic and at worst, well, just foolish.

    Jason continues:

    “by deferring important architectural and design decisions until the last responsible moment, you can prevent unnecessary complexity from undermining your software projects (a quote I found on IBM DeveloperWorks, but if you know who actually said this first, please fill us all in by commenting).”

    I have long known this as “the principle of deferred binding”. When I say “long”, I mean since the late ’60s or early ’70s at the latest (I started programming around 1964/1965), long enough ago that from the perspective of the present day it just seems to have been “in the air” back then, and I can’t point to someone who “actually said it first”. It’s so fundamental a design principle that I think it must occur to any reflective practitioner at some point in their career. The specific phrase “deferred binding” seems to have become associated with the Google Web Tools compiler, so we may have to find another name for the general design principle.

    For me, the principle of deferred binding isn’t about avoiding unnecessary complexity. It’s about making the thing work the way it’s supposed to work. Premature binding doesn’t introduce complexity, it forecloses options. It may be that the foreclosure of options results in unnecessary complexity as a consequence of “workarounds”, but more generally it’s a bad idea because it renders inaccessible and unusable alternatives that may be the route to a better solution to the design problem.

    Jason continues:

    “In this context, an emergent property of a CAS is a property of the system as a whole that isn’t a property of any of the sub-systems of that system.”

    I’d argue that this is what makes something a “system”. An assembly whose behavior is simply the sum of the behaviors of its parts is just that, an assembly or an aggregation. As such, I don’t think this idea of emergence is limited to complex adaptive systems, i.e., this notion of emergence isn’t dependent on the system being complex or adaptive. It is inherent in the idea of “systemness”. One of the fundamental ideas of systems thinking is that the relationships between the elements of a system are as important as the elements themselves, and it these relationships that give rise to the “emergent” behavior of the system as a whole.

    Jason continues:

    And in any case, there’s no general reason to consider software systems to be complex systems, as the properties of their architecture or design are manifest in their components.

    Here I have to differ with you. To me, software systems can unquestionably be complex, indeed, I think many of the software systems we routinely rely on nowadays are among the most complex artifacts we as a species have ever crafted. And I think almost every software system I have ever worked on at some point exhibited behavior that was “emergent” in the sense that it was a priori unexpected given our understanding of the individual behavior of its elements. While said emergent behavior was understandable in retrospect (it’s not magic, after all), that’s not what emergent in this sense is about; the “emergent” behavior exhibited is not the behavior of any individual element of the system — that doesn’t mean it’s not understandable, only that you won’t see it until you appropriately connect the pieces to one another.

    Finally, regarding “The best architectures, requirements, and designs emerge from self-organizing teams.”

    I suspect this is true, but “self-organizing” doesn’t mean non-purposeful. To me it means self-adaptive, of both intention and the means of achieving that intention. For teams, this is driven by thoughtful reflection.


    • Jason Bloomberg says:

      Thanks for your thoughtful response! I don’t go into the question as to whether unintentional software architecture is a good idea, as that road has been well-trodden already. However, your analogy to deferred binding is right on point.

      As for your concerns about the meanings of the word “system” and “complex,” I think the issues at hand are simply the definitions of the words as we’re using them. I try my best to be precise in my meanings, but that doesn’t mean I’m using such words as they might be used in a more informal context. I refer you to my latest book for a deeper discussion of these terms.

  2. […] Emergent behaviors are behaviors of complex systems of systems (in our case, IoT devices) that only appear at the aggregate level, but not at the level of the devices (see my discussion of emergence from 2015). […]

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Subscribe to our Cortex & Brain Candy Newsletters!

Thank you for reading Intellyx thought leadership!

Please sign up for our biweekly Cortex and Brain Candy newsletters.

The Cortex features thought leadership on Agile Digital Transformation topics, and Brain Candy highlights disruptive vendors in enterprise IT.

We won't spam you and you can unsubscribe at any time.