Introduction

Every once in a while, the past taps you on the shoulder and says, “Hey… you sure you’re not doing the exact same thing again?”

I’ve been feeling that tap lately. And if you lead insights, build insights tech, or depend on insights inside a brand, you probably have too.

Because your week sounds like this:

• “We need an answer by tomorrow. Also, can you make it global?”
• “Great deck. So what do we do?”
• “Can AI do this faster, safer, and cheaper, while also keeping Legal calm?”

Same pressure. New tools.

Back in the early 1980s, I was an IBM 370 operating system support programmer at Emory University, building and optimizing in Basic Assembler Language. That meant living in a world where “fast” and “painful” were separated by microseconds. When you made a mistake, it did not fail politely. It failed loudly. Like “why is the whole campus printing gibberish at 2:00 a.m.?” loudly.

Fast forward to today. Teams are racing to adopt generative AI, building agents, workflows, and new operating models for work that does not behave like neat input and output diagrams. Requests are messy. Priorities shift. Context arrives late or never. And the “user” might be a person, a system, another agent, or a Slack message that reads like a fortune cookie written by someone in a hurry.

Different era. Different tools. Same challenge.

How do you build an ecosystem that supports many users, many workflows, and many decisions, without turning into chaos with better branding?

The real parallel: ecosystems beat heroics

The IBM 370 was not one program. It was a platform that let many applications run at once, for many users, with sub-second response time. The OS work was not about building an app. It was about creating the conditions for all apps to succeed.

That required obsession over scheduling, prioritization, memory, I/O, and stability under unpredictable demand.

Sound familiar?

In 2026, we are trying to do the same thing, but the shared resource is not just computing. It is cognition. Models, context, tools, and trust.

The old question was: How do we allocate CPU, memory, and I/O across simultaneous workloads and still stay responsive?

The new question is: How do we allocate context, tool access, guardrails, and confidence across simultaneous requests and still deliver reliable outcomes?

Same game. New pieces.

Why things break: contention and variance

In the mainframe world, contention looked like memory pressure, CPU saturation, queue buildup, lock contention, and one runaway job consuming the world.

In the agent world, contention looks like tool bottlenecks, context overflow, duplicated work, runaway reasoning, quality collapse under volume, and hidden costs multiplying quietly.

The difference is that in the 370 era, you could see the system struggling in metrics and queues.

In the AI era, it is sneakier. The system still “runs,” but the output drifts, people redo the work, and leadership wonders why productivity did not magically double.

That is not a model problem. That is an ecosystem problem.

Four OS lessons that make AI relevant to brands and agencies

1) Scheduling becomes orchestration

On the 370, scheduling determined who got CPU time and when.

With AI, orchestration determines:

• which agent runs first
• which tools it can use
• when it should stop
• when it should hand off
• what gets escalated to a human
• what can be batched
• what needs immediate turnaround

Stakeholder translation: orchestration is the difference between “we acted in time” and “we got a deck after the decision.”

If you do not orchestrate, you do not have agents. You have a room full of talented interns shouting over each other.

2) Memory management becomes context management

Assembler teaches you respect because the machine punishes you instantly.

AI teaches you respect because it will confidently improvise when you forget to give it the right context.

Context discipline means:

• what does the agent need to know
• what can it fetch just in time
• what should be summarized

If you stuff everything into the prompt, you do not get intelligence. You get confusion with a larger invoice.

3) I/O optimization becomes tooling and data access

Back then, I/O was the bottleneck.

Today, the bottleneck is permissions, messy data, inconsistent definitions, noisy search, and workflows that require ten approvals to do one simple thing.

You can have the smartest agent in the world. If it cannot access the right data quickly and safely, it is a genius locked outside the building.

4) Reliability engineering becomes guardrails and observability

On big systems, you built monitoring, alerting, recovery routines, and predictable failure modes.

In AI terms, that becomes guardrails, evaluations, red-teaming, confidence thresholds, human review points, audit logs, and “why did it do that?” traces.

If you cannot observe it, you cannot trust it. If you cannot trust it, you will not scale it.

Agents that “think for themselves,” now add an octopus

Jonathan Brill and Stephen Wunker, in AI and the Octopus Organization, make a point that matters for every brand leader and agency builder: AI is not just a tool layer. It is an operating model redesign.

Their octopus metaphor works because it holds two truths:

• autonomy at the edges creates speed and relevance
• coordination across the whole organism prevents chaos

Here is the practical version.

Give each agent an “agent charter,” one page, six bullets:

• purpose and the decision it supports
• inputs and what “messy” looks like
• tools and data it can access
• guardrails, what it must never do
• escalation rules, when a human steps in
• definition of good, how you score quality

That is it. Enough structure to move fast without emailing 8,000 customers the wrong answer. Which is the modern version of printing gibberish at 2:00 a.m.