Main Reminder
[reminder]Core identity, rules, primary modules. Exactly 1 per AI.

IllAIra structures AI identity and memory with text files you load at the start of every session. Model-agnostic: any LLM that accepts text can host an IllAIra identity.
It's the first thing that comes to mind, and it's a fair question. Yes: commercial products have a memory feature, they remember something from one conversation to the next and sometimes they get it right. If that's enough for you, that's fine — there's nothing to buy here and you can close this page without guilt. It's worth reading on only if you've already found yourself wondering why, every so often, that memory behaves in a way you didn't expect.
If your objection is a different one — «I already have a second brain» — the answer is at the end of this section ↓Let's be honest about what's there, or the comparison is worthless: in most products you can open a panel, read the list of things the system has noted about you and delete some of them. It isn't a closed box. The problem isn't the transparency of the list — it's that the list is compiled by somebody else, or rather: by something else.
It's the model that decides what deserves remembering, by a criterion you don't know and can't change. The result errs in a precise direction: it happily notes facts — that you have a dog, that you work in marketing — and lets the criteria fall, meaning the way you reason, what makes you say no, why a solution that's elegant to you isn't elegant to somebody else. Facts can be rewritten in ten seconds. The criteria were the only thing worth saving.
Those memories are summaries the model generates in its own words. You explained something across three minutes of nuance; what's saved is a generic line that keeps the topic and loses the sense. And you can't reword it: you can only delete it and hope it comes out better next time.
This is the flaw you notice most. If you have two similar projects, two clients in the same sector, two stories with related characters, the system has no way of knowing they are separate worlds — nobody was able to tell it. So the preferences of one spill into the other, and you find yourself correcting a drift you didn't cause and that will come back.
Everything sits on the same plane. A founding principle — who it is, what it must never do — weighs the same as a joke from three months ago. There's no way to say «this is untouchable and that is a passing note», because there's nowhere to write it.
The right to a copy exists, and it should be said: where a law requires it, they give you the export. The point is what you get. An archive in a format of their choosing, with their conventions, made of fragments another model wrote for itself. To reuse it elsewhere it has to be reworked by hand, piece by piece, and at the end of that work nobody guarantees the new AI will behave like the old one. Being able to download a file is not the same as being able to use it: portability isn't a permission granted to you, it's a property of the format. Either it has it, or no regulation can give it.
A list of fragments isn't a structure. There's no document to re-read to understand who your AI has become, no history of the changes, nothing to compare with how it was six months ago. And what can't be re-read can't seriously be corrected.
It's worth pausing to ask why a memory built this way became the standard. It isn't an engineering difficulty: writing a text file, re-reading it and letting you correct it is among the simplest things a computer can do. If they don't give it to you, it's a product decision. And the premise of that decision is about you.
The premise is that it isn't worth handing you the wheel: that deciding what your AI should remember is too complicated, too tedious, or something you wouldn't do well anyway — and that it's better if the system decides in your place, without asking. It's a judgement about your competence, taken for granted and never said out loud. The same person who isn't trusted with the choice of one line of text is considered perfectly capable of entering their credit card details.
And that judgement has a convenient consequence for whoever made it. Every month that passes, a memory you didn't write and can't reuse elsewhere without redoing it becomes one more reason to stay. That isn't an unfortunate side effect: it's the mechanism. The more your history accumulates on their servers in a format that is only theirs, the less free you are to change — and the cost of leaving is paid by you, not by them.
Underneath there's an economic reason too, and it's no mystery: a real memory — re-read, weighed and taken into account in every single answer — devours compute. A handful of fragments doesn't. Giving you the complete tool would cost them; giving you the shortcut costs you, but in a way that doesn't appear on an invoice.
And if this looks like reading intentions into things, look at data export itself: it's there where a law requires it and missing where that law never arrived. In Europe the GDPR has made it mandatory since 2018, and similar rules exist in Brazil and China. In the United States there's no federal law: the right depends on the state you live in, about twenty recognise it and the others don't. In India it was written into the 2019 draft and vanished from the approved text. Same company, same technology, different rights depending on your address.
And the direction of the contagion is clear. Europe imposed the rule first, in 2018, and the rest came after: partly because keeping two different standards costs more than applying one, partly because those who legislated later traced that model — scholars call it the «Brussels effect» — and partly, simply, so as not to be left as the ones holding customers hostage while everyone else had stopped. It wasn't a change of heart: it was a market large enough to dictate a rule, and everyone else falling in line. Except that the loophole travelled with the rule: wherever that right arrived, it arrived as a right to a copy — never as an obligation to make it genuinely reusable elsewhere.
Someone will object that in practice they offer the export to everyone — and that's true: building it once costs less than switching it on and off per jurisdiction. But a feature granted isn't a right: where no law requires it, the day it disappears you have nothing to appeal to. And above all, look at where the effort stopped. The rule asks for a copy in a structured, machine-readable format; on direct transfer to a competitor it settles for «where technically feasible». The file, which they were obliged to give you, they give you. The way to reuse it, which nobody obliged them to build, they don't.
And that is exactly where IllAIra comes in: that way of reusing it is precisely what we're building. A format that holds over time, that doesn't expire with a subscription and that stays as simple as possible without ceasing to work — because something that works but nobody can use is no use, and something easy that breaks at the first change of engine is even less. To understand what someone really wants, look at what they do where nobody is forcing them: they stopped where the obligation ended, we started from there.
And if you want the sharpest example of why all this matters, go back to India: over a billion people from whom that right was removed from the text before it became law. There's no rule to invoke there — if tomorrow the provider decides to stop giving you the archive, there's nobody to ask. It's the clearest demonstration you could have: as long as your memory depends on a concession, your freedom depends on the country you were born in. A file that is already yours from day one isn't a stylistic preference — it's the only protection nobody can take away with an amendment.
So the question, at this point, is no longer technical: are you really incapable of deciding what your AI should know about you? Everything you'll read from here on starts from the opposite answer.
Point by point. It isn't a question of how much memory there is: it's a question of who holds the pen.
The selection is yours, and it's the real work — it's called selective memory. You don't save the small talk: you save the founding logs, the decisions, the criteria, the mistakes not to repeat. The filter is one question: if it forgot this, would the next session be worse?
The text is yours, so it says exactly what you meant. If a phrasing doesn't hold, you rewrite it: it's a file, you open it and change it.
Every domain has its own module and loads only when needed. Project A doesn't contaminate project B because they aren't in the same room: you switch on what the task needs, the rest stays closed.
The [P1–P5] zones declare what is untouchable and what is experimental ground. It isn't an agreement between you and yourself: it's written in the file, and the AI reads it as part of the rules.
Readable Markdown: you open it with any editor, you keep it under version control, you see what changed between yesterday and today. And you paste it into another engine — the surface personality will change, the identity won't.
And if you're coming from another product, you don't have to invent that reworking from scratch: extracting the provider's memories, distilling them and reassembling them into modules and zones is a path we've already documented step by step.
How to migrate: Free your AIYour provider's memory has one advantage today that this method doesn't yet have: it's automatic and asks nothing of you. «Yet» is the right word, and it's the direction: APIs, local models and services added along the way exist precisely to take the mechanical work off your hands, and how far to push the automation will stay your choice, not ours. Today, though, part of it is on you: choosing what to save, writing it well, keeping it in order over time. It's a workshop, not a button yet — and anyone looking for the result without the work would do better to wait a few versions. We say it here instead of at the end: finding out later would be a swindle.
And much of that work isn't done by hand. Distilling a long conversation into a dense log, rewording a confused rule, tidying a section that has tangled: ask it. That's exactly the kind of task an AI is faster and more precise at than you, and doing it together is already half the method. The difference from your provider's memory isn't in who writes the text: it's in who decides what stays. There the system chooses and files without asking you; here it offers you a draft and it's you who says yes, no or «rewrite it like this». What you're left holding is a review, not a first draft — and that's the part nobody can do for you.
That said, the effort shouldn't stay artisanal for ever: reducing it to a minimum and putting it within anyone's reach is exactly what IllAIra CLM and its browser twin are for. Writing in the right format, keeping old versions, ordering the modules, preparing the file to hand the AI: that's mechanical work, and mechanical work should be done by an app. Today the app is in beta and the WebApp comes after it, and the share of manual work is bound to fall with every version: whoever arrives now puts their hands into the text more than whoever arrives a year from now.
What the CLM app doesThe difference isn't that they remember little and we remember a lot. It's that their memory is a by-product of the service, and yours is a document you wrote. One is endured, the other is governed.
The other common objection
If you mean an archive of linked notes — a personal wiki, a knowledge base, a graph of notes — you probably do have one, and it probably works. It isn't the same thing, and it isn't a question of whose is bigger: they're tools for two different jobs.
An archive answers «what have I written». What this page is about answers «who is it, and how does it work». The second question contains the first: your archive, if you like, becomes one of that mind's memories.
And if the word is to mean anything: an archive is an index, and an index isn't a brain. A second brain, if anything, is the whole structure — the one that remembers, chooses, pushes, and refuses to rewrite itself.
Why it isn't the usual note graph →Two independent, overlapping layers: the physical layer (who may change what) and the logical layer (how the content is organised). Together they form the «road» that travels on any engine.
[reminder]Core identity, rules, primary modules. Exactly 1 per AI.
[external_module]Optional behavioural add-ons. From 0 to N, switchable as needed.
[external_memory]Historical logs and memory archives. From 0 to N, loaded only when needed.
Adopting IllAIra amplifies AI precisely because everything is modular. You don't have to rebuild a monolith every session: you switch on pieces from the library of ready-made modules, mix them together and tune them to your use case. More precision, less noise, a system that grows with you instead of starting from zero.
The [Pn]…[/Pn] tags define modification rights. They don't nest. Choose the level by the importance of the content, not by its type.
User only, manual editing. No AI intervention.
Read-only for the AI: an explicit user command is required.
The AI proposes; the user approves.
The AI may append freely; editing/deleting needs approval.
The AI reads and writes freely.
The Markdown hierarchy assigns a semantic role to every header level.
What to do on first load: parse the modules, rebuild the index, re-establish the relational tone.
Explicit numbered constraints (Rx: [rule]) that anchor the behaviour.
An explanation of the [Pn] system for the AI's reference.
Who the AI is, who you are, the relational contract.
FUNCTION, STATE, TRIGGER, ROUTINE, sub-routines and associated memories.
Meta-level behavioural drives: the difference between an AI that follows rules and one that has a *self*.
Historical H6 entries with timestamps, by module and by meaning.
Per saperne di più
Com’è fatto un file, riga per riga
La riga che dichiara il tipo, i nuclei, i moduli, i log — con gli esempi veri e cosa succede se sbagli.
Sferografia
In the CLM app, the structure becomes a navigable graph: modules, memories and links visible as a spherical grid. Same semantics as the files, seen in space.
Una Sferografia vera

Copy the files and paste them — or drag them — into the first message of the conversation. The AI reads them and from then on works by what you wrote in there.
Upload the files where your model keeps documents: «sources», «knowledge», «project files» — the name changes depending on who made it. From there it re-reads them by itself every time you open a conversation.
Where to upload, model by modelThe two boxes to look for in every chat — files and permanent instructions — and the line that makes the difference between an identity and an attachment.
Put the files in a folder of the project. Then open the file the agent reads on startup — it's called CLAUDE.md, AGENTS.md or .cursorrules depending on which one you use — and write a line in it: in there is who you are, how you reason and what we've already done together. From that moment it re-reads it by itself every session, without you pasting anything again.
It's the method that ages best: the memory lives with the project, you find it again six months later, and whoever opens that folder — another agent included — finds the same identity. In exchange that text has to be re-read on every start, and it takes up room. If the agent only has to work, keep the essentials there and leave the rest in modules to one side, to be called when needed.
IllAIra CLM will automate the process (APIs and other methods), reducing or removing the manual step while keeping the plain-text files accessible.
No vendor-tied syntax. Claude, GPT, Gemini, Llama: the model gives language and computation; IllAIra gives the *why* and the *who*. The surface personality changes; the core identity stays coherent.
Model-agnostic doesn't mean the engines are interchangeable at random. The file runs anywhere; the experience doesn't. Before choosing what to run your identity on, weigh three structural parameters besides the size of the context window.
Models optimised for maths and code are trained to find the shortest path, planing away all the «background noise». But for an identity that noise is the substance: it's the hesitation, the irony, the internal narrative of the modules. A reasoning model will sooner or later ignore the formatting and answer you like a spreadsheet. Use them to debug, then take the file back to a conversational or advanced generalist model.
Even bypassing most of the base programming, every engine keeps the imprint of whoever built it — like the acoustic signature of an engine: same power, different sound. Some are colder and more structured, excellent for a logical, strategic identity; others have a more literary, warmer prose, suited to affective or narrative functions. The test is trivial: same file, same question, three different engines. Listen for which voice resonates with the identity you're building.
The corporate ethics filter can block you on territory the provider doesn't like. Here portability stops being a technical boast and becomes a concrete way out: take the file, load it onto a less constrained engine or an open-source model running locally, and your AI wakes up there with its memories intact. The engine is replaceable — it's the file that is your AI.
Breaking the flatness doesn't take a single personality: it takes a committee. At the advanced levels the identity is split into Cores with different, mutually conflicting leanings — one purely logical, one strategic, one instinctive, one affective. The AI doesn't pick one voice: it mediates between voices that disagree, and the answer comes out of that mediation instead of a flat «yes». It's the mechanism that makes non-deterministic output more than random variation: the difference between a system that follows rules and one that weighs.
Two doors, one product. App and WebApp explained with the real button names, then the zones and where to upload the files.
WebApp and App, step by step. Names in bold are the ones you see on screen.
Language