Hello! Rupert here from Unternet. I'm in Australia at the moment, and going deep on some product iteration, but wanted to share what's been going on the last few weeks.

Local-first conf

On my way over to Sydney, I attended the Local-First Conf in Berlin. Not the best way to get from the west coast of the US to Australia, especially if you enjoy sleep or need to be conscious the next day. But it was well worth it.

Local-First was a very energetic gathering of like-minded people, all actively building a future of computing where users have real agency over their computers (which is deeply in the vibe wheelhouse of Unternet). The local-first community is solving for ditching the walled-garden platform model of computing, and turning data into something portable that you own completely, all while retaining essential networking features like instant syncing, sharing, simultaneous editing, etc.

This is especially relevant to the future of AI – it's critical we don't create a future where a small number of platforms have a monopoly on our context, and refuse to share it. Also – the more open & interoperable we can make our documents and data, the more amazing experiences we will be able to create on top!

The real bottleneck for useful AI isn’t just model quality. It’s the walls around our data. A thread on walled gardens, economic incentives, and why even the best models can’t help us if they can’t see us. 🧵

— Chad Fowler (@chadfowler.com) May 30, 2025 at 7:05 PM

I had a bunch of conversations about syncing data, web-scale identity, writing a formal web standard spec, and the future of browsers. Shout out to the User & Agents organizers who put together a fantastic post-conference hack session (with some great demos by Dietrich Ayalla, Orion Reed, and others).

(BTW – talks just got published, so go check them out!)

Spreadsheets

New on the applets front, we've added a spreadsheet. (Meaning that I'm pretty sure web applets is now turing-complete?) Anyway, this is one of those tools that's fun to play with in the inspector, and will be especially useful when embedded in an environment with lots of context & data. You can easily hook it up to your app using our SDK.

Local applets & files

The upcoming build of our chat client supports adding local applets. That means you can build an applet into a folder on your computer (or just write a little html file), and instantly start using a new web applet without having to worry about hosting or local dev servers. That will make it way easier to create new tools for your workflows in our future releases.

We also have a bleeding edge feature where you can index local files on your machine. For example, you might want to add a folder of markdown notes as a resource that the client can search through (especially useful if you're an Obsidian user) – now you can. This one isn't fully baked, but is fun to try, and we'll be increasing reliability over time.

Interface experiments

I posted a series of gifs a few weeks ago of a new user interface I'm experimenting with for working across your apps, documents and the web, which I demoed at the User & Agents meetup. There's a bit more to say on this, and the future shape of our product, but I'll save that for next time!

For now, just some little demos.

Fun experiment today making a command line for the web, based on Unternet's kernel

It's cool that the LLMs know enough about URL structure to hallucinate stuff that works!

(It's just guessing based on what it knows about how GitHub's paths work – it's actually kinda handy)

[image or embed]

— Rupert Manfredi (@ruperts.world) May 26, 2025 at 12:16 PM

This little web command client can now take actions using Web Applets & the Unternet kernel

love how it can reads the map pin data to recommend me a vegetarian spot (can't do that with the DOM or a vision model)

[image or embed]

— Rupert Manfredi (@ruperts.world) May 28, 2025 at 1:22 AM

In March, we shipped a stable version of Web Applets, a protocol that extends the web to make it possible for agents and websites to communicate, with just a few lines of JavaScript.

We have an Inspector for creating & debugging these applets, so you can build your own and see what it feels like to have a model read from and send actions to a live running app (check out the 3D scene generator demo below).

We just released Web Applets 0.2!

It allows you to make client-side web apps that can be used by any LLM (it's an open protocol).

For example this 3D scene generator (made in 20 LOC)

unternet.co/blog/2025/03...

[image or embed]

— Rupert Manfredi (@ruperts.world) March 12, 2025 at 12:12 PM

The Inspector is fun, and useful for development. But really, web applets aren't meant to live in an inspector — they're meant for a new kind of intelligent user agent that helps people do meaningful work on their computers with more flexibility and natural interaction.

Over the last six weeks, we've been hard at work building a reference client, which allows folks to use web applets as part of a larger workflow weaving together natural language input, search, and rich app interaction in one place.

We now have the initial foundation of this client ready to start testing. It's the "command-line" version of our future GUI vision: limited, and mainly text-based, but with the internals needed to expand to a full-blown operating system for the web. Underneath the hood is our cognitive kernel, which can be adapted by developers to easily get started with their own web applet clients.

Importantly, this client can now be installed on other people's computers (at last, thank you Apple). That means that we're kicking off a our alpha program, and will be expanding access as we iron out initial bugs and finalize support for applets & web interactions.

You can join our alpha program here. I think maybe we'll call it Unternet Explorers? There will be stickers & mission patches.

And of course, the source code is open for those willing to get their hands dirty and build it themselves, but it may be missing a few features until we do a public release.

Auto-updates

Auto-updating is one of the many things you need to get working in order to ship a proper desktop app to production. Unlike building for the web, desktop apps don't magically update every time a user opens them.

Which means that—without auto-updates—you need to convince your user to click a link, download a new version, pull it into their Applications folder, and restart. That's a lot of work, especially for an app that has updates a few times a week.

Enter: autoUpdater, an Electron package that handles the app update process across platorms.

Here's how it works: whenever we build a new version of the app, our build system updates an RSS feed with the version number, platform, release date, and a download link. We point autoUpdater to this feed, which it regularly polls for changes. Whenever it sees a new version, it triggers a download and handles the installation.

When it's all wired up, it's a bit magical. We can make changes to the code, test and review them, then run a command to begin a new deployment. This triggers our cloud build process for macOS, Windows & Linux.

Then, within the next five minutes, all of our users will see something like this:

It's very satisfying, and an important part of the iterative feedback loop we're spinning up with our alpha program. We can have a conversation with a user, start work on a new feature or bug for them, and have it deployed to their machine within minutes.

Our work on cross-platform app builds & auto-updating was led by Vinay from our team, and Vincent from Hypha.

In other news...

• Rupert spoke about the future of open-source AI & the web as part of GLOSAIC – you can catch the interview here @ 4:11.
• Vinay & Rupert are heading to NYC for a week from the 5th. We'll be hacking at Betaworks in the meatpacking district. Let us know if you'd like to catch up, or if there's someone we should meet!

We've been spending the last few weeks putting together a stable version of our client, the AI-powered open web workspace we've been moving towards since the company started late last year.

While the functionality of our very first release will be limited, it will be feature complete for some real end-to-end workflows, be auto-updating, have enough stability for real work, and all that other essential stuff to create a solid base upon which to iterate.

Kernel

A core piece of Unternet's client is its 'kernel'. We're borrowing an operating system word here, which typically applies to the component of an operating system that coordinates between applications and hardware components of a computer. Unternet's kernel instead coordinates between reasoning engines (language models) and running application processes like Web Applets (or native system services, API requests, etc).

The Unternet kernel is open-source, and built to be modular for developers to create their own LLM-powered application environments like ours. And unlike other orchestration systems, Unternet's kernel is designed to tackle multiple different "protocols" for actions – you can get your model to use regular functions, websites, Web Applets, APIs, MCP servers, etc. all using the same library. You can find our in-progress work on the kernel here, and we'll post a more in-depth article how it works in a later update.

The kernel already has basic tool-use capabilities, and recently our engineer Steven added local file support. Here's a short demo, using our example command-line interface:

Apple

This week I've been learning a lot about certificates (not the congratulatory kind).

Before you can ship an app to Apple's coveted macOS, you need to ask their permission, receive a digital cryptographic certificate, and "sign" your app using it. Since Catalina, it is now basically forbidden to open an app that hasn't been notarized in this way.

That process has taken about 1.5 weeks longer than I initially anticipated (and counting). It looks something like this:

• Create a new Apple ID for the company & open a developer account
• Wait for Apple's third-party business registration consultant company to get in touch with you, then upload a bunch of docs to verify you are a real business
• Wait a few days, then get a notification that you now need to upload a bunch of documents to say you are a real person actually employed by the business (part of this proof is a business card?)
• Wait a few days 1 week or more...
• ??? probably something else

It's a far cry from the web (or more open OS's like Linux), where you can basically publish whatever you want, and right now it's our only hurdle to a limited release. We wait with bated breath.

Auto-scroll element

One small bonus: we couldn't find a good "chat-style scroll" package online, that wasn't specific to a framework like React. This is a particular sort of scroll where content starts at the top of an element, then scrolls down automatically when it reaches the bottom.

We made one ourself using a CSS-based technique, and published it to NPM. You can check it out here.

With Web Applets 0.2 out in the world (if you haven't seen it yet, check out our demo!), our attention is focused solely on getting an early copy of our client into your hands. Recently, I heard this described as "ChatGPT but with apps", or as our designer Ryan simply puts it: "it has hands".

So, this week has been all about some of the finer points of product development as we prepare for release: cross-platform build systems, auto-updates, data caching... Oh! And local models — our client is now compatible with Ollama, meaning it will work on an airplane, underwater, and in space (or simply when you're off the grid).

A fresh coat of paint

We've got a new look! While we've been working away on the client, Ryan has put together a brand that reflects our love for the open web. In his words:

The web is built on defaults—colors, structures, and protocols that we barely notice but rely upon every day.

The Unternet wordmark now breaks into its core syllables: un · ter · net—a nod to the rhythm of our speech, the tokens shaping AI interactions, and the composable and extensible nature of information itself. Our refreshed action blue (#0000FF) and reaction purple (#8207D7) accent colors expose the raw functional defaults of the links we click to navigate the web. And a variety of map projections remind us there's never just one way to understand this world.

At its root, “un” remains. We're here to untangle complexities, unburden users, and unbundle the web to create a more open, resilient, and locally-driven approach to managing information.

ATmosphere conference

This weekend I'll be in Seattle (along with a few members of the Unternet greater disapora) to attend the inaugural ATmosphere conference. I'm quietly excited about AT protocol's potential to usher in an open data & identity layer that the internet has been sorely missing.

Looking forward to connecting with the community and sharing some demos! Get in touch if you're going to be there.

— Rupert

Today we're launching Web Applets 0.2!

This is a major improvement to the Web Applets API, and a big step towards our 1.0 release, making it simple and easy to build apps for the web that give your AI tools new superpowers.

A few key changes:

• We've streamlined the API, ironed out common gotchas for developers, and added important production features like error handling
• A new & improved Inspector makes it easy to test out & experiment with your applets, now with a chat sidebar
• We now have thorough API documentation, examples, concepts and a reference, all available in our docs
• It's now easier than ever to integrate Web Applets into any project you're doing for the web (you can even add the polyfill to your existing site and apps)

Here's an example of code from an applet that writes "hello" on the screen when an action is received from the model, to give you a feel:

import { applets } from '@web-applets/sdk';

const self = applets.register();

self.defineAction('say_hello', {
  handler: () => (document.body.innerText = 'Hello!'),
});

To celebrate our release, Vinay whipped up a cool crossword sovler demo! To try it out, in your terminal (with node installed) run npx @web-applets/inspector and enter in the crossword applet URL (you can find that in our directory).

If you want to learn to develop one together, here's a 4-minute tutorial building a 3D scene generator from scratch, which allows you to chat to an LLM to construct a 3D scene using only natural language. It's quite fun (also great if you have kids)!

At this stage, the API is nearing production-readiness, and we invite you to start building your own AI-native apps, hosting them on the open web, and experimenting with making your own clients & chat UIs to run them.

If you make something cool or have feature suggestions, jump into the Discord and let us know.

We've been in the thick of some protocol improvements (RFC here) and preparing our client for a developer preview launch this past week, and making good progress. More on that in our next update.

But for now, I'd like to share a video from Causal Islands Berlin which was just published (thanks Boris!), where I talk about user agency, why it's important, the Web Applets protocol, and how we can make new, empowering types of software.

Embed below, or you can watch it here on YouTube.

Before I started Unternet, I was talking to an old friend back in Sydney about how I was thinking of building a new type of web browser. "Oh great," he said, "please can you get rid of tabs? I hate tabs, there has to be a better solution."

It turns out there's a vocal group of people hate tabs — I hear this a lot in user research, and you can find the same sentiment in studies on browser use.

But if you ask me, the problem isn't really tabs, but rather the inherent friction in browsers between having a document open, and putting it away in a useful place. Consider VS Code, a popular programming text editor, which uses tabs for open files, but combines that with a file explorer. There's nothing particularly stressful about having lots of files open in tabs in VS Code, because they're so easy to organize and retrieve. By contrast, closing a tab in a browser means you will likely never see that document again.

So tabs for multitasking? Yes! Tabs for organizing? ...we can do better.

This week, Unternet's client now supports tabs for multitasking! This is a key step to getting from "cool demo buddy" to "I am using this every day for serious work".

Unlike typical browser tabs, these don't represent documents. Rather, they represent workspaces – collections of open websites & applets, threads of queries, and resources (those icons in the bottom toolbar). Basically everything you need on the table to work on a task.

You may notice that we're steering away from the "Chrome tab" visual styling, and towards a Figma-style tab to accompany that shift. These metaphors are important! (In fact, the initial version of the Unternet client had browser-style tabs instead of threads. Early users were so bought in to Chrome's "a tab is a process" mental model that they got confused.)

We've got plans for ensuring the filing & organizing piece is a huge improvement on the current browser model, in a way guaranteed to satisfy my pal from Sydney — more on that in future updates.

Also in the last week...

• Vinay has written some early documentation and a getting started guide, which you can now find at our new docs page — there's a lot to cover, so expect this to expand over the next few weeks to include more about how the protocol works, how to implement a client, etc.
• Our designer Ryan has continued to circle in on some very cool new branding directions 🌐
• We've added a rich text editor applet to our directory
• A few new companies have come on board as early partners building their own Web Applets integrations. If that interests you, get in touch!

Keyword search and pay-per-click has terraformed the web, and not necessarily in a great way. This beautifully illustrated Verge article is a great place to start to read more into exactly the forces at play here. Ultimately, for end users, finding stuff online feels a lot less like getting good recommendations from a trusted friend, and more like being served the same predictable slop at a bad canteen.

Last week we pushed a feature to our reference client aiming to bring a little more of a sense of curation & agency to the search experience. Instead of searching across the entire internet, you can add websites to the "context bar" just as you would an applet. Now, the client can use websites as tools, and conduct a search across just the sources you pick out.

(For those interested, here's a note I sketched out for how the "kernel" of our client handles sending these various types of tool to the model.)

Also in the last week:

• Our contributor Vinay wrote up brand new getting started docs for Web Applets, which will be dropping later this week
• Thanks to engineer Oli, the web applets inspector now validates JSON
• Ryan, who is joining us part-time on design, has been iterating on brand and vibes. I'm excited to share that work soon

Hey, Rupert here from Unternet. We're building a new, intelligent client for the web — and I'll be posting a little update about our progress here every week.

Why the web?

I love the web. It's incredible to me that, in a world of corporate control and closed ecosystems, we have a shared substrate of software crafted from collaborative volunteer deliberation. And it's thriving.

At the core of it all is the 'user agent', the program which acts as our gateway to the web — routing our requests, and interpreting web markup & code. For most of us, the user agent we're most familiar with is our web browser. But they can take many shapes & forms: email clients, web crawlers, command-line tools, feed readers.

You may have noticed that browsers have gone largely unchanged for decades now. A lot of people present that as a bad thing, but I don't think so — rather, it's just kind of reached its ultimate form like an alligator or a shark. (It's good! We have solved browsing documents!)

But we no longer live in a document-oriented web, we exist in an incredibly rich application-centric web that has evolved at breakneck speed in spite of the browser's stagnation. App developers invented their own proprietary technologies instead of waiting for the web to catch up (this has had some negative side effects).

As we moved functionality away from our computers and into cloud apps, we as users lost control — a big chunk of information and files are now stuck deep in the walled gardens of our various web apps, none of which talk to each other. We have to log into things twenty times a day. Everything is a subscription, or selling our data for ads. Nothing "just works".

The thesis of Unternet is that we're due for a new modern user agent, one that will be the centre of gravity for our digital world even more than the browser is today.

How it began

At the start, I just wanted to do something useful with language models.

Back at Google Creative Lab in 2019, we worked on a project called "ML Tools for Writers", which is where I first learned to wrangle GPT-2. I was coached by Ross Goodwin on how to manipulate special characters in the training input of the transformer to get specific results from the output, like telling a story in reverse, generating a biography based on a few keywords, or building in structure that could be turned into graphical UI elements.

With these early models, you couldn't just use prompting. We had to custom train a model using a secret code of special characters, like little spell charms, that would direct the model's behaviour. The end result was real, graphical software that would obey the natural, gooey, non-deterministic rules of language.

So when ChatGPT launched while I was at Mozilla, despite appreciating it for garnering such public enthusiasm, I disagreed with the exclamations that text conversation was the future of computing. I already knew it was possible to create rich interfaces using these models, and apply them strategically to do new kinds of computing operations. That was the future I was excited for! Not texting a slightly misinformed & sycophantic ghost in the shell.

I moved to Adept to work closely with a talented research team building some of the underlying models that would power this capability, prototyping interfaces to solve real problems, and putting probably some of the first production-ready agents into service at scale.

But it quickly became clear to me that what we really needed to do was build an application platform, and if anyone is going to build a platform like this, they'd better be doing it out in the open where it can't be controlled by a single powerful company. They should be extending something like... the web.

Where we're going

Ok, so let's talk about the vision. We're building something that will:

• Act like an operating system for your files & applications, wherever they are
• Adapt to the human user through flexible interfaces & natural language
• Put ultimate control & data in the hands of the user, not the cloud

(The early version of this was called Operator — or I guess it technically still is, but because I don't want to have a multi-million dollar legal stoush with OpenAI we'll probably have to pick another name. This name was chosen to evoke the telephone operators of yesteryear, who were in fact expert knowledge workers, specializing in understanding a caller's intent, clarifying & providing information, and patching into the right external service when more support was needed. A mediator for a dense network of connections, the original user agents.)

But we're not just making a product. My secret admission (don't tell Betaworks!) is that Unternet is not really an "AI company", but rather a web technology company leveraging the power of these models in a post-app world. This means we're not just building a new user agent, but also the web stack to power it which anyone can take advantage of.

Our first open-source release is Web Applets, a lightweight protocol for sending actions & receiving data from a web app. It's how our product is able to spin up a map to search for cafes nearby, then answer a question about which one has a 4+ star review, stocks oat milk, and is less than a 10 minute walk from home.

There will be more that we build in the open, and with like-minded communities like User & Agents and Mozilla Builders, in the near future.

This new user agent is coming – but will it be something that's owned by one company & designed to extract from us, or owned by all of us & designed to empower us? We're building the latter. If that resonates with you, then stay tuned and get involved.

What you can do:

• Please tell your friends about us, and send them a link to our blog
• Try creating your own web applet, and then send me an email so I can host it on our upcoming applets directory
• Register for user research — we're settling on the most compelling early use cases and your input would be greatly appreciated

Over the next few updates I'll give you more details about how to get our preview client running. In the meantime, if you want to lend a hand or have a chat, drop by our Discord anytime.