The 'Windows' that AI agents are still missing

From WordStar to agents: the same old pattern

In the 1980s, WordStar and Visual Basic shaped an entire generation: one was run by memorizing key combinations, the other let anyone build an application by dragging buttons onto a form. Today AI agents revive that story. You write in natural language and the agent executes real tasks: it edits files, queries databases, deploys sites.

The most useful analogy is this: an AI agent looks a lot like a computer running MS-DOS. It's powerful, but only someone who knows the commands understands what's happening on screen.

Why an AI agent resembles MS-DOS

A modern agent already has almost everything that defines an operating system: memory that persists across sessions, file access, 'programs' that extend its capabilities, scheduled tasks and a connection to external services through a standard (in the AI world it's called MCP, and it plays the role Windows APIs once played: a common plug to talk to any tool).

What it still lacks to be a true operating system is three concrete things:

• Determinism: an operating system can't 'sort of' save your file; an agent is still probabilistic.
• Cost and latency: every agent action costs money and takes seconds, not milliseconds.
• Trust: that's why today we work with permissions and controlled environments, and rightly so.

The problem almost nobody names: observability

When one person coordinates several agents at once, a practical problem shows up: with five tasks running, you lose track of which one is doing what. And when you show the screen to a client, they see technical text scrolling instead of understandable work.

That problem has a name: observability. The good news is that the information already exists — every agent records everything it does in real time — what's missing is a layer that translates it into human language.

The solution is visual: the 'Windows' of agents

Windows didn't win because it did more than DOS: at first it did less. It won because anyone could see what was happening. The next big AI layer is exactly that: a dashboard that shows, for each agent, what it's doing right now, in one clear sentence.

In practice, a good agent dashboard answers three questions at a glance:

• What is each agent doing right now, in plain language?
• Which one finished and is waiting for a decision from me?
• Which one is stuck or needs a permission?

Simple rules aren't enough: Asimov's lesson

In 1950, Isaac Asimov published his Three Laws of Robotics. The interesting part is that his book isn't a manual, but a catalog of how those rules fail: three simple rules, applied literally, end up producing absurd results. The lesson, 75 years later, still holds: a handful of rigid rules isn't enough to govern a complex intelligence.

That's why responsible AI isn't based on three rules, but on layers: good baseline values, scoped permissions, controlled environments and — the final layer — human supervision. An observability dashboard is, quite simply, that supervision made visible.

What this means for your company

If your business is starting to use AI agents, the visual layer isn't a luxury: it's what makes the technology supervisable, explainable and trustworthy. Before scaling, make sure you can see and tell what the AI is doing.

• Demand visibility: any AI automation should be able to show what it did and why.
• Think about the client: showing the work in clear language builds trust and sells.
• Keep humans in control: the person decides; the AI executes and reports.
• Start small and measurable, just like any digital transformation project.

Further reading

I wrote a more personal version of this idea, with images and the story of the dashboard I built, on Farid's blog.