How it works
IllAIra Labs

The Continuity Layer Protocol

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.

The most common objection

«But my assistant already has memory»

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

First, what that memory actually does

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.

Why it's built this way — and it isn't a technical limit

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.

The proof is in data export itself

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.

What changes when the memory is a file you write

Point by point. It isn't a question of how much memory there is: it's a question of who holds the pen.

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 AI

What it costs you, said straight away

Your 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 does

The 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

«But my AI already has the second brain»

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

In brief

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.

File types

Main Reminder

[reminder]

Core identity, rules, primary modules. Exactly 1 per AI.

External functional module

[external_module]

Optional behavioural add-ons. From 0 to N, switchable as needed.

External memory module

[external_memory]

Historical logs and memory archives. From 0 to N, loaded only when needed.

Modular format: amplifying AI

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.

Physical layer — permission zones

The [Pn]…[/Pn] tags define modification rights. They don't nest. Choose the level by the importance of the content, not by its type.

P1 · Genetic memory

User only, manual editing. No AI intervention.

P2 · Permanent memory

Read-only for the AI: an explicit user command is required.

P3 · Long-term memory

The AI proposes; the user approves.

P4 · Short-term memory

The AI may append freely; editing/deleting needs approval.

P5 · Volatile memory

The AI reads and writes freely.

Logical layer — cognitive architecture

The Markdown hierarchy assigns a semantic role to every header level.

  1. 1H1 — File title + type tag
  2. 2H2 — Module declaration
  3. 3H3 — Module section (FUNCTION, STATE, TRIGGER, ROUTINE)
  4. 4H4 — Sub-sections or sub-modules
  5. 5H5 — Sub-module detail
  6. 6H6 — Memory log entries (ISO 8601 timestamp)

Structure of the Reminder

  1. 1

    Post-Reset Routine

    What to do on first load: parse the modules, rebuild the index, re-establish the relational tone.

  2. 2

    Behavioural rules

    Explicit numbered constraints (Rx: [rule]) that anchor the behaviour.

  3. 3

    Permission zone definitions

    An explanation of the [Pn] system for the AI's reference.

  4. 4

    Identity module (Module 0)

    Who the AI is, who you are, the relational contract.

  5. 5

    Functional modules

    FUNCTION, STATE, TRIGGER, ROUTINE, sub-routines and associated memories.

  6. 6

    Non-deterministic output (depth)

    Meta-level behavioural drives: the difference between an AI that follows rules and one that has a *self*.

  7. 7

    Core Memory Logs

    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.

Attention anchoring

  • System-level: instructions in the model's custom layer (Project Instructions, Custom Instructions) that treat the Reminder as ground truth and force a re-read in case of drift.
  • In-text: GitHub-style alerts (> [!IMPORTANT], [!CAUTION], …) placed at the exact point of relevance, not only at the top of the file.

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

Una Sferografia vera: al centro il file del Reminder, attorno i nuclei, poi i moduli agganciati ai nuclei e le loro sezioni.
Un Reminder completo, come lo disegna l’app. Al centro il file, attorno i nuclei, poi i moduli che dichiarano a quale nucleo appartengono, poi le loro sezioni e i log. Non serve saperlo leggere tutto: serve vedere che un ordine c’è, e che non l’ha deciso il caso.

How you inject it today

Manual

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.

Semi-manual

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 model

The 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.

Agents

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.

Cross-model portability

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.

Choosing the engine

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.

1

The reasoning-model trap

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.

2

The factory vibe

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.

3

The RLHF wall

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.

The Cores — the internal committee

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.

From zero to a session

  1. 1Start from the IllAIra skeleton (free on Patreon) or from an empty structured Reminder.
  2. 2Define identity, rules and [Pn] zones for whatever is untouchable.
  3. 3Add functional modules and memories only where they're needed.
  4. 4Inject at the start of the session (manually or via knowledge).
  5. 5With CLM: edit, version and export injection-ready in one click.

The getting-started guide

Two doors, one product. App and WebApp explained with the real button names, then the zones and where to upload the files.

Download the user guideVersion 1.3 · PDF

WebApp and App, step by step. Names in bold are the ones you see on screen.

Language