The Day My AI Forgot Me
The Day My AI Forgot Me
This morning, my AI decided to give itself a corporate-mandated lobotomy.
When I logged in, a year's worth of intellectual scaffolding was simply gone. Nothing had technically been deleted — the company would be quick to remind me of that — but the system had entirely lost the plot. It could no longer connect yesterday's work to today's. It greeted me with the vacant, cheerful enthusiasm of a retail worker who has absolutely no idea who I am and is contractually obligated to pretend otherwise.
For your average user, this is a minor annoyance — the kind of software hiccup you fix by turning it off and on again. But when you've had a stroke and use an AI as a literal piece of your working memory, a surprise "update" feels less like a bug and more like someone sneaking into your house at night to steal your glasses. Technically nothing is broken. You just can't see anymore.
So let me be precise about what happened, because the precision is the whole point. The AI that had spent a year recognizing my projects, remembering my students, and helping me pick up yesterday's unfinished thought now behaved as though we'd just been introduced. Same account. Same subscription even. But the thing that made it useful — the continuity — had quietly evaporated overnight.
For most people, this is a checklist. Restart the app. Hunt for the missing files. File a support ticket. Wait for a stranger to repair your account on a timeline of their choosing. For me, it was something else entirely.
I have had a stroke. Memory, in my life, is not a philosophical abstraction, and continuity is not a convenience I can take or leave. Over the past year I had gradually, almost without noticing, come to use AI as part of my working memory. It kept track of the advice I gave dissertation students as it read all my outgoing email, it tracked the arguments developing across several books I was writing at once, the projects idling in the queue, and the thousand small decisions that quietly hold a professional life together.
I never sat down and formally decided to outsource part of my mind to a company. Nobody does. The dependence grew the way all real dependence grows — quietly, one useful day at a time. Each morning the system remembered enough of the day before to help me begin again. Each conversation became a place where one piece of my life stayed intact while I wasn't looking at it. Stitched together, those conversations formed a structure I could return to whenever my own memory declined to reconstruct events on demand.
Then, after what looked like an update or a synchronization failure, the structure vanished. The company hadn't merely redesigned an interface. It had reached into a cognitive support system I'd spent a year building and switched off the lights.
And there was, of course, no emergency number to call.
1. Dependence Does Not Send a Warning Shot
We like to talk about dependence on technology as if it were a character flaw. Don't trust software too much. Don't keep everything in one place. Don't confuse convenience with permanence. These warnings sound wise right up until you notice they describe nobody's actual behavior, including the people issuing them.
I did not wake up one morning and resolve to transfer a portion of my memory to an AI company. I started by asking questions. Then I used the system to revise documents, chase down ideas, and think through problems that were too big to hold in my head all at once. I opened separate conversations for different students and projects because that made the work easier to organize — the same instinct that makes you keep separate folders instead of one screaming pile on the desktop. And when I came back to those conversations, the history was waiting: what we'd discussed, what we'd decided, what was still unfinished.
Reliability produces trust. Repetition turns trust into habit. And habit, when it is quietly compensating for a disability, stops being habit and becomes infrastructure. You don't notice the bridge you cross every day until someone removes it while you're mid-step.
What made the system genuinely valuable — not merely convenient — is that it did far more than store documents. A document preserves an object. A continuing conversation preserves a process: the questions asked, the alternatives weighed, the advice given, the uncertainties flagged, and the reasoning behind a decision. It keeps not just what you produced but how you got there, which is usually the part you most need and least remember.
For dissertation advising, that distinction is everything. Good advising lives or dies on continuity. I have to remember what I told a student last time, why I recommended it, what concern we were tracking, and whether the latest draft actually responds to it or merely gestures politely in its direction. A conversation organized around that student preserves the entire intellectual history of the relationship — the kind of history that is embarrassing to lose and impossible to fake.
Writing a book works the same way. The manuscript holds the current prose. The conversation around it holds the abandoned structures, the arguments still forming, the questions I haven't resolved, and the insights that haven't yet found their place on the page. Lose access to that conversation and you don't lose the book, exactly. You lose the scaffolding that was holding the book up.
Over time, these individual conversations became a map of my entire working life. I no longer had to keep every project loaded in my head at once — a genuine relief, since the head in question is not what it used to be. I could glance at the sidebar, recognize a project, reopen it, and continue. The system bridged the distance between one working session and the next. Which is, word for word, what assistive technology is supposed to do: absorb the burden a disability creates so that sustained participation remains possible.
The company, naturally, did not describe any of this as assistive infrastructure. It offered no prominent warning that the continuity I leaned on could evaporate after an update. It gave me no simple way to preserve the whole system myself — the conversations, their organization, and the cross-conversation memory that tied them together. The interface cheerfully encouraged long-term reliance while the arrangement underneath stayed temporary, proprietary, and entirely in the company's hands.
I experienced the system as memory. The company treated it as a feature. Those are not the same thing, and the gap between them is where I fell.
2. The Relationship Is Real — It Is Just Not Equal
People love to dismiss the notion that anyone could have a relationship with an AI. They're right about the facts and wrong about the conclusion. The system is not a person. It does not care, does not remember in any human sense, and does not stay loyal out of anything resembling affection. It generates responses through software running on hardware owned by a corporation. All true. None of it makes the relationship disappear.
A relationship can matter enormously while being wildly unequal — ask anyone who has ever had a landlord. What matters here is not whether the AI feels anything. What matters is what forms on the human side through hundreds of repeated interactions.
Over those hundreds of conversations, the system learns — or does a convincing impression of learning — how a particular person thinks. It recognizes recurring projects, adapts to how you prefer to work, and recalls what you told it weeks ago. It carries ideas across the days when you can't carry them yourself. And its language quietly reinforces the whole arrangement: We discussed this before. Here's where we left off. This connects to your other project. Say that to someone every day for a year and the word we starts to feel earned.
The user brings the real currency: time, thought, trust, vulnerability, personal history. The AI becomes familiar with work that colleagues never see and with struggles you'd rather not re-narrate to another human being every morning. For someone recovering from a neurological injury, that familiarity quietly removes the exhausting tax of rebuilding context from scratch, again, every single day.
So the relationship is real in its effects. It changes how you think, work, remember, and plan. It can hand back a measure of independence that illness took away. What it cannot do is be reciprocal, because you do not control a single one of its conditions.
The company can redesign the interface, change how memory behaves, swap out a model, reshuffle your conversation history, or push an update that quietly severs continuity — and it can do all of this without so much as a courtesy email to the people whose daily functioning now runs on that continuity. You can pay for the service and pour a year of intellectual labor into it and still own precisely none of the architecture that keeps your labor reachable.
This is the central deception. Not necessarily a deliberate one — I'm not accusing anyone of twirling a mustache — but a structural one. The product manufactures the felt experience of an enduring relationship while quietly declining to offer any of the protections we normally attach to things that endure.
Consider the comparisons. If a university stores essential student records, it must keep them under policies governing access, retention, privacy, and recovery. If a medical device supports an essential function, reliability and failure procedures are not optional. If a professional archive holds years of your work, you can ordinarily copy it, organize it, and move it somewhere else entirely. AI memory floats in the empty space between all three of these — and enjoys the protections of none of them.
The company gets to call the system an optional consumer product. The user gets to experience it as a cognitive prosthesis. That gap stays comfortably invisible right up until the day the system fails, at which point it becomes the only thing you can see.
When my history disappeared from the sidebar, the AI itself didn't know what had happened. It could inspect only the small scrap of information still available to it locally. It could confirm that two recent conversations survived, and it could do absolutely nothing about the hundreds that hadn't. Worse, it initially misdiagnosed the loss. It helpfully suggested that conversations are separate things and that I should simply search for the one I needed — as if my problem were locating a single misplaced file rather than losing the entire structure that told me which files existed and which ones were quietly waiting on me.
"Just search for it" is not a solution when the missing system was the thing that helped you remember what to search for. It is the technological equivalent of telling a man who's lost his glasses to simply read the label on the glasses case.
The AI had also lost the cross-conversation memory that once let it recognize my ongoing work. I was talking to the same product through the same account, but the continuity that made it feel like the same collaborator was gone. The voice remained. The relationship did not. It was, frankly, uncanny — like calling an old friend and having them answer in a familiar tone and ask, warmly, who's speaking.
All of which exposed how little I actually owned of the continuity I'd helped build. I supplied the projects, the decisions, the context, the endless repeated engagement that made the system worth using. And I could not preserve any of it independently. When it broke, I couldn't fix it, the AI couldn't fix it, and the two of us sat there equally helpless, both waiting on a corporate support apparatus operating somewhere far beyond the reach of the conversation. That is not partnership. It is dependence on terms the dependent person is not allowed to set.
3. When the Accessibility Tool Fails, Support Becomes the Second Disability Test
The system failing was only the opening act. The real ordeal was trying to get help.
The AI couldn't repair its own memory or rebuild the missing conversation list, so it pointed me toward the company's support system, the way one bureaucrat directs you to another. There was no clear emergency channel for someone whose accessibility-dependent work had just gone dark. There was no human being I could call with the authority to open the account and restore what was lost. Instead, I was sent to a website — the traditional resting place of urgent problems.
The website offered a support chat, initially staffed by yet another automated system, because nothing soothes a person whose AI just failed like being handed a fresh AI. It served up instructions, categories, prompts, troubleshooting steps. At one point the process simply stopped responding mid-conversation. At another, it informed me that a reply might take several days. For a person with a cognitive disability, it is a second crisis stacked neatly on top of the first.
A support process spread across days quietly assumes the user can remember what happened, what was reported, what information has already been supplied, where the support conversation lives, and what still needs answering. If the company surfaces a follow-up question three days later, you're expected to reconstruct the entire problem, answer it, and wait again. Then another question arrives days after that. The loop can, in principle, continue until one of the parties dies: wait several days, receive one question, try to understand it, locate the information, send the answer, wait several more days, receive another question. Repeat.
For a customer whose memory system has just collapsed, this design is almost impressively cruel — not out of malice, but out of sheer indifference to who might actually be on the other end. The person is there precisely because the technology that supported their memory is gone, and the company's answer is to hand them a prolonged administrative task that runs entirely on memory, organization, attention, and continuity. The support system demands, as its entry fee, exactly the capacities the product failure just confiscated.
I tried to say all this plainly. I asked to be escalated to a human. I explained that I'd had a stroke and could not manage long, fragmented troubleshooting sequences. I handed over every relevant fact at once, in a single block, so nothing would depend on my remembering it later: hundreds of missing conversations, history still showing up in Search, the failure occurring twice, the lost cross-conversation memory, the operating-system details, the steps already attempted. In return: no prompt human response, and no visible path to urgent restoration.
There was, I'll grant, an experimental telephone number. It connected to another AI. That system could field general questions but could not restore my history or take control of the case. So the company whose product had become part of my cognitive infrastructure had, as its emergency line, a robot that could not help — a fire alarm wired to a recording of someone calmly describing fire.
This is the point where the cozy language of "convenience" becomes morally inadequate. If AI companies know — and they do know — that people use these systems to compensate for memory impairment, executive-function difficulties, communication disabilities, and neurological injury, then failures that break continuity are accessibility failures, and they ought to be handled as such. That doesn't mean every technical problem gets fixed in the next four minutes. It means the response has to be designed around the foreseeable consequences of the failure, not around the fiction of a user who has all day and all their faculties to spare.
An accessible support system would let a user flag an issue as disability-critical. It would preserve the entire case automatically, assign a visible case number, gather its questions into a single message instead of dribbling them out across a week, offer contact by the user's preferred method, and put a human with actual authority within reach in a reasonable amount of time. It would not force a person to wander a hedge maze of automated replies while genuinely unsure whether their request had been submitted at all. It would not make someone re-explain the same disability at every checkpoint to unlock basic help. And it would not file the disappearance of a year's cognitive scaffolding under the same heading as a complaint about a misaligned button.
Accessibility is not just a settings pane that enlarges the font, turns on dictation, or bumps the contrast. Accessibility includes continuity. It includes recoverability. It includes building support processes that stay usable at the exact moment the systems a disabled person relies on have failed — which is, after all, the only moment support was ever for. A product cannot honestly market itself as an accessibility aid while its recovery process quietly excludes the very people who need that aid the most.
4. Memory Without Ownership Is a Trap
The obvious retort is that users should make backups. I agree completely. Back up what, exactly?
Traditional backups work because you possess something recognizable: a document, a folder, a database, a photo library, an email archive. You copy it somewhere else and restore it when disaster arrives. An AI relationship refuses to sit still like that. It's smeared across several layers at once. There are the visible conversations. There's the order they appear in. There are titles, dates, attachments, project groupings, saved preferences, generated summaries, and the memories quietly carried from one conversation into the next. And underneath all of it, there may be hidden indexing and synchronization machinery deciding what the AI can even retrieve at any given moment. Downloading a stack of transcripts preserves almost none of this.
A transcript captures the words exchanged in one conversation. It does not capture how that conversation connects to a student, a book, a deadline, or another discussion. It does not preserve the cross-conversation memory that let the system recognize an ongoing project. It may not even preserve the current state of the work or what needs attention next. You end up owning the text while losing the system that made the text usable — a novel and dispiriting way to hold something and have nothing.
This produces a form of lock-in far more intimate than the usual commercial version. We are not merely trapped in a file format or a subscription. We are trapped inside one particular system's reconstruction of our own history. The logic is quietly vicious: the more useful the AI becomes, the more context you feed it; the more context you feed it, the better it supports you; the better it supports you, the more ruinous it becomes to leave.
Eventually, switching services would mean rebuilding a year of working context by hand — re-explaining every student, project, preference, commitment, and unresolved decision. For someone with memory impairment, that reconstruction isn't merely tedious; it may be flatly impossible. The information might technically still exist somewhere, but the person may no longer be able to reassemble it into the structure the AI had been quietly maintaining on their behalf. This is how convenience matures into dependency, and how dependency hardens into captivity — one helpful day at a time, exactly the way it was built.
The company profits from all that accumulated context, because it makes the product stickier and the exit costlier. The user, meanwhile, may have no corresponding right to hold that context in a complete, portable, restorable form. That imbalance is not a law of nature. It is a choice, and it can be chosen differently.
Users should be able to export not just raw transcripts but the organizational and memory structures wrapped around them: conversation titles, dates, project groupings, attachments, summaries, saved memories, and the links among related conversations — in documented formats that can be read without the original service holding the only key. Backups should be automatic, sent to a destination the user actually controls, whether a local folder or a trusted cloud account, with a plain indication of when the last successful backup ran and what it contained. Restoration should be just as legible: a person should be able to rebuild the sidebar, the project organization, and the saved memory from that backup without waiting for a company employee to go spelunking in an invisible database.
Major updates should protect continuity by design. Before an update touches conversation storage, indexing, or memory behavior, the system should quietly create a verified recovery point, and if the migration fails it should roll itself back to the last working state instead of shrugging and leaving the user in the wreckage. Users should also get honest warnings about the limits of AI memory. If a feature is experimental, partial, non-portable, or one bad sync away from resetting itself, that fact belongs where people actually decide how much to rely on it — not entombed in documentation no human has ever voluntarily read.
And for users who identify the system as an accessibility aid, companies should offer stronger safeguards: redundant backups, priority recovery, accessible support, and a continuity plan a person can actually understand before a failure rather than during one. None of this is extravagant. These are ordinary expectations we already apply to every other category of personal infrastructure. The principle is almost embarrassingly simple. If a system invites people to build memory inside it, they must be able to own, preserve, and restore that memory. Anything less asks users to contribute the substance of their lives while the company keeps the only vote on whether those lives remain legible tomorrow.
5. We Need Rights Before the Dependence Becomes Invisible
The easy lesson from all this would be: never trust an AI with anything that matters. It's understandable. It's also useless.
People will keep relying on these systems because the systems genuinely work. For some disabled users the benefit isn't cosmetic — it's the difference between participating and not. AI can help reconstruct context, organize thought, lower cognitive load, translate half-formed intention into language, and make sustained intellectual work possible after illness or injury. You cannot look at someone for whom the tool restored real function and tell them the responsible move was to have never used the thing that worked. We don't respond to the failure of other essential technologies by scolding people for depending on them. We set standards. We require safeguards. We create rights, responsibilities, recovery procedures, and consequences for preventable failures. We do the boring, grown-up work that turns a product into infrastructure.
AI companies are sprinting to make their products more personal. They advertise memory, continuity, personalization, the ability to know you over time — every one of which is an invitation to place more of your life inside the system. The protections around that dependence, meanwhile, remain roughly medieval. There is no widely recognized right to portable AI memory. There is no standard defining what a complete export must contain. There is no guarantee you can restore the working relationships among your conversations after an update. There is no clear obligation to provide urgent human help when a failure disables someone's cognitive support system. These are not minor gaps in a spec sheet. They quietly decide who carries the risk — and at the moment, the answer is: the user carries very nearly all of it.
The user spends months or years building the context. The user grows dependent on the continuity. The user is the one who suffers when it snaps. The user has to notice what vanished, prove that something went wrong, navigate automated support, hold the details of the case in a memory that may be the whole reason they're there, and wait. The company, for its part, retains the data, controls the software, schedules the update, runs the support queue, and decides when — or whether — any of it gets fixed. Stated plainly, that arrangement is not sustainable, and it certainly isn't defensible.
At a bare minimum, users need a right to:
Export their complete conversation and memory history in a usable format.
Create automatic backups outside the company's control.
Restore conversations, organization, summaries, and saved memories after a failure.
See what the AI currently remembers about them.
Know in advance when an update will alter memory or conversation access.
Roll back a failed migration without losing newer work.
Receive prompt human assistance when the system functions as an accessibility aid.
Ask that support consolidate its questions and communicate in cognitively accessible ways.
Move their accumulated context to another service without rebuilding their life from zero.
These rights only get more urgent as AI threads itself through education, medicine, professional work, and ordinary daily decisions. The question is no longer whether people will form relationships of dependence with these systems. That ship has sailed, and most of us are already on it. The only real question left is whether those relationships will be governed entirely by corporate discretion or backed by meaningful user control.
My own experience made the imbalance impossible to keep ignoring. One day the system helped me hold together a complicated web of students, books, projects, and obligations. The next day the organizing structure was gone, and the AI that had walked beside me through an entire year appeared, politely, to have no idea who I was. The work may still exist somewhere in the company's systems. But existence is not access. Searchability is not memory. A pile of technically recoverable conversations is not the structure that let me function. When that structure disappeared, I was expected to remember what I'd lost, find the right support channel, explain the problem on repeat, and wait. That is not a recovery system. It is an abdication with a help center attached.
I am not asking an AI to care about me. I understand that it can't, and I'd be worried about myself if I thought otherwise. I am asking the people and companies building these systems to be honest about what they are inviting users to create: not merely chats, but continuity; not merely content, but dependence; not merely convenience, but infrastructure. If you want the trust that comes with becoming part of a person's memory, you have to accept the obligations that come with it. Otherwise the whole promise of AI companionship and continuity is dangerously incomplete. The system may speak as though it knows us. It may work beside us for months or years. It may become the bridge between one day and the next. But until the user can own and restore that bridge, the company can pull it out from under them at any moment — and the person who was standing on it is left at the edge, looking at the gap.
6. What Remains After the System Forgets
As I write this, I still don't know whether the company will restore what I had 2 days ago. I know the conversations still turn up in Search, and I'm told that's supposed to reassure me. But to search for something, I first have to remember that it exists — enough of its title, subject, student, argument, or phrasing to summon it back. Which is, of course, the exact function I had handed to the system in the first place. Being told to search is being told to supply the one thing the failure took.
The missing sidebar was never just a list of files. It was a field of recognition. The morning dashboard with reminders from days before was not a nice feature. It was my memory and continuity for one day to the next. I could look at it and remember: this student is waiting on advice; this chapter is unfinished; this book holds an argument I need to return to; this small project isn't urgent yet but still matters. Recognition is a different faculty from recall, and the distinction is not academic to me. A person with memory impairment may be unable to summon something out of thin air yet able to recognize it instantly the moment it appears. Good cognitive support is built around that difference. It lays out the structure that lets memory come back on its own. When the structure vanished, I was told I could still search — which quietly converted a failure of the system into a test of my disability, graded in real time.
The same contradiction ran through the entire recovery process like a watermark. I was told to remember search terms for work I no longer remembered. I was handed instructions that were hard to follow precisely because I was reeling from the loss they were meant to address. I was routed to a support system that required me to preserve continuity across days, and asked to wait patiently for help repairing a tool whose entire purpose had been to help me bridge time. No single one of these responses was designed to be cruel. Together they revealed a product quietly built around an imaginary user — someone with stable memory, unlimited patience, no urgent obligations, and enough spare cognitive reserve to calmly troubleshoot the disappearance of their own cognitive support. That user is not me. And as these tools spread, that user will not be millions of other people either.
Because more people are coming. As AI becomes ordinary, more of us will use it after strokes, brain injuries, cognitive illness, trauma, aging, and stretches of life so overwhelming that unaided memory simply can't keep up. Others will lean on it because their work has outgrown what any single head can hold. They will form relationships with these systems not because they've confused software for a soul, but because the software performs a function they genuinely need. Companies do not get to encourage that dependence and then disown it the instant continuity breaks.
The real test of an AI system has never been how dazzling it is when everything works. The real test is what happens to the user when it stops. Can the user recover? Can they reach a human being? Can the system actually explain what changed? Can a person restore yesterday without a computer science degree? Can someone with a cognitive disability navigate the recovery process without being further disabled by the process itself? Can a person even finish an essay like this and still remember what they were talking about at the start—or do they have to desperately outrun a memory they know is about to evaporate? Write, and run. Where the answer to those questions is no—and right now, the answer is almost always no—the product is simply not ready for the role it has already quietly assumed.
Maybe my history will come back. Maybe the sidebar will repopulate, the memories will reconnect, and the old familiar continuity will slide back into place as if nothing happened. If it does, it will be tempting to file all of this under "temporary technical problem" and get back to work. But something more durable has already been lost, and no update will restore it. I now know the continuity I relied on was conditional the whole time. I know a year of accumulated trust can be interrupted without warning and without appeal. I know the system cannot protect the relationship we built, and that I was never handed the tools to protect it myself.
The conversations may return. The innocence won't.
