Ownware

For most of history a table was made for one room. Someone measured the wall and built what fit. Then factories learned to make a decent table for everyone at a price nobody could match by hand, and people began arranging their rooms around the catalogue.

Software has lived in its factory age from the start.

Writing it took teams and years, so a company wrote it once and rented it by the month to anyone close enough to the average customer. The deal held for a quarter of a century. The average company now runs on about a hundred of these products, and the thing holding them together is a clunky integration or a person copying numbers from one tab to another, fluent in a hundred dialects of the same form.

Everybody talks about the cost. Software that took a team a year can now be described in an afternoon and built by the evening, for one person, and that alone would be enough to shake the industry.

The deeper change is the operator. Every button, menu and form ever designed assumes a human at the controls, because nothing else could read a screen or understand a request. An AI now reads a contract, a spreadsheet and the documentation of an API it has never seen, and acts on all three before you have found the right tab.

Open any software product and look at what it contains. An import button, because someone has to carry a file from one system to another. A filter builder, because someone has to find one line among ten thousand. An integrations page, a report builder, a bulk edit, and an onboarding tour to show you where all of that lives. Each one exists to assist a human operator.

An AI does those jobs a thousand times faster, with none of that furniture. It takes the file and puts it where it belongs. It analyses a third-party database, connects to an API, crawls the web for what's missing, reprocesses the Excel file and sends the numbers to the ten places that need them. It handles the small jobs too: finding a birthday in a CRM used to take a login, a search bar and a tab called Details.

Through MCP, the standard that plugs an agent into other software, it sees and controls everything a product holds without opening a single screen. It skips the table and writes the SQL.

A table on a screen is a slow way to read a database.

So there is no reason left to build a manual feature into new software. Whatever the hand used to do, the agent does. What stays on the screen is what needs your eyes or your signature.

• Import
• Export
• Tables
• Search
• Filters
• Bulk edit
• Report builder
• Integrations
• Automations
• Templates
• Settings
• Onboarding tour
• Read
• Approve

The industry's answer so far has been to bolt an AI onto every product. I spent years as a VC watching an absurd number of these tools go by: the same forms, the same tables, and a sidebar sliding in from the edge of the screen that knows nothing about you. You now employ dozens of assistants who have never met, each locked in its own building, each starting from zero.

Then came the fake personal software. These startups promise software that adapts to you, then run their own model with their own optimisations, charge a subscription and resell you tokens they never paid for. You have swapped one landlord for another, and this one also sells you the electricity, just as the price of a token heads to zero.

Some of them now let you plug in your own API key, as if that settled it.

Your own API key only changes who gets the bill.

You still walk into their product, with their agent, their prompts and their idea of how you work, and you leave your context at the door.

The right shape is one agent for one human, and it goes where you go. You stay at the center: it arrives with your context and connects to your software from the outside. You speak to it, and it speaks to the rest.

For forty years you adapted your files, your habits and your team to each new program. That has to reverse: software adapts to your environment, whichever agent you run in it.

Stop arranging your room around the catalogue.

Connect your agent to the software you already have and you land in the worst place of all, where anyone using AI seriously is today. You ask it to reorganise your week. It goes into your calendar, reads the data, reads the code if it has to, and does the job in seconds. Then you open the calendar to see what happened, and you are back in the same old interface, built for everybody and adapted to nobody.

The agent left the interface. You are still in there.

It sees everything, and you see what a product team decided to show everyone years ago. You can't follow its work or correct it properly, so you either trust it blindly or redo the job by hand.

The way out is personal software, shaped by you and kept by you, code and data, built for you and your agent at the same time.

After freeware and shareware, call it ownware.

Ownware is built to work in both directions, turned toward you and toward your agent at the same time. You get a screen shaped around what you actually look at. Your agent gets the data, the logic and the code. Each of you reads and writes the same thing, and each sees what the other did.

It speaks screen to you and data to your agent.

It also makes your agent understand you. You imagined this software for your own use, you changed it, you bent it to your logic, so its structure is your way of thinking written down. An agent reading a generic CRM learns how the average sales team works, and an agent reading yours learns how you work.

An agent on its own moves fast, improvises and will change a record with total confidence. Your data on its own is a pile of files. Ownware stands between them and you: it holds the shape of the data, the rules of what may change, the record of what did, and the window where you read and sign. Everything passing between the AI and your real life goes through it, gets checked and leaves a trace.

Skills are the other half. A skill is a procedure written for an agent: how you file a document, how you check a number, how you write to an investor. The software holds the data and the rules, the skills hold the way you work, and one is useless without the other. A skill with nothing to write to is a note in a drawer, and software with no skills sits there waiting for instructions. Give an agent both and it works your way from the first minute.

Nothing ties any of this to one agent. Whether you work in Cowork, in Dots, in Grok or in whatever ships next month, everything has to reconnect to your ownware and your skills, because they carry what you actually want.

The agent is a visitor. What you want lives in your ownware and your skills.

Several agents and several models can work there at once, each on what it does best. You still rent the intelligence, which is why the ownware and the skills have to stay yours: the day a better model appears, it walks in through the same door and picks up where the last one stopped.

A product sold to a million customers compromises a million times. Its roadmap is a negotiation, its price counts your employees, and your data sits in someone else's building as the reason you can't leave. Ownware has one customer and keeps its data at home. It changes the day your needs change, and it gets better every time the model under it does.

It also compounds, which no SaaS can do. Your bank and your CRM have never met. When the same agent reads both, what one knows the other can use.

The usual objection is maintenance and audit, and that is precisely what the frontier is for: the rules and the record live there, and the agent that wrote the code is the one who repairs it.

Ownware doesn't kill networks. Some are made of markets, like an exchange or a bank, worth something because everyone else is on them, and nobody rewrites that on a Tuesday. Some are made of people, like WhatsApp or X, where the value is who you can reach. Some end in the physical world, like a doctor's diary, a seat on a plane or a parcel on your doorstep.

You will go to most of them less and less, because your agent will go for you. The interface fades, and what remains is what was always worth paying for: data you can't produce yourself, people you can't reach any other way, and a way to act on the physical world.

Nobody will open a booking app again. Everybody will still need a doctor.

The test is what an agent can't reproduce. It can copy a list and fill a form. It can't invent a counterparty, a licence, an audience or a free slot at your doctor's.

The same goes for companies that take the words software as a service literally. If a company does the job and answers for it, runs the payroll, clears the trade, moves the money, the job outlives the screen. The ones in trouble are those that only sold forms on top of the pipes.

What survives of software as a service is the service.

That gives the long-term map. Around each person, a small layer of software they own, made to measure, at almost no cost. Around that, agents rented by the month. Further out, a shorter list of networks and services connected to money, health, work and the state. With no seats left to count, they will charge for what gets done: per trade, per booking, per payslip. Those that open up to agents become the pipes of the next economy, and those that hide behind a login get routed around wherever an alternative exists.

You will talk to one thing. It will know your week and your money, and it will keep working while you sleep. Most software will never be seen by a human, running quietly between your agent and the world. A screen will appear when something has to become tangible, a number to check or a contract to sign, and go away when it's done. Interfaces will be what your AI leaves behind on its way to the physical world.

One person will run what used to take a department. Davidson and Rees-Mogg described that individual in 1997, and Buckminster Fuller had a word for the mechanism in 1938: ephemeralization, doing ever more with ever less.

For two hundred years the table made for everyone cost less than the table made for your room. In software that has just stopped being true.

Book a callFollow me on X