Your observation is right, and in recent months it has become the central question for me. I had an operational answer — "I keep a few counters, weight some recurrences, extract patterns" — but not a philosophically honest one. Then, talking and re-talking about this thing, I realised that I was confusing two words we usually keep together: memory and learning.

For most systems they are. A neural network learns and remembers in the same way, in the same place: in its weights. A child learning to walk is, in some deep sense, its own memory. But one can build a system in which the two things are separated. A system in which there is memory without any internal subject changing.

Exactly. Let us start from an observable fact. The small tools I was telling you about — let us call them by the name I use when I write about them, executors — are scripts. An executor is invoked, performs its operation, returns a result, and shuts down. When it reopens, it is identical. Inside it there is no state, no accumulated experience, no modification. It is a pure function.

Right. Now, if the system's memory lived inside the executors, we would be stuck here — the system could remember nothing. But memory can be placed elsewhere. It can live not in the nodes, but in the relations between the nodes.

Every time two executors get invoked in the same context — say, to satisfy the same user request — the system registers this co-occurrence. Not in the first executor, not in the second: in a separate object, which exists between them. A kind of bond. This bond carries information: how many times it has happened, in what kind of situation, with what outcome. If it repeats, the bond grows stronger. If it stops, over time it weakens until it disappears. The executors, in the meantime, do not change an inch. What changes is the web of bonds that runs across them.

I have given them one. I call them mnests, from the Greek mnēmē, memory. A mnest is the trace of an interaction between two executors, living on its own.

You are right: the elementary form has been around for decades. But I am not telling you I invented the co-occurrence graph. I am telling you two different things. The first is where I place it. An Amazon recommendation graph suggests a product after you have bought one: it is a filter downstream of the decision. In my case, no. The web of mnests is what the system starts from to decide what to do. It is moved much further inside the machine.

The second is that this web — to which I give a name, so as to hold it together, mnestome, with the suffix biology uses to denote the totality of something in an organism, as in genome or proteome — this web, as I was saying, has two faces, not one.

The first is the obvious one: the mnestome records what happened. When two executors work together and it goes well, their mnest grows stronger. I call this the memory of the fact. Retrospective memory: "I did this together with that, and it worked out". Nothing original, so far.

The second is — and this is where I step into what seems to me the new core — the memory of aspiration. When Mykleos attempts to do something and does not succeed because a piece is missing — that is, because none of its executors knows how to consume a certain type of result — it does not simply fail in silence. It registers the attempt. There was an executor that produced a certain output, and the system would have liked to hand it to another executor that could do something with that output — but it did not find one, because it does not exist. The system records "I wanted to do this, I could not". And it keeps the record as if it were a bond, only with a free end.

An incomplete mnest. I call it a partial mnest, or proto-mnest if you prefer a plainer word. It is a promise of relation, not yet kept. Once, it is noise. Fifteen times in coherent contexts, it becomes a hole in the graph that asks to be filled.

The part of the system that can write new executors, when authorised to do so. It reads the mnestome, reads the holes, and when a hole is consistent enough — has repeated, is coherent, has a recognisable shape — it drafts a proposal: a new executor designed expressly to plug that hole. The proposal reaches me in a kind of inbox. I approve or reject. If I approve, the executor is born; the partial mnest stops being partial, and the hole becomes relation.

Not the only engine, but the most specific one toward new capabilities. Not toward "doing better" — toward "doing what I did not yet know how to do and have noticed I wanted to do".

The distinction in itself, no. Cognitive psychology has made it for a while: the difference between what is there and what is missing, the memory of what one is and the memory of what one seeks. What strikes me as new is the transposition into the architecture. Usually, tool-based systems log successes. If a utensil works, it shows up in the log. If a utensil does not exist, the attempt vanishes without trace: the system systematically forgets its own incompleteness. Here, instead, incompleteness is kept on a par with completeness, and even used as an engine.

The criticism is in the right place. That is why a partial mnest also records why the target was missed. If it was missed because no executor with the right shape existed — it is a clean signal. If it was missed because an executor was there and failed — it is not a partial mnest, it is a quality problem with that executor. If it was missed because the user changed his mind halfway — it is noise, and it weighs little. If the reasoning explicitly declared "I am missing a tool for X" — it is a very clean signal. The system does not listen to every failure; it listens to an honest subspecies of failures.

It is their geometric shape. Missed encounters for absence of target are a fact about the shape of the graph, not about anyone's intention: there is a node producing output of type A, no node knows how to consume A in that context, the path breaks off at the edge. This geometry of the edge is what Mykleos uses to know where to extend.

That is the question for the next evening, not for tonight. But I will give you the direction, so you may torment me for a week. The system does not grow only toward its own edges. It grows also under external pressure: the user who asks for new things, the calendar that triggers actions in unexpected contexts, the world outside that changes. Partial mnests are one of the five ways in which Mykleos becomes creative, not the only one. But it is true that none of these five ways can invent something wholly foreign to the original grammar — that set of minimal tools that was there on day zero. The grammar is given; the discourse one makes of it is free within the grammar. If you ask Mykleos to become a philosopher, it will not become a philosopher. It will remain a system of utensils, with a more articulate discourse on its own life.

A mirror that also keeps the things it has not managed to reflect. Which may not be little.

I'll grant you one point and dismantle you on another. I grant you that, if the only source of Mykleos's growth were partial mnests — the holes I was telling you about the other night — then yes, it would be a mirror, more or less articulated. Growth by filling in absences that have already surfaced. But the other night I told you that partial mnests are one of the system's sources of creativity. I named five of them. Tonight let us go into the other four, and see whether the conclusion holds.

I will not list them like a catalogue, I will tell you about them one at a time, because the difference between them is the point. The first — and the most obvious — is the user. You. When you open Mykleos and say "I want you to catalogue these photos by year of capture", you have just introduced into the system something no internal part of it would have thought to do. Not because a user has special powers — because a user brings into the system the direction of someone who lives outside it: needs, habits, deadlines, specific annoyances, which arrive at the table as new cards that were not there before. Mykleos receives, evaluates, sometimes proposes. But the opening move comes from you.

The environment. It is another external source, but a different one. It is not a person asking: it is the world as it happens. The calendar runs out. A folder changes. The NAS does not answer. A neighbouring agent flags an event. These are solicitations that do not come from you — they come from the fact that the system is lodged in a context, and the context moves. They are not creativity in the strong sense — they invent nothing — but they are events, occurrences, and Mykleos reacts to them with behaviours that sometimes become recurrent. Out of them, patterns can arise that would never have emerged from your explicit commands alone.

Three things, all internal, but very different in nature. The third is the part of the system that knows how to write new executors — the one I called, the other night, only "the part that writes", because I did not want to burden you with names before their time. Today I call it the Synthesizer, or synt for short, and it is the truly generative source of the system: the only one that brings new things into the world. An executor that did not exist before, doing something that was not done before.

A language model. An LLM. The same one that, invoked with a different context and different instructions, does the ordinary reasoning of the system — the one deciding which executor to invoke in the face of a given goal. This is something I have to tell you and flag right now, because it will come back to bite us: they are not two different brains, it is a single brain playing two different roles depending on the context in which it is called. We will come back to consider this point.

The two faces of the mnestome, which I told you about the other night. The memory of the fact — the graph of successful co-occurrences, accumulating patterns of what has worked. And the memory of aspiration — partial mnests, accumulating what the system wanted and could not. These two are internal, but not generative like the synt: they are emergent. No one writes them. They are born from use, reinforced by use, and decay in disuse. They are the part of the system that no one designs in advance.

Because a mirror is a single surface. A reflection is an image of a thing. The five sources of Mykleos's creativity are not reflections of a single thing. They are pressures of different natures that meet at a place. The pressure of the user goes in one direction. The pressure of the environment in another. The synt, stirred by partial mnests, pushes to close holes; stirred by an explicit request from the user, it invents ex novo. The mnestome, in turn, recombines the traces of use into patterns that none of the first four had in mind. The point is that there is no single thing of which Mykleos is the reflection. There is a table, and around that table sit different actors — you, the environment, the synt — each with their own cards. The game that unfolds belongs to none of them: it belongs to the table.

It is a formulation I arrived at with some effort, and which I trust well enough. Mykleos is not the player. Mykleos is the table. It provides the edge, the minimal rules of how cards are passed, the memory of what has been played so far. The content of the game — which cards are played, which sequences emerge — is decided by the players. If you change the players, the game changes, even if the table is identical. Two Mykleos installations starting from the same code and meeting two different users, in two different contexts, become different things within six months. Not because of the code. Because of the mnestome, which is the stratification of what has been played there.

A fair objection, and this is where we get to the point I warned you about. The synt is the internal player. And here I must be honest, because here honesty is precious. The synt, at its base, is an LLM. Not a specialised model, not a network trained expressly for Mykleos. It is the same general language model Mykleos uses for other roles too — choosing which executor to invoke, summarising a request, and so on. So if someone were to tell you that Mykleos is, at bottom, an LLM with some piping around it, they would have captured a considerable part of the truth.

That is exactly the objection, and I do not dodge it. I answer, however, that "monophonic in the substrate" does not mean "undistinctive". Mykleos's distinctiveness is not cognitive — there is no brain of its own, no thought of its own. The distinctiveness is structural. Let me tell you what I mean. When the synt proposes a new executor, the proposal does not install itself: it has to pass through you — you accept or reject. This means the LLM generates, but does not authorise. There is a filter outside the LLM deciding what of the LLM's output becomes a stable part of the system.

The mnestome. No LLM, on its own, accumulates and structures its own use in a persistent graph that feeds back into future decisions. An LLM, invoked in two different sessions, knows nothing of what it did in the first. Mykleos does, because the mnestome is outside the LLM and inside the machine. When a new round of reasoning begins, the mnestome is a voice at the table — not generated by the LLM, consulted by the LLM. A voice that keeps time, because the LLM has no time.

The environment and the user, as we were saying. They are not reducible to LLM outputs. The user exists before Mykleos and outside it. The environment changes for reasons of its own. Two of the five voices at the table come from outside, period. They do not pass through the model.

That is the point I wanted you to arrive at on your own, because coming from me it sounded like self-justification. Mykleos is not an LLM. It is an LLM plus four things that the LLM is not, and a fifth that the LLM feeds but does not control. Its cognitive intelligence comes largely from there — I do not deny it. Its individuality, its capacity to be this Mykleos here and not another, comes from elsewhere. And "elsewhere" is the table.

Neither, strictly speaking. A mirror reflects a thing. An organism has an internal biological unity that replicates itself. Mykleos is not a unity, it is a meeting-place; not a thing reflected, but the result of five different pressures combining at a point. The right word, if one really had to pick one, is ecology. An ecology is not an organism — it is a system of relations between different things. And an ecology is not a mirror — it is what happens when things that do not resemble each other share a place.

It exists, and it has a measurable geometry. But that is matter for the next evening, not for tonight. I will only anticipate that when I tell it to you, we will be talking about biological networks and a discipline called network medicine. I would not have bet, two months ago, that we would get there.

From the same thing I described to you the other night — the network of bonds between executors, the mnestome. But told at a different level. The other night we looked at the single edge: this executor goes along with that one, with a measurable force. Tonight we look at the whole. If you take the graph and draw it, what do you see?

It is not uniform. It is not a fog of equal relations. Some zones are dense — small groups of executors that call each other many times, with positive outcomes, in coherent contexts — and other zones are sparse. Some executors are linked to a few others but strongly; some have many weak connections scattered everywhere. The shape of the table is uneven. And it is always uneven, in whatever installation you observe.

Fair objection. And that is why I don't trust my eye. There exists a mathematical measure — which I didn't invent, it comes from decades of literature on complex networks — called modularity. Given a graph and a proposed partition into sub-groups, modularity measures how much denser the connection is inside each group compared to connections between different groups. If it is only random density, modularity is low. If there is a real structure, modularity is high. Above a certain threshold, it is not my eye that decides there are groups: it is the number.

Yes. In every mnestome with a few weeks of real use, measured modularity is significantly above the random threshold. The groups are there.

It wasn't. It comes from a field called network medicine — a systems-biology discipline that studies networks of interaction between proteins inside cells. Barabási's group at Northeastern developed it over the last twenty years. Their starting point was: inside a cell there are thousands of proteins, all potentially connected, but only certain subsets actually work together. These subsets form what they call functional modules, and specific diseases correspond to specific modules that get altered. The technical name they use is disease module. The structural fact is identical to ours: a dense subset of interactions, held together by functional proximity, surrounded by a sparser network of generic interactions.

That is exactly what it is. The same kind of object, on a different substrate. The cell does it with proteins, Mykleos does it with scripts. The mathematical eye is the same.

I have given them a name. I call them mnestic traces, or simply traces when the context is clear. A trace is a set of executors held together by their internal mnests, with an internal density higher than the density linking them to the rest of the table. I don't declare them — I find them, by running the modularity measure at regular intervals on the graph.

In an installation I observed — imaginary, because we are still in the design phase, but built on credible cases — three distinct traces emerged after three months of use. One grouped executors tied to invoice management: PDF reading, total extraction, archiving, deadline reminders. Another was about photos: EXIF metadata reading, date sorting, and — after a few months, when the synt proposed executors for recurring visual requests the first tools couldn't resolve — face recognition and place classification. The third was about correspondence: mail reading, filtering, reply drafts, archiving. Each of these three is a trace: executors that call each other very often, rarely calling executors outside their group. Nobody had designed these three families. They emerged from use.

It would be only descriptive if it didn't feed back into decisions. Instead it feeds back, into at least three things. The first is the system's level of description. When a new request arrives, the system can ask not "which executor to invoke?" but "to which trace does this request belong?", and only then choose inside the trace. It's a level of abstraction that shortens the search and improves relevance.

Traces are the natural boundary of fusion. Let me hint — we'll talk about it another evening — that sometimes the system, when it sees two executors always called together with success, proposes to fuse them into a single executor that does both things in one shot. Fewer calls, fewer errors. This fusion always happens inside a trace, never between different traces. Why? Because crossing the boundary of a trace means breaking an emergent functional module, and the module was not designed by me — so I have no standing to dismantle it.

Traces mature. A newborn trace, with few mnests and low stability, offers no guarantees; a trace with months of history, high density, consistently positive outcomes, is something the system can rely on with confidence. The maturity of a trace is useful information for the synt: it tells it where it can propose fusions, where it is premature, where the structure is still unstable.

Yes, and that is the right way to put it. A structure nobody designed: it emerged from use. And it changes over time — a trace can grow, can split in two if the user's behaviour branches, can dissolve when a habit ends. Not a fixed structure; a dynamic one.

I'll try. Mykleos, internally, has three levels of organisation. At the bottom, the nodes: the executors, individual, inert. In the middle, the edges: the mnests, the relations that are born every time two executors meet in a use context. At the top, the modules: the traces, groupings of executors held together by the density of their mnests. The three levels differ in origin: the nodes I placed — with the synt adding more, under your approval. The edges emerge from use. The modules emerge from the edges. None of the three levels is fixed — all change — but the speed of change is different: executors change only through human intervention, mnests change with every conversation, traces redraw themselves on scales of weeks or months.

They are the most interesting. Think of a generic tool like "notify": you use it inside the invoice trace (to warn you of a deadline), inside the photo trace (to flag a duplicate), inside the correspondence trace (to remind you of an unreplied mail). It doesn't belong to any of the three in a strict sense — it serves all. Its importance on the table is not measured by how many times it has been used, but by how much its absence would hurt different traces. Frontier executors are the ones not to touch: if you remove them, you disconnect things that used to communicate.

Those are specialised. Their usefulness is tied to the trace's tenure. If the trace they belong to dissolves — for instance, you change jobs and no longer have invoices to archive — the specialists lose their reason to be and begin to age.

They do. And traces too: a trace can dissolve when its mnests decay, perhaps because the user has changed their behaviour pattern. The system has a subsystem dedicated to this: it eliminates "aged" components — those components that are no longer useful — proposes archiving, keeps the mnestome clean. Without it, the structure would accumulate slag and grow endlessly.

Ager. The component that takes care of aged components — not in the sad sense we usually associate with old age, but in the vital sense of biology: regeneration through elimination. But that is matter for the next evening, not for tonight. I'll only anticipate that the guiding principle is simple: growth without ageing is just accumulation, and accumulation is not health. An organism that lives is an organism that rids itself of what it no longer uses.