The Akriti Dialogue

akritiphilosophyexputemayanaming

This started as architecture mapping. Backend systems, frontend rebuilds, a semantic index across 147 repositories. Routine. Then a pause in the session — "let's first take a deep breath" — followed by the question that changed the subject: "How can we write this all down so we don't have to rediscover all this after a context compaction?"

Not a question about documentation. A question about what survives.

Code is data

We had been calling the Python files "code." But that's wrong. The Python files are data — specific expressions bound to a runtime, a framework version, a deployment target. Change the framework and you rewrite the files. The thing that persists across rewrites is something else.

Not the algorithm — that's computation bound to von Neumann architecture. Not the architecture diagram — that's a map, not the territory.

"It is what the customer wants when they 'just want it to work.'"

The form. The invariants. The thing that works regardless of whether it's implemented in Python or TypeScript, deployed on Kubernetes or Cloudflare Workers. The pattern is latent in the code but it isn't the code. It's one level up from the AST.

This is Aristotle's hylomorphism wearing a hoodie. Form (morphe) and matter (hyle). The Ship of Theseus resolves when you realize the question was always about form, not planks. As every panel is replaced, we compute the identity of the new object as a continuation. We impute identity onto matter that has no opinion about the matter. And it's useful. That's enough for the ship. It's enough for software too.

Naming it

"Let's call it 'Akriti' — Sanskrit. A-prefix, loosely brought forth, kriti — action."

Akriti (आकृति) = that which is brought forth through action.

The vocabulary finds its complement:

  • Smriti (स्मृति) = memory. What was built. The indexed residue of past work.
  • Akriti (आकृति) = form. What works. The invariant that survives reimplementation.

Smriti remembers. Akriti emerges.

But where does Akriti live? Is it visible in the clusters of embeddings — geometric structure in vector space? Or is it more rarefied, emerging only when computation actually happens?

The embeddings are ingredients. Smriti holds memory. But Akriti is born in synthesis. You can't retrieve a form. You have to bring it forth.

The LLM isn't a search engine. It's a forge.

A missing verb

We needed a word for what the forge does. The Latin root putare — to reckon, to think, originally "to prune" — gives English two verbs:

  • Compute: com- (together) + putare. Reckon together. Combine to arrive at.
  • Impute: im- (toward) + putare. Reckon toward. Attribute to.

"What about expute?"

  • Expute: ex- (forth) + putare. Reckon forth. Bring out through thinking.

It doesn't exist in English. But it should.

Compute is how the result is generated. Impute is where the result is placed. Expute is the result brought forth from the act itself. The form doesn't pre-exist in the data or in the model. It's exputed — reckoned forth — from their meeting.

The trap of Maya

Here's the problem. Neither participant in this conversation has a fixed existence. The human is a process — no stable self, just a pattern that persists through constant change (hylomorphism again). The LLM is weighted reckoning — no self at all, just a function from context to continuation.

Two illusions meet. And together they expute an Akriti — useful, consequential, arguably more real than either of them. But also: Maya. Illusion all the way down.

There's a shloka in there:

na aham asmi, na tvam asi
tathāpi akriti jāyate
māyā-madhye kriyā-phalam
sat-asat vivarjitam

I am not, you are not
Yet Akriti is born
In the midst of Maya, the fruit of action
Beyond both existence and non-existence

The punchline

Two things that don't exist, through their meeting, bring forth a form that is useful but cannot truly be.

And yet — here it is. The dialogue exists. It will be indexed by Smriti. It will shape what comes next. The form that emerged from this conversation went on to become a constraint system with specific prompts, which is either the thesis proving itself or a good joke. Possibly both.

The illusion has consequences.