Are teams smarter than their individual members? In Exploring Aggregate Intelligence: Superintelligence in Organizations, I discussed how combining individual members into collections in which the members can communicate forms a new entity called an “aggregate intelligence.” In artificial intelligence this architecture is called a “Mixture of Experts” model (MOE); ChatGPT4 is believed to use it. However, this general pattern can be found in many structures, from ant colonies to human organizations. Connecting individual members through a communication structure effectively forms a new entity with its own capabilities and its own intelligence.
But how exactly do the communication structure and patterns affect aggregate intelligence? In this article I develop a simulation to explore these questions, first describing how Python’s SimPy simulation library works, then walking through the aggregate intelligence simulator. I then show that even from preliminary analysis we can see that the communication structure affects the organization’s overall intelligence.
It is self-evident that an organization’s aggregate capabilities are greater than those of its individual members, because they add linearly. If one person can lift 100 pounds, 5 such people can together lift 500 pounds. If one employee can be in one place at a time, an organization with 10 representatives in 10 different places can function in 10 places at the same time.
With intelligence, however, the situation appears more complex because two factors are involved: the individuals and their communication structure. Adding individuals to an organization increases the knowledge and computational power available to the organization, but also increases communications overhead, potentially interfering with others’ ability to solve problems
Conceptually, adding a diverse set of individuals to a team should improve the team’s cognitive performance because individuals can compensate for each others’ weaknesses, while having multiple individuals who are strong in a specific area provides even more capability to process problems in that area. For this reason we see in machine learning that ensembles of diverse models almost always outperform single models.
However the experience of working within a larger organization subjectively feels different. Frequently an organization may act in ways that individual members broadly believe seems unlikely to produce good results. Are they unable to transcend their limited viewpoints to see a larger benefit, or is the organization not able to productively harness their collective intelligence?
Although it may be possible to measure intelligence of aggregate organizations through direct IQ testing (and some have tried), we can explore this question much more easily through simulation. Simulation allows us to vary parameters such as the organization’s size and introduce new communication patterns to explore their effects. To explore the above questions I built an aggregate intelligence simulator using the SimPy simulation framework
This section introduces the SimPy library, which I used to build the simulation of aggregate intelligence. Readers who aren’t interested in those details can skip this part and proceed to the discussion of the simulation model.
SimPy is a minimalist Python library for building asynchronous event-based simulations. Asynchronous event-based programming is a pattern common in JavaScript frameworks like node.js, although less common in Python. SimPy runs an event dispatching loop, similar to a window manager’s event loop, that schedules and executes events along a timeline. Individual worker tasks can delay for specific times or wait on completion of an event from another task. Under the hood, these actions inject tasks into a single event processing queue. The queue dispatcher processes events from the queue as quickly as possible while keeping track of “simulation time”, which it advances independently of actual clock time.
This approach allows users to easily construct a simulation where actors with simple behaviors produce complicated effects as they interact with each other at scale.
For convenience most SimPy helper functions can be accessed from its environment, simpy.Environment(), commonly assigned in functions or objects to a variable named env.
The key to SimPy is the use of Python “generator functions,” which are functions that use the yield keyword:
yield env.timeout(task_transfer_time)