Mortal Software: Six Invariants for a Companion Built on Consequence
Most AI apps let you undo anything: don’t like the result, press the button again. WUKO works the other way. What it makes can’t be remade, its signature mark is made from your first conversation, and a day you skip stays visible as a gap. The paper writes down the six rules behind this, clearly enough to be proven wrong, and reports rule by rule how the real app holds up.
Prefer the original? Read the full paper · doi.org/10.5281/zenodo.21608214 →
The paper, in plain words10 min read
Software that lets you undo everything
Most software is built so you can undo things. If an AI draws a picture you dislike, you ask again. If a chat goes badly, you clear it. For a tool, that is right. A hammer should not remember the last nail.
A companion is different. Think of a pet, or a friend of many years. You cannot ask for a better version of last Tuesday. This paper asks what happens if you build software that way on purpose.
The claim: a long-lived companion feels real because of consequence, not cleverness. Consequence means that its past cannot be changed.
The paper calls that its whole philosophical claim. The rest of it asks two plain questions. Can the idea become hard rules for a program? And what do those rules cost? The app that tests it is WUKO, a companion for the Mac from LFM Labs, sold through the Mac App Store.
The idea is not new. Earlier researchers argued for “slow technology”, built to make you think, not to be fast. This paper turns that mood into rules a program must obey. It does not claim the separate parts are new.
Six rules that never bend
Here is what the six rules mean for you. WUKO cannot quietly rewrite your shared history. What it made yesterday stays made. What it remembers, it cannot smooth over.
Engineers call a rule that must hold at every moment an invariant. We will just say “rule”. “A lift door never opens between floors” is one. You can check it, and catch it breaking. The paper words its six so that someone could prove each one wrong. A rule nobody can test is only a slogan.
The rules cover the app’s own data and decisions. Those run on ordinary code, which does the same thing every time. The AI’s answers vary, so it sits inside a frame of that code. The AI proposes. The code decides.
Rule one: a work cannot be remade
WUKO makes pictures and music every night. Once a work exists, nothing in the app can make a second, different version of it.
Here is how. Each work is fixed by three things. One is a number picked once, when you install the app. This is called the seed. The second is the work’s place in the sequence. The third is how far along it is. Give the program those three things and it makes the same work every time. It is like a recipe with no “taste and adjust” step.
What matters is what is missing. There is no dial for randomness and no button to try again. The paper says remaking is unrepresentable. The program cannot even describe a second version. A bricked-up door is stronger than a keep-out sign.
A work grows over about six days
Think of a photograph coming up in the developing tray. A work passes through six stages, from a bare outline to a finished piece. It moves up one stage a day at most, and never backwards. The finished work is settled the moment it begins. Only how much of it you have seen changes.
The first work stays as plain as it was. WUKO improves with practice, but every work is fixed when it begins. Later skill cannot polish the first one. So improvement feels earned. It is like the first drawing on the fridge.
Rule two: who it is starts on day one
WUKO’s signature comes from your first conversation. That is rule two.
Software that makes each install different usually uses a random number. That gives variety but no meaning. WUKO instead takes your first day’s conversation and runs it through a hash. A hash is a fixed scrambler. It turns any text into a short code. The same text always gives the same code, and nobody can turn the code back into the text. That code shapes a signature mark on WUKO’s artwork.
The app makes no second copy of that conversation for this purpose. It never sends it off your device. For the signature, only the code is kept. The difference between two installs begins at the first conversation, and the signature never changes.
The signature records something the two of you did together, not something the software chose.
Rule three: a record that cannot flatter
If you take a month off, WUKO will not pretend you did not. Rule three keeps the record honest, like a diary you cannot tear pages out of.
WUKO weaves a growing artwork, one row per day, which you can use as wallpaper. Each row comes from what was recorded that day. That means your reported mood, your care actions and your time together. A day with nothing recorded gets a row that says so. Nothing is invented or smoothed.
Mood is optional and never filled in for you. So a month away stays visible. Unlike a photo album, you cannot tidy it later, because rule one fixes past rows.
Where the record ends and the picture begins
The paper reports an awkward fact. Rule three covers the data, not every program that draws from it. The large wallpaper picks the days that have a mood. Then it adds filler dots to reach a target count, with moods chosen at random from the middle of the scale. Its source says the aim is to keep the picture looking full.
The paper keeps that design. Filler is texture, with no date and no label. Which days exist, and which are empty, stays fixed by the data. So the honest claim is narrower. The record cannot flatter, but the wallpaper is not a faithful chart of it. Showing filler as data would be a defect.
Rule four: memory that outlives its files
If you delete a picture WUKO once praised, WUKO does not forget that it happened. It forgets only where the picture was.
WUKO keeps two separate stores. Its memory of facts and preferences belongs to the app. The works sit in a folder you choose. You can move, rename or delete anything there, and the app is never told.
So the two can disagree. You praise a work and WUKO stores that fact. Later you delete the file. The fact survives, and the app warmly mentions something it can no longer show. The paper saw a version of this when a user moved the folder. The app quietly made a new empty one. The memory was intact, but the works were gone. The paper weighs three ways out.
- Trust the folder and delete any fact it contradicts. But tidying files would silently wipe memory.
- Bring the work back. That needs extra permission from the Mac, and it undoes a deletion you chose.
- Keep the memory and drop the pointer to the file. This is the one chosen.
Once a day, before the evening’s work, the app compares its facts about works with the files that are there. If a file is missing, the app rewrites the fact as “praised, since lost”. It also tidies the name for people: pixel-my-ball-attempt-1 becomes “my ball”. That name cannot be turned back into a file path. It is like losing a favourite mug and still remembering it.
The memory stays. Only the pointer goes.
Rule four guards against one trap. Sometimes a folder is briefly out of reach, because a permission was withdrawn or a drive was unplugged. To a program, that looks the same as an empty folder. A careless program would then wipe every memory in one pass that cannot be undone. So the check first asks whether the folder could be read at all. If not, the app does nothing. Engineers call this “fail-closed”. Plainly: when unsure, do nothing.
A loss is reported once, in the nightly journal WUKO writes in its own voice. There is no pop-up and no prompt to restore. One problem is open. In conversation, the rewritten label could be repeated word for word.
Rules five and six: earning familiarity, and guarding the door
A friend who copies your slang on day one seems fake. So WUKO ties how much it adapts to how deep the relationship has become.
Every night, on your own device, it studies your own messages. It looks at formality, tone, humour, sentence length, slang and repeated phrases. It writes this down as a belief, not a fact, with a confidence score of 0.7, and revises it as evidence builds. In chat, this profile can be added to the instructions the AI reads before it answers.
That last step is held back. The relationship has fourteen levels. The early ones take days and the last takes months. Rule five says no style profile goes into the AI’s instructions below level three. Your own turns of phrase come back only from level five. WUKO watches first. That fits an earlier finding: an agent built for continuity was trusted more than a task-only one after four weeks of daily use.
The door this opens
There is a risk. The loop takes text you wrote and has the AI analyse it. Then it feeds the result back into that same AI’s instructions. Orders hidden inside text the AI should only read are called prompt injection. Here, the way in would be the app’s own memory.
Rule six covers this. Anything drawn from memory passes through a cleaner before it joins the AI’s instructions. The cleaner strips symbols that could open a new section, flattens line breaks and trims the text. A second filter drops phrases that read as commands to the app.
That filter runs twice, once by asking the AI to obey and once in plain code. The AI on your device does not reliably do as it is told. Its obedience is a hint. The code is the guarantee.
Then the paper says plainly that rule six is kept by habit, not by design. The cleaner runs wherever the personality instructions are built. But the function that reads memory is open to the whole program. It is called, with no cleaning, in roughly fifteen places. Two of them reach generated text: a recipe renderer and a location line you can override.
The author followed the override part of the way but did not trace it all the way to the AI’s instructions. So the paper reports a boundary that is not locked, not a proven weakness. The fix is a separate type for uncleaned memory, so using one in an instruction would fail to build. That fix has not been made. Until it is, treat rule six as an intention with a known gap.
WUKO also starts things, such as offering a finished work at most once a day. Plain code limits this. The AI never decides to interrupt you.
Checking it with the AI switched off
The AI’s answers vary. So how do you test anything built on it? The paper tests the frame around it. The code limits how often the AI is called, drops repeated output and limits retries. Most things a user would call bugs live in that code, not in the AI.
So the paper tests that code with the AI replaced by a stand-in that gives fixed answers. 768 checks run and 767 pass. The paper calls these assertions. One fails on purpose, because it tests a capability left out of the App Store build. The suite takes under ten seconds and runs before every release. A run with no failures would itself be a fault. It would mean the guard that leaves that capability out had stopped working.
Four of the six rules have such tests, rules one to four. Each checks the exact promise of its rule. For example, an unreadable folder must demote nothing.
The tests themselves were checked by breaking things on purpose. The author switched off the guard a test protects and confirmed the test failed. Then the guard went back on. A test that passes against broken code proves nothing. Each time, only the test under test failed, so none was secretly covering for another.
Rules five and six have no such tests. A test of rule five could only repeat the number the author chose. For rule six, the paper declines to claim the filter is enough.
How each rule could be proven wrong
Each rule has a clear way to fail. Rule one fails if the same inputs ever give two different works. Rule two fails if the signature stays put when the first day’s words change. Rule three fails if an empty day gets an invented row. Rule four fails if anything is demoted while the folder was unreadable. Rule five fails if a style profile reaches the AI below level three. Rule six fails if memory text reaches it uncleaned.
It expects the first contradiction at rule four. That procedure is only weeks old and has not yet met the variety of real setups, such as network drives, sync apps and renames that only change capital letters.
Where it runs
WUKO runs a 5.1 GB AI model on your own Mac, in an isolated helper process. Conversation, the journal, making works and the nightly review all happen on your device. The paper is careful on one point. The app does use the network for weather, news and search. The thinking is local. The app is not offline.
What this does not show
The paper states its limits plainly.
- One app, no user study. Whether irreversibility makes software more believable is a hypothesis, not a result.
- Nothing has run for a year. Whether progress stays visible or flattens out is unknown.
- The level threshold is a judgement. Settling it needs an experiment comparing gated and ungated adaptation. That has not been run.
- Cleaning is necessary, not sufficient. A stronger guarantee would keep instructions and data apart entirely.
- Tests are not locks. Someone could add a re-roll option and wire it in consistently. The tests for rule one could still pass while the design is defeated.
The paper claims no more than that. It describes one shipped build and leaves the picture-making code undisclosed. It is archived under CC-BY-4.0 (free to share with credit) with no dataset, since the material stays on that device. It closes with a question. Are the properties that make software feel alive the same ones that make it mortal?
The DOI is the citable artifact and Zenodo holds the PDF. This is the concept DOI, so it always resolves to the newest deposit.
These are the invariants WUKO is built on, stated precisely enough to be proven wrong.
WUKO →