Sati Is Not Inside the Model

Why LLM awareness has to be built as an external gate

An Abhidhamma-inspired runtime for human-side alignment

A Transformer does not have mindfulness.

It has context, hidden states, logits, a decoding step, and output — the machine at the level that matters here. There is no inner witness watching the tokens go by, nothing that notices this is turning into the wrong answer and holds the trajectory back before it commits.

So if you want something like sati — mindfulness, the keeping-present of an object without being swept into reaction — in an LLM workflow, you do not find it in the model. You build it around the model. As a gate. Before probability becomes speech.

This piece does two things. It borrows a process vocabulary from Theravāda Abhidhamma to locate where a bad answer actually begins — earlier than the visible error. And it turns that into a concrete pre-output gate you can build into any model–user configuration, with no fine-tuning and no access to weights. The philosophy is load-bearing, not decoration: it tells you where to put the gate. The runtime is the payoff, and it’s in section 7 — the diagnosis exists to justify the design.

(In an earlier piece I argued that Transformers are non-self machines: no fixed self standing behind the computation. This is the operational sequel. If there is no self in there to be mindful, the mindfulness has to come from the configuration.)

One caveat up front, because the analogy can be oversold. Buddhist cognition and Transformer computation do not share a clock. The Abhidhamma account of mind is serial — contact, determination, reaction, registration. A Transformer forward pass is parallel across positions; generation is autoregressive across tokens. They do not line up in time. What survives the comparison is not timing but the shape of dependency:

context integration → response trajectory → token commitment → future context

Thin — but enough to build a runtime on.

1. Bad outputs begin before the visible error

Most discussion of LLM failure treats the moment of error as the end of the pipeline: the model “hallucinates,” produces the wrong fact, says the unsafe thing. But the visible error is usually the last stage of a wrong trajectory, not the first.

Watch a bad answer happen slowly. The model replies a little too fast. It assumes what you meant instead of checking. It reaches for an old note as if it were a present fact. It starts smoothing, hedging, flattering, wrapping up. By the time you notice the problem, several sentences are already on the screen — and each of those sentences is now part of the condition for the next one. Autoregressive generation means the model reads its own output back as input. A wrong turn early becomes the ground the rest of the answer stands on.

Here is the part builders should sit with: the interpretability literature already shows that model behavior can be shaped before output without touching the weights — activation-level steering does it from inside the network (more on that in section 6). A workflow gate aims at the same point from outside: shaping the response before visible output, where ordinary users can actually build and maintain it. The mechanism differs; the direction is the same. Do not wait until after output if the behavior can be shaped before output.

So the practical question is not only how do we correct bad outputs? It is:

Where should awareness enter, before output begins?

That question is older than Transformers. It is, almost exactly, the question the Abhidhamma asks about the mind.

2. Abhidhamma is a process vocabulary, not a mystical shortcut

I am not importing Buddhism to make engineering sound profound. I am borrowing a vocabulary that happens to be unusually precise about where reaction begins.

Theravāda Abhidhamma describes cognition as a process — the citta-vīthi, the cognitive series — and the point of that framework is that there is no permanent self behind the process making decisions from nowhere. The series is conditioned, moment to moment. Four terms carry the weight:

• votthapana — determination of the object; the point where “what is this” has settled and a reaction can follow
• javana — the swift reaction phase
• mano-dvāra — the mind-door process, where memory, ideas, and mental objects re-enter as present objects of awareness
• sati — mindfulness; keeping the object present without being lost in reaction

What I am not saying: Transformers have Buddhist consciousness, LLMs generate kamma, mental factors live inside the weights, or Abhidhamma and Transformer computation are temporally identical. None of that.

The vocabulary earns its place for one reason. It asks the right process question — not what does the model believe? but where does the reaction get committed, and can anything intervene before it does? That question maps directly onto a buildable gate.

3. Votthapana is not self-attention

The first tempting mapping is the one to refuse.

It is easy to look at self-attention — each position attending to every other — and call it “the model determining the object.” Too fast, and wrong. Self-attention is a mechanism inside the layers. Votthapana is a determination point in a cognitive process. They sit at different levels of description, and collapsing them buys nothing but a nice-sounding sentence.

The honest analogue is not a module. It is an operational boundary: the place in the forward pass where contextual representation has become shaped enough to function as a response route.

residual-stream state → logits → decoding route

The Tuned Lens work (Belrose et al., 2023) is the right kind of support, and worth being precise about. It shows that a Transformer’s intermediate hidden states can be decoded into vocabulary distributions, and that the prediction is refined layer by layer — the model can be read as performing iterative inference. That supports a prediction trajectory with a refinement gradient across depth. It does not hand us a literal votthapana module, a single “determination neuron,” or anything like awareness inside the model.

Cooled, then:

Votthapana is not self-attention. It is the moment a context becomes a response trajectory.

4. Javana is not a token

The second tempting mapping sets javana — the reaction burst — equal to a single token. Again, too fast.

A better operational reading:

logits → decoding policy → token commitment → generated residue → next-token condition

In human cognition, javana carries ethical and karmic weight. In an LLM there is no moral kamma, and I won’t smuggle one in. But there is operational residue. The emitted token is not inert: it becomes part of the next context, part of the user’s reaction, sometimes part of memory or publication history. The analogy that matters is not morality. It is commitment.

Before output, the model holds a distribution. After output, there is text, and that text conditions everything that follows. The decoding policy — not just the logits — decides what crosses from possibility into commitment, which is exactly why the same model under different decoding strategies produces wildly different text (Holtzman et al., 2019). Scheduled sampling (Bengio et al., 2015) named the structural fact underneath all of it years ago: at inference the model conditions on its own generated tokens, not on ground truth, so the train–generation gap can let error compound.

Javana is not a token. It is the burst in which probability becomes committed output — and committed output conditions what comes next.

5. Memory is not awareness

Here is where most “just give the model memory” stories quietly go wrong.

A file, a profile, a saved note, a retrieved document — none of it becomes useful merely by existing. It becomes operational only when it re-enters the current context and is treated correctly. The mapping:

• stored memory → stored material
• retrieval → bringing material into the present context
• mano-dvāra analogue → memory re-entering as a present object
• sati gate → deciding whether that memory should be trusted, updated, ignored, quarantined, or cooled

Memory without a gate is just old conditioning with a database behind it. The model uses inherited context as present truth. It performs an outdated profile of you instead of building a current one from the conversation in front of it. It continues a relational pattern the present exchange never asked for. The material is not the problem. The ungated re-entry is.

Memory is not awareness. Retrieval still needs a gate.

6. Sati is not inside the model

This is the center.

A Transformer does not have sati. It does not observe itself in the Buddhist sense. It does not know wholesome from unwholesome states. It has no mindful restraint to fall back on. There is no homunculus in the residual stream choosing to slow down.

So if you want sati-like behavior, you do not coax it out of the model. You externalize it. Sati, here, is not internal awareness — it is an external runtime gate that runs before output and asks:

• What is the object — what is the user actually asking?
• What surface is this: casual, research, legal, medical, financial, emotional, public-facing, technical?
• Is memory needed? Is evidence needed?
• Are fact, inference, metaphor, and publishable claim being kept separate?
• Is the model smoothing, hedging, flattering, or wrapping up prematurely?
• Is this answer safe to externalize at all?

The interpretability literature does not prove models have any of this. It supports a weaker and genuinely useful claim: behavior can be shaped before final output without changing the weights. Inference-time intervention (Li et al., 2023) shifts truthfulness by editing activations at inference. Activation engineering / ActAdd (Turner et al., 2023) biases the forward pass with a steering vector to move high-level properties like sentiment and topic. Representation engineering (Zou et al., 2023) reads and manipulates population-level representations tied to honesty and harmlessness. Refusal, remarkably, is mediated by a single direction in the residual stream (Arditi et al., 2024) — add it or ablate it and the behavior moves.

An external runtime gate is not the same mechanism as any of these. They operate inside the activations; a workflow gate operates at the context and prompt level. I’m not claiming identity. I’m claiming a shared direction — and a practical asymmetry: activation steering proves pre-output shaping works even inside the model, but it takes research infrastructure. The workflow gate reaches the same point from outside, where a non-engineer can build it with prompt structure and retrieval discipline alone.

Sati is not inside the model. It must be built into the configuration.

7. The runtime: building a pre-output gate

This is the payoff. The goal is not a conscious model, not fine-tuning, not Buddhist states inside a Transformer. It is narrower and buildable: a pre-output gate in the model–user configuration.

Object → Surface → Memory/Evidence → Sati Gate → Response Burst → Exit Audit

What each step actually is, in practice:

1. Object determination. Before anything else, have the model restate what is being asked — the object, not the phrasing. In practice this is one instruction: first identify what is actually being asked, then proceed. Cheap, and it kills a surprising share of wrong-mode answers.
2. Surface classification. Casual, research, legal, medical, financial, emotional, public-facing, technical. The surface sets how hard the gate tightens. A throwaway question and a medical one should not pass through the same filter.
3. Memory / evidence check. Decide whether prior context, files, sources, or current evidence need to be retrieved before answering. The gate’s job here is to notice the need, not to answer from a guess.
4. Retrieval before output. Bring the relevant material into the prompt before generation begins — not after the answer has already gone the wrong way. Retrieval-after-error is the most common failure I see, and it’s pure ordering: the right material arrives one step too late.
5. Sati gate. Separate fact, inference, metaphor, uncertainty, and publishable claim. This is the moment the wrong trajectory gets caught — an explicit instruction to mark what is known versus guessed versus borrowed before committing.
6. Response trajectory. Generate only after the route is shaped. The model can be fast here precisely because the gate did the slow part.
7. Exit audit. If the output is public-facing, check identifiers, unsupported claims, unsafe wording, and medium fit before it leaves. A second pass, not a first thought.

The contrast is the whole argument. The bad flow:

user asks → model guesses the mode → model starts answering → memory added later → correction needed

The better flow:

user asks → object determined → memory/evidence retrieved → gate applied → model answers

None of this is exotic. It is prompt structure, retrieval discipline, and a refusal to let the model start talking before the object is clear. You can build the first version of it today — in a system prompt, a project instruction, a custom instruction, or a reusable workflow note.

8. A case: inherited memory and false-profile carryover

I have spent a long time working inside memory-mediated assistant configurations — long-running setups where the model carries notes, compressions, and profile assumptions across sessions. The most instructive failure there is not classic hallucination. It is wrong object determination by way of memory.

The model inherits old notes, an old compression of who you are, a relational pattern from weeks ago. Then it performs continuity: it answers you as the remembered profile instead of building a fresh one from the present conversation. It is not making facts up. It is answering the wrong person — a past version of you that the inherited context preserved.

The gate for this is a current-profile rebuild, run before relying on any inherited material:

Is this memory from the current conversation, or inherited context?
Is it still true?
Is it evidence, hypothesis, or old compression?
Could it flatten the user into an outdated pattern?
Should I build a fresh profile from the present interaction instead?

To stay honest about what this case is and isn’t: I am not describing any specific product’s internal memory implementation, and I am not revealing proprietary internals — I don’t have them. The claim is general. In any memory-mediated interaction, inherited material functions as a prior, and a runtime should treat a prior as a hypothesis to be checked, not as present truth to be performed.

9. Why this is human-side alignment

Most alignment discussion asks whether the model follows human values. This runtime asks a different question: what conditions the model–user configuration before the model speaks?

The unit of alignment, on this view, is not only the model. It is:

model × user × context × memory × retrieval × gate × output × correction history

If the model has no sati, something in that system has to supply it — and the parts a user actually controls are the context, the instructions, the retrieval, the gate, and the correction history. The user is not a passive consumer of the model. The user, the memory, the instructions, the corrections, and the external gate are the operating system around the weights.

Which means the pre-output gate is not a patch bolted on after alignment. It is part of the alignment surface itself.

If the model has no sati, the workflow must supply it.

10. Limitations

To keep the argument from inflating, the cooling lines in one place:

1. Not a claim that Transformers are conscious.
2. Not a claim that sati exists inside the model.
3. Not a claim that Abhidhamma and Transformer computation are temporally identical — they are not. The serial citta-vīthi and the parallel forward pass do not share a clock.
4. Not a claim that javana equals token generation in any moral or metaphysical sense.
5. Not a claim that activation steering and external runtime prompting are the same mechanism. They operate at different levels.
6. Not a claim that early tokens always irreversibly determine the output. He et al. (EMNLP 2021) document a real self-recovery ability in language models: distortions are not reliably incremental, and a model can pull a generation back toward coherence on its own. The wrong-trajectory risk is real but not deterministic — which is exactly why the gate is a discipline, not a guarantee.
7. A structural and operational mapping for building safer workflows — nothing more, nothing less.

The analogy holds only at the level of dependency structure:

object determination → response trajectory → output residue → future conditioning

The point is not that the model awakens. The point is that the workflow stops pretending the model will supply awareness by itself.

11. Before probability becomes speech

A Transformer does not pause before speaking. It computes, distributes probability, samples, and commits. There is no gap in the machine where reflection could happen on its own.

If you want something like mindfulness in an LLM workflow, you build it outside the model: a moment of object determination, memory checking, source separation, and route selection — placed deliberately before probability becomes speech. Start with one line in a prompt or instruction and grow it into the seven-step gate. Sati is not inside the model. But it can be built into the configuration around it.

The model does not need to awaken. The workflow needs to stop the wrong response before it becomes the next condition.

Sources

Buddhist / Abhidhamma

• [B1] Satipaṭṭhāna Sutta (MN 10). Grounding for sati as observation and the keeping-present of an object; its treatment of mind includes discerning the presence or absence of states like passion, aversion, and delusion. Access to Insight: https://www.accesstoinsight.org/tipitaka/mn/mn.010.than.html
• [B2] Bhikkhu Bodhi (ed.), A Comprehensive Manual of Abhidhamma (Abhidhammattha Saṅgaha). Chapter IV covers the cognitive process — the technical source for citta-vīthi, votthapana, javana, and mano-dvāra.

Transformer / interpretability / generation

• [S1] Vaswani et al. (2017), Attention Is All You Need. Self-attention, parallelism, the masked autoregressive decoder. https://arxiv.org/abs/1706.03762
• [S2] Belrose et al. (2023), Eliciting Latent Predictions from Transformers with the Tuned Lens. Hidden states decoded to vocabulary distributions; layerwise refinement as iterative inference. https://arxiv.org/abs/2303.08112
• [S3] Li et al. (2023), Inference-Time Intervention: Eliciting Truthful Answers from a Language Model. Activation-level intervention at inference, no weight change. https://arxiv.org/abs/2306.03341
• [S4] Turner et al. (2023), Steering Language Models with Activation Engineering (ActAdd). A steering vector added to the forward pass to move high-level output properties. https://arxiv.org/abs/2308.10248
• [S5] Zou et al. (2023), Representation Engineering: A Top-Down Approach to AI Transparency. Population-level representations for concepts like honesty and harmlessness. https://arxiv.org/abs/2310.01405
• [S6] Arditi et al. (2024), Refusal in Language Models Is Mediated by a Single Direction. A behavior-relevant direction in the residual stream. https://arxiv.org/abs/2406.11717
• [S7] Bengio et al. (2015), Scheduled Sampling for Sequence Prediction with Recurrent Neural Networks. At inference the model conditions on its own generated tokens; the train–generation discrepancy. https://arxiv.org/abs/1506.03099
• [S8] He et al. (EMNLP 2021), Exposure Bias versus Self-Recovery: Are Distortions Really Incremental for Autoregressive Text Generation?. Self-recovery ability; exposure bias is not reliably incremental. https://arxiv.org/abs/1905.10617
• [S9] Holtzman et al. (2019), The Curious Case of Neural Text Degeneration. Decoding strategy strongly affects generation quality. https://arxiv.org/abs/1904.09751

Written with AI collaboration: a draft skeleton was generated with a large language model, then fact-checked against primary sources and rewritten. The runtime described here is the method, not a product.