BEHAVIOR - THE EXECUTION ARM

 

The Short Version

Behavior is the output of the Overreaction Machine. It's what the machine actually does, whether that's talking, arguing, leaving, apologizing, waiting, or deciding not to do anything at all. The Execution Arm, located in the Dashboard, carries out the trajectory selected by the Commit Gate. But not every movement or adjustment requires another trip through the machine. Once something is underway, the parts that don't require new choosing simply run. When a new choice is required, the machine evaluates the available futures and commits again. And here's the problem with understanding other people: you can see their behavior, but you can't see the machinery that produced it. Two people can do exactly the same thing for entirely different reasons.

WHAT THE MACHINE ACTUALLY DOES

You've probably watched someone do something and wondered what on earth was going through their head.

Maybe your coworker ignored an email that clearly needed an answer. Maybe your spouse walked out in the middle of a conversation. Maybe someone apologized, then did exactly the same thing again the following week.

Or perhaps you've been the person everyone else was staring at, wondering why you did something that seemed perfectly reasonable to you.

We spend an extraordinary amount of time observing human behavior, interpreting it, criticizing it, defending it, and trying to change it. We build entire theories about people based on what they do.

But there's a problem.

Behavior is the output of the machine. It isn't an explanation of the machine.

You can watch what someone does without knowing which information they detected, which pancake was controlling, what futures they anticipated, or what those futures were expected to cost.

And since those are the processes we're trying to understand, behavior is both our most obvious evidence and one of our least reliable explanations.

 

THE EXECUTION ARM

By the time the machine reaches the Execution Arm, the choosing has already happened.

The Antenna has detected information. The Pancake Stack has established which problem takes priority. The Forecast Chamber has developed possible futures, and the Commit Gate has selected the trajectory with the lowest projected True Cost once its commitment conditions were satisfied.

Now something has to happen.

That's the Execution Arm's job.

It's part of the Dashboard, alongside Activation Level and Recovery Rate, and it carries out the current commitment under the machine's operating conditions.

The Execution Arm doesn't reconsider the alternatives or decide that another future looks more attractive. Choosing belongs to the Commit Gate.

Execution belongs to the Execution Arm.

And the resulting behavior is the output of the machine, not another component added to the diagram.

 

SOMETIMES THE BEHAVIOR IS NOTHING

Suppose you send someone a text asking a straightforward question.

Three hours pass. No answer.

You start wondering whether they're annoyed with you, avoiding the subject, being inconsiderate, or perhaps deliberately making a point.

But what do you actually know?

You know they haven't answered.

They might have read the message and decided not to respond. They might be waiting until they have more information. They might have forgotten about it. They might not have seen it at all.

The visible result is identical.

No reply.

But only some of those possibilities involve a commitment not to answer.

Doing nothing can be a selected trajectory. But the absence of behavior doesn't prove that doing nothing was chosen.

That's an important distinction, especially since humans are remarkably talented at assigning motives to things other people haven't done.

Someone doesn't invite you. Someone doesn't say thank you. Someone doesn't offer to help.

Before long, the Storyboard has assembled an entire explanation, complete with motives, character defects, and supporting evidence from 2017.

Meanwhile, the other machine may not even know there's a case being heard.

 

NOT EVERYTHING REQUIRES A NEW CHOICE

Imagine driving into a parking lot and deciding to park in an available space.

You approach the space, turn the wheel, adjust your angle, reverse a little, straighten out, and pull forward.

You don't need a new commitment for every steering correction.

You're carrying out the existing one.

Your nervous system has learned how to perform an enormous number of operations without asking the Forecast Chamber to evaluate a fresh collection of possible futures every few seconds.

The same thing happens when you're walking, typing, brushing your teeth, playing the piano, or carrying a cup of coffee across the room.

Anything that doesn't require a new choice simply runs.

That doesn't mean the activity is completely fixed. The machine can use feedback, make adjustments, and respond to ordinary changes while continuing the same operation.

But suppose you discover that the parking space is reserved.

Now there's a new problem. You might leave, look for another space, or decide to stay.

The new information may require a new choice.

And when a new choice is required, the machine runs again.

Not because a person consciously decided to activate the machinery. The choosing process doesn't require consciousness to supervise it.

And not because every piece of sensory information automatically starts a new run. Much of that information is simply used to keep the current operation going.

 

THE MACHINE DOESN'T NEED YOUR PERMISSION

People often talk as though there's a conscious person inside the head, supervising behavior and deciding when to intervene.

But the machine doesn't wait for conscious permission.

You can recognize someone's voice, move your hand away from something hot, adjust your balance, or perform a familiar routine without consciously directing each operation.

And choosing itself doesn't have to be conscious.

You may become aware that you've decided something without knowing exactly how the decision was produced.

Consciousness can be part of the experience, but it isn't a little manager sitting above the Commit Gate.

The machinery operates whether or not you're watching.

Some automatic bodily responses don't involve choosing a trajectory at all. Others are part of carrying out an existing commitment. Still others may involve a new choice without the person being consciously aware of it.

The important distinction isn't conscious versus unconscious.

It's whether new choosing was required.

 

WHAT ABOUT WHEN SOMEONE CHANGES THEIR MIND?

Suppose you decide tonight that you're going for a run tomorrow morning.

You put your shoes by the door, set your alarm, and go to bed.

Tomorrow arrives. You slept terribly, your legs hurt, and it's raining.

You stay home.

Someone might say you lacked discipline, failed to follow through, or didn't really want to exercise.

But the machine that made the decision last night wasn't operating under the same conditions as the machine evaluating the morning.

The new information changes the projected costs of the available futures.

Running may now be more expensive than staying home.

If a new choice is required, the machine evaluates the alternatives and commits again.

That doesn't make the original commitment imaginary. And we don't need to invent a special mechanism called failure to explain the new behavior.

The machine made a commitment under one set of conditions, then encountered another set of conditions and made another commitment.

Of course, sometimes the machine attempts something and doesn't accomplish it. You can try to catch a falling glass and miss. That's an outcome, not evidence that you secretly committed to dropping the glass.

Gravity doesn't need its own pancake.

 

THE SAME BEHAVIOR, DIFFERENT MACHINES

Now imagine a meeting where a manager criticizes a proposal.

Three employees say nothing.

The first employee thinks the manager is wrong but anticipates that arguing will create more problems than it solves.

The second agrees with the criticism and sees no reason to speak.

The third hasn't decided what to say yet.

Same meeting. Same criticism. Same silence.

Three different machines.

And we haven't even considered the employee who's distracted because they're thinking about lunch.

The observer sees the behavior, but not the internal evaluation.

This is why statements like "She was silent because she's intimidated" or "He didn't respond because he doesn't care" can be so unreliable.

They might be correct. But the behavior alone doesn't establish them.

The machine's internal priorities, memories, forecasts, and projected True Costs aren't printed on the person's forehead.

Which is inconvenient, considering how confidently humans interpret one another.

 

DIFFERENT BEHAVIORS, SAME PROBLEM

The reverse happens too.

Suppose two people anticipate social rejection.

One starts talking more. They explain themselves, offer additional information, make jokes, and try to repair the interaction.

The other withdraws. They stop talking, avoid eye contact, and leave as soon as possible.

From the outside, these people appear almost opposite.

One moves toward the interaction. The other moves away.

But both machines may be trying to solve a similar problem.

The controlling pancake establishes the regulatory priority, but it doesn't prescribe a single behavior. The Forecast Chamber develops possible trajectories, and the Commit Gate evaluates their projected True Costs.

One machine may anticipate that talking will reduce the cost of rejection.

Another may anticipate that leaving will.

The same problem doesn't necessarily produce the same behavior, and the same behavior doesn't necessarily reveal the same problem.

This is one of the reasons comparing people by their visible actions can be misleading.

 

THE DASHBOARD CHANGES HOW BEHAVIOR LOOKS

Even after a commitment is made, the machine's current operating conditions matter.

A person might explain something calmly in one situation and speak rapidly in another. They might perform a familiar task easily under ordinary conditions but have difficulty adjusting when they're exhausted or highly activated.

The Dashboard describes activation and recovery characteristics, while the Execution Arm carries out the trajectory.

But we have to be careful about what we infer from the resulting behavior.

A person can look calm while experiencing substantial internal activation. Another person can speak loudly and enthusiastically without being particularly distressed.

Silence doesn't prove composure. A raised voice doesn't tell us exactly what's happening inside the machine.

Behavior is observable. Activation is not necessarily observable in the same way.

And the two shouldn't be treated as interchangeable.

 

THE STORYBOARD ARRIVES WITH AN EXPLANATION

Suppose someone interrupts a conversation.

Later, when asked why, they say, "I was just trying to help."

Maybe they were.

Maybe the interruption was driven by urgency, impatience, concern about losing their opportunity to speak, or an expectation that the other person was about to make a mistake.

The person may sincerely believe their explanation.

But the Storyboard's account isn't necessarily a complete record of the machinery that produced the behavior.

The Storyboard organizes what happened into a story that makes sense to the machine. That story can become part of what the person remembers and uses in future situations.

It doesn't have to be a deliberate lie to be incomplete.

This also applies when we explain our own behavior.

We may have much better access to our intentions and experiences than an outside observer does, but that doesn't mean we can inspect every process that contributed to a commitment.

The explanation comes from the machine too.

 

AND THEN ANOTHER MACHINE SEES IT

Here's where behavior becomes especially interesting.

One machine produces an output.

Another machine detects that output through its own Antenna.

And what the second machine detects isn't necessarily what the first machine intended.

Imagine someone saying, "Do you need help?"

The speaker may be offering to make a task easier.

The listener may detect an implied judgment that they aren't capable of doing it themselves.

The same sentence enters two different machines with different expectations, histories, and priorities.

The listener's machine now has its own problem to solve.

It may commit to accepting the help, declining politely, becoming defensive, ignoring the offer, or explaining that everything is under control.

That response becomes new input for the first machine.

And now we have two machines generating behavior in response to one another, each evaluating its own futures through its own projected True Costs.

This is how a perfectly ordinary interaction can become surprisingly complicated without either person deliberately trying to create a problem.

The machines don't exchange their internal calculations.

They exchange behavior.

 

WHY BEHAVIOR ALONE ISN'T ENOUGH

When someone repeatedly does something we dislike, it's tempting to conclude that we've identified the problem.

They're selfish. They're stubborn. They're controlling. They're emotionally immature. They're just that kind of person.

But those descriptions don't tell us what the machine detected, what it anticipated, or why one trajectory became preferable to another.

They describe the behavior, or our judgment of it, without necessarily explaining the mechanism.

And knowing the mechanism doesn't mean we have to approve of the behavior.

Someone can repeatedly impose costs on other people. Someone can ignore important consequences. Someone can produce behavior that's harmful, irresponsible, or extraordinarily inconvenient.

The fact that the behavior came from a machine doesn't make the consequences disappear.

It just means that if we want to understand why it happened, we have to look beyond the output.

Which brings us back to the original problem.

We can see what people do.

We can see what happens afterward.

We can even ask them why, although that generally means requesting a report from the Storyboard.

What we can't do is look at the behavior and assume we've seen the whole machine.