Deletion Is in the Contract. Is It in the Model?
In 2021 the FTC ordered a photo-storage company called Everalbum to delete more than photos. Everalbum had used customers’ pictures to train facial recognition models, and the consent order required destroying those models too: the algorithms themselves, not just the data they were built from. The Commission had already imposed the same remedy on Cambridge Analytica, and it did so again a year later against WW , whose Kurbo app had trained models on data collected from children. Lawyers call the remedy algorithmic disgorgement. The premise behind it is simple and, for anyone running production AI, uncomfortable: deleting data means little if everything learned from the data survives.
Most companies will never see a consent order. Almost every B2B company, though, signs data processing agreements, and standard DPA terms, tracking Article 28 of the GDPR, obligate a vendor to delete or return a customer’s personal data when the engagement ends. Whether that obligation reaches the weights of a model fine-tuned on the customer’s data is, in most contracts, unstated. An unstated obligation is not an absent one. It is one you find out about later, when a churned customer’s counsel asks what happened to everything derived from their data. Many enterprises resolve the ambiguity by prohibiting vendors from training on their data at all, which works, at the price of every product improvement that training would have bought. The rest are carrying a question nobody has asked yet.
Europe’s right to erasure is the slower version of the same pressure. It plainly covers your databases. Whether it covers models trained on them is unsettled: the EDPB’s Opinion 28/2024 treated the question of whether a model even contains personal data as case-by-case, said nothing about how erasure would be operationalized against weights, and one German supervisory authority has argued that LLMs do not store personal data in the GDPR’s sense at all. It is tempting to read that ambiguity as shelter. It cuts both ways. The same case-by-case logic that shields a model today can produce a deletion demand tomorrow, aimed at a system that was never designed to subtract.
Why models can’t subtract
Every explainer of machine unlearning reaches for the same analogy: training is a blender, the data is the fruit, and once the smoothie exists you cannot pull one ingredient back out. As a description of gradient-descent training, the analogy is fair. Each batch nudges millions of shared weights simultaneously, and each example’s influence ends up smeared across parameters that also encode every other example. There is no folder to shred, because there is no address where the customer’s data lives.
Two practical problems follow. The first is that approximate unlearning, the family of techniques that try to cancel a data point’s influence after the fact by reversing gradients or estimating influence, tends to damage the model it operates on, and the damage grows with the amount you try to remove. The second is worse: even when the technique works, you cannot readily show that it worked. Demonstrating that a model has forgotten something is proving a negative. The best available evidence, membership-inference testing, is statistical, and a statistical argument is an awkward thing to hand a regulator or a customer’s auditor as proof of deletion.
One thing is worth noticing before moving on. The smoothie is a property of one training algorithm. It is not a law of nature.
What careful teams already do
The cleanest answer is to keep customer data out of the weights entirely. That is half of why retrieval-augmented generation became the enterprise default: the model stays generic, the customer’s documents live in a database, and deletion means deleting rows. Filing cabinet, not blender. For facts and documents, RAG is the right architecture, and nothing below argues otherwise. Its boundary is behavioral. Retrieval feeds a model information; it does not change what the model has learned to do. Output formats, a house classification scheme, ranking behavior, a vision model’s classes: these live in trained weights or nowhere. The moment a team fine-tunes, it has re-entered the blender.
The second answer is modularity: arrange the training so deletable things live in deletable places. Give each tenant its own adapter, and deleting the tenant means deleting a file, which is genuine, exact unlearning at almost no cost. The academic version, sharded training, splits the corpus so any single example can be removed by retraining one shard rather than the whole. These are good tools, and a team not using them where they fit should start there.
Their shared limit is granularity. Deletion is cheap exactly when the request lines up with a module boundary, and requests do not consult your architecture before arriving. One person among the millions in a shared recognition model. Three hundred poisoned examples discovered in last quarter’s training batch. A feature that a new rule says can no longer inform decisions in one jurisdiction. Each of these is smaller than any module, and once the unit of deletion is smaller than the unit of training, the honest cost of the request is a retrain: compute, pipeline engineering, revalidation, and redeployment risk, all to produce a model that mostly did not change.
Removal as a first-class operation
This is the gap Optimizing Mind works on. Our solution learns for regulatory feedback rather than feed-forward neurons, and the property that matters here is separability: what the network learns for one output class is not entangled with what it learns for the others. Entanglement is a cost of gradient descent specifically, not of learning in general.
Separability makes removal an operation with defined behavior. An output class can be removed outright, and the network then behaves as it would if that class had never been in the training set. The distinction from masking matters: hiding a class’s output at inference is easy in any framework, but in a gradient-trained network it does nothing about that class’s influence on the shared weights every other class rides on. Removal here means the second thing. A class can also be inhibited instead, switched off reversibly, which matters when a deletion dispute is still being argued and destroying the capability would be premature. Within a class, specific training examples can be removed while the rest of the class’s knowledge stands, which is the shape of the poisoned-batch problem. The same operations apply on the input side: an input the model may no longer consult can be removed or inhibited without rebuilding the network around its absence. Removing an input does not erase every correlated trace of it, and proxies remain their own audit, but it turns a compliance change from a rebuild into an edit.
The scope of this deserves plain statement, because the smoothie problem is usually told about foundation models and this is not a claim about them. The base model is your vendor’s liability and your contract’s problem. Documents belong in retrieval. What we are describing governs the layer you train: the classifier heads and fine-tuned tops where your data and your customers’ data become behavior. That layer is small next to the foundation model underneath it. It is also the layer you are accountable for, and the one real deletion demands have actually targeted. The Everalbum order was not about a web-scale language model. It was about recognition models trained on identifiable people, a setting where a person and an output class are the same thing, and where removing the class is the remedy the FTC ordered.
Verification changes character too. Approximate unlearning leaves you arguing probabilities: the model probably forgot, the test found no trace. Structural removal supports a different kind of statement: here is the mechanism, here is what was removed, here is the network behaving as if it had never seen it. No standards body has defined what proof of model deletion looks like, and we will not pretend otherwise. But between a statistical argument and a structural one, it is not hard to guess which a future auditor prefers.
The economics follow from the same fact. Today a granular deletion request is priced at a retrain, so organizations do what rational actors do with expensive obligations: batch them, defer them, and hope the volume stays low. That posture holds only while requests are rare, and little about DPA deletion clauses, post-hoc poisoning discoveries, or jurisdictional carve-outs suggests the volume falls. When removal costs what the removal is, the posture can change. A deletion request becomes a ticket someone closes, not a project someone schedules.
A note on numbers, because this is where vendors usually get ahead of themselves. Our published Flash Transfer Learning results, adapting foundation models with about 1% of the data and 100x less rehearsal without forgetting, are transfer-learning benchmarks. Updating requires even less rehearsal less than a percent and removal depends on the number of data ingested. Moreover performance is very scalable and additional savings depend on task and size. The API’s free trial exists for exactly this: run a removal against your own model and data, and time it against your retrain.
The question to put to your inventory
Take your model inventory and put one question to each entry: who can demand subtraction from this model, whether a regulator, a churned customer’s contract, or your own team finding bad data, and what would honoring that demand cost as built? Where the answer is a full retrain, deletion is priced at its maximum, and the exposure compounds as models multiply. The smoothie was a fact about one way of training, not about machine learning. Models that can only add are a choice now, and the bill for that choice arrives with the first serious deletion request.
Run a removal against your own models with a free trial of the Flash Transfer Learning API at OptimizingMind.com.