Adventures in Game Theory, Part Four

For those of you freshly joining this adventure, the last three posts have led us on a strange, thrilling journey that has passed through the valleys of introductory game theory, the jungles of applied improv, and the mountains of software simulation. Now, at last we arrive at our thunderous finale on the shores of Lake Awesome. I highly recommend reading from the start of the sequence, otherwise what I have to say may be too extraordinary and wonderful for your mind to fully hold!

At the end of the last installment caught me teetering on the brink of a realization–that by adding just a little more functionality to my simulation, I could start exploring some more socially useful truths about how people behave. My insight was to add status.

What this meant in practice was splitting the population of agents in my model into two groups: bosses and workers, or in training community parlance: leaders and team-members. Then, in order to make the interactions between bosses and workers a little less benign, I added two extra constraints.

One: If bosses were aggressive (nose-thumbing) to workers, workers were not empowered to reciprocate and be aggressive back in their next encounter.

Two: Bosses were unable to remember the specifics of positive interactions they had with workers. So for instance, if a boss and a worker both chose paper in one round, the worker would remember the fact, but the boss would not.

Implementing these changes was easy, as it simply required that the two memory rules I’d already added to make the first simulation work were now dependent on status. (I also added a little extra logic around the movement of the agents to ensure that workers had to interact with bosses, and to make the movements of bosses dependent on other bosses but not workers. However, while necessary, that code is somewhat beside the point.)

What happened next was wonderfully clear. Within a few seconds, all the bosses were behaving aggressively while the workers normed on a set of social standards of their own. My simulation suddenly looked a lot like some of the more awful companies I’d worked for. Without having to say anything about the kinds of people who become leaders, or about the specifics of organizational culture, I’d captured a simple truth about leadership: that without the incentives to behave otherwise and the right skills to succeed, people with power slide towards bad behavior, even if they start off thinking like saints.

What was even more interesting was that as the simulation progressed, the bosses started to bump up against the corners of the virtual environment as if desperate to leave. Because aggressive behavior was so successful for bosses in their interactions with workers, they were applying the same behavior to each other, resulting in a rapid erosion of their ability to collaborate. The lesson: by letting leaders behave badly, we ensure that leaders have less pleasant interactions with each other, as well as with us.

My goal, though, was not to engage in rhetoric about leaders, but instead to see whether models like the one I was looking at could tell us something about how to help organizations do better. To do this, I looked at what happened when I turned each of the status dependencies off in isolation.

Turning off the status dependency for remembering positive interactions is rather like sending your managers on an employee recognition course. They learn to value the specific information they get from each person they work with, and to let their team members know that they’re seen and valued.

The result in the simulation is that the culture improves significantly. The workers integrate more tightly and the bosses take on the same cultural colors as the workers they lead. Interestingly, the bosses don’t all start cooperating at once. Many of them initially retain their aggressive behavior. Then, one by one, they figure out that collaboration is more effective.

The lesson here: that training leaders to listen can make a huge difference in their effectiveness, but that the change they take on depends on their willingness to implement what they learn.

If instead, we turn off the status dependency for worker retaliation to boss aggression, the effects are even more interesting. Making this change is rather like implementing a shared accountability system like the one that revolutionized the airline industry and transformed the safety standards in air travel. Under this system, the pilots of planes are no longer the unquestionable captains of the air that they once were. If copilots think that they’re witnessing a mistake, they’re duty-bound to call the pilot on it and to report it to air traffic control if necessary. In our simulated business, we can imagine that we’re instructing the worker agents to hold their bosses accountable if they don’t uphold the collaborative social standards of their organization.

What happens when we make this change is that the behaviors of the bosses have trouble settling onto any specific color. When we watch the ‘mood’ of the agents to see how many positive or negative interactions they’re having, we see that the tables have been turned. The workers are now having a pretty great time all round and the bosses are mostly miserable–the opposite of what we see if status dependence for retaliation is left on. This is because the workers now have an advantage that the bosses don’t–they can remember and repeat positive interactions whereas bosses cannot. Because aggression no longer secures automatic results, bosses don’t have an easy way of stabilizing on a successful behavior.

The lesson here is that enabling everyone in an organization to hold leaders accountable for their behavior is what creates the incentive for leaders to improve, but that without the right training and direction, the main result is leader unhappiness.

As you might expect, turning off both status-dependent features creates a benign, functional organization that settles rapidly onto a cooperative culture. If you want to play around yourself, and have Java installed, the simulation is the second applet on this page. (It has four buttons.)

As before, red, blue and green denote different positive interactions. Gray denotes aggressive behavior. Swapping to ‘mood view’ shows the success of the agents interactions, ranging from blue (unhappy agents) to yellow (cheerful ones).

Clearly there’s a lot more to do here. For a start, in order to turn this into a science result, the simulations will need to be a lot more rigorous, which will probably mean sacrificing the visual playfulness.  Furthermore, we’ve only looked at one memory model for agents and solid research would need to try out others. However, the results seem pretty clear. We’ve gone from a simple game played in a room full of people to a model that turns business intuition into something rather like unavoidable, mathematical fact.

Thus, in the wake of our adventure, we can say with real confidence that any society or organization that doesn’t empower its people hold its leaders accountable, and which doesn’t teach those leaders how to listen, can expect its leaders to turn out bad, regardless of how ‘good’ we believe them to be as people.

This is something most of us already believe but which we often fail to implement. For instance, we’re all used to the idea of holding elected officials accountable, but explicit training in ‘voter recognition’? We leave that to chance. Similarly, we’re used to the idea that good managers are the ones who pay attention, but company-wide accountability systems? Those are pretty rare. I believe that simulations like this can make these points unavoidable, and also perhaps show us how to build measures that make our adherence to such standards quantifiable.

For any skeptics out there, my huge thanks for reading this far, and here’s a final thought to consider. Agent-based simulations of this sort have been used by biologists for years on the following basis: we can’t capture all the details of natural systems like cultures or the lives of organisms, so instead we capture only what we know is true. From that, we look to see what else must be true as a consequence. Thus we attempt to make the simplicity of the model a strength, not a weakness. In this instance, the agents are so simple that we can expect the same effects to arise regardless of the memory model we employ for our agents, so long as that memory model permits learning. Further work in this area will hopefully make that point even clearer.

That’s it. The adventure is finished. And while the ending perhaps isn’t unexpected, it feels like a step forwards to me. After all, if we can do this starting with Rock Paper Scissors, think what we can do with the game of Twister.


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s