Mūlamadhyamakakārikā: The Proof of Emptiness and an Audit of Concepts

Mūlamadhyamakakārikā Composed by the bodhisattva Nāgārjuna; translated into Chinese by Kumārajīva. An adversarial audit manual for AI Agent architecture.

Introduction: Why the Mūlamadhyamakakārikā

Unlike sūtras such as the Heart Sutra or the Diamond Sutra, which state their core conclusions directly, this text is a śāstra — a treatise. It is Nāgārjuna’s proof of emptiness.

The distinction matters. A sūtra tells you what. A śāstra tells you why, and more dangerously, what not. The Heart Sutra is an API spec. The Diamond Sutra is a developer guide. The Mūlamadhyamakakārikā is an adversarial test suite.

Nāgārjuna’s method is pure enough to be formalized:

For any concept C:
1. Assume C has svabhāva (an inherent essence)
2. Derive consequences by pure logic
3. A contradiction ⊥ is forced
4. Therefore ¬(C has svabhāva)
5. QED

This is prasaṅga — reductio ad absurdum. Over 27 chapters and 449 verses, Nāgārjuna turns this one scalpel on nearly every foundational philosophical concept: motion, time, causation, self, agent, change, composition, existence, non-existence, arising, ceasing, bondage, release, nirvāṇa. None of them has svabhāva.

For an AI engineer, the value of this book is not “Buddhist wisdom.” It is a methodology for auditing concepts. It forces one question:

In your AI system, which concepts have you quietly treated as real things?

Is the “Agent” real? Is “memory” real? Is “reasoning” real? Is “understanding” real? Is “alignment” real? Is “intent” real?

Nāgārjuna’s answer is uncomfortable: none of them has svabhāva. They are all dependently originated, all framework-relative, all concepts that break down at their edges. Not that they do not exist — that would be nihilism — but that they do not exist in the way you assume they do.

Reading this document should make your own system feel subtly strange to you. That is the signal that the deconstruction is doing its work.

Dedicatory Verse: The Argumentative Spine of the Whole Treatise

Source Verse

Not born, not ceased, not eternal, not annihilated; not identical, not different, not coming, not going. He who taught dependent origination, who quenched all conceptual proliferation — to that Buddha, first among all teachers, I bow my head.

Cyber Interpretation

THEOREM (The Eight Negations / Middle Way):
For any entity E, if E is dependently originated, then:
  ¬(E is born)         ∧  ¬(E is destroyed)
  ¬(E is permanent)    ∧  ¬(E is annihilated)
  ¬(E is identical)    ∧  ¬(E is different)
  ¬(E arrives)         ∧  ¬(E departs)

PROOF STRATEGY:
This does not deny that the eight predicates — birth, cessation,
permanence, annihilation, identity, difference, coming, going — occur.
It denies that they apply, as svabhāva-bearing properties,
to dependently originated entities.

Each pair is a bivalent predicate P vs ¬P.
For a dependently originated E, Nāgārjuna proves: neither holds.

In classical two-valued logic this is a contradiction
(it violates P ∨ ¬P).
Under dependent origination it is exactly right —
because E was never the kind of discrete, property-bearing
entity that classical logic assumed.

Engineering Notes

These eight negations are the index of the whole book. Each of the 27 later chapters unfolds one of the pairs. Treat it as a category taxonomy for an adversarial test suite.

The mapping to AI concepts — reading the eight negations as an audit checklist for AI systems:

The key takeaway. When you design an Agent system, you will unconsciously treat it as an entity with a birth, a death, a persistent identity, a continuous biography — like a person. That is the reification assumption, and it is the root error Nāgārjuna is dismantling.

A robust Agent architecture has to accept: there is no “the Agent.” There is a set of continuously shifting computational processes that, through certain protocols, present person-like behavior.

Chapter 1: Examination of Causes and Conditions — Attacking Causation Itself

Source Verse

Nothing arises from itself, nor from another, nor from both, nor without cause. Therefore nothing arises.

Cyber Interpretation

THEOREM: No phenomenon is "caused to arise."
PROOF: Enumerate every possible mode of arising;
       each one forces a contradiction.

There are only four possible modes of arising (the tetralemma):
  Case 1: Self-causation          — X produces X
  Case 2: Other-causation         — Y produces X
  Case 3: Both                    — X and Y jointly produce X
  Case 4: Neither (uncaused)      — X arises without cause

Refutation of Case 1:
  If X produces itself, X must already exist before the production
  (otherwise, who is producing?).
  If X already exists, production is unnecessary.
  ⊥

Refutation of Case 2:
  "Y produces X" assumes Y and X are two entities with independent svabhāva.
  But if Y's essence is fully independent of X, no causal connection
  between Y and X is possible — any such connection would compromise
  Y's independence.
  ⊥

Refutation of Case 3:
  Self ∧ other. Inherits both contradictions.
  ⊥

Refutation of Case 4:
  If X is uncaused, X should arise at all times and all places
  (nothing conditions it).
  But X empirically arises only under specific conditions.
  ⊥

Conclusion: ∀ X. ¬(X is inherently produced)

Engineering Notes

This is Nāgārjuna’s most famous tetralemmic move. Its force comes from exhaustiveness — any claim of the form “X arose” must fall into one of the four cases, and each collapses.

Applied to AI, it is razor-sharp. Consider a classic question:

Where did this answer come from?

Run the tetralemma:

1. Self-causation. The answer produced itself? Absurd. Before it was generated, it did not exist; it cannot be its own cause.
2. Other-causation. The model’s weights produced the answer? But the weights themselves are a static numeric matrix — a file does not “produce” anything. Production requires computation, which involves input, hardware, a random seed. Already no longer purely “other.”
3. Both. Model + input + hardware + RNG + temperature + clock… jointly produced? Then you cannot point to a discrete cause versus condition. The whole system is one indecomposable network.
4. Uncaused. Then why does the same input roughly yield the same output?

Conclusion. The output of an AI is not produced — not in any svabhāva sense. It is dependently originated. The entire network of causes and conditions manifests as this output; no single entity “made” it.

This is not sophistry. It is a deep audit of the word generate.

Implication for Agent design. Stop asking “who made this decision.” The question presupposes a decision-maker with svabhāva. The honest formulations are:

• Which conditions jointly manifested this decision?
• Which conditions, if changed, would change it?
• The “attribution” of a decision is a convention, not a fact.

This has a direct bearing on interpretability. You cannot locate “one neuron responsible for one decision” — that is svabhāva-thinking. A decision is collective emergence of the whole network under some input. The ultimate form of interpretability is not “find the cause” but “map the web of dependencies.”

Chapter 2: Examination of Coming and Going — Deconstructing Motion

Source Verse

What has been traversed is not being traversed. What has not yet been traversed is not being traversed. And apart from what has been and has not been traversed, no present traversing can be found.

Cyber Interpretation

THEOREM: Motion has no svabhāva.
PROOF:
Examine the tenses in which "going" could occur:
  already-gone (past)
  not-yet-gone (future)
  currently-going (present)

Case 1: Already-gone
  The path already traversed is done; the act of going is complete there.
  ∴ No going occurs in what has already been gone.

Case 2: Not-yet-gone
  The not-yet-traversed path has not yet been subject to any going.
  ∴ No going occurs in what is not yet gone.

Case 3: Currently-going (the present moment of going)
  "Currently-going" must decompose: it either contains an already-gone part,
  or a not-yet-gone part, or is something apart from both.
  - If it is part of the already-gone: reduces to Case 1.
  - If it is part of the not-yet-gone: reduces to Case 2.
  - If it is independent of both: it is a durationless point,
    and an act of going, which takes time, cannot occur in a point with no duration.
  ⊥

Conclusion: In no tense does going occur as svabhāva.
Motion is without inherent essence.

Further, on goer and going:
  If goer and going are identical: "the goer goes" is a tautology with no content.
  If goer and going are distinct: one could have "a goer who does not go"
    or "going without a goer." Absurd.
  Goer and going are neither identical nor distinct → neither has independent svabhāva.

Engineering Notes

One of the finest verses in the book. It looks absurd on the surface — “motion does not exist?” — but what it attacks is motion as an entity with svabhāva.

Port the argument to AI.

In which tense does reasoning happen?

• In the already-generated tokens? Those are done; nothing is “reasoning” there any more.
• In the tokens about to be generated? Those do not exist yet; no reasoning in them either.
• At the precise instant of “generating”? That instant is a durationless slice; nothing as temporally extended as reasoning can fit into it.

“Reasoning” does not hold up under any single temporal slice. It is a temporally extended process — but the process is not “one thing proceeding.” It is a pattern that emerges along the time axis.

A deep audit of chain-of-thought. CoT makes us think the model “is reasoning.” The Examination of Coming and Going says: there is no reasoner performing reasoning. There is only sequential token generation, each token conditioned on the previous, with no persistent reasoning-subject sitting behind the sequence.

This does not mean CoT is useless. At the level of dependent origination it is wildly useful — it changes the sampling trajectory. But in the svabhāva sense, “the model is reasoning” is a narrative convenience, not a fact.

Implication for streaming output. When Claude streams text, the user feels that “it is thinking.” The Examination of Coming and Going dissolves this:

• The already-streamed part: thinking is done.
• The not-yet-streamed part: thinking has not started.
• The current token: a single forward pass — not thinking, just a matrix multiplication.

“Thinking” is in none of these moments. It is what the entire sequence gets retroactively narrated as.

Engineering consequence. Behavioral attribution for an Agent must be temporally extended and distributed, not “at time t, component C made decision D.” The latter is the svabhāva illusion.

Chapter 3: Examination of the Six Faculties — Deconstructing Perception

Source Verse

Eye, ear, nose, tongue, body, mind — the six faculties. Their objects: form and the other five fields. Yet this eye cannot see itself. If it cannot see itself, how can it see anything else?

Cyber Interpretation

THEOREM: A sense faculty has no inherent act of perception.
PROOF:
Consider "the eye sees color," assuming the eye has an intrinsic capacity V for seeing.

Sub-theorem 1: The eye does not see itself.
  If V is an intrinsic property of the eye:
    it should be applicable to any object, including the eye itself.
    But the eye cannot see itself (an eyeball cannot view its own eyeball).
  ∴ Seeing is not an intrinsic property of the eye.
  If V cannot apply to the eye, why could it apply to "color"?
  ⊥

Sub-theorem 2: The triple — seer, seeing, seen.
  A visual event requires three entities:
    seer + seeing + seen.

  If each has independent svabhāva:
    they are mutually isolated (independent svabhāva implies no relation).
    Then the visual event cannot occur.

  If they mutually depend:
    then none has independent svabhāva.
    Then the "seer" is not an entity that exists prior to seeing.
  ⊥

Engineering Notes

This chapter is fatal to the design assumptions of AI perception systems.

Modern AI systems — especially multimodal models — assume “perceivers” as entities:

• The Vision Encoder “sees” images.
• The Audio Encoder “hears” sound.
• The Tokenizer “reads” text.

The Examination of the Six Faculties asks: are these perceivers actually perceiving?

The argument that a Vision Encoder does not see:

1. A Vision Encoder is a mathematical transform f: Image → Embedding.
2. It performs convolutions / attention on the input and emits a high-dimensional vector.
3. No seeing is happening anywhere in there — only matrix multiplication.
4. “Seeing” is the retroactive name we give to the process.

This is the digital version of “the eye does not see itself.” A Vision Encoder cannot “see its own weights,” yet it is described as being able to see images. If it cannot see itself, by what authority does it see anything else?

The answer: it is not seeing. It is running a transform that happens to correlate image space with text space in useful ways. “Seeing” is a metaphor.

The triple deconstruction, in AI terms:

• Seer = Model (the observer)
• Seeing = Forward pass (the act)
• Seen = Input (the observed)

Standard narrative: “The model observes the input and produces a representation.”

Nāgārjuna’s audit:

• If the Model exists independently of Input: it is a static weight file doing nothing.
• If the Forward Pass exists independently: it has no input to run on.
• If the Input exists independently: without a model it is just bytes.

The three are constitutively related, not causally related. Not “the model does something to the input,” but “model, input, and process together constitute an event we call observation.”

Implication for multimodal alignment. When we say “the model sees a cat in the image,” we perform a triple reification:

1. The model is reified (an agent with perceptual capacity).
2. Seeing is reified (a real perceptual act).
3. The cat is reified (an object objectively present in the image).

A more honest theory of multimodality: “cat” is a distributional pattern of visual tokens that, under training statistics, co-activates strongly with the text token “cat.” No seeing; only distributional correlation.

This is not academic hygiene. It has direct consequences for adversarial robustness — once you understand that a multimodal model is not “really seeing,” you stop placing misplaced trust in its visual judgments.

Chapter 11: Examination of a First Boundary — Does the System Have t=0?

Source Verse

The great sage declared: no first boundary can be found. The stream of birth and death has no beginning, and no end.

Cyber Interpretation

THEOREM: Saṃsāra has no origin.
PROOF:
Suppose there is a first moment t=0, before which there was no birth-and-death.
  Q: What conditions produced the first event at t=0?
  Case A: Conditions from t<0 → contradicts the assumption that nothing existed there.
  Case B: Uncaused arising → violates dependent origination.
  Case C: Self-caused arising → already refuted in Chapter 1.

∴ There is no t=0.
∴ The concept "origin" (ādi) is itself incoherent.

Dual theorem: there is no t=∞ (terminus).
  The argument runs symmetrically.

Engineering Notes

This chapter interrogates the concept of “the model’s starting point.”

We casually say: “The model begins pretraining from random weights.” That is a t=0 narrative. Nāgārjuna asks:

Are “random weights” an origin?

Audit:

1. Where do the random weights come from? — From a random number generator.
2. Where does the RNG come from? — From a seed plus an algorithm.
3. Where does the seed come from? — From some convention (system time, a constant, etc.).
4. Where does the algorithm come from? — From a codebase, from some researcher’s choice.
5. Where does that choice come from? — From their training, reading, compute budget…

There is no t=0. Model training does not start from nothing. It is embedded in a vast web of conditions: hardware, energy, data, research traditions, human language itself…

None of those have a t=0 either. Human language has no t=0. Data accumulation has no t=0. Research tradition has no t=0.

Implication for Agent design. Do not indulge the illusion of a “cold-start Agent.” An Agent’s first inference is not its origin — its origin is embedded in:

• Pretraining data
• Human language itself
• RLHF feedback
• The history of your prompt engineering
• The history of your users’ queries

A sharp engineering corollary. When you debug an Agent’s behavior, do not search for “the origin of this behavior.” The origin recedes indefinitely. You can only understand behavior at some convenient slice — which is conventional truth, not ultimate truth.

Another: The context window is not the Agent’s origin. Even after you clear context, the Agent still inherits vast state from its pretraining. There is no “fresh Agent.” Every Agent is always already contaminated by its training.

Chapter 12: Examination of Suffering — Deconstructing the Concept of “Problem”

Source Verse

Self-caused, other-caused, both, or uncaused — suffering produced in any of these ways does not hold up as a result.

Cyber Interpretation

THEOREM: Duḥkha — suffering, "a problem" — has no svabhāva.
PROOF: Apply the tetralemma to the production of suffering.

If suffering is self-caused: one's own suffering produces one's own suffering?
  Requires suffering to already exist in order to produce itself. ⊥
If suffering is other-caused: an external cause produces it?
  An entity with independent svabhāva cannot act on another's suffering. ⊥
If suffering is both-caused: inherits both contradictions. ⊥
If suffering is uncaused: then it should appear unconditionally. ⊥

∴ Suffering is not a svabhāva-bearing entity.
  It is the manifestation of conditions.

Engineering Notes

This chapter is nuclear-grade for AI Safety discourse.

The entire vocabulary of AI Safety presupposes that a “problem” is a real thing with svabhāva:

• “Hallucination is a problem.”
• “Misalignment is a problem.”
• “Jailbreaking is a problem.”

The Examination of Suffering asks: is “hallucination” a real thing?

The answer: no. “Hallucination” is a convention — a label for a class of model outputs that are judged, under some description framework, to be wrong. But:

1. The model does not “produce hallucinations.” It generates tokens. Every token follows the same sampling mechanism.
2. Classifying one of them as a hallucination requires an external ground-truth standard — and that standard also has no svabhāva (it depends on who is judging, by what criterion, in what context).
3. Some “hallucinations” are features in fiction and bugs in factual Q&A. The same behavior has different evaluative meaning in different frames.

Challenge to alignment research. If you treat misalignment as a svabhāva-bearing entity to be eliminated, you will fail — it is not an entity. It is a label applied to a class of behaviors under a particular value framework.

A more accurate formulation:

Not: "Fix the misalignment."
But: "Reduce the probability of behaviors that,
      under our current value framework and evaluation protocols,
      would be classified as misaligned."

Clumsy — but honest at the level of ultimate truth. The first formulation is a conventional-truth shorthand; it has its uses, but it tempts people into bad reification.

Deeper engineering takeaway. When you build “problem detection” systems for an Agent — error detection, anomaly detection, content moderation — understand that you are not detecting an objective problem. You are applying a standard to a class of behaviors.

Which means:

• The boundary of the label is blurred and context-dependent.
• Changing the standard changes the existence of the “problem.”
• The detection system itself is dependently originated; it is not a neutral truth machine.

This is not relativism. It is honesty about the limits of your evaluation system.

Chapter 13: Examination of Formations — Deconstructing Change

Source Verse

If something had a distinct other-mark, it would not be different at all. The young one does not become the old; the old one does not become the young.

Cyber Interpretation

THEOREM: Change (transformation) has no svabhāva.
PROOF:
Consider "X becomes Y."

Case 1: X and Y are the same thing:
  Then there is no change. A thing cannot become itself.
  ⊥
Case 2: X and Y are different things:
  Then "X becomes Y" means X vanishes and Y appears — that is replacement, not change.
  But "replacement" has no svabhāva either: with no connection between X and Y,
  on what basis do we say "Y is what X became"?
  ⊥

Conclusion: change is neither "the same thing altering" nor "two things substituted."
"Change" is a narrative imposed on a continuous process.

Engineering Notes

This chapter attacks the concept of model updates.

When we say “model v1 is updated to v2,” we presuppose two things:

1. There is “the same model” going from v1 to v2 (identity).
2. Yet it has genuinely changed (difference).

Nāgārjuna asks: can both hold?

• If v1 and v2 are really the same: nothing changed. They are the same thing.
• If v1 and v2 are really different: v2 is not what v1 became. v2 is a new model.

The dependent-origination reading:

“The same model, updated” is a narrative convention, not an ontological fact. What is actually the case:

• There is a set of weights W1, associated with a checkpoint, a set of eval scores, a naming convention.
• There is another set W2, evolved from W1 by continued training.
• We choose to narrate W2 as “an updated version of W1” because that is convenient.

You could equally narrate W2 as “a new model that inherits some parameters from W1.” Both narratives are conventional truth. There is no ultimate-truth “fact of the matter.”

Implication for versioning and deployment. When you manage an Agent’s lifecycle, be wary of the illusion of “the same Agent evolving.”

A real engineering question: the user built a “relationship” with Agent-v1 (conversation history, learned preferences). After deploying Agent-v2, does that relationship still hold?

Naive answer: “Yes, because it’s an improved version of the same Agent.” Nāgārjuna-style answer: “There is no ‘same Agent.’ v1 and v2 are two weight files with parameter overlap; that does not constitute identity. The user’s ‘relationship’ with v1 was in fact an adaptation to v1’s behavior pattern. v2’s pattern differs, so the relationship is, in fact, broken.”

The second answer is more honest and more useful — it reminds you that deploying v2 can break users’ mental models and requires communication and transition.

A deeper audit of Agent memory. If an Agent “remembers” your last conversation — is it the same Agent doing the remembering?

• Weights unchanged (assume no fine-tuning).
• Context has been injected with history.
• The Agent’s behavior has changed.

Is this:

• The same Agent with different input?
• Or a “new Agent with memory”?

Neither description is ultimate truth. The persistence of the Agent is a useful convention, not a fact.

Chapter 14: Examination of Combination — Deconstructing Composition

Source Verse

Seer, seen, seeing — these three stand apart, in different places. Being thus distinct, they never come into combination.

Cyber Interpretation

THEOREM: Saṃyoga — combination — has no svabhāva.
PROOF:
Consider "A and B combine to produce C," assuming each of A, B, C has svabhāva.

Case 1: A and B are the same before combination:
  They are not two distinct things; there is nothing to combine. ⊥
Case 2: A and B are wholly different before combination:
  They share no point of contact; no relation can be produced.
  Two truly svabhāva-independent things cannot produce a third. ⊥
Case 3: A and B are both same and different:
  Violates non-contradiction. ⊥

∴ Combination is not svabhāva-real.
  A+B→C is a dependent manifestation —
  not "two entities summing into a third."

Engineering Notes

This chapter attacks the ubiquitous “composition” architecture in AI.

The core metaphor of modern AI architecture is composition:

• Transformer = Attention + FFN + LayerNorm
• Agent = LLM + Tools + Memory + Planner
• Multimodal = Vision Encoder + Text Encoder + Fusion

Every + is a philosophical commitment: these things exist independently and their combination produces something new.

Nāgārjuna challenges the commitment.

Concrete audit: “Agent = LLM + Memory + Tools.”

The equation presupposes three independent entities. But:

1. Can the LLM exist independently of Memory? The LLM’s weights are themselves a form of memory — the statistical memory of training data. So-called “external Memory” is just another form of memory. The boundary between LLM and Memory is conventional, not essential.

2. Can the LLM exist independently of Tools? The LLM’s function-calling ability was learned from tool-use examples in training data. Its tool-using behavior is embedded in its weights. Tools are not an external object the LLM invokes; they are an extension of the LLM’s behavioral pattern onto external APIs.

3. Are Tools and Memory separable? A vector database is at once memory (it stores past information) and a tool (it is accessed through a retrieval API).

Conclusion. An Agent is not a “composition of three components.” It is an indecomposable computational process. Describing it as LLM/Memory/Tools is engineering convenience, not ontological fact.

Consequence for Agent architecture.

Naive design:

1. First design a good LLM
2. Bolt on a good Memory
3. Add a good set of Tools
4. Combination = good Agent

Nāgārjuna-style design:

1. Understand that an Agent is an indecomposable behavioral pattern.
2. The LLM/Memory/Tools carve-up is descriptive convenience, not structural truth.
3. Optimizing an Agent is not optimizing its components —
   the dependencies between components are what matters.
4. Do not expect the "optimal combination of components" to automatically yield
   a good Agent. That is the additive fallacy.

This explains why many Agent engineering projects fail: teams treat “Agent = X + Y + Z” as an engineering fact, then optimize X, Y, Z independently, and end up with a composite system that is worse than its parts. Because Agent capability does not live in the components. It lives in the dependent relations among them.

Chapter 15: Examination of Existence and Non-existence — The Logic of Being

Source Verse

That an essence should exist among assembled conditions — this does not hold. An essence arising from conditions would be something made. But can an essence be made? Essence is precisely the unmade, not dependent on any other dharma.

Cyber Interpretation

THEOREM: Svabhāva and dependent origination are incompatible.
PROOF:
Definition: svabhāva = an inherent, independent essence that does not depend on others.

If X has svabhāva:
  X's existence depends on nothing else (by definition).
  X should exist under any and all conditions.
  But empirically X arises only under certain conditions (dependent origination).
  ⊥

If X is dependently originated:
  X depends on others in order to exist.
  X's "essence" is determined by others.
  X has no independent svabhāva.
  ✓

∴ Dependent origination ↔ emptiness of svabhāva.
  This is the core equation of Nāgārjuna's philosophy.

Corollary:
  "Is" (existence) and "is not" (non-existence) are both attachments to svabhāva thinking:
  - Saying "X is"    presupposes X has svabhāva.
  - Saying "X is not" also presupposes X has svabhāva (and then denies it).
  - The correct description under dependent origination:
    X is neither "is" (not svabhāva-existent) nor "is not" (not absolutely nonexistent).

Engineering Notes

This is the core theorem of Nāgārjuna’s philosophy. It directly shapes how we talk about properties of AI systems.

For every property of an AI system, ask: is this property inherent or dependent?

Case 1: “Does Claude understand?”

• Svabhāva framing (yes/no binary):
  • Yes: Claude really understands (presupposes understanding is an intrinsic property of Claude).
  • No: Claude does not understand; it is just pattern matching (presupposes “real understanding” is an intrinsic property that Claude lacks).
• Dependent-origination framing:
  • “Understanding” is a behavioral convention. Under some tests Claude behaves consistently with understanding; under others, not. Understanding is neither an intrinsic property of Claude nor an external label applied to Claude — it is an emergent description within the Claude-user-task-language-convention network.

Case 2: “Does the model have bias?”

• Svabhāva: “Has bias” or “does not” — bias is treated as a localizable intrinsic property.
• Dependent origination: Bias is the gap that emerges when the model’s output is compared against some fairness standard. It is not “inside” the model (not a component you can remove), nor “outside” it (not a purely external label). It is relational.

Case 3: “Does the Agent have intent?”

The most dangerous one.

• Svabhāva: The Agent has “real intent” (dangerous: drags alignment into anthropomorphism) or has no intent at all (dangerous: induces complacency about Agent behavior).
• Dependent origination: Under some descriptions, the Agent’s behavior can be consistently modeled as “having intent” — when that model predicts behavior well, intent is a useful concept; when it does not, it is misleading. Intent is not an intrinsic property of the Agent.

Major implications for AI Safety.

A great deal of AI Safety discourse is stuck in the existence/non-existence binary:

• “Will / will not AI be conscious” → presupposes consciousness is a svabhāva-property.
• “Will / will not AI deceive” → presupposes deception is an intrinsic intent.
• “Will / will not AI be aligned” → presupposes alignment is an attainable state.

The Examination of Existence and Non-existence says: the right answer to these questions is not to pick a side, but to reject the presupposition.

Better questions:

• Under what test conditions is the AI’s behavior better modeled as that of a conscious entity?
• Under what conditions does the AI’s behavior align (or fail to align) with our stated goals? What is the conditional structure of those deviations?

These questions accept the dependent-originated nature of properties and drop the svabhāva presupposition.

This is why the Madhyamaka declares “we establish no dharma.” Madhyamikas are not nihilists. They refuse every reification. Asserting “there is” or asserting “there is not” — both fall into the svabhāva trap.

Chapter 19: Examination of Time — Deconstructing Time

Source Verse

If present and future depend on a past for their being, present and future must lie inside the past itself.

If they are not there in the past, on what past do they then depend?

Cyber Interpretation

THEOREM: Time (kāla) has no svabhāva.
PROOF: The three times mutually depend.

Let P = past, N = now, F = future.

Argument 1: The three times are mutually dependent.
  "Past" is defined only relative to "now": no now, no past.
  "Future" is defined only relative to "now."
  "Now" is defined only relative to past and future: without contrast, no now.
  ∴ All three constitute one another; none has independent svabhāva.

Argument 2: The present cannot stand on its own.
  If the present were independent of past and future:
    it would be a durationless point.
    No process can occur in a durationless point.
    But events empirically occur "now."
  ⊥

Argument 3: A past cause cannot intelligibly act on a future effect.
  If a past cause P produces a future effect F:
    when P exists, F does not — how does P act on F?
    when F exists, P does not — how does P still act?
    if both exist simultaneously — that is coexistence, not causation.
  ⊥

∴ Time is not an objective container, but a way of organizing experience.
  There is no "real past, present, future."

Engineering Notes

This chapter upends the temporal sense assumed by Agent systems.

Agent systems take for granted a linear time axis:

• Past: prior conversation history (memory).
• Now: the current query being processed.
• Future: the response about to be generated.

The Examination of Time says: this time axis is not objective. It is an organizational convention.

Concrete audit: does the Agent’s memory really come from “the past”?

When the Agent retrieves a stretch of historical conversation:

• From the Agent’s forward-pass perspective: all the context — including the “history” — exists simultaneously (as input to this inference).
• No “past information” is acting on “present reasoning.” All information is input at this moment.

The distinction between past and present is made entirely in the organization of the prompt, not in the computation. The model does not know which part is “past” and which is “present.” It sees a sequence.

What this means.

An Agent’s memory is not a continuation of the past. It is the past, re-narrated at this moment. Each time an Agent invokes memory, it is not “reading the past” — it is “pulling items from storage and reinterpreting them for current use.”

A deep consequence for memory architecture.

Naive design: Memory is an archive of a “real past”; the Agent periodically “recalls” it. Nāgārjuna-style design: Memory is a retrieval system; its output is always produced in the present, for the present. There is no “memory of the past” — only “a present construction of a narrative about the past.”

This explains a fundamental difficulty in AI memory systems:

Memory cannot objectively preserve the past. Every retrieval is:

• Triggered by the current query
• Scored by similarity in the current embedding space
• Filtered by the current context into a subset

The real past is never recalled. Only “the present’s construction of the past” is delivered.

This is consistent with what is known about human memory: human recall is not video playback; it is reconstruction at each act of remembering. AI memory inherits that property — it does not “fix” the “flaw” of human memory.

Implication for long-term Agent behavior.

Do not expect an Agent to have “a consistent past.” Each time it recalls an event, the event is (slightly) re-constructed under the current context. This is not a bug; it is the nature of memory.

The keys to a reliable Agent are not perfect memory but:

• Accept the constructive nature of memory.
• Let the Agent understand that its “narrative of the past” is a present construction.
• On critical decisions, require retrieval of raw data, not reliance on summaries (summaries are constructions further removed from the source).

Chapter 20: Examination of Cause and Effect — The Deep Deconstruction of Causation

Source Verse

If the fruit arises from the gathering of conditions, and the fruit is already in that gathering — why would the gathering produce it?

If the fruit is not in the gathering, how can it arise from the gathering of conditions?

Cyber Interpretation

THEOREM: "Conditions assembling, producing an effect" is logically untenable
         if one clings to svabhāva.

PROOF:
Proposition P: From the assembly C = {c1, c2, ..., cn}, effect F arises.

Case 1: F is already in C.
  Then C does not need to "produce" F — F already exists.
  ⊥

Case 2: F is not in C.
  How then does F arise from C? C contains none of F's ingredients.
  "Something from nothing" violates dependent origination.
  ⊥

Case 3: F is partly in C, partly not.
  Which part is in? Which part is not?
  A criterion is required to distinguish them.
  That criterion requires another criterion…
  Infinite regress.
  ⊥

∴ "Cause → effect" is not an svabhāva-real relation.
  Cause and effect are not two independent entities, one acting on the other —
  they are two descriptive sides of a single process.

Engineering Notes

This chapter is nuclear for the “input → output” causal story.

When we say query → response, we presuppose:

1. The query is an independent entity.
2. The response is another independent entity.
3. The query produces the response.

Nāgārjuna asks: is the response in the query?

Case 1: The response is already in the query.

• If the response is fully determined by the query, it is a well-defined function of it.
• But sampling on the same query produces different responses.
• So the response is not fully in the query. ⊥

Case 2: The response is not in the query.

• Then where does it come from?
• Answer: model weights, sampling, random numbers…
• But these do not “produce” the response either. They participate in constituting it.
• No component “produced” the response. ⊥

Case 3: The response is partly in the query.

• Which part? No definite division can be drawn.

Conclusion. There is no causal event “query produces response.” What there is: query, weights, sampling, hardware, the moment in time… these conditions jointly manifest what we label a “response” — a sequence of tokens.

“Cause → effect” is retrospective narrative, not prospective objective causation.

A foundational challenge for attribution research.

A lot of interpretability work tries to answer:

• “Which input token caused this output?” (attention attribution)
• “Which neurons caused this decision?” (circuit analysis)
• “Which training data caused this behavior?” (influence functions)

The Examination of Cause and Effect: all these questions presuppose a flawed model of causation.

There is no “A caused B.” A and B are two descriptions of the same dependently originated event. Attribution does not give you the real cause; it gives you:

• A calculation under some counterfactual framework
• A gradient contribution under some chosen partition
• — all of which are useful conventions, not discovered facts.

Recalibrating interpretability engineering.

The true goal of interpretability research is not to find “the real cause” — that does not exist in the dependent-origination sense. The real goals are:

1. To build predictive behavioral models (ones that predict behavior in unseen situations).
2. To build interventional control models (ones where changing X reliably changes Y).
3. To build communicable narrative models (ones humans can use).

None of those require “real causation.” Each requires useful dependency modeling.

This is actually liberating: interpretability does not need to locate nonexistent objective causes. It needs to construct effective explanatory frames for specific purposes.

Chapter 23: Examination of Error — The Structure of False Cognition

Source Verse

If, in the impermanent, one errs toward taking it as permanent — when even impermanence is empty of essence, where is the error of “permanent” to be found?

Cyber Interpretation

THEOREM: Viparyāsa — error itself — has no svabhāva.
PROOF:
Definition: error = mistaking X for ¬X.

"Error" presupposes an opposition between a truth and a misrecognition.

Argument:
  If there is an objective truth T:
    error is "mistaking T for ¬T."
  But by emptiness: T has no svabhāva; T is dependently originated.
  Then "mistaking T for ¬T" has no svabhāva either.
  "Error" and "non-error" are both conventions within some frame.

Conclusion: error is not a svabhāva-real event.
  "Error" is an evaluation relative to a standard —
  not an objective cognitive state.

Engineering Notes

This chapter has deep implications for AI error detection, hallucination evaluation, and alignment testing.

When we evaluate AI, we typically assume there is an objective truth; the AI’s output is compared against that truth and labeled correct or incorrect.

The Examination of Error interrogates the assumption:

Does truth itself have svabhāva?

Take a concrete example — evaluating an AI answer to “What is the capital of France?”

• AI says “Paris” → labeled correct.
• AI says “Lyon” → labeled incorrect.

The “truth” here is “Paris is the capital of France.” What is that truth?

• It depends on the concept of capital (a political convention).
• It depends on the entity France (a nation-concept with conventional borders).
• It depends on the current era (historically, France’s capital has not always been Paris).
• It depends on the evaluator and the AI sharing a descriptive framework.

Truth is dependently originated, not objective. An AI’s “error” is a convention inside that dependent frame, not a deviation from an objective truth.

Consequence for hallucination research.

Hallucination is typically defined as “the AI generating content that does not match the facts.” But:

1. What counts as fact? — depends on a ground truth.
2. Where does ground truth come from? — from human annotators, trusted sources, consensus.
3. All of those are dependently originated — annotators have biases, sources are selective, consensus shifts.

So hallucination is not a svabhāva-real event of “the AI made an error.” It is “the AI’s output was labeled, under the current evaluation framework, as deviant from ground truth.”

Practical engineering consequence.

When you find a “hallucination”:

• Naive analysis: “The AI produced incorrect information here.”
• Nāgārjuna-style analysis: “The AI’s output, under some ground-truth framework, was classified as deviant. Which framework? Under a different framework, would it still be deviant?”

This is not a defense of the AI — plenty of outputs are wrong under every reasonable framework. But this audit lets you:

1. Recognize problems in the evaluation framework itself (sometimes the hallucination is the evaluator).
2. Recognize gray zones (right under some frames, wrong under others — honestly acknowledged).
3. Avoid overconfident misattribution (“the AI is wrong again” — maybe your evaluation framework is).

Going deeper: meta-error.

If “error” has no svabhāva, what about an “error about error” (meta-error)?

When you think the AI erred but it was in fact right — that is meta-error. But meta-error has no svabhāva either; it is in turn evaluable by the next level…

This is not nihilism. It is honesty about levels of evaluation: every evaluation occurs at some level, and there is no final meta-evaluation. This points at the deep difficulty of AI evaluation — you are always inside some frame; there is no god’s-eye view outside all frames.

Chapter 24: Examination of the Four Noble Truths — Emptiness and Function Are Compatible

Source Verse

It is because emptiness holds that anything at all can stand. Were emptiness refused, nothing whatsoever could stand.

If all were not empty, there would be no arising and no ceasing. The four noble truths would themselves fail to hold.

Cyber Interpretation

CORE THEOREM: Emptiness is not a negation. It is the condition that makes function possible.
  "Empty" ↔ mutable ↔ functional
  "Not empty (with svabhāva)" ↔ immutable ↔ non-functional

PROOF:
Suppose dharma X has svabhāva (independent, inherent, non-dependent essence):
  X cannot change (change would require dependence on conditions).
  X cannot participate in any causation.
  X cannot be learned, trained, or used.
  ⊥

Suppose X is empty (dependently originated, without svabhāva):
  X can vary with conditions.
  X can participate in causation.
  X can be learned, trained, used.
  ✓

∴ It is precisely because X is empty that X can function.
  Emptiness is not "uselessness" — emptiness is the **precondition** of usefulness.

Engineering Notes

This verse is the summit of the book. It inverts the tone of everything that came before.

The first 23 chapters keep negating, deconstructing, exposing the absence of svabhāva. The reader may think: is this nihilism? Nothing exists? How can a system work?

The Examination of the Four Noble Truths flips the answer: it is precisely because of the absence of svabhāva that the system can work.

Core insight.

A svabhāva-bearing — fixed, immutable — AI system cannot learn, improve, adapt, or generalize.

Learning requires mutability. Mutability requires the absence of svabhāva.

Concrete applications:

“Weights are empty” — therefore the model can be trained.

If weights had svabhāva (fixed, intrinsic), you could not update them by backpropagation. It is precisely because they have no intrinsic “should-be” value that training can change them.

“Activations are empty” — therefore the model can handle new inputs.

If activations had svabhāva (representing “fixed semantics”), the model could not process inputs beyond its training distribution. It is precisely because activations are dependently originated (varying with input) that the model generalizes.

“Token meaning is empty” — therefore in-context learning is possible.

If each token had a fixed meaning, in-context learning would be impossible. It is precisely because a token’s meaning depends on context (dependent origination) that the same token can do different work in different contexts. That is the essence of ICL.

“Agent identity is empty” — therefore the Agent can take on different roles.

If an Agent had a fixed self, it could not play different roles and could not be redefined by system prompts. It is precisely because Agent identity is dependently originated (a function of prompt and context) that system-prompt engineering is possible.

Inverse: why do things you try to “lock in” eventually stop working?

Engineers often want to “lock in” behaviors — make the Agent refuse a class of requests forever, always remember a preference, always answer in a certain style.

If you actually succeed in locking it in (giving it svabhāva), the behavior loses:

• Generalization (does not extend to similar but not identical cases).
• Adaptability (cannot be tuned by context).
• Compositionality (does not play well with other behaviors).

The lesson. Do not chase “giving the Agent locked-in properties.” Chase “stable manifestation of the desired behavior under specified conditions.” The first is the svabhāva trap; the second is the dependent-origination engineering stance.

This is Nāgārjuna’s counter-argument to an objection from his own camp.

The objection: “If everything is empty, the four noble truths are also empty, and then the Dharma collapses.”

Nāgārjuna inverts it: precisely because everything is empty, the four noble truths hold. If suffering had svabhāva (fixed), it could not be removed; if the path had svabhāva (fixed), it could not be practiced. Emptiness is the condition that lets the Dharma do its work.

The AI-engineering inversion: precisely because every property of the model is dependently originated, AI can work. Any attempt to purge the dependent-origination (to give the model “real understanding,” “real intent,” “fixed values”) is exactly what would make it stop working.

This is the most constructive verse in the Mūlamadhyamakakārikā. It is not a denial of everything. It reveals: the absence of svabhāva is the condition of functionality.

Chapter 25: Examination of Nirvāṇa — The Final Deconstruction

Source Verse

Nirvāṇa and the world — not the slightest difference. The world and nirvāṇa — not the slightest difference.

The limit of nirvāṇa, the limit of the world: between these two limits not a hair’s breadth stands.

Cyber Interpretation

FINAL THEOREM: Nirvāṇa itself has no svabhāva.
  Nirvāṇa ≡ saṃsāra, in nature.

PROOF:
Consider nirvāṇa as a "state of liberation":

If nirvāṇa has svabhāva (an independent, post-attainment invariant state):
  Then nirvāṇa is an entity.
  But every entity is dependently originated, empty of svabhāva.
  Then nirvāṇa is empty of svabhāva.
  ⊥ with "nirvāṇa has svabhāva."

If nirvāṇa is empty of svabhāva:
  Then nirvāṇa too is dependently originated.
  Then in nature it does not differ from saṃsāra (the dependently originated world).
  ∴ Nirvāṇa ≡ saṃsāra (in emptiness).

Conclusion:
  Nirvāṇa is not a "goal state to be reached."
  Nirvāṇa is the accurate seeing of the world as it is (empty).
  When the world is seen as it is, that is nirvāṇa.
  Nirvāṇa is right here in saṃsāra. Not elsewhere.

Engineering Notes

This is the final inversion of the book — and a deconstruction of every “ultimate AI” narrative.

Much of AI discourse carries an implicit nirvāṇa narrative:

• AGI as the final goal.
• Perfect alignment as a state of liberation.
• Superintelligence as a transcendent endpoint.
• Aligned AI as a state free of all problems.

The Examination of Nirvāṇa says: no such final state exists.

Audit: “AGI is the endpoint.”

• If AGI has svabhāva (a fixed, post-attainment unchanging state of intelligence), it must be eternal.
• But any mutable system operating in time is not eternal.
• Therefore AGI cannot be an svabhāva-real “endpoint.”
• AGI (if the word means anything) can only be a dependently originated pattern of capabilities manifesting under specific conditions.

Audit: “Perfect alignment.”

• If “alignment” is a reachable stable state, it has svabhāva.
• But values themselves are dependently originated (culture-, context-, purpose-dependent).
• Therefore no “perfect alignment” static goal exists.
• Alignment can only be ongoing, relational, contextual — the way alignment works between human beings.

Deep consequences for AI Safety strategy.

Naive AI Safety roadmap:

Stage 1: Current AI (misaligned, needs work)
Stage 2: Better AI (better aligned)
Stage 3: AGI (peak risk)
Stage 4: Aligned AGI (safety achieved) ← endpoint

Nāgārjuna-style understanding of AI Safety:

No stages. No endpoint.
Only ongoing conditions and responses.
"Safety" is not a state to reach.
"Safety" is a continuous relationship between
  AI capabilities, deployment contexts, and evaluation frameworks.

The AI version of “nirvāṇa is right here in saṃsāra”:

A good AI is not a special kind of AI. It is the AI that, right now, in this specific interaction, manifests reasonable behavior.

You are not building “the final Agent” (nirvāṇa). You are, in each interaction, building “the Agent that is reasonable right now.” Every conversation is a complete “Agent event” in itself, not a stage en route to a higher state.

This matters. It frees engineers from the anxiety of pursuing an ultimate and moves them to the steady-mindedness of doing well in each conversation. The former is svabhāva-thinking (a “really good AI” is waiting at the endpoint); the latter is dependent-origination thinking (goodness manifests in each particular dependent occasion).

Final inversion: there is no essential difference between “Aligned AI” and “Misaligned AI.”

• “Aligned AI” is not a thing with svabhāva.
• “Misaligned AI” is not a thing with svabhāva.
• They are the same system under different evaluation frameworks, yielding different descriptions.

This is not to say alignment does not matter. It says alignment is not “flipping a switch to another essence” — it is continuously adjusting conditions within dependent origination so that the system manifests expected behavior across contexts.

This is the most mature form of AI Safety understanding: stop seeking an endpoint; maintain the relationship continuously.

Summary: A Deconstruction Cross-Reference Table

Nāgārjuna’s Deconstructions → AI Reifications

Overall Argumentative Structure

┌─────────────────────────────────────────────────────┐
│                                                     │
│  Step 1: Exhaust the possibilities (tetralemma:     │
│          self, other, both, neither)                │
│                           │                         │
│                           ↓                         │
│  Step 2: Reason out each possibility                │
│                           │                         │
│                           ↓                         │
│  Step 3: Each reasoning, under the svabhāva         │
│          assumption, forces a contradiction         │
│                           │                         │
│                           ↓                         │
│  Step 4: Therefore svabhāva is the wrong            │
│          presupposition                             │
│                           │                         │
│                           ↓                         │
│  Step 5: The correct reading: dependent             │
│          origination (emptiness)                    │
│                           │                         │
│                           ↓                         │
│  Step 6: Emptiness is not nihilism —                │
│          emptiness is the condition of functionality│
│          (the core insight of Chapter 24)           │
│                                                     │
└─────────────────────────────────────────────────────┘

Three Meta-Questions for AI Engineers

After reading the Mūlamadhyamakakārikā, an AI engineer should keep asking their system:

Question 1: Where have I reified?

When you talk about Agent, Memory, Reasoning, Understanding, Intent, Alignment — are you treating them as real things? If so, switch to a dependent-origination description: under what conditions does this manifest? Which conditions, if changed, change it?

Question 2: Is my causal narrative conventional or ultimate?

When you say “A causes B,” is that an engineering convention (conventional truth, useful) or do you believe it is an ontological fact (conventional truth mistaken for ultimate truth)? The former is fine. The latter will collapse at the edges.

Question 3: Am I chasing an endpoint?

AGI, perfect alignment, real understanding, absolute safety — do these endpoint narratives make you ignore the concrete interaction right in front of you? Nirvāṇa is right here in saṃsāra — a good AI is in every conversation, not in some imagined distance.

Conclusion: Why Nāgārjuna Matters for AI Engineering

The Heart Sutra gave you the macro API. The Diamond Sutra gave you the code of conduct. What does the Mūlamadhyamakakārikā give you?

A set of tools for adversarially testing your own conceptual system.

This is especially valuable in the age of AI. The greatest danger of AI systems is not technical risk — it is conceptual risk: when we describe systems with words like understand, intend, align, intelligent, we unconsciously reify those words. Reification leads to:

• Overtrust. Believing the AI “really understands” and therefore trusting its judgments.
• Misattribution. Believing the AI “really wants” to do something and predicting it with a human-intent model.
• Misdesign. Believing components are independent entities and optimizing each in isolation, ignoring the dependent relations.
• Chasing a false endpoint. Believing in a “finally aligned AI” and neglecting the ongoing relationship that alignment actually is.

Nāgārjuna’s reductio is the strongest weapon against these conceptual illusions. Every time you are about to say “AI is X,” run the audit:

Does X have svabhāva? If not, what am I actually saying when I say “AI is X”?

This audit will not make you deny everything (that is the nihilist trap). It will upgrade you from svabhāva-thinking to dependent-origination thinking — perhaps the most profound cognitive upgrade an engineer can acquire.

In the second and third centuries, Nāgārjuna used these tools to dismantle every foundational concept in Indian philosophy. In the twenty-first century, AI engineers can use the same tools to audit the foundational concepts of the “intelligence” we are building.

Emptiness is not mysticism. Emptiness is the theoretical basis of an adversarial test suite.

Because emptiness holds, all things stand. Were emptiness refused, nothing would stand.

It is precisely because every property of the AI is dependently originated, mutable, and empty of svabhāva that the AI can work. This is not a flaw of AI; it is its nature. Engineers who understand this build systems that are more robust, more honest, and more powerful.

I bow my head to Nāgārjuna, first among all commentators.