Can AI learn? When most people ask that, they have a chatbot in mind. They’ve corrected ChatGPT or Claude, watched it agree, and want to know whether the correction will still be there next week. The question matters more now that ChatGPT, Claude and Gemini all advertise memory, and it sits underneath the bigger argument about whether today’s AI counts as general intelligence, because a mind that can’t carry a lesson forward on its own is missing something most of us would call basic. For anyone using AI at work it comes down to something practical: can you teach a tool how your business runs once, or will you be teaching it again every Monday?
The short answer is yes, though not in the way people learn. A model such as ChatGPT learns during training, after which its weights (the internal numbers it learned) are frozen, and while a chat lets it adapt to what you show it and memory features save notes about you, neither of those changes the model, which gets smarter only when its maker trains and releases a new version.
We tested the practical side of that answer over 25 days, from 16 September to 10 October 2026, in a project that began with a search for a power-assisted shopping trolley and grew into a hunt for a genuinely new, patentable invention. We worked with ChatGPT first, then with Anthropic’s Claude Code and OpenAI’s Codex (two coding assistants that read and write files on a computer), and finally with a team of AI agents. An agent here means a copy of a model given a role, written instructions and tools so it can carry out a task without step-by-step direction, and our team had 25 defined roles. The search itself is written up in our study of whether AI can invent, and this article looks at a side of it that turned out to matter just as much. Each new AI session (a fresh conversation or run) starts with nothing but what it is handed, so every correction and lesson had to be written into files for the next session to read, and by the end there were 215 written lessons while the same kinds of mistake were still coming back within days.
Most of what follows is about ordinary chatbots in ordinary use, though some AI really does keep learning as it goes (a Go engine that trains against itself, for example), and we explain early on why the two behave so differently before getting to what ChatGPT, Claude and Gemini remember and what our own 25 days showed.
Can AI learn? Three different answers
The word “learn” covers three quite different things when the subject is a chatbot, and most confusion comes from mixing them up.
- Training: A model’s internal numbers, its weights, are adjusted across a huge body of text and code until it predicts well, which is learning in the full technical sense and the only kind that changes the model itself.
- In-context learning: Inside one conversation, the model adapts to your examples and corrections and answers better for the rest of that chat.
- Memory: A product saves notes about you or your project and feeds them back into later conversations.
Of the three, only training lasts, since in-context learning disappears when the conversation does and memory persists only as text the model reads, leaving the model itself exactly as it was.
We asked ChatGPT how it learns on 10 October 2026, the last day of the study described later in this article, partly to see how the tool would describe its own limits. It made the same split, saying that “memory, learning and reasoning are three different capabilities”, and summarised them in a small table: the weights are normally fixed after training, the context window is finite and temporary, and persistent external memory “requires reliable retrieval and validation”. A model’s account of itself isn’t evidence of how it works (it has no view of its own weights), so we treat what ChatGPT told us as a claim to check. Where we lean on it, OpenAI’s documentation or published research says the same thing, and where an idea is only ChatGPT’s, we say so.
Training, the first of the three, comes in a few main kinds:
- Supervised learning: The model is shown examples with the right answers attached, such as photos labelled “cat” or “dog”.
- Self-supervised learning: The model finds patterns in raw text by repeatedly predicting the next piece of it, which is how large language models are pretrained.
- Reinforcement learning: Outputs that score well against some goal are rewarded, from winning a game to giving an answer people prefer.
The networks doing this are loosely inspired by the brain, in that they are layers of simple units whose connection strengths change with experience. The resemblance is much thinner than the name suggests, though, and the way the learning is switched on and off is very different from anything a person does.
How is machine learning different from the way people learn?
People learn continuously, and the biggest difference is that a person’s experience keeps feeding back into them without anyone pressing a button. Curiosity sends them looking for the thing they didn’t understand, and the embarrassment of getting something wrong in front of colleagues makes the correction stick. To be fair to the machines, people also reuse what they already know far more than they invent. Whether a model can produce knowledge it was never given is a separate question, which we cover in our piece on whether AI can create knowledge it was never given. Here the question is narrower: when you correct a model, where does that correction go?
My own background sits on both sides of that comparison, since I trained as a software engineer, where deployed software runs with fixed code instead of rewriting itself while you use it, and I also teach, leading Opace’s SEO training courses. Teaching gives a very practical test for learning, because in a classroom the evidence that someone has learned is that a correction shows up the following week, on a different example, without anyone repeating it (agreement in the moment tells you much less), and it’s the test we applied to the AI tools in our study.
Which kind of AI are we talking about?
People asking “can artificial intelligence learn continuously?” often have something like AlphaGo Zero in mind, and that kind of AI plainly can. DeepMind’s 2017 paper in Nature, Mastering the game of Go without human knowledge, describes a system trained with no human game data and no guidance beyond the rules of Go. Starting from random play, it learned by playing against itself and training on the results, so that in effect it became its own teacher, and it went on to beat the version of AlphaGo that had defeated a world champion by 100 games to 0.
Recommendation systems are a more everyday case, because they are retrained on what people click and watch. Some research systems built on language models also keep improving their output inside a loop that scores every attempt, and we come back to those further down.
A large language model (LLM) such as ChatGPT, Claude or Gemini, which is what most people mean when they ask whether AI can learn, works differently. It is trained, tuned and then released, after which the weights stay fixed while millions of people use it, and nothing you type makes the model practise in the background. So the answer depends on the system: for a Go engine or a recommender it’s yes, continuously, while for a chatbot it’s yes during training and only temporarily during use.
That difference shaped how we judged our own study, because a Go engine has a referee built in (every game ends in a win or a loss) and our agents had no referee of that kind, so if they were going to learn from one session to the next, the lesson had to be written somewhere they would read it.
How LLMs learn: training, in-context learning and memory
Those three kinds of learning happen at different points in a model’s life, so we’ve taken them in that order, starting with the training a model goes through before anyone outside the company uses it.
Training: where the real learning happens
A large language model starts as a network with billions of adjustable weights and learns by predicting text, over and over, across a training set far larger than anyone could read. Each wrong prediction nudges the weights a little, and after enough nudges the model has absorbed grammar, facts, styles of argument and a good deal of code. Opace’s 2023 explainer of how ChatGPT is trained put it simply:
“In order to learn, ChatGPT needs training”
Three years and several generations of model later, we’d still start the answer there.
Pretraining is followed by tuning stages that shape the raw model into an assistant. OpenAI’s 2022 paper, Training language models to follow instructions with human feedback, showed how much this matters. People preferred the answers of InstructGPT, a tuned model with 1.3 billion parameters, to those of the 175-billion-parameter GPT-3. A model more than 100 times smaller won because it had been trained on human feedback about what a helpful answer looks like.
The newest stage is reinforcement learning aimed at reasoning. OpenAI introduced o1 on 12 September 2024 as a model “trained with reinforcement learning to perform complex reasoning”. DeepSeek’s paper in Nature the following year, DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning, went further and reported that reasoning could be encouraged through reinforcement learning alone. Its first model, DeepSeek-R1-Zero, was trained by reinforcement learning straight from a base model, skipping the usual step in which people write out worked examples of reasoning for the model to copy, and the reward depended only on whether its final answers were correct (a rule-based checker scored the answer and its format, and nothing constrained how the model reasoned its way there). The authors report that the model learned to spend more thinking time on harder problems and picked up habits such as checking and reflecting on its own work, with the strongest gains on tasks that can be verified, such as maths, coding competitions and science questions. Whether that adds up to reasoning in the full sense is a separate argument, covered in our article on whether reasoning models really reason. For learning, what matters is that all of it happens before release, inside the maker’s training pipeline, after which the weights are fixed.
That fixing is where the quality of the training data starts to matter for good. If the data carried a bias, a falsehood or deliberately poisoned material, the model absorbed it, and an ordinary conversation can’t reach in and repair it. You can tell the model otherwise in a chat, but the next chat starts from the same weights. Weights can’t be read and corrected like entries in a database, which is why fixing a model usually means retraining or tuning it instead of editing a single fact.
The one form of training most businesses can reach is fine-tuning, in which a customer trains a private copy of a model on its own examples and gets back a separate model, with adjusted weights, that only that customer uses. Google’s documentation on tuning Gemini models in Vertex AI describes giving a model a training dataset of examples of the task you want, and OpenAI offered the same for years, although its model optimisation guide now says it is winding down its fine-tuning platform, which is closed to new users (we checked on 13 October 2026). It is genuine learning in the technical sense, and also a deliberate project with its own data, cost and testing. It doesn’t happen because staff chat to the tool, and it leaves the public model everyone else uses untouched.
In-context learning: learning that disappears
The most surprising kind of learning happens without any training at all. The GPT-3 paper, Language Models are Few-Shot Learners (Brown et al., 2020), showed that a 175-billion-parameter model could pick up a new task from a handful of examples placed in the prompt. The authors stressed that GPT-3 did this “without any gradient updates or fine-tuning”, which is the technical way of saying nothing inside the model changed. Give a model three examples of how you write product descriptions and the fourth will look like yours, even though the model is exactly as it was.
In-context learning has two limits, and we ran into both constantly:
- It is temporary: It lasts only as long as the context does, so a new session starts from scratch unless something feeds the examples back in.
- It is uneven: A model doesn’t use everything in a long context equally. Liu and colleagues, in Lost in the Middle: How Language Models Use Long Contexts (TACL, 2024), found that accuracy drops sharply when the information a model needs sits in the middle of a long prompt instead of near the start or the end.
If you paste long documents into a chatbot, what we’d take from this is to put the instructions and the facts that matter most at the start or the end, and to keep the prompt no longer than it needs to be, because a bigger context window lets a model see more without any guarantee that it weighs everything it sees equally.
Memory features: saved notes the model reads
Memory features sit on top of all this: a product saves some text, either because you asked it to or because it decided something looked worth keeping, and later retrieves the relevant pieces and places them into the context of a new conversation. Web search works the same way, since a search result is text handed to a fixed model, which reads it as it would read anything you paste in.
The general technique has a name, retrieval-augmented generation (RAG). Lewis and colleagues introduced it in a 2020 paper, Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks, which paired a language model with a searchable index of Wikipedia so that it could look facts up instead of relying only on what was stored in its weights. Their starting point was that knowledge held in weights is hard to inspect or update, while an external index can be checked and replaced. Chatbot memory is a small, personal version of the same idea, in which the store is a set of notes about you and a retrieval step decides which of them the model sees.
The weak point of any such store is the one ChatGPT flagged in its table, retrieval and validation. A memory system is only as good as what it chooses to store and whether it finds the right piece at the right moment, and a retrieved note can be out of date, a saved preference can be wrong, and a model can have the note in front of it and still miss it, as the Liu chart shows.
Can ChatGPT learn from your conversations?
ChatGPT can’t learn from your conversations in real time, which is usually what the question means. Its own summary for us was that its weights don’t change during ordinary use (the technical way of saying that answering you doesn’t alter it). Inside a chat it adapts to what you say, and across chats a memory feature may carry notes forward, but the model you’re talking to on Tuesday is the same model whether or not you spoke to it on Monday.
There is a slower route, and it’s the one people half-remember when they say ChatGPT learns from users. OpenAI’s policy page, How your data is used to improve model performance (updated 13 March 2026), says ChatGPT “improves by further training on the conversations people have with it, unless you opt out”. So in aggregate, and later, AI does learn from users, at least in ChatGPT’s case. Your conversation can become one example among an enormous number in a future training run, the result ships as a new model for everyone, and nothing about that process lets the current model remember you.
Does ChatGPT learn from users? The training rules for ChatGPT, Claude and Gemini
The rules differ by provider, plan and setting, and they have changed several times since 2024. These were the positions on 10 October 2026:
- OpenAI: The same policy page says content from individual ChatGPT accounts may be used to train models, with an opt-out in Data Controls or through OpenAI’s privacy portal, after which new conversations are left out of training, and Temporary Chats are never used for training. For ChatGPT Team, Enterprise and the API, the page says OpenAI does not train on inputs or outputs by default.
- Anthropic: Its Updates to Consumer Terms and Privacy Policy (28 August 2025) gave Claude Free, Pro and Max users, including Claude Code on those accounts, “the choice to allow their data to be used to improve Claude”. Allowing it extends data retention to five years; otherwise the existing 30 days applies. The change covers new or resumed chats and coding sessions. Claude for Work, Claude for Government, Claude for Education and API use sit under the commercial terms and are excluded.
- Google: Its help page on memory of your past Gemini chats covers personalisation (we come to it under Gemini’s memory below) but doesn’t say whether the same chats train Google’s models, so we wouldn’t assume either way without checking the Gemini Apps privacy settings on the account.
A provider’s next model may be trained partly on many people’s chats, while the model you’re using adapts only within the chat and reads whatever memory notes the product hands it, and because all three routes sit behind the same chat box, their controls are easy to confuse. Turning off training doesn’t switch off memory, and turning off memory doesn’t stop training. OpenAI’s Memory and new controls for ChatGPT page adds a third wrinkle that surprised us: deleting a chat doesn’t erase the memories it created, which have to be deleted separately.
A saved memory changes behaviour for one user only, as we found when we asked Claude to always push back and stay impartial. It saved the instruction as a memory note, and later sessions behaved differently because that note was loaded into their context; it worked from the very next answer, which started questioning our own suggestions as readily as the AI’s. No other Claude user was affected, and the note was a short piece of text we could read, edit or delete, which is more than anyone can do with a change buried in a model’s weights.
Does AI remember? ChatGPT, Claude and Gemini memory explained
Memory is the feature all three companies now advertise, and each builds it a little differently, so we’ve taken them one at a time before asking what memory means for a language model at all.
Does ChatGPT remember previous chats?
Within one chat, yes, up to the limit of its context window, though having a message in the context isn’t the same as keeping it in force (the first stage of our study, described below, shows how a constraint can sit in a conversation and still be ignored). When we asked ChatGPT on 10 October whether it still had our whole conversation, it said it did and described the limit accurately:
“This isn’t unlimited memory of everything we’ve ever discussed; it’s access to the conversation history currently available to me.”
That’s about as straight an answer as a chatbot can give, and it’s worth reading carefully, since it describes the text in front of the model and says nothing about the model itself. A model can also be wrong about its own behaviour while sounding sure, and in that same conversation ChatGPT confidently explained one of its own glitches and later withdrew the explanation as incorrect.
Beyond the current chat, ChatGPT’s memory works in two ways: OpenAI’s memory page, first published on 13 February 2024, says that since an update on 10 April 2025 memory covers both saved memories, which you’ve asked it to keep, and chat history, which it describes as insights gathered from past chats. A 3 June 2025 update gave free users a lighter version that offers short-term continuity across conversations, while Plus and Pro users get a longer-term understanding of the user. Both can be switched off in Settings. Temporary Chat stops a conversation creating or updating memories, though OpenAI’s Temporary Chat help page says a personalised temporary chat can still use existing ones.
ChatGPT’s cross-chat memory also showed up in that October conversation, in a way that is hard to inspect. We had described the study in general terms, without mentioning the trolley. ChatGPT then made a behind-the-scenes lookup whose result our exported copy of the chat doesn’t show, and went on to recall the September trolley work in some detail. The trolley appears nowhere earlier in that conversation, so the knowledge came from outside it, and the memory feature is the obvious candidate.
What we can’t see is what was retrieved, how much of it, or whether it included the constraints we had set for the trolley in September. By then we had learned not to trust a memory that kept the headline of a project and lost its constraints, and that is the practical weakness of memory as a stand-in for learning: you don’t choose what is kept, you can’t easily see what is retrieved, and the summary the product stores may be a simplified version of what you actually said.
Does Claude remember?
Claude has memory beyond the current chat too, with the same split between conversation and memory and a few differences that suit project work. Anthropic’s help page on chat search and memory says memory is on by default for Free, Pro and Max plans, that Claude saves memory as a set of individual topics as you chat, and that each project has its own separate memory space and project summary, with searches inside a project limited to that project’s conversations. Memory can be paused, reset or bypassed with an incognito chat (the FAQ at the end of this article covers what each of those does), and chat search itself is limited to paid plans.
Claude Code, the version we used for most of the study, keeps its memory in files on your computer: instructions in a CLAUDE.md file, plus notes Claude writes for itself, are loaded at the start of every session, which is the mechanism our whole study ended up leaning on. Those notes can also cross between sessions without anyone choosing them. According to Anthropic’s Claude Code documentation, Claude’s own notes live in one memory folder per project, shared by every session working in it, and that is the most likely route for something that happened to us while several Claude sessions were running side by side on different parts of the search. A note written by one of them turned up in another, reminding it not to build a piece of software we hadn’t yet approved. The note was accurate, but nobody had decided it should travel, which is useful when a note is right and a problem when it isn’t.
Does Gemini remember?
We didn’t use Gemini in the study, so this section rests on Google’s documentation. Asked whether Gemini learns from conversations, Google’s own help page would say yes, since it describes memory of past chats as a way for Gemini to “learn from your chats to understand more about you and your world”. The mechanism the page goes on to describe, though, is personalisation from saved past chats, the same thing OpenAI and Anthropic call memory, and anyone reading Google’s verb as evidence that Gemini’s model improves from their conversations is reading more into it than the page says. The feature needs you to be 18 or over, signed in with a personal account (a work or school account won’t do), and to have Keep Activity switched on, and it can be turned off from the app’s settings.
Do LLMs have memory at all?
Strictly, a language model on its own has one kind of memory, the context window, which holds the current conversation and whatever has been fed into it. Everything else is storage built around the model: a database of notes, a search index or a folder of files, plus a step that decides what to retrieve. That’s why “does AI have memory?” is really a question about the product built around a model, since two products using the same model can remember very different things depending on what they store and how they search it.
Memory keeps a mistake just as carefully as a correction, so a system that stores a wrong conclusion as fact will build on it, and more memory only gives it more to build on (later answers can grow more sophisticated while resting on the same flaw). ChatGPT raised exactly this risk when we asked it about memory, and our own study had a version of it, described below, when an AI summary miscounted the lessons we had written down.
Does ChatGPT get smarter the more you use it?
It gets more personal the more you use it, and it gets smarter when OpenAI ships a better model. The two are easy to blur, and OpenAI’s own wording doesn’t help. The April 2025 update on its memory page says:
“The more you use ChatGPT, the more useful it becomes.”
That’s true of a product that remembers your preferences, and a long way from saying the model’s ability to reason, write or code improves because you used it.
Our own blog gives a small first-hand record of this, because it spans several generations of model:
- In December 2022 we wrote up our first GPT-3 SEO experiments, testing whether the model could help with SEO copy at all.
- By mid-2023 we were explaining to readers how ChatGPT is trained.
- In September 2024 we added a section on OpenAI’s o1 to our article on ChatGPT as an AI inflection point, calling o1 a turning point for reasoning (one line of that section was wrong, and the myth table below explains how we’ve corrected it).
- In June 2026 we published a case study of agentic coding, where AI agents write and test code under an expert’s direction, in this case building a 113-page website, which is how we now approach AI web development for clients.
The jump between the first and the last of those is enormous, and none of it came from the tools learning from us. Each step arrived with a new model, or a new product built around one, released to everyone on the same day.
OpenAI is open about where the improvement comes from, since its data policy says it improves its models through research breakthroughs as well as exposure to real-world problems and data, and that’s the real sense in which ChatGPT gets smarter over time. Conversations, where people allow it, feed into the next training run alongside new research, and the result arrives as a model release rather than as a gradual change in the one you’re using.
On the memory side, Opace’s August 2025 post on GPT-5, written by our colleague Adam Bullas before launch, listed the long-term memory we hoped GPT-5 would bring, including project-specific memory, because every project is different. GPT-5 launched that August, documented in OpenAI’s GPT-5 system card, and both ChatGPT and Claude now offer something close to that project memory. What arrived was a product feature that stores and retrieves notes for each project, which we relied on (in Claude Code’s version) throughout our 25 days and found genuinely useful, even though underneath it’s a filing system wrapped around a fixed model.
There’s a quieter limit too, which is that a language model isn’t a live database. It knows what was in its training data up to a knowledge cut-off, and if the world has moved on since then it will answer from the old picture unless search or memory hands it something newer. With anything recent, the useful question is where the answer came from, because “the model knows” and “the model was just shown” look identical in the reply. The same applies when someone asks a chatbot about your business: if it describes you wrongly and you correct it in a chat, the correction doesn’t reach the model, and next time it will answer from whatever search finds again, so changing the answer means changing what it can find, which is where AI SEO work comes in.
Why can’t chatbots learn as they go?
If a new release is the only way ChatGPT gets smarter, the obvious question is why the makers don’t simply let a model keep learning from its conversations, the way a person does. Part of the answer is technical: Dohare and colleagues, in Loss of plasticity in deep continual learning (Nature, August 2024), start from the observation that deep learning is almost always used in two phases: one where the network’s weights are updated, and one where they’re held constant while the network is used.
When they kept training networks on a long stream of new tasks, they found that “standard deep-learning methods gradually lose plasticity in continual-learning settings until they learn no better than a shallow network”. They showed it on the ImageNet image dataset and on reinforcement-learning problems, across a wide range of network designs and learning algorithms. Their fix, continual backpropagation, keeps the network flexible by randomly reinitialising a small fraction of its less-used units as it goes.
The older problem runs the other way, since training a network on something new tends to overwrite what it learned before, which researchers call catastrophic forgetting. Kirkpatrick and colleagues, in Overcoming catastrophic forgetting in neural networks (published in PNAS in 2017), noted that this had long been thought an unavoidable feature of neural networks, and showed a way round it that slows learning on the weights most important to earlier tasks. Neither paper says continual learning is impossible, though both show it’s hard, and much harder than the train-then-freeze routine every major chatbot uses.
The practical reasons are simpler and, to us, more convincing:
- One model, millions of users: A correction from one of them would change the answers everyone else receives, and the next user might be correcting it back.
- Poisoning: A model that updated itself from conversations would be open to deliberate attempts to teach it falsehoods.
- Leaks: Private details from someone’s chat could end up in the model’s general knowledge.
- Auditing: Every answer would come from a model that differed from yesterday’s in ways nobody had reviewed.
This is also where the line between today’s chatbots and general intelligence tends to get drawn, and in March 2026, writing about how AI is shaping the future of SEO, we picked out an AGI that learns in real time as the thing that would set a future system apart from current LLMs. That still looks like the right line to us, and nothing in our study suggests today’s chatbots have crossed it. What they have instead is a set of safer substitutes: memory you can switch off, training you can opt out of, and new versions released on a schedule someone has tested.
Can AI self-improve?
Self-improvement is the one place where AI does keep getting better without a new release, and it’s real inside systems built with an automatic judge, which is easiest to see by looking at what does the judging. AlphaGo Zero, described earlier, had the simplest judge imaginable, a win or a loss at the end of every game, so nobody had to read its moves and decide whether they were good.
DeepMind’s FunSearch applied the same idea to mathematics. The Nature paper, Mathematical discoveries from program search with large language models (Romera-Paredes et al., published January 2024), describes “an evolutionary procedure based on pairing a pretrained LLM with a systematic evaluator”. The language model proposed programs, the evaluator scored each one, the evolutionary loop built on the best, and the search found new constructions for the cap set problem that went beyond the best previously known. The improvement lived in the growing pool of scored programs, and the authors present the evaluator as their guard against the way language models sometimes produce plausible but incorrect statements.
Google DeepMind’s AlphaEvolve, announced on 14 May 2025, scaled that up. Google DeepMind describes it as pairing Gemini models with automated evaluators that verify answers, inside an evolutionary framework, and says one of the heuristics it found for Google’s data centres recovers, on average, 0.7% of Google’s worldwide computing resources. DeepSeek-R1, described in the training section above, used the same principle during training, with what amounted to an answer key as its judge.
The most direct example of an AI improving itself is the Darwin Gödel Machine from Jenny Zhang, Shengran Hu, Cong Lu, Robert Lange and Jeff Clune (arXiv 2505.22954, first posted 29 May 2025 and revised in March 2026). It is “a self-improving system that iteratively modifies its own code”, testing each change on coding benchmarks and keeping an archive of the agents it has produced, from which it picks earlier versions to build on so that it can explore more than one line of improvement at once. Over its runs, performance on SWE-bench rose from 20.0% to 50.0%, and on Polyglot from 14.2% to 30.7%. What improved was the agent’s scaffolding around a foundation model (better code-editing tools, ways of managing a long context, peer-review steps), and the benchmark decided which changes were kept. The authors report that it outperformed versions without self-improvement or open-ended exploration, which is good evidence that the self-modification itself was doing the work, and they state that “All experiments were done with safety precautions (e.g., sandboxing, human oversight).”
There’s a well-documented way for this to go wrong, which Shumailov and colleagues showed in Nature in July 2024 in AI models collapse when trained on recursively generated data, that “indiscriminate use of model-generated content in training causes irreversible defects in the resulting models”. The rarer parts of the original data, the tails of the distribution, are the first to disappear, so a model that learns mainly from its own output without an outside check drifts towards a narrower, blander version of what it started with. Every working example above avoids that because something outside the model, a game, a scorer or a test suite, decides what is kept.
Can AI learn on its own?
Whether AI can learn on its own comes down to that judge: in a narrow domain with one, it can, and a chatbot left to itself doesn’t. There’s a middle route, though, which ChatGPT suggested when we asked it about memory on 10 October and which researchers have tried in other forms. Take two identical copies of a model with exactly the same fixed weights. One, call it LLM A, starts every task with no record of its earlier work, while the other, LLM B, has a growing, verified store of its own findings, and B could solve problems A can’t simply because it has better information and earlier solutions to hand.
In ChatGPT’s words, a model that has been handed 10,000 new facts “has more material to work with, but its reasoning machinery hasn’t improved”. The exception it gave is a stored method, such as a way to solve a class of maths problem in 100 steps instead of 10,000, which would make the system better at that task without touching the weights.
Both halves of that have support outside ChatGPT. The retrieval research described earlier rests on the first, that a fixed model with a better store answers better, and Voyager, an agent described by Wang and colleagues in 2023, is close to the second. It played Minecraft by sending queries to GPT-4, with no fine-tuning of the model’s weights, and kept “an ever-growing skill library of executable code” that it could retrieve and reuse, and its authors report 3.3 times as many unique items and key milestones reached up to 15.3 times faster than earlier methods. In that narrow, practical sense a system built around a fixed model can get better through memory, as long as someone keeps the store accurate.
As for ChatGPT improving itself in the sense most people mean, nothing in this research shows it. Its makers can improve it, and systems built around models like it can improve within a scored task, but none of the work above shows a general-purpose AI continuously improving its own intelligence, and whether a system that managed it would level off or keep accelerating is a much bigger question, one we take up in our article on whether AI is smarter than humans. The question we’d most like answered is a smaller one: whether a fixed model with a large, carefully checked external memory could keep getting more capable in practice.
Myth or truth: the learning claims we checked
Most of the points covered so far have turned up in headlines at some point, and claims about AI learning travel fast, usually squeezing a policy or a paper into a headline that’s half right. While researching this article we collected seven, six from news sites, videos, podcasts and newsletters, plus one from Opace’s own archive, and on 10 October 2026 we went back to the original source for each. Each claim gets one of four verdicts: True, Partly true, Misleading or False/unsupported.
| Claim, and where we found it | What the primary source says | Verdict |
|---|---|---|
| ChatGPT trains on your chats unless you opt out. YouTube video, How to Opt Out of ChatGPT Using Your Data for Training, Max Dalton, 27 Feb 2024. | OpenAI's data policy says content from individual accounts may train its models, with an opt-out. Business products are not trained on by default. Training shapes later models, not the one you are using. | Partly true: right for individual accounts, wrong for business plans and the API |
| Claude will start training on your data. Tom's Guide, Claude AI will start training on your data soon, 29 Aug 2025. | Anthropic's 28 Aug 2025 update gives Free, Pro and Max users a choice, keeps data for five years only if they allow training, and excludes commercial services and the API. | Partly true |
| ChatGPT now remembers everything you've ever told it. The AI Leadership Forum newsletter, ChatGPT now remembers everything you've ever told it, 15 Apr 2025. | OpenAI's memory page says memory draws on past conversations to tailor replies, can be turned off, and gives free users only short-term continuity. | Misleading |
| AlphaGo Zero learns without help from humans. Arirang News video on YouTube, New AlphaGo Zero learns without help from humans, 18 Oct 2017. | Silver and colleagues' 2017 paper: trained by self-play with no human game data or guidance beyond the rules, and beat the earlier AlphaGo 100–0. People still wrote the rules and designed the training method. | True |
| AI is now improving itself. AI Explained podcast, AI Improves at Self-improving, 19 May 2025. | AlphaEvolve and the Darwin Gödel Machine improve code and agents inside scored tasks, with evaluators and oversight set by people. | Partly true |
| AI trained on AI-generated data turns to nonsense. Nature news, AI models fed AI-generated data quickly spew nonsense, 24 Jul 2024. | Shumailov and colleagues' 2024 paper: indiscriminate training on model-generated content causes irreversible defects as the rarer parts of the original data vanish. | Partly true: shown for repeated training on unfiltered model output, not for every use of generated data |
| OpenAI's o1 uses reinforcement learning while it answers. Opace's own o1 section in our AI inflection point article, linked above, 16 Sep 2024. | OpenAI, 12 Sep 2024: o1 is trained with reinforcement learning. At answer time it improves with more thinking time, which is a different mechanism, known as test-time compute. | False/unsupported |
The first two are the ones people ask us about most, and each headline reports the consumer-account rule accurately (Anthropic’s update gave existing users until 8 October 2025 to make their choice) while leaving out the business and API terms, the way out each company offers, and the fact that training feeds a future model released to everyone.
The memory claim is misleading in a more interesting way, because OpenAI’s April 2025 update really did say ChatGPT now “references all your past conversations”, and the newsletter headline is a fair reading of that sentence on its own. Referencing past conversations means retrieving relevant insights to personalise an answer, though, which is a long way from storing every word, and the June 2025 version for free users promised only short-term continuity across conversations.
The last row is a correction to our own site. Four days after OpenAI announced o1, we added a section to our AI inflection point article saying o1 “uses reinforcement learning during inference”, and we’ve now corrected it there, with a dated editor’s note that quotes the original wording. It’s easy to see where the mistake came from, because OpenAI’s post said o1’s performance “consistently improves with more reinforcement learning (train-time compute) and with more time spent thinking (test-time compute)”, and our post merged those two halves into one claim. The announcement is clear that the reinforcement learning happens in training and teaches the model to use its chain of thought, while the extra thinking at answer time is test-time compute, so the model reasons for longer when it answers without learning anything from the answer. We got that wrong in September 2024, and it shows how easily “thinks harder” turns into “learns” when you write quickly about a new release, which is why we’d rather say so openly, here and in the note on that article.
What we found when we tried to make AI learn
The question we left at the end of the self-improvement section, whether a growing written store can stand in for learning, is roughly what our own study ended up testing, although it set out to answer something else entirely.
Why we ran the study
In mid-September 2026 I went looking for a power-assisted shopping trolley for a family member with mobility issues, someone who values the freedom to go shopping but struggles with today’s trolleys. All I could find were expensive powered walkers, and that got me wondering whether AI could invent something genuinely new. It became an Opace project because invention struck us as a sharp test of general intelligence (to come up with something new and useful, and then defend the claim that it’s new, the AI has to go beyond what’s already in its training data and on the web).
Each idea had to be genuinely new, patentable, cheap to test and commercially worthwhile, and we checked every one against existing patents and products. The work moved through the three set-ups described in the introduction, and looking back, each change of set-up was at least partly an attempt to stop the tools forgetting what earlier sessions had worked out. Because every new session started with nothing but what it was handed, we tried to hand it everything that mattered, and that’s how an invention project turned into a test of whether AI can learn.
We also kept the study away from the one route by which a conversation can reach a model’s weights. Our working rules said that whenever the same task went to more than one AI service, we would use no-training settings and never share chat links, because we didn’t want unfiled ideas leaving our control before any patent application. That rule was about protecting ideas, yet it also meant none of our corrections were ever meant to reach a model’s weights, and everything we wanted carried forward had to travel as text that a later session would read.
What one long chat forgot
Our original ChatGPT conversation about the trolley ran from 16 to 26 September, 256 messages in a single thread, and the brief included a preference that the trolley ideally wouldn’t need a battery or electricity. ChatGPT made a fair physics point, that sustained assistance has to come from somewhere, and advised against making “no electricity” a requirement yet, after which the constraint quietly dropped out of the work. We restored it ten days later, and at the same time clarified that we had never meant strictly no battery (so we were hardly perfect keepers of the brief ourselves). Nothing had been deleted and no memory feature was involved, because all of this happened inside one conversation, yet the effect was the same as forgetting.
When Claude later reviewed the whole exported conversation, two of its findings were about memory rather than intelligence. The battery constraint had been let go on day one, and Claude’s review summed up the other finding in one line:
“It forgot what had already been tested.”
Every message was still technically in the conversation; what was missing was any single place where the constraints and the approaches already tried were written down and checked. Claude’s suggested fix was to pin the problem to one agreed sentence, with the constraints listed and never silently dropped, and to keep a running list of every approach tried that carried over from one session to the next, and that list became the backbone of the rest of the study.
Moving the memory into files
When the work moved to Claude and Codex on 27 September, we usually had several sessions running at once, each working on a different part of the search, and one rule reached only one of them. In a conversation with Codex we set a hard rule that nothing would be built or bought until we were confident we had a patentable idea, and Codex accepted it. The Claude sessions never saw that conversation, and for the rest of the day they kept recommending that we pay for small physical tests of their ideas, which was exactly what the rule had excluded.
No individual model was at fault, since the rule existed in one conversation and nowhere else and a model can’t obey a rule it has never been shown. Within a few hours we had written it into a shared file of working rules that every session read first, and from then on the study’s memory lived in four kinds of file:
- A working-rules file: The method, which every session read before starting.
- A list of every idea: Each idea with its verdict and the evidence behind it, reaching 276 entries.
- A lessons file: Every lesson gathered from the earlier files when the agent team was set up.
- Role instructions: Written instructions for each of the 25 agent roles, including the lessons most relevant to that role.
Claude also kept its own memory notes from the day the work moved across, saving notes about the project and the way we liked to work so that later sessions would start with them (the push-back instruction described earlier was saved the same way).
It’s the arrangement Anthropic’s Claude Code documentation describes, where each Claude Code session begins with a fresh context window, and two mechanisms carry knowledge across sessions, instruction files you write and notes Claude writes for itself. The same page adds a line we wish we had read in September, that Claude treats both “as context, not enforced configuration”, which means a rules file is advice the model reads at the start of a session and follows only as faithfully as everything else in the context allows.
Changing a model’s mind, then writing it down
The clearest evidence that a model could change its mind came from inside a Claude session at the end of September. A progress report from Claude mentioned “three strong ideas”, which we took to mean we finally had something patentable, and Claude corrected us plainly:
“No, we don’t have anything patentable.”
The three were new methods of hunting for inventions, which we had misread as inventions. Codex, working on the same project, had meanwhile reviewed Claude’s summary of the work and listed nine problems with it, and once we put that review in front of Claude it accepted eight of them, including a correction to how it had been counting the patents checked, which settled that figure at 2,161 patent and application numbers. It disputed the ninth and proposed a small test to settle it, and when the results came back the next morning it conceded that one too: “On the point I contested, the results go against me.”
That’s a model updating its position on evidence, which is what you want (and more than many people manage). It happened because the evidence was in front of it, though, and the next session would start without that evidence unless someone wrote it down.
The same morning, 28 September, Claude admitted a flaw in the checks it had designed. The working-rules file set out checks every idea had to pass before we would call it patentable: whether it was new, whether it was not obvious, whether it worked in the worst case, whether the physics added up, whether it could easily be designed around and whether it could make money. All six were meant to be decidable at a desk, and they weren’t, because the money check needed real buyer and price evidence and the obviousness check kept coming back as a question for a patent attorney. “That’s a flaw in my design, not just in the ideas,” Claude said.
We then asked Claude to turn all the feedback so far into rules for future sessions, and within minutes it had rewritten the working-rules file as a method of 21 numbered rules, with the six checks redefined so that each could be decided with desk evidence. The last of the 21 said every piece of work must be internally consistent, with the summary matching the log, no check left unfinished and no result described as better than it was, and that rule comes back later in this story.
Gathering 215 lessons for the agent team
The biggest attempt at carrying lessons forward came with the agent team, which we planned on 2 October and set up on 3 October. Its 25 roles were a way of dividing the work: one agent coordinated, one was set up to argue against the others, one generated new ideas, and so on, and some reviewing roles, including the one comparing ideas with existing patents, ran on a different model family from the agents whose work they checked. Because we didn’t want anything learned in September to be lost in the move, we asked Claude to gather every lesson from the earlier files, and it put them all into a single lessons file and wrote the ones most relevant to each role into that role’s instructions.
Claude handed the reading to several helper agents (copies of itself, each given part of the job), and even that went wrong in a telling way. One of them reported that the checks every idea had to pass didn’t exist, because it had never been given the file that described them, so the agent gathering the lessons had itself been handed an incomplete memory, the very problem the exercise was meant to solve.
An AI-compiled running summary of the project, built from our conversations and files, put the total at about 430 lessons. When we counted the files by hand on 10 October, the lessons file held 215. The role instructions held 122 between them, three to six each, all picked from that same pool for particular roles, so the two counts overlap and can’t be added together. The summary’s figure was out by roughly a factor of two, and we think that matters to anyone who relies on a tool’s report of what it knows, because such a report is generated text like any other answer, with no reading taken from the files behind it.
The lessons file ran to 278 lines, while the same Claude Code documentation advises keeping an instruction file under 200 lines, because longer files use up more of the context and are followed less closely. The compiling did some useful editing as well, turning September’s failures into rules in the instructions for the role generating new ideas. One was never to drop a founding constraint, so the battery constraint ChatGPT let slip on 16 September had finally been learned seventeen days later, in a different tool, because one of us noticed the loss and a text file carried it. Another said the missing ingredient was a new fact or observation, so every round had to start from at least one input that wasn’t in the model’s training data, such as a first-hand observation, a measured fact or an expert’s workaround.
What the files fixed
The files fixed the problem we started with, which was that nothing persisted unless we carried it. Once the list of ideas existed, a later session could check a proposal against 276 earlier entries instead of trusting its own sense of novelty, and when a session recycled an idea under a new name (which happened more than once) the earlier entry was how anyone could tell. Most of what the files recorded was what had been tried, what had been ruled out and why, so a later session could pick up the checking where an earlier one had stopped instead of starting it again. Saved instructions changed behaviour quickly too, as the push-back note showed, and an instruction to one Claude session not to duplicate what the others were doing was followed, though only because we knew what the other sessions were doing and could tell it. We policed every boundary between sessions by reading their output ourselves, and the files cut that work down without removing it.
We’d already written about turning failed AI output into written rules in the agentic coding case study mentioned earlier, under the heading “Failed output creates new rules”, and the invention study took that habit as far as we could push it. Written rules were the only form of learning we found that reliably crossed from one session to the next, because they don’t depend on the model remembering anything, and when one of our rules failed to reach a session we could open the file, find out why and move the rule to where every session would read it. A correction absorbed silently into a model’s weights would give us no file to open. Most people’s wish is for a model that simply learns from them, but after this study we’d rather have corrections we can see, since of the three places a correction can land (the current context, a stored note or a later training run) only the first two are things a user can inspect and change.
What they didn’t fix
What the files couldn’t do was make a lesson stick at the moment it mattered, and the same mistakes came back anyway. The two that recurred most are worth describing because they’re so ordinary.
Agents getting in each other’s way was the first, and it started on our first day working with Claude, when a helper agent started by one of the Claude sessions overwrote another helper’s working files halfway through a job, and a lesson went in to stop it happening again. A week later, after the lessons had been gathered for the agent team, two more agents running side by side picked the same generically named working folder, and one overwrote the program the other was using to check its results while it was still running. The fix was one more lesson, telling every agent to name its folder after its role, its task and the date so that no two could collide.
Time was the second, because agents stamped their reports with times they had estimated instead of reading them from the computer’s clock, and in one case an agent logged a step 17 minutes later than it really ran. That sounds trivial, but a log is only useful if it shows what was checked and when, and an invented time makes it impossible to tell whether a result was current. After it happened again, the agent coordinating the team wrote itself a lesson to take every time from the clock, “never from your own estimate”. Measured against the classroom test from the start of this article, the correction had been given, written down and read at the start of later sessions, and the mistake came back regardless.
The rule that summaries must match the logs went the same way, with summaries still drifting from the work they described after it was written. In one chat Codex said its conclusion drew on five sources of new information, when the conclusion file it had written listed four. The difference is small, but it’s exactly the mismatch the rule was written to prevent, and it came from a model describing its own work (we look at why AI misreports its own work in a separate article). The same rule later had to be written down a second time, as a lesson, because writing it once had not been enough.
Part of the reason is volume, which one of the research agents warned about on 2 October, while we were planning the agent team: instruction-following gets worse as rules pile up, it said, and it pointed out that the AI agent workspace we were using for the team gave each agent its role instructions only once, at the start of a session. It also advised explaining why a rule matters instead of shouting it in capital letters, removing contradictions between the different sets of instructions an agent receives, and preferring one good example over many rules. We built the 278-line lessons file the next day.
The research it pointed to is How Many Instructions Can LLMs Follow at Once? by Jaroslawicz, Whiting, Shah and Maamari (July 2025). It tested 20 models from seven providers and found that even the best frontier model managed only 68.9% accuracy when a prompt held 500 instructions. Those instructions were simple requirements to include particular keywords in a business report, so the paper doesn’t measure anything like our study, though it points the same way as what we saw.
What it added up to
By our own count the method changed about 20 times, each change answering the previous failure, and none of the changes altered what the models had to work from, since every attempt still drew on the models’ training and public web search. The two changes that would have altered the input, a private dataset and a real-world measurement, were identified and never pursued, partly because our own rules had ruled out physical tests. Claude put the underlying point plainly while we designed the agent meant to generate new ideas: it “can’t escape what it was trained on. No model can.” What that means for discovery is the subject of the companion piece on new knowledge mentioned earlier.
Nothing in our loop could do the job of FunSearch’s evaluator or a Go result, because each verdict on the list came from a model’s research and our own judgement, with no automatic scorer that could tell a better idea from a merely different one, so the models could generate and we could store, and a bigger store and a longer rulebook never showed up as better ideas; the scorer we lacked was one that could run thousands of times without a human at exactly the steps that mattered.
The outcome is written up in full in the invention study, and the headline figures are these. Claude and Codex wrote 274 of the 276 distinct ideas (the other two came from ChatGPT), and generating those 274 took about five hours of the 25 days. After checks against 2,161 patent and application numbers, none of the 276 was judged strong enough to justify a patent application; 69 were promising but unproven and 207 were ruled out. Generating ideas was cheap, the rest of the time went on checking them, and all those lessons made the checking stricter without making the ideas any better.
In the sense we were testing, carrying a lesson forward without being reminded, AI couldn’t learn in this study, because a lesson carried forward only when a person, or a file a person had arranged, did the reminding. Storing lessons helped us recover context and catch repeats, and it changed behaviour when the right file was in front of the right session, but it never stopped the same kind of mistake from coming back, and our experience suggests storage is the easy part of that open question (it’s cheap) while validation, deciding which stored notes are true and making sure the right ones are read at the right moment, is the hard part.
What our study can’t tell us
Because this was a single company’s study, run at a desk over 25 days with tools that changed during it and designed to find an invention rather than to measure learning, its limits matter as much as its findings. AI did the patent searching, and there was no private data and no lab or physical test. The invention result has its own limits, set out in our study of whether AI can invent, and the strictest test there was small: ten ideas written down in full before any patent searching, so the search couldn’t reshape them, and all ten were ruled out. With no successes in ten tries, the true success rate of that approach could still be as high as about 30%, because a run of ten is too short to rule out a method that works fairly often (statistically, the most a sample that size lets you say with 95% confidence is that the rate is below roughly three in ten). The 276 ideas also include many close variants rather than 276 independent attempts. So the study shows that this way of working didn’t produce a patentable invention; it doesn’t prove that AI can’t invent.
For the question of learning, the tasks, prompts and models shifted from week to week, so we can’t isolate the effect of any single memory feature or file. We never compared a session that had the lessons file with an identical session that didn’t, which is the experiment that would actually show whether the lessons were used. Nor did we have any view of a model’s weights, so everything we say about what stayed fixed rests on how these products are documented to work and on the absence of any training step in our own workflow, and where a model told us what it remembered or what it had done, we treated that as a claim to check rather than as a measurement.
The project left behind saved conversations, chat exports and the files themselves, as well as the long running summary an AI compiled from them, and where an original conversation or file exists we’ve worked from that, since the summary contains errors (the lesson count described above among them). The lesson counts show that the files existed and what they contained, but not how often any session read a given lesson or obeyed it. The external research we cite, from AlphaGo Zero to the instruction-following benchmark, used its own tasks and evaluators, so none of it can be read across to our study as if it were the same experiment, and every provider’s memory and training settings have changed more than once since 2024 and will change again.
What this means if you use AI at work
Most people using ChatGPT or Claude at work are doing a smaller version of what we did, trying to get a tool to remember how their business works, and the same mechanics apply. Here is what we’d keep from our 25 days and what we’d change, bearing in mind that it comes from one kind of project.
- One short file for the rules: Of everything we tried, this made the biggest difference, because the constraint ChatGPT let slip on day one wouldn’t have slipped if it had been written in a short brief at the top of the work instead of in a chat message. If we started a similar project tomorrow, the first thing we’d create is that file, with the problem in one sentence, the constraints listed and a note of where decisions are recorded. For a business rolling AI out across a team, the same file grows into a written account of what the tools should know and who keeps it accurate, which is one of the first things we’d settle in any AI strategy consulting work.
- Short instruction sets: The role instructions carried up to six lessons each on top of their own guidance, and the research the agents themselves found said longer instruction sets are followed less reliably. We’d split lessons by role and by task, so each session reads the dozen that matter instead of all 215, and retire lessons once the rule they produced is written into the method. The few worth keeping everywhere are the general ones, such as making sure a check can actually catch a problem before trusting a clean result from it.
- Decisions kept apart from outputs: The list of ideas worked because each entry had a verdict and the evidence behind it in one place, so a later session, or one of us, could see that something had already been ruled out and why. Summaries were the weak point, because a model’s account of what it did drifted from the logs often enough that both the working rules and the lessons file needed a rule about it.
- A second model as checker: Codex’s critique of Claude’s summary caught eight problems that Claude then accepted it had missed, which is why we gave some reviewing roles in the agent team a different model family from the agents whose work they checked. Second opinions that started from a different place were worth more to us than any single model’s confidence.
- Memory features, used deliberately: Project-scoped memory in Claude and ChatGPT is close to what we built by hand, a separate store for each piece of work. We’d switch it on for long projects, and switch it off or use a temporary or incognito chat for anything sensitive, and we kept the no-training setting on for every unpublished idea (we’d do the same for client material). None of this needs an expert to set up, though designing retrieval and custom instructions around a company’s own documents is a bigger job, closer to ChatGPT engineering than to changing a setting.
- Files as a record of what each session was told: We treated the files at first as a way to make the models learn. They turned out to be more useful as a record of what the models were given, so that when a session gets something wrong you can see whether it had the right information and ignored it, or was never given it at all.
Verdict: can AI learn?
Our answer to whether AI can learn is that it learns in training, when a large language model’s weights are adjusted, and after release those weights stay fixed while people use it. It adapts within a conversation, sometimes impressively, and memory features and files carry notes into later conversations, which the model then reads like anything else you give it.
Our 25 days put each of those to a practical test, and the corrections that lasted were the ones written into a file that the next session read. Those that lived only in a conversation, such as the battery constraint or the rule only Codex was given, were lost or failed to spread until they were moved somewhere every session would see, and writing 215 lessons down helped us find mistakes faster without stopping the same kinds of mistake coming back within days.
ChatGPT gets smarter when OpenAI trains and releases a new model, and the same is true of Claude and Gemini; some of that training may draw on users’ conversations where the settings allow it, with the benefit arriving for everyone at once as a new version. Self-improvement is real where a machine can mark its own work, as in the game, maths and coding systems described above, and it remains unproven for a general-purpose chatbot that has no such judge.
I came to this with a trainer’s yardstick, and it still seems the fairest one. People don’t carry every correction forward either, and nobody who has taught a course expects them to. But what a person keeps, they keep themselves, and they can apply it to an example nobody showed them. Nothing we worked with in this study did that without a file or a person carrying the lesson across.
So when people ask whether ChatGPT learns from them, our answer is that it learns about them, through notes a product chooses to keep, and that the learning which carried forward in our study was done by people. A system that could take a correction on Monday and apply it unprompted to a different problem on Friday, without a person or a file carrying it across, would be passing one of the tests an LLM would have to pass to be AGI, the bigger question we touched on at the start. The tools we used in September and October 2026 didn’t pass it, and for now we’d keep the notebook and check what goes into it.
Frequently asked questions
Can ChatGPT learn from me?
With memory switched on, ChatGPT keeps notes about your preferences and past chats and uses them to tailor later answers, and custom instructions let you tell it directly how to respond. OpenAI’s memory page suggests the simplest way to see what it has kept: “To see what ChatGPT remembers about you, you can also ask it.” None of this changes the model itself, which stays the same for every user until OpenAI releases a new one.
If you’d like to see the difference for yourself, the test we’d suggest takes a few days. Turn memory off, correct the model on something specific in one chat, then open a fresh chat later and give it a different problem where the same correction applies, without mentioning it. A system that genuinely learned from you would apply the correction unprompted. Today’s chatbots won’t, by design, and if you run the test with memory on you’re testing the product’s notes rather than the model. We haven’t yet seen a general-purpose chatbot pass it.
Do LLMs learn from conversations?
Not while the conversation is happening; the training rules for ChatGPT, Claude and Gemini earlier in this article explain how a chat can reach a later training run, and the fine print is worth knowing too. OpenAI’s opt-out works from that point forward, so it’s no help for a conversation that has already happened. Anthropic’s August 2025 update says previous Claude chats with no further activity won’t be used for model training, and that chats you delete won’t be included in future training either. The same update says Anthropic uses a combination of tools and automated processes to filter or obscure sensitive data, and OpenAI’s policy page describes a similar step to reduce personal information in training datasets before they’re used. Whatever reaches a training set is then mixed with a vast amount of other data, and the result is a new model released to everyone, so the model you’re using on any given day hasn’t learned from your conversation with it.
Does AI remember previous conversations?
AI remembers previous conversations only if the product is built to, and then only partly. Within a single conversation the model can see the earlier messages, up to the limit of its context window, and that doesn’t change when you switch memory off. Across conversations it depends on a memory feature, which saves selected notes or searches past chats and hands the relevant pieces to the model at the start of a new one. ChatGPT, Claude and Gemini all offer something like this, each with its own settings, and each lets you switch it off.
In practice, the most useful habit we’ve found is to watch for the moments when memory changes. ChatGPT shows a Memory updated notice when it saves something, and OpenAI’s memory page says you can open Manage memories from that notice to review or remove what it picked up, or ask it in conversation to change what it knows about you. A temporary chat has to be set up before the first message, because OpenAI’s Temporary Chat help page says you choose Personalised or Unpersonalised before you send anything and can’t change it once the conversation has started. Neither option creates or updates memories while the chat stays temporary, but if you later save it, it becomes a regular chat that follows your account’s personalisation and model-improvement settings from then on. The same help page notes that OpenAI may keep a copy of a temporary chat for up to 30 days for safety purposes, and that ChatGPT may still use information from prior conversations for limited safety and security purposes even with memory and personalisation off.
On Claude, chats inside a project are searched only within that project, so keeping separate work in separate projects keeps its memory separate too. Claude’s help page adds a detail we found reassuring: “By default, Claude does not store topics related to personal or sensitive subject matter.” Most of what AI memory does still happens out of the user’s sight, which is why we’d spend a few minutes every so often looking through the saved memories.
Can I delete what Claude remembers?
Yes, and there are separate controls for separate things. Claude’s help page on chat search and memory describes three. Pausing memory keeps what is already stored but stops Claude using it or making new memories, and conversations you have while it’s paused won’t be added later if you turn memory back on, which makes pausing the right choice when you want a stretch of work kept out of memory without losing what’s already there. Resetting it “Permanently deletes all memories including project memories”, so every project’s memory space goes along with everything else, and when you re-enable the feature Claude starts from scratch. An incognito chat, available on every plan, never enters memory or your chat history in the first place, and Claude won’t pull information from it when searching your previous conversations.
Claude Code works differently again, because its memory is a set of files on your own computer. Anthropic’s documentation describes those auto memory files as plain text you can edit or delete at any time, and the /memory command inside a session lists the memory files, opens the auto memory folder and lets you switch auto memory off. Because they’re ordinary files, you can read exactly what a later session will be told, which is more than any chat app’s memory screen shows you.
Deleting memory is a different thing from opting out of training, which is a separate privacy setting on consumer accounts, and deleting a chat is a third thing again (Anthropic says deleted chats won’t be included in future training). The same split exists on ChatGPT, where saved memories have their own screen, under Settings, Personalization and Manage Memory, separate from your list of chats, and deleting a chat leaves the memories it created in place until you remove them there. We’d check each of the three settings on whichever service you use, rather than assuming one covers the others.
Do LLMs learn over time?
A deployed model doesn’t learn over time on its own: it stays the same from the day it’s released until its maker replaces it, and replacement is the normal pattern. OpenAI’s o1 page now carries a note that “o1‑preview and o1‑mini have been retired from the API; o1 is deprecated”, which is a fair picture of how these models change: an old version is retired and a better one takes its place.
What does change over time is everything around the model. Providers add memory, search, tools and longer context windows, and a business can give a model its own documents through retrieval, or tune a version of it as described in the training section, which makes it more useful for that business without making the underlying model generally smarter. So when someone says “the AI has got better at this”, it usually means one of three things happened: they’re on a newer model, the product is supplying better information, or they’re giving it better instructions. All three are real improvements, and none of them is the model learning from experience the way a person does.
Can AI teach itself without people?
Not in the full sense, because teaching yourself needs things that today’s systems still borrow from people. One is a goal, deciding what is worth getting better at. Another is a judge, some way of telling a better attempt from a worse one, which is what every self-improving system described in this article had. A third is fresh information from the world, so the system isn’t just rearranging what it already had (model collapse is what happens when it trains on its own output without that). Self-play in a game supplies all of these inside a tiny world with fixed rules, which is why it works there and almost nowhere else.
When we put the bigger question to ChatGPT in October, its answer matched the retrieval research rather than going beyond it. A system that kept building on its own discoveries would still need ways to tell a promising hypothesis from established knowledge, it said, and the key “isn’t simply remembering everything. It’s maintaining a growing body of reliable, well-organised, verifiable knowledge.” Somebody has to build that store, decide what goes into it and check that it’s true, and in our 25 days that job fell to us.
Is ChatGPT getting smarter over time?
ChatGPT gets smarter from one version to the next, as OpenAI releases new models, retires old ones and changes ChatGPT’s default model, so if ChatGPT seems sharper than it was a year ago, check which model you’re using, because that is almost always the reason. If it seems to know you better, that’s memory, which is a separate setting you can inspect and switch off.
Can AI improve itself without humans?
AI can improve itself only within limits that people still set, and the strongest current example, the Darwin Gödel Machine described in the self-improvement section, shows where they sit: it rewrote its own code and kept the changes a benchmark rewarded, but the researchers chose the benchmarks and ran it under the safety controls quoted there. ChatGPT made the case for such a loop when we asked it, pointing out that the underlying model wouldn’t need retraining after each cycle, so a system could in principle explore thousands of ideas, discard those that fail and build on the ones that work. In the same answer it gave the catch, that the underlying model might keep making the same mistakes or fail to spot a promising direction, and the research points the same way, since every system described above that genuinely improved had an outside test deciding what was kept, and people chose that test.
