What limits how well we use AI stopped being model capability a while ago. It's that the data about me isn't mine.
The AI Doesn't Know Me
I use LLMs every day, and none of them know who I am.
A model can help me write code, analyze an architecture, rework my résumé — and once it has tools, carry out real work on my behalf. But every time I open a new provider, I have to explain myself from scratch: which languages I use, what I do for a living, which projects I run, how I like code organized, which technical constraints can't be waved away.
At first I treated this as an annoyance. Then I realized it was the ceiling.
The Bottleneck Has Moved Many Times — Never on My Side
On the July 28th episode of Invest Like the Best↗, Patrick O'Shaughnessy and Sam Altman spent close to an hour on where AI actually gets stuck. One stretch is about exactly that (22:27): over the past few years the binding constraint kept rotating — sometimes research ideas, sometimes compute, sometimes data, then back to compute again.
That's the bottleneck as seen by the people building the models.
The bottleneck on my side has never rotated once.
Models jump a tier every few months, inference costs fall by an order of magnitude, the capability frontier keeps expanding. And every time I open a new conversation, I still start by explaining who I am. Progress on the model side is exponential. My side restarts at zero, every time.
So the real question isn't "is the AI smart enough." It's: how many facts about me can a sufficiently smart system actually reach?
The answer is: very few, and none of them are in my custody.
Every Product Keeps Its Own Copy of Me
Providers usually offer somewhere to put this, something like things about me. Write it in and the problem looks solved. But once I started maintaining it seriously, I realized I was only building one more copy of the data about me.
My personal site stores my work history, skills, projects and bio. The app that tailors my résumé needs the same data, so it imports another copy. The LLM provider keeps its own profile, and the next product will ask for a profile of its own.
These systems aren't holding different data. They're holding different projections of the same person. The problem is that each projection gradually starts acting like the source.
The moment data gets copied, drift follows. I update a piece of work history — which one do I edit first? A project changes its stack; which system holds the correct version now? And when a preference the provider memorized goes stale, I may not even know an old fact is still shaping its answers.
At first I read this as a context problem. Maybe I needed a better system prompt, or a JSON file I could import into different models. Later I understood that this was just another way of copying.
Context is the shape data takes when some consumer uses it — it is not the data itself. A prompt, a RAG document, a résumé page and a site API can all be ways of consuming it, but none of them should own a separate source of truth.
What You Can't Walk Away From Isn't the Product
The same conversation gets to a sharper question: once intelligence itself is a pure commodity, which moats are left?
Altman's ranking runs roughly like this. Compute fleet scale is the most durable. The stickiness that comes from workflows and integrations is next. Brand and distribution sit in the middle — he calls ChatGPT's bundling advantage "very very tiny." And the product itself is the weakest of them: if someone builds something better, people will move.
I sat with that for a long time, because it says from the other side exactly what I'd been circling:
If a product can be swapped out at any time, the only thing keeping you in place is the context that has settled inside it.
Altman is saying it from the company's side: the product will get replaced, so the moat has to live somewhere else. From my side it's the same fact under a different name — that isn't a moat, it's a lock.
The more context I accumulate inside a platform, the deeper its moat and the less able I am to leave. And that context was my life to begin with: the projects I've built, the notes I've written, the résumés I've reworked, the technical preferences I've explained a hundred times.
So the question isn't "can the AI remember me." It's: who owns the thing that remembers me?
Context is the output; ownership is the precondition. Whoever holds the data decides who may use that context, whether it can be carried out, and whether it still exists on the day you replace the product.
The Data Boundary Runs the Wrong Way
Large platforms today usually organize data like this:
one domain × many people
A health platform collects health data from many people, a music platform collects listening history from many people, a hiring platform collects careers from many people. Their domain boundaries are perfectly clear, but one person's data is sliced vertically and left inside separate companies.
What personal AI needs is the opposite:
one person × many domains
Career, knowledge, photos, music, health, travel and browsing history belong to one person. They may arrive from different products, but the product shouldn't remain the final boundary forever.
The direction sounds obvious, and it's easy to underestimate how hard it is. I tried it.
I Built One, and Building It Showed Me It's Only a Mirror
I wrote myself a personal database called Kioku: one PostgreSQL holding career, knowledge, photos, music, health and browsing history, read by my site over an API and by LLM clients over MCP. It does solve the copy-and-drift problem — there's exactly one source now, and everything else is derived.
But once it was working I could see plainly what it is: right now it's only a mirror and a sync of other platforms' data.
The data still originates in someone else's system. Listening history comes from a streaming service, health data from a phone and a watch, code activity from a Git host, reading and viewing history from their respective apps. What Kioku does is pull it in on a schedule, reconcile it, and store it. What I own is a reliable copy, not the origin.
That has very practical consequences. When a platform changes its export interface, my side breaks. When a platform offers no incremental interface, all I get is a one-off archive. And what a platform never recorded in the first place will never appear on my side at all. Ownership moved to me on paper; the end that produces the data did not.
I don't regret building it. Building that layer is exactly what showed me where the problem actually sits: storing was never the hard part. The origin is.
There Is Still No Eye
Pulling scattered data back only solves half of it.
Almost everything I can reclaim is a digital footprint: what I clicked, what I bought, what I listened to, what I committed. That's the version of me a platform wrote down — a second-hand projection.
What I did in the physical world, nothing is recording. Who I met today, what we talked about, what I saw, what I was thinking at the time — that layer explains me better than any of the rest, and it is entirely missing. No device sees the real world the way my eyes do and keeps what it takes in.
In the same conversation, Altman spends real time on robotics (35:33): he expects a ChatGPT moment for robotics in the next two or three years, and argues it would be very bad if the remaining role for humans were to act as actuators for cloud-side AI. That's about giving cloud intelligence a pair of hands.
But personal AI isn't missing hands. It's missing eyes.
That gap will get filled, and most likely by a device. What I care about isn't when it arrives — it's who the data belongs to by default when it does. If the most intimate, most explanatory layer of a person's life sits in somebody else's database from the first second it is recorded, then every argument about data ownership up to that point was tidying a smaller room.
Which is why this isn't a "later" problem. It also isn't a "record more" problem — the gap isn't that too little gets captured, it's whose hands the intake is in. The boundary has to be drawn before the data exists, not negotiated back after it's already sitting somewhere else.
People Have Walked This Road Before
"A database for one person" is not a new idea.
Vannevar Bush proposed the Memex in 1945, imagining an external memory that could store and link a person's own material. In 2001, Gordon Bell, Jim Gemmell and Roger Lueder started MyLifeBits↗ at Microsoft Research: a SQL-based "personal database for everything," holding documents, mail, photos, web pages, recordings and sensor-captured life logs, and exploring full-text search, annotation, linking and similarity.
Later, Personal Data Stores and Solid approached the same tension from another direction: data shouldn't be bound inside applications; applications should access storage the person chooses, once authorized. As of 2026, the W3C is still pushing Linked Web Storage↗ forward, trying to standardize secure, authorized application access to external storage.
There is also a more pragmatic engineering line. HPI↗ doesn't wait for the whole internet to agree on one protocol first; it uses export files and adapters to turn chat, music, browsing, location and health data into interfaces a personal program can query.
These projects aren't one continuous lineage, but they keep answering the same question: when a person's digital life spans many applications, can the data be reorganized around that person?
Why It Never Became the Internet's Default Architecture
The idea keeps reappearing, and it keeps stopping at research projects, open-source tools and a handful of self-hosting users. The obstacle was never disk space.
First, platforms have little incentive to hand over continuous, complete, machine-readable data. Even where an export exists, what you get is often a one-off archive rather than a stable incremental interface. Being able to retrieve your data doesn't mean you can reliably sync it — which is exactly the wall I ran into.
Second, data from different sources is hard to unify automatically. The same place, contact or activity may share no identifier across systems; timestamps carry different timezone assumptions; two devices may record the same workout twice. Putting the files in one directory is easy. Making them one database in any semantic sense is much harder.
Third, centralization widens the blast radius. Scattered data is inconvenient to use, but aggregated health, location, career and browsing history becomes a concentrated loss the moment one authorization goes wrong. Data sovereignty can't only mean "everything is on my side" — it has to include least privilege, auditing, backups and recoverability.
Finally, an ordinary person shouldn't have to become a database administrator in order to own their own data. For a developer, one PostgreSQL per person is acceptable. If this model is going to serve more people, the realistic shape is a hosted personal space or a logically isolated data account — not a server everyone has to maintain.
AI Turns This From Worthwhile Into Urgent
For most of its history, a cross-domain personal database lacked a strong enough everyday consumer. Charting your health or searching old messages is useful, but not necessarily enough to make an entire ecosystem move its data boundaries.
Personal AI changed that. An agent that helps me plan work, rework a résumé, review a project or make sense of how I've been living can't know only one domain. It has to reach across career, knowledge, preferences and history — while each task gets only the slice that task requires. It's the first consumer that naturally needs all of it, and the first time data ownership stops being a matter of principle and starts setting the ceiling on what the system can do.
The external conditions are shifting too. The EU Data Act↗ already pushes connected products to give users the data they generate along with the metadata needed to interpret it, and the DMA is pushing large platforms toward timelier portability interfaces. Those rules won't create a personal database on their own, but they are turning "getting my data back" from a reverse-engineering exercise into a capability you can actually demand.
Still, AI only makes the demand stronger. It hasn't solved data governance for us.
An LLM cannot be the single source of truth. A vector index doesn't preserve exact quantities, and a relationship the model infers is not a fact. An agent may suggest that two records could be related, but it shouldn't rewrite my work history because of one generation. Natural language makes data easier to use; provenance, permission and certainty still have to be expressed explicitly by the system.
Intelligence Will Commoditize. Context Won't.
If intelligence really does become a pure commodity, then the one thing that can't be commoditized is the context about me. It decides what the same model can do in my hands, and it decides what I get to carry out when I leave.
What I hold today is a mirror. It beats being scattered across a dozen platforms, but it isn't the destination — the origin still sits with someone else, and the physical-world layer has no intake at all.
So this isn't a solution. It's a statement of where the problem actually is: what limits how far we can push AI isn't the model, it's who owns the data about us.
Models will keep getting stronger. This question won't resolve itself.