There is a story Stephen Hood likes to tell about the set of Star Trek: The Next Generation.

It is 1989. Actor Wil Wheaton, who plays the teenage prodigy Wesley Crusher, occasionally pilots the Enterprise. On the show that means sitting at the helm and tapping a flat black panel covered in glassy slabs and abstract symbols. Star Trek’s famous LCARS interface. There is no stick, no yoke, no instruction manual. So Wheaton invents his own gestures: a flick here, a tap there, a small flourish to indicate course correction. After a while, he starts to wonder if he is doing it wrong.

He finds the production designer, Michael Okuda, and asks. Okuda has spent years building Star Trek’s visual language; if anyone knows the right way to fly a starship, it is him.

Okuda tells him there is no right way. In the future, the interface will adapt to the user. Wheaton’s gestures are correct because they are Wesley’s gestures. When other actors take the helm, theirs will be different, and that won’t matter.

That was 1989. The Mac was five years old. The web was two years away. There were no smartphones, no broadband, no machine learning to speak of. And a television production designer, working out the logic of a fictional starship, had articulated something that most of the actual computing industry would spend the next thirty-seven years reaching for.

Stephen Hood thinks about this story a lot. Telepath, his fourth startup, was founded late last year with Rupert Manfredi and Josh Whiting, two former colleagues from Mozilla, where he had previously led open source AI work and helped ship a project called Llamafile. He keeps vintage computers on his desk. He talks about the history of personal computing the way some people talk about jazz.

What he sees, when he looks at the modern computer, is a Jenga tower.

“It’s an unstable, wobbly, tall structure that we built over decades of accrued assumptions and decisions,” he says. The desktop, the windows, the icons, the menus. None of it is the platonic ideal of how humans and machines should interact. It’s just what got built, decision by decision, working around the limitations of the machines available at each step.

It was also working around the fact that people did not know what a computer could do, and were a little afraid of it. Designers borrowed from the physical world to make the machine feel familiar: the screen became a desk, files became paper documents stacked in folders, deletion became a trash can you dragged things into. The conceit was that you were not really using a computer. You were sitting at a desk, moving objects around. It made the machine discoverable for people who had never used one.

One of Hood’s advisors is Scott Jenson, who joined Apple’s Human Interface group in the late 1980s and went on to work on design for Google, and Frog Design. At the Ubuntu Summit last year, Jenson argued that desktop UX has not meaningfully changed in twenty years. The interface most of us still use, he pointed out, traces back to the Xerox Star prototype from 1981; everything since has been a copy of a copy. His complaint was not that the metaphor was wrong. It was that desktop design had always evolved by copying the previous generation, and the field has now spent two decades copying itself.

Hood’s argument goes further. He thinks the conditions that produced the desktop metaphor in the first place no longer hold. Most computer users today have grown up with computers; they don’t need a metaphor to picture what a file is. The metaphor solved problems we mostly don’t have anymore. And the machine can now respond, observe, and adjust in ways it couldn’t in 1984.

But the industry’s first instinct, having been handed this new capability, has been to put it inside a chat box.

Hood finds this insufficient. “Everything is based around chat today,” he says. “Even things like Cowork, which is a great, amazing project. It’s still fundamentally a chat experience.” He is not knocking the projects. He is pointing out that chat is what we have because it is the easiest thing to ship, not because it is the right interface for what is actually happening underneath. He calls it a return to the command line.

The problem with a chat log, in Hood’s view, is that it flattens everything. Every project, every task, every half-finished thought becomes a line in the same scrolling ticker. A linear scrolling log. People try to use chat threads as projects, but threads don’t really map to projects. They accumulate, drift, get abandoned, mix together. Information you needed an hour ago becomes hard to find again. Context evaporates.

He thinks the next interface will be non-linear and persistent. A visual space, not a transcript. A canvas where information can be pinned, organized, and revisited; where the agent and the user share a workspace that keeps existing whether or not anyone is currently looking at it. Some projects don’t get finished in a single sitting.

This is also where Wheaton’s hand gestures come back. The interface, Hood argues, should be built from primitives that are common across users, but how those primitives are arranged, what stays open, what gets surfaced when, should be tuned to the individual. Not because the user vibe-codes a new layout from scratch every morning, but because the system has long-term memory that accrues. It remembers what you do. It anticipates. It rearranges itself, slowly, to fit you.

Mike Okuda asserted in 1989, with no machine learning and no LLMs and a budget for plywood and gel filters, that interfaces would one day work this way. What Hood is building, as a first product, is narrower than what Okuda imagined: a screen that rearranges itself around how you work. The fuller vision is multimodality, voice, a computer that meets you wherever you are, but the visual interface is where you start, because today’s personal agents are the closest thing to a runtime for it. Importantly, it is the first time the underlying claim, that the interface should bend toward the user rather than the other way around, has been a buildable claim rather than a science-fiction conceit.

Telepath’s first product is called Television. It is narrow — a visual client for agents like OpenClaw, Hermes and Claude Code currently — but it points at the larger idea. As you talk to the agent, the agent generates visual artifacts in a persistent canvas. Things you can move around, resize, return to. Not a chat log dressed up as a UI, but a workspace that the agent and the user manipulate together.

Hood is clear that Television is a starting point. It is built for developers and enthusiasts; the mass market version is a much longer road. He compares the current state of personal AI agents to the Altair 8800, the 1975 kit computer that was, in some sense, the first personal computer you could buy in a box. The Altair had no keyboard and no display. You programmed it by flipping switches on the front panel and reading lights. It was unapproachable and prone to behaving in unexpected ways. It was also a turning point.

The other comparison Hood reaches for is the Apple I, which Steve Wozniak demoed at the Homebrew Computer Club in 1976 as a bare motherboard. You had to supply your own monitor, your own keyboard, your own case. The initial audience was enthusiasts. The trajectory was everyone. Hood is betting on the same arc.

The shape of what they’re building has shifted once already. When Hood founded the company, the plan was to build a series of standalone apps that worked alongside existing tools, hedging against the slow arrival of better infrastructure. Then, in the months that followed, model capabilities and agent harnesses improved enough that the hedge stopped being necessary. They could move higher up the stack faster.

Telepath is one of a handful of teams trying to figure out what comes after the chat box. The reason this matters is that interfaces are sticky. The desktop metaphor was built for people who had never used a computer, and we are still using it in 2026, because once a few hundred million people learn an interface, replacing it is a massive challenge. Whatever paradigm gets locked in for AI agents over the next few years is likely to shape how people interact with computers for the next thirty.

If that paradigm turns out to be the chat box, we will have replicated the command line and called it progress. If it turns out to be something else - persistent, visual, adapted to the user - we will have done something the industry has been theorizing about for nearly forty years and has never actually shipped.

The labs building the underlying models are clearly aware the chat box is a stopgap, as are the application companies trying to wrap agents in something more usable. Which paradigm wins will be decided in the next few years, mostly by which early products people actually keep using. The chat box is the incumbent. So was the command line.