Headless vs Headful: Why Computer Use Survives an Agent-Run Internet

There's a clean story about where agents take us. As they get better, the work moves under the surface: agents call APIs, drive headless browsers, talk to each other, and the messy human interface, the screen with its fields and buttons, fades into the background. I understand the appeal of that story. I just don't think it's where we end up, and the reason has to do with how computers were built in the first place.

Key takeaways

• Headless software runs without a user interface (APIs, backends, headless browsers an agent drives). Headful software has a UI built for a person to look at and click.
• The common assumption is that agents push everything headless. But the internet and computers were built for people, so the screen is the default and the API is the add-on.
• APIs mostly exist on modern, developer-friendly platforms. Legacy, regulated, government, and long-tail systems often have no API, and never will.
• In regulated work the screen is also the control surface: the auditable path a person can check, which is its own reason it persists.
• That makes computer use, operating the UI the way a person does, structural for agents, not a temporary workaround.

what headless and headful actually mean

The words get used loosely, so a quick definition. Headless software runs without a user interface. It's the API, the backend, the script, the headless browser an agent drives in the background, with no screen rendered for anyone to look at. Headful software has a UI: the screen a person sees, with fields and buttons, built to be looked at and operated by hand.

Most of the agent conversation assumes the future is headless, that anything worth automating will eventually expose a clean, programmatic way in.

the internet was built for eyes and hands

That assumption runs into a simple fact: the internet and the computer were built for people with eyes and hands. The screen came first. The API came later, and only where someone decided to build one. Every website, every desktop app, every internal tool started as something a human was meant to look at and operate, and the programmatic interface is an add-on that a lot of software never gets.

Look at where APIs actually exist. The big, modern, developer-friendly platforms have them. The long tail doesn't: the legacy enterprise systems, the carrier and custodian portals in finance, the government sites, the internal tool a company built fifteen years ago and never touched again, the vendor with no reason to let you automate around its product. When I was building data infrastructure at a hedge fund, even the premium systems gave us partial access at best. People shared a single Bloomberg terminal and copied numbers off the screen by hand, because the API was too expensive for how rarely they needed it. That is not a corner case. It is most of the working world.

And it isn't only legacy. New software is still built UI-first, because humans are the ones who buy it, use it, and decide whether it's any good. A clean, complete API is something teams add when they have the time and the reason, which is often late and often never. So the headless surface stays patchy, even as everything else moves quickly.

the honest counterargument

The strongest case against me is that this changes: agent-to-agent protocols, a web that slowly rebuilds itself for machines instead of people. Some of that will happen, and where it does it will be great, because an API is faster and cleaner than driving a screen. But I'd be careful betting the whole future on it. Rebuilding the world's software to be headless is a decades-long project that much of it will simply never go through, for the same reasons those systems are still here: no budget, no incentive, too much risk in touching what already works.

There's also a quieter reason the screen sticks around, which is trust. When an agent does something that matters, in finance, in healthcare, in anything regulated, a person still has to be able to see what happened and check it. In regulated work the screen is more than a stubborn interface. It is the control surface: the validations, the approvals, and the audit trail live in the app, so operating it the way a human does keeps the agent inside them. (The practical side of that is in enterprise computer use and the agent trust framework.)

why computer use is structural

Put those together and you get a future where agents do an enormous amount of headless work and still hit a wall constantly: the system with no API, the portal only a human was ever meant to log into. There is one general way through that wall, which is to operate the screen the way a person does, by looking at it and acting on it. That is computer use. It doesn't disappear once everything goes headless, because everything is never going to go headless. As long as the world is full of software built for eyes and hands, an agent that can use a screen can work where an API-only agent can't.

This is the bet underneath what I'm building. Interfaces keep changing, from pixels to accessibility trees to whatever standard comes next, while the work being done underneath them stays the same. The screen is the one interface that is everywhere, and in regulated work it is also the one a person can audit. An agent that can use it the way we do can work across the whole world of software, including the systems that will never build a back door for machines. For a long time, maybe for good, that is where most of the work still lives.

FAQ

What is the difference between headless and headful? Headless software runs without a user interface, like an API, a backend service, or a headless browser an agent drives. Headful software has a UI: a screen built for a person to look at and click.

Why do AI agents still need to use UIs if they can call APIs? Because most software has no API, or only a partial one, especially legacy, regulated, government, and long-tail systems. Computer use lets an agent work wherever a person can, not only where a developer interface happens to exist.

Will everything become headless and agent-to-agent eventually? Some of it will, where there is budget and incentive. But a large share of the world's software will stay UI-only, and humans still need a readable interface to oversee and audit what agents do, so the screen sticks around.