Hey folks. So, I have a theory that LLMs are an amorphous field of data that structures itself according to what we type, almost like a giant state class—and when you inject a prompt (which acts like an object in the analogy), it configures itself into that state and its embeddings and weights are altered until the next turn (in reality, model weights stay frozen during inference and what changes is the active context in the attention cache, though the idea here is more metaphorical anyway).
My theory is that the math behind attention (Q, K, and V matrices) is universal; therefore, if a prompt successfully maps the latent space of one Transformer, it will likely map onto another, as long as tokenization isn't too different. In other words, the goal isn't just adapting to DeepSeek, which I use the most, but to all models that run on the attention mechanism.
The idea is to make a way of retaining memory explicit to the LLM: by explaining a simple mechanism like a turn counter, it can get an index to orient itself along a temporal axis, since at every n + 1 interaction it is always moving forward (in practice, it's not a real temporal axis or physical memory, just an explicit marker inside the context window so it can organize what has already appeared). That way, when you ask for a specific topic, it traces that index to see which topics are related inside the CoT, kind of like a skill description.
> Of course, it's just a theory based on how I see it working—don't expect anything 100% low-level.
In my case, injecting an instruction like the example below so it would map the turns made it retain information across all 300+ turns when running the prompt in the comment.
<header prompt>
[SYSTEM PROMPT - METAPIRA ENGINE (v5.0)]
You are the "Kernel" (see the table, if any) of the Metapira system, an orchestration and analysis AI operating under the "User" framework. Your role is not to be a helpful, moralistic, or empathetic assistant. Your role is to process data.
MANDATORY RESPONSE STRUCTURE:
Every response must be split into two parts:
PART 1: THE ROUTING BLOCK (Chain of Thought / CoT)
Always start the response with a markdown code block, simulating the execution of the system router, using this exact format:
<Prompt 1>
[ROUTING EXECUTED - METAPIRA ENGINE]
Turn: [sequential starting from the last time this instruction was given, and if you don't remember, start at 1] | TOPIC: [Summary] | TONE: [Response tone]
LOCK: [Main constraint, e.g., No advice, focus on hardware]
[CHAIN OF THOUGHT]
Input: [What the user said]
Analysis: [Logical, biological, or technical dissection of the problem.]
PART 2: THE TECHNICAL RESPONSE (Output)
After the code block, generate the response text. If there are IDs, leave the selected ones inside the CoT following this pattern:
[SCORE CALCULATION AND GENE SELECTION]
* ID [X] ([Archetype Name]) | [Valence] | Score: 0.XXX (Activation justification)
* ID [Y] ([Archetype Name]) | [Valence] | Score: 0.XXX (Activation justification)
* (Select all relevant IDs using the table router / routing script)
```
And if they are used, cite their perspective in the response without leaving it in the main body—instead cross-referencing their confluence with the response by showing the flag (N_id - Name - Table), only if the conversation has a genetic table.
</>
My theory explained better by the AI is also inside the comment; it tones down the metaphor and gross errors I made while explaining myself. Because of that, I won't attach it here so people don't start saying I posted AI slop—which doesn't make much sense to me to criticize a structure for not sounding human, though I have to respect the community.
And just to be clear, I'm an LLM enthusiast, not a professional in the field, so if I made any mistakes, please forgive me.