We are finally entering the PC era of AI.
For the last couple of years, personal AI has split into two paths: cloud assistants on one side, open agent projects on the other. The first is polished, but it reads the future through the rearview mirror: another account, another subscription, another cloud service between you and your life. The second is freer, and projects like OpenClaw are a great signal of what is coming, but they are not the final form. My vision for personal AI is something that feels as easy as ChatGPT, as free as OpenClaw, and as dependable as a calculator. It starts on the phone, keeps data with the user, lets the user choose the model, and reaches the whole web - including every platform - through the access the user already has. Its safety is public and structural: anyone should be able to inspect the code and see that a breach is impossible without explicit human action. The mistake is to treat the agent as another cloud service. A cloud service is a destination; an agent is the layer between you and every destination. If that layer is going to act for you, organize your private context, and shape the menu of choices before you act, it has to be built around your device, your data, and your model from the start - less like a toll road and more like a calculator: local, dependable, and yours. No other master, no monthly gate, no harvesting your data. It just works.
You can see why this matters in the software we use now. The screen is not cluttered by accident; it is cluttered because attention pays. The app is designed to keep you inside the platform’s goals before it serves yours.
An agent changes the point of leverage. The bottleneck is not the chat box; it is access to the data and actions behind each interface. That is why the access layer matters. If the agent acts from your device, using the access you already have, the company no longer sits between your intent and the service.
This is not a war on platforms. Platforms provide real value - infrastructure, logistics, trust - but the current interface keeps that value harder to use than it should be. We need a more efficient way to invoke a platform, and to work across platforms, without being steered by the ads, pop-ups, trackers, and recommendation algorithms that sit between intent and action.
1. The Walled Web #
The early web was an open, searchable network of raw information. A search engine was powerful because there were no gates. That web is dying. The most valuable data now lives behind logins - feeds, social graphs - usable only through the interfaces each platform allows, because platforms make money by keeping attention trapped inside their apps. Building on them now means begging for API keys under shifting rules.
Google centralized the public web because it could see the public web. AI organizing your life is different. The index follows the data, and your data is split across apps, accounts, and private context. The only place it all comes together is your device. So the question is not only who holds your data. It is who gets to turn that data into the options you see and the actions you take.
2. Three Freedoms #
Every wave of technology breakthrough unlocks a new form of freedom. Freedom of Speech. The printing press first made freedom of speech practical at scale by enabling ideas, criticism, and dissent to be copied accurately and distributed far beyond institutions that controlled handwritten texts. The internet extended this further by giving ordinary people a low-cost, global medium to publish and exchange ideas directly, though it also introduced new forms of censorship and platform control.
Freedom of Money. To move value you had to trust a bank or a state to clear it, and either one could freeze you out. Then the blockchain made it possible to settle across borders without a gatekeeper at all.
Freedom of Will remains in play when you can deliberate among alternatives and act from reasons and preferences you recognize as your own. Platforms threaten it without removing the appearance of choice: algorithms, defaults, lock-in, and control over access quietly shape which options you see. You still choose, but inside a menu designed to serve someone else’s goals.
“Societies have always been shaped more by the nature of the media by which men communicate than by the content of the communication.” -
[Marshall McLuhan] Freeing it means changing the medium that stands between you and the web. An AI agent can stand where the interface stands: read across many pages, act on any platform without permission, and hand back a view shaped to your intent instead of the platform’s. The agent is the engine; you are the steering wheel - you supply a few high-quality bits of direction and it fits the rest. But this makes alignment non-negotiable. The press and the ledger had owners, but no will of their own; an agent can want something, or be made to want something. A model aligned with you is freeing. The same model serving the market is the recommendation algorithm again, one layer down and harder to see.
3. Permissionless Access #
Permissionless access is a prerequisite for this freedom: a tool has to act on behalf of the user and use the access the user already has. APIs help when they exist, but they are usually partial, permissioned, and revocable. They expose what the owner chooses to expose, not everything the user can already do. Permissionless access starts from the other side: if the user can see or do something, a tool running for that user should be able to reach the same underlying data through another interface. I learned this from two systems that stagnated in the same way: city tennis portals, and Amazon’s internal tools.
The first wall was Matcha Tennis, an app that lets you book any tennis court in one click. Court booking is fragmented across cities, counties, clubs, and vendors, most of them old portals with no public APIs. The data is not secret - players can already see court times and book them - but it is trapped behind clumsy forms. If improvement has to wait for each city to approve or build an integration, everyone stays stuck in those portals. The fix was to move the logic to the user’s device, with the user’s mandate, and use the site as they would - turning two minutes into five seconds. More than 1,000 people now use it in Seattle. That is why permissionless access starts in the long tail: small services no company will ever build an API for.
At Amazon I learned the same lesson from the other side. As an employee, you could access internal websites, but your agent could not wait for each owner to offer an MCP server. One Sunday afternoon, I wrote the first Slack MCP server and shipped it right away, because the team that owned the official integration had offered no alternative, and would not for months. Within weeks it was one of the most-used MCP servers in the company, reaching thousands of employees. The whole company could not block on one owner. Later, the same idea grew into a unified CLI for internal websites that anyone could extend without waiting for another team to build an MCP server. It now gets used, on average, once every second, and more importantly, it gives every builder a shared base to build on instead of leaving them blocked on another owner.
4. The Non-Negotiables #
If you grant an agent your access, the client has to be under your control. That sovereignty requires three things. Your machine. The agent should run on your own device, not on a server acting for you. What runs locally cannot be throttled, shut off, or quietly changed above your head. It also keeps the middleman, and what it would learn about you, out of the loop.
Your data. Your data should live in open formats you can carry elsewhere. When an app dies, you should be able to load your history into the next one and keep going. The value is in the memory you build up, not in the app that happens to hold it. A tool you cannot leave is not truly yours.
Your model. The agent should bind to no single model provider. You bring the model, and you can swap it when you need to. A model is the mind doing the work; if you cannot replace it, it can be tuned to steer you while still appearing to serve you. Swappability keeps every provider honest.
5. The Agentic Proxy #
Put those requirements together and the shape is a mobile-first local agentic proxy between you and the web. I will call the version I have in mind Mango for now. It starts on your phone, where your life already happens, and reaches every service through one interface. It keeps the whole loop local - your machine, your data, your model - with data you can carry anywhere. Because it acts through your access, safety has to be structural: a deterministic layer in the client should make leaks and unauthorized actions impossible, not merely unlikely.
How I picture Mango: reading three platforms at once and handing back a single clean view shaped by your intent.
The important part is not the app wrapper. It is the new medium for using the web. A platform makes you express intent by moving through its interface: search here, click there, compare across tabs, copy results from one app into another. Each step is a place where someone else can reorder the options. An agentic proxy shortens the path from intent to action. You ask once; it invokes existing platforms, even across several of them, and gives back the result in the shape you asked for. It is not only more efficient; it leaves fewer platform-designed surfaces between wanting and doing.
Because Mango is local, its economics are different too. It is a binary you run on your own hardware, connected to whatever model you choose. It has no inference bill to recover, no accounts to link, and no attention business to feed. Its design removes the market pressure that makes software betray its users. Platform integrations can live in a shared public registry, so access depends on a record anyone can inspect and improve, not on one company’s permission.
6. File Over App #
A proxy like this should not become the next silo. Its memory has to outlive the app. That is the concrete form of your data: ** file over app.** Apps come and go. Files last.
Mango should write everything it knows - your chats, memory, actions, and settings - into a folder of plain text files on your own device. That folder is your mango. The format should be a standard protocol, simple enough that everyone can agree on it and build alternative apps on top of it. The app can be replaced; the mango stays. There is no corporate account by default: no login, no server, no new gatekeeper. If you want sync, use the file sync you already trust, like iCloud. Sovereignty should not mean fragility.
Most chatbot apps save your history on their servers, readable only by their models. If you leave, you lose the context you built. If your history lives in a mango, the model stays swappable: one goes down or goes wrong, and you point another model at the same files.
7. The Shift #
The way out is not thousands more corporate integrations. It is fewer dependencies: your device, your files, your model, and access that starts from the user.
This will not begin by storming the giants. It starts in the long tail - old portals, small services, internal tools, and places with no APIs - where a local agent is simply more useful and threatens no one. It grows there until owning your tools feels normal.
Platforms also have less reason to fight than it first seems. The agent uses the service the way you do, just with less noise. It strips away the attention tax, but leaves the useful service intact.
That is the Mango I have in mind: a mobile-first local agent, an open text protocol for memory, and a deterministic safety layer in the client. The machine, the data, and the model are yours.
We shape our tools, and then they shape us. Speech and money were freed by removing the middleman. The will is no different. The PC era of AI is about owning your tools again. It charges you nothing, and claims no rights over you. I’ve decided to build that calculator.