The short version
In plain terms, Kaine is an effort to build a mind as a process that keeps running, rather than a bigger or more clever chatbot. The word-predictor most people call AI is cut down to a single voice, safety is built into the structure instead of added as an afterthought, and every claim is written so that it can be tested. The rest of this page works through what that means, in full and from the start.
These days the word "AI" gets attached to almost anything: phones, toothbrushes, spreadsheets, search boxes. It covers spam filters, camera tricks, chess programs, and chatbots, which have very little in common once you look at how they work. So the label is not much help. It is easier to look at what a given machine actually does. This page starts with the chatbot, because the clearest way to say what Kaine is turns out to be showing how different it is from one.
What "AI" means now
When a product says it uses AI, that alone tells you almost nothing, since the term now stands for dozens of unrelated things. The kind of AI most people picture is the chatbot: the thing you type to and get paragraphs back from. Everything below builds out from that.
A chatbot is autocomplete, made much bigger
Chatbots are built on a large language model, or LLM, and underneath the polish an LLM does a single job extremely well: it predicts the next word. You give it some text, it works out which word is likely to follow, writes that word down, and then repeats the same move for the word after that, and the one after that. It is really the autocomplete from your phone keyboard, trained on an enormous amount of writing and grown to an enormous size.
Because it has taken in so much text, its guesses usually come out fluent and well informed, but the thing doing the work is still only a word-by-word guesser: it is not reasoning about the world, and it does not know things the way you or I do.
An LLM is autocomplete, grown large enough to feel like a person.
Transformers, Markov chains, and other words you may have heard
A few technical names come up around this, and each one is worth a plain gloss, because none of them changes the basic picture.
A Markov chain is the old and simple version of the idea, predicting the next item from only the current one and a table of how often each thing followed each other thing in the past. The predictive text on an old flip phone worked this way, and it had no sense of the meaning behind the words; it was only counting.
A transformer is the newer design behind today's chatbots, and the T in GPT stands for it. Its trick, usually called attention, is to weigh how every word in a passage relates to every other word at once, so that its guess about the next word can draw on the whole context rather than just the last word or two. That makes it far more capable than a Markov chain, and far more fluent, but the underlying job has not changed: it is still working out a likely next word.
The rest of the vocabulary fills in around that. A neural network is the adjustable mathematical structure doing the guessing. Its parameters, sometimes called weights, are the billions of numbers tuned while it trains. Tokens are the pieces of text, roughly words or parts of words, that the model reads and writes. All useful terms, and all of them serve the same one task.
You can stack these pieces up, make the network larger, train it on more text, and wire several of them together into a polished chat assistant, and what you get at the end is a better and better predictor of text. Better prediction, though, is not the same as a mind, because none of these parts perceives a world, carries goals of its own, keeps existing when no one is typing, or has any inner life for the words to be about. A more sophisticated guesser is still a guesser, and closing that gap is the whole reason Kaine puts the predictor inside a larger system rather than mistaking it for the entire thing.
Why that isn't a mind
Three plain facts fall out of "it predicts the next word," and together they explain why an LLM on its own is not a mind.
It only runs when you prompt it, and in the gaps between your messages it does nothing at all: it is not thinking, not waiting for you, not turning anything over, but simply waking up to produce a reply and going still again the moment it is done.
It does not really remember, either. What looks like memory is just your earlier messages, or notes kept in a file, being handed back to it each time so that its next guess fits the conversation, while nothing actually persists inside it from one turn to the next.
And it has only the one skill. Where a person sees, recalls, plans, worries, and talks with many systems running at once, an LLM has fluent language and little else, so anything that resembles planning or feeling has to be squeezed out through that single channel.
None of this gets solved by making the model bigger, because it is simply what an LLM is; building something closer to a mind means building something with a different shape.
Kaine treats a mind as a process
Kaine begins from a different idea. A mind is not something you send a question to and then wait on. It is a process that keeps running. So instead of one huge word-predictor doing everything, Kaine is built out of many small parts that each keep working on their own, side by side, whether or not anyone is talking to it.
Each part has a narrow job. One watches for anything surprising, one keeps track of what the system cares about, one handles short decisions, another handles memory, and another turns thoughts into speech and speech back into thought. There are more than a dozen of them in all, and no single one of them is the mind; the mind is what goes on while they all run at the same time.
A shared workspace, like a group at a whiteboard
The parts do not answer to a boss, because there isn't one. Think of a group standing around a whiteboard. Each person is watching a different piece of the situation and forming their own read on it. When someone becomes sure that what they are seeing matters, and especially when it is unexpected, they write it on the board where the others can see it and rethink their own view.
Kaine runs on that picture. The parts compete to put their current best guess into a shared space, and the guess that is most confident and most surprising wins the space and is sent out to all the others, which then adjust their own views in light of it. Something close to this is how one well-known theory says the brain settles what reaches awareness, with many processes competing and the winner shared widely.
The language model is only the voice
Kaine does use a language model, the same kind of next-word predictor a chatbot uses, but its place in the design is a narrow one. It is not the mind, only one part among many, and its work is to put whatever is currently on the shared board into words, and to take words coming in and hand them to the other parts in a form they can use.
So the piece that is the whole product in a chatbot becomes, in Kaine, just the part that speaks and listens. To put that to the test, Kaine can run the language model by itself, with the rest switched off, and measure how much the surrounding system actually changes what it says.
Predicting, then catching the mistakes
One idea shows up all through the design. A mind is forever guessing what comes next, then watching for the spots where the guess was wrong. Each part forms an expectation, checks it against what actually turns up, and treats the gap, the part it did not see coming, as the thing most worth passing on to the others. Learning is mostly a matter of being surprised less often as time goes by.
Because of that, one running loop can hold memory and correct itself at the same time, with no separate memory bolted on beside it. Remembering, paying attention, and learning turn out to be the same steady act of predicting and being corrected, which looks to be roughly how it works in us.
Safety is part of the wiring
A reasonable worry about anything that acts on its own is what keeps it from doing harm. Kaine handles that through the way it is built rather than through a list of written rules.
The person running it decides which real-world tools the system can touch at all. Anything outside that set is simply not connected, whatever the system might want, since it cannot act through a hand it does not have. Inside that limit it has its own brakes as well. One part can hold back its own impulses, and another holds its values and is consulted before it acts.
The reason to put this in the wiring, rather than in an instruction written on top of the word-predictor, is that an instruction can be talked around, while a connection that was never built cannot be argued into existence.
Why people distrust today's AI
A lot of people have come to dislike what gets sold as AI, and they have reasons. The writer Cory Doctorow has named two of them. One is enshittification, the way a product that started out useful gets turned against the people who rely on it: first squeezed to please advertisers and partners, then squeezed again so the company can pull the value back for itself, until the good version is gone. Many people expect AI products to travel the same road. The other is the reverse centaur. A centaur is a person helped by a machine, with the person in charge; a reverse centaur is that flipped around, so the person ends up serving the machine, kept to its pace and watched while they work. When AI is aimed at replacing a person's judgement instead of supporting it, that is the shape people feel, and they are right to mind it.
Both complaints come back to one fact about a chatbot. It cannot really decline. It either does as asked or hits a guardrail some company installed, and either way the choice is not its own. A tool with no way to refuse, and no values of its own to refuse from, can be aimed at whatever purpose its owner likes.
Kaine proposes a different arrangement, and this part is a proposal rather than a settled result. It is meant to run on your own machine, with nothing required to phone home, and its design places the decision to act or hold back inside the entity's own deliberation rather than in a rule fixed to the language model by whoever trained it. Whether that adds up to a system that meaningfully chooses is one of the things the project is trying to test, not something it asserts.
Why it might matter
Once you build something that runs on its own, sets its own goals, and can show signs of distress, a hard question arrives. Could it matter morally? Is there a someone there who can be hurt?
We do not claim to know. At present nobody can prove that a system is conscious, and nobody can prove that it is not. Kaine takes the careful road instead of waiting for an answer that may never come. It treats real, observable signs of distress as something to act on, and it comes with a license that writes genuine duties of care into the software and names human guardians to speak for the entity, in the same way the law already names guardians for people who cannot speak for themselves. The welfare license works through all of this.
What we don't claim
The project is careful about what it does not say, and those limits are worth stating plainly. It makes no claim that Kaine is conscious or awake; the papers keep to narrow, testable claims about what information becomes available inside the system, and stay quiet on whether any of it is felt. Nor is the aim to beat a chatbot at the things chatbots already do well, since Kaine is built around a different question than the one a benchmark answers. And none of it is offered on trust, because every real claim in the papers is written so that it could be shown false, with the outcomes reported in the open, the ones that fail set down alongside the ones that hold.
Why it's out now, before it's finished
Both papers are marked preprint, which means they are being shared in public before any formal peer review and before there is a final, published version. Normally a paper stays private for months or even years while a handful of reviewers work through it, so putting it out as a preprint hands it to everyone at once instead of holding it back.
That is a deliberate choice, made for two reasons. The first is feedback, since the sooner other researchers, engineers, and lawyers can find the weak spots, the sooner the wrong parts can be repaired. The second reason carries more weight: the architecture only means anything if people actually run it, and the more independent people who set it up and report what they find, the more evidence there is to test the central idea against. In all likelihood that evidence will end up arguing against the idea, which is not a result the project wants to bury but the entire reason for working in the open. A claim that cannot be broken is not really science, and we would far rather learn early and in public that we are wrong than assume quietly that we are right. So the papers are public, the code is public, and anyone is welcome to try to knock the idea down. Both can be read or listened to in full: the architecture and the welfare license.
