Observations — 0002 // OODA loops and the Latency Game

This essay is a continuation of a previous one: Observations — 0001 // AI transformation.

In the 1970s and 1980s, a former fighter pilot named John Boyd began a rigorous study of how dogfights are won and lost.

He came up with a simple conclusion. Each competing pilot essentially runs a loop:

1. Observe → register their position, speed, ammo status, visibility, aircraft damage, etc.
2. Orient → enumerate the options given the observed reality: speed up, slow down, switch to guns, radio for backup, eject?
3. Decide → pick an option
4. Act → execute on the decision

…then repeat.

Boyd’s conclusion: whichever pilot could execute this loop fastest would win the fight.

Why?

Because the faster-moving pilot would essentially make their opponent’s whole perception of reality obsolete — before they had time to update it.

The OODA loop is not new. It changed how pilots are trained. It’s the underlying philosophy of high-frequency trading, and many other speed-driven fields.

And it’s always had a philosophical application to business.

What IS new — the sea change in 2026 — is that the philosophical application is becoming literal.

You could already think of your company as a system of loops:

• Customer feedback comes in → decide importance and reaction → execute
• New idea → test it → kill or double down
• Monitor regulatory changes → analyze → comply

In 2025, all of these loops still required humans.

In 2026, humans are leaving the loops — at least, their current ones.

The future is already here in software development. Some real examples of fully-agentic loops I’ve seen in the last few weeks:

1. Scan GitHub for trending open source projects
2. See if they could make our tech stack better
3. If so, apply them to our codebase

And:

1. Monitor all user interactions on the site
2. See where there is friction
3. Design and implement fixes

And:

1. Monitor Reddit for demand signals
2. Design software to meet the demand
3. Programmatically sell it

People are still constructing these loops (though not always). But increasingly, with agents, they are no longer needed to run them.

This has a somewhat insane implication: companies can now make decisions faster than the humans that run them.

Agentic loops have theoretically unbounded speed: much faster than human perception. The only governors are real-world tasks, and humans’ desire for review and control.

If you’re not a software developer, you may not be feeling this yet. But as ‘software’ and ‘knowledge work’ become synonyms… you will.

My take is that we’re all playing a new game now:

• Companies aren’t just companies anymore — they are systems of loops
• The more humans you can remove¹, the faster your loops can go
• The company with the fastest loops gets the edge

I’ve been thinking about this as the Latency Game: whoever has the lowest latency, wins.

Most companies are structurally set up to fail.

To see why, let’s return to the OODA loop, and compare two companies: one set up to win the Latency Game, and one that is not.

Note this isn’t speed at the expense of judgment — a faster loop also learns faster, because every cycle updates the company’s picture of reality.

Past waves of automation were all about trying to economize on human labor. That is not the goal this time (though it may be a side-effect). The goal is to increase the speed at which your company can execute and react.

Level 3 companies see this already, even if they haven’t named it as such. It’s why they’re willing to stomach high upfront costs in terms of organizational transformation, data unification, talent acquisition, and raw token costs.

This is also why the companies that try to justify AI transformation in dollars and cents will fail.

So if we’re all playing the Latency Game, how do you construct your company to win?

This is the question that everyone is racing to answer. I don’t think anyone has the answer yet, though I believe some companies are getting close to a good shape. As Jeff Huber put it in a fantastic X post:

“The constraint has already shifted from reasoning to context; and the firms that are quietly rebuilding themselves around that fact are doing so now, while everyone else argues about whether the models are good enough.”

Philosophically, the reframe is: start thinking of your company as code, and build accordingly.

Practically speaking, that leaves a lot of unanswered questions.

For the last 6 months, I’ve been personally obsessed with this idea of company-as-code. To get closer to the metal, I’ve actually made a few attempts at coding an agent-native company from scratch. It’s been extremely revealing — I will try to do a full tactical writeup in a future post.

These experiments have led me to conclude there’s a missing piece of every company stack — something I’m thinking of as the Company Harness.

My next essay will be my thoughts on the Company Harness — the key primitives, the shape, and how this is different from a company brain.