Personal agents like OpenClaw, Hermes, Claude Code, and Codex are the first clear glimmers of that new personal computer. They have powerful capabilities, but their chat-based interfaces leave users stuck in the MS-DOS era.

Users understand this and they already want a better interface. From that viral essay by a Claude Code team member, to tweets from Karpathy and sama, to a16z’s latest request for startups, it seems like lately everyone’s talking about the need to move beyond chat and embrace things like HTML artifacts.

That’s why we created Television. It’s the missing GUI for your personal agent. It works with any agent harness, giving you virtual screens on which you and your agent can create and work with visual HTML artifacts. Artifacts can be anything from static visualizations, to editable documents, to entire vibe-coded web apps. Your agent uses the Television skill to create and modify artifacts on your TV, based on your requests and needs.

Television is useful for computing tasks that don’t fit with an infinitely scrolling stream of text. Turns out that’s a lot of tasks, which is why so much of computing moved to the GUI forty years ago. A few examples include dashboards, agentic coding, online research, long-running projects, working on documents, and interacting with web apps and services. But there are loads more just waiting to be discovered.

We think Television is the start of a new kind of user experience, one built less around fixed apps and more around reusable skills that can generate interfaces as needed. It’s a first step toward freeing users from the constraints of traditional software.

Recently, the Nous Research team invited us to demo Television for the over 250 people in the Hermes community. The response echoed what we’ve been hearing from early alpha users: Television is a much-needed new way to work with agents, and an early glimpse of a broader shift in how agentic software is experienced.

Television will be open source, but right now we’re doing invite-only alpha testing. To join the wait list, visit television.run.

Why did we create Stash? Our work on Telepath involves a lot of agents, not just inside our products but also inside our startup. We’ve moved most of Telepath’s internal documents and data into Markdown, and built agents that use Claude Code and OpenClaw to manage team priorities, tasks, coordination, and all the operational stuff that keeps us moving forward. These agents run across multiple machines and environments, both local and remote, and they read and write to shared sets of files constantly.

One problem we kept running into was keeping all these shared files in sync. It showed up in a few different places for us:

• Agent configuration across environments. We have skills, memory files, and documentation that need to stay in sync between a remote OpenClaw instance and a local machine running Claude Code. When an agent learns something or a skill gets updated, that change needs to propagate everywhere without anyone thinking about it.
• Coordination between remote agents. We use our own agentic development platform Thopter Swarm to orchestrate swarms of agents working on a problem together. They share a folder of temporary planning files, artifacts, and coordination state that multiple agents are reading and writing to concurrently, sometimes within seconds of each other.
• Company docs that live in multiple places. We wanted our shared documentation to be browsable on GitHub, accessible from remote environments, and editable locally in whatever tool we feel like, whether that’s an AI code editor, Obsidian, or just vim. The same files, everywhere, always up to date.

Git is great for source code, but it’s a poor fit for files that are being continuously edited by multiple machines and processes — and agents would often forget to sync. Tools like Dropbox, iCloud, and Syncthing handle continuous syncing, but they choke on conflicts — their resolution strategy is basically “here are two copies of your file, good luck.” Plus, they’re a pain to set up in remote environments where you already have Git credentials.

So we built Stash. It’s a little tool that syncs a directory to a GitHub repository, automatically and continuously, using the same conflict-free algorithm as Obsidian Sync. The neat thing about GitHub is that you probably have a token on all the machines your agents live on, and it gives you a GUI to view & share note links remotely. (Stash is sync provider-agnostic, so you can extend it to other endpoints too — we’re excited about the possibilities of peer-to-peer).

While Stash is a handy solve for a problem we’re having with agents now, it’s also part of an ongoing exploration on the future of agentic filesystems.

Files are fantastic — long-lived, interoperable, and (it turns out) a surprisingly good foundation for a new breed of genuinely useful agents. But when it comes to our vision of a sensemaking computer, there are additional layers of indexing, meaning-making, versioning, and collaboration that feel increasingly necessary. Stash is a small and practical piece of this larger effort on our path to a new kind of personal computer.

Stash is open source and available now at github.com/telepath-computer/stash.

You might argue we’re already doing this as an industry: we’ve spent untold billions on frontier models; hype is at fever-pitch; and it seems every app on your computer now has a chat sidebar, soon to be home to an uber-capable AGI.

But I fear we are still missing answers to some basic questions, like: what does an AI-native computer actually look like? What does it feel like? How do I use it? With a truly revolutionary technology, iteration can only take you so far — in order to leap towards this future as an industry, we need a clearer vision of it.

I’ve seen the power of collective imagination that a well-defined vision can unlock. At Google Creative Lab, demos I gave turned into experiences we shipped to millions of users. At Adept, a prototype our 3-person design team showed one Friday afternoon led to a tectonic shift in company direction by Monday morning.

So a few months ago, we at Telepath set out to create a compelling demo of what an AI-first personal computer will actually look like. (We’re trying to build one, after all.) My co-founder Stephen Hood presented it at Betaworks this past November, and you can watch it here:

The generative interface

The Telepath Computer has no apps. Instead, its interface is generative, meaning that a significant portion of the user interface is synthesized and/or composed on the fly in response to user intent.

The primary benefit of a generative interface is that it closes the gap between intent and outcome. For many tasks, it’s easy to express our goal in natural language and have the computer work out the exact steps to achieve it. It’s much harder to find the right app or multiple apps and perform all the steps yourself (assuming the software actually works the way you need).^[1] A generative interface means the space of possible actions, and the possible ways information can be displayed, is infinite.

This doesn’t come without challenges: the greatest risk for a generative interface is disorienting the user. Good software design gives users a conceptual model of the system, so they can accurately predict what will happen when they perform an action^[2]. If we allow an agentic system free reign over our computer screens without structure or constraints, aren’t we setting our users up for a chaotic and unpredictable environment? How will they know what they can do, and what will happen when they do it?

One solution is to package up generative software in app-like bundles, and try to keep the same metaphors we have today. (In other words, a generative UI just means anyone can generate their own app.) This approach is tempting, and we’re already seeing several startups coalescing around it. However, it’s ultimately a skeumorphism that commits us to the familiar idea of software as discrete shippable things, instead of something that exists everywhere all at once.

Instead, the Telepath Computer interface solves this problem by having well-defined “laws of physics”. It provides a logical structure: a magnetic 3D space of cards, upon which generative interfaces are rendered. Each card adheres to the same conventions and behaves the same way within the space. Cards can be grouped into workspaces and stacked into collections to revisit later. Each has a command bar at the bottom, where users can discover further functionality.

While this structure was sufficient for the demo workflow, it must ultimately extend into many more areas. How do I organize and file away objects long-term? When the system kicks off an asynchronous task, how do I see it and know its status? How do I interact with specialized interfaces, like for editing video or creating a CAD drawing? These questions were deliberately out of scope for the demo, but we’re already addressing some of them as we begin to translate our vision into working software.

Voice & multi-modality

If there’s one thing that came up overwhelmingly when we surveyed science fiction, it’s voice input. From Her to Star Trek, it’s clear we humans love to fantasize about talking to our computers. It turns out there are good reasons for this (beyond being more fun to watch than someone typing).

Voice gives us an additional stream of information for input, one that can happen concurrently with direct manipulation using a keyboard, mouse, or touch. With the Telepath Computer, you can touch and type for tasks where control and accuracy are important, while simultaneously using your voice to direct the computer. This mimics our natural behaviour in the physical world: for example, imagine cooking a meal with family or friends, asking someone to fetch the basil or chop the onions while your hands are busy with the pasta.

Up until now, voice has been unusable for most serious computing tasks. But with near-perfect speech recognition^[3], and agents that can interpret our intent and act for us, we can finally bring this multi-tasking to our digital world too. Already our user research shows participants are increasingly comfortable with voice, using it as a high-bandwidth, low-structure input mode, dictating thoughts or instructions to then process with language models. I expect this usage to expand over time, as we design systems specifically for it^[4].

Using voice as an additional information stream is also useful when it comes to output. The Telepath Computer speaks through voice, while simultaneously displaying documents and information for the user to reference and interact with. This “show and tell” approach is also present in how we tend to communicate complex information in the real world: sketching on a napkin as we discuss a problem with a colleague over dinner; design teams assembling stickies while talking about user feedback; pulling up maps and hotels on your laptop while planning a group vacation.

The benefits expand dramatically when your computer is also context-aware. A context-aware computer knows where you are and what’s available to you: step back from the screen or pick up a sketchbook and it shifts to voice; go for a walk and you can work as effectively as when you’re sitting at a desk. Generative software can morph itself into whatever modality and form is suitable for the current situation, which has profound implications not just for productivity but for accessibility and quality-of-life too.

Deep personalization

At the outset of the demo, Stephen says to the computer: “Hey, catch me up.”

To respond to this effectively, the computer needs a model of the user and their information landscape. This is deep personalization: the ability to make sense of the user’s digital world, construct a model of them, and assess all new information and all generated interfaces against that model.

One discovery we made during our design process was that deep personalization is not just a useful feature for agentic action-taking; it’s also a requirement for an effective generative interface. Our interfaces today show us everything: every email, message, note, webpage, document, and notification, constantly pouring unfiltered into our screens for us to handle manually^[5]. But a generative system must make editorial decisions about what to include, what to leave out, and how to present information to maximally align with the user’s goals.

In order to do that effectively you need a deep understanding of the user, otherwise the system is bound to make decisions that either remove important information, or highlight something irrelevant. As such, any good generative UI will depend on a sophisticated user model with sufficient depth that it can accurately and predictably make these predictions. This goes beyond simply “memory”, instead pointing towards something that is constantly updating itself based on new information and past performance, that understands what’s recent and what’s outdated, and that can represent different structured facets of the user’s world like ongoing projects, relationships, and personal preferences.

Without this, a generative interface cannot truly close the gap between intent and outcome. It can only guess.

Process & acknowledgements

We created this demo through a process that combined equal parts evidence and imagination^[6]. First we interviewed computer users to identify problems that presented themselves as fundamental to the computer use generally, then zeroed in on specific knowledge worker use-cases. We combined insights from these interviews with our own forecasts of technology trends (especially around voice input and local models), researched prior art, and watched a bunch of sci-fi. Then we began sketching the first concepts and iterating on our designs with user feedback, finally partnering with Territory Studio for the animation and visual effects.

It’s important that I acknowledge some of the work and people that inspired us during our research:

• The Apple Knowledge Navigator concept, a great example of the creative power a product demo can have. It predicted the web, voice assistants, and touch-screen tablets long before any of these existed. (We have yet to innovate on putting bow-ties on agents, but it’s surely just a matter of time.)
• Mercury OS by Jason Yuan, a speculative vision for a fluid, intent-driven operating system based around modular panels that was well ahead of its time, and influenced Telepath’s card metaphor.
• Desktop Neo by Lennart Ziburski, which was a great example of how to take emerging capabilities (multi-touch, voice control) and design for them from first principles
• The film Her. Not for its depiction of AI (some things we don’t want to emulate…), but rather its humanistic, depth-based, textural screen design which influenced our visual language for the demo.
• Matt Webb, whose thinking on conversational interfaces helped shape our “show and tell” metaphor and our emphasis on using voice and direct manipulation in concert.

Also thanks to Scott Jenson, and Josh & Stephen my co-founders, for their helpful feedback along the way.

I hope this work encourages others in the industry to consider an optimistic vision of what they want this technology to look like in a user’s life — with more clarity and fidelity than “AGI” — and to share it broadly to the world so we can discuss and create this exciting future together, in the open.

If you’d like to follow along with Telepath’s progress on making our vision a reality and get access to early releases, you can do so here.

Let’s back up: for as long as I can remember, I’ve been obsessed with computers, fascinated not just by what they can do but what they could become. Like many, I took my early inspiration from science fiction. I dreamed of someday having something like the Enterprise’s computer. And why not? Science fiction has always driven scientists, engineers, and inventors to create real things that change the world.

As the years went by we got some of the futuristic stuff we dreamed about: a global information network, powerful mobile devices, interactive touch surfaces. But our computers? They stayed stuck, not intelligent but stubbornly dumb, unaware of us and our needs.

Then along came LLMs. It seemed immediately obvious to me that the real breakthrough of this newest wave of AI wasn’t what it could generate, but rather all the things it could now understand. While I was still at Mozilla I wrote and spoke about the inevitable, exciting consequences: the collapse of today’s computing stack and the chance to create something even better in its place. It seemed certain I was finally going to get my Enterprise computer, or at least something like Apple’s fictional Knowledge Navigator.

But that’s not what happened. Instead, we immediately started grafting AI on top of the same interfaces we’ve already been using for over 40 years. Suddenly, every app has its own separate AI sidebar or copilot, each of them slightly different in capability or scope. Meanwhile we’re burning megawatts of power to have intelligent agents… uh, move mouse pointers around our screens and click on things?

The problem is that we’re just building hybrid cars. That is, we’re taking a mature but largely played-out platform (the GUI) and bolting on a new technology (AI) in order to wring out every last drop of additional value that we can.

Hybrid cars have their place. You can sell a lot of them. But they aren’t the future; they are at best a bridge to it. They are the obvious thing that you build when you don’t want to actually change anything.

It’s time to start building EVs. We need to stop stubbornly clinging to today’s computing stack and its metaphors, and create something that’s native to the world we now actually live in. Until we make that jump we’ll never fully realize the potential and power of a computer that can understand us and our needs. And until we can demonstrate a positive, optimistic vision for AI in our daily lives, people will rightfully continue to be skeptical of it.

That’s the mission of my new startup, Telepath. We’re building that metaphorical EV: the software stack for a new kind of computing experience, freed from decades of accrued assumptions, powered at its core by machine intelligence but employed in the service of individuals. We aren’t really an “AI company”, and we aren’t chasing AGI. We see AI as normal technology, just one that carries an unusual level of both promise and peril. Used wisely and responsibly, this technology has the potential to elevate our computers and unlock a revolution even greater and more exciting than the move from CLI to GUI forty years ago.

I’m proud to be taking this journey with my brilliant friends and co-founders Josh Whiting and Rupert Manfredi. We all worked together at Mozilla, where I led open source AI and founded projects like Llamafile. Between us we have five startups worth of founding experience, and companies like Google, Adept, Mozilla, and Yahoo under our belts. We have a clear vision of the future (you can get a sneak peek of it here) and a plan for getting there. Our investors include Betaworks, True Ventures, Mozilla Ventures, RRE, Fermont Capital, Joshua Schachter (del.icio.us), Thomas Wolf (Hugging Face), and Ari Weinstein (OpenAI), with more to be announced soon.

If you share our optimism about the future of computing, I hope you’ll join our waitlist and keep tabs on our progress.