By Sharath Sathish·April 2026 ·

GitHub Pages Version: https://sharathsphd.github.io/pratyabhijna

PCE v0.4 is a pre-registered, mechanism-level study of a recursive self-reflexivity layer for large language models built on the Pratyabhijñā philosophy of Abhinavagupta and a deliberately small subset of active inference. We do not claim to have re-engineered creativity; we claim to have isolated which sub-mechanisms inside a five-śakti cascade carry the load and which do not, with all numbers visible on this page and reproducible from the open repository.

The headline is mixed and honest. The cascade-vs-bare contrasts (H1 through H4, pooled in H5) do not move at n = 25 paired items per protocol; the pooled effect is g = 0.14 with a 95% CI that crosses zero. The recursive revision pass is, however, robustly positive on its own (H8a: g = 0.65, p = 1.2e-4), and a learned commit gate outperforms the v0.3 event-driven gate at predicting when a revision is worth committing (F1 = 0.65 vs 0.52). The proxy scorer disagrees with a calibrated Sonnet-4.5 LLM-judge at ρ = 0.0, which we treat as a methodological flag rather than a refutation.

Headline numbers

Forest plot — primary contrasts and pooled effect

Where to read more

• Results Section — every hypothesis with prose, charts, and per-item drill-downs.

• Discussion Section — the seven-subsection mechanism reading, including the H9 sensitivity flag.

• Showcase Section — nine creative outputs (Sanskrit chandas, English poetry, scientific creativity) with the full five-śakti trace animated.

• Plugin & CLI Section — install paths for Cursor, Claude Code, and the standalone pce CLI.

• Paper PDF — the v0.4 mechanism-study paper.

This is the second project in an ongoing program that grounds agent design in classical Indian darśana. The first, Pratyākṣa, is a context-discipline plugin. PCE is the recognition+creativity counterpart.

Motivation

Creative writing benchmarks for large language models are now common, but the mechanisms by which an LLM is supposed to get more creative when wrapped in an agent loop are seldom decomposed. v0.3 of this project asked the holistic question — does the cascade beat the bare model? — and reported a null result. v0.4 takes the next, more disciplined step: it treats the cascade as a stack of named sub-mechanisms, each of which can be tested in isolation against either a bare control or a deliberately weakened sibling. This is the difference between a feature evaluation and a mechanism study.

The vocabulary we use to name those sub-mechanisms comes from Abhinavagupta’s recognition philosophy (Pratyabhijñā). The choice is not metaphorical. Vimarśa — reflective self-recognition — is exactly the operation we ask the cascade to do: re-read its own draft and decide whether revision is warranted. Apohana — exclusion or negation — is exactly the operation that prunes the candidate set inside the icchā stage. The classical Indian framework offers vocabulary that is unusually well-fitted to a recursive self-reflexivity layer, and v0.4 is an attempt to discharge the obligations of that vocabulary against measurable outcomes.

The second motivation is a pragmatic one. The early v0.4 protocol bound the experiment to the OAuth Claude CLI substrate, which constrains which models can be addressed and from where. Phase 8 widens the surface: PCE is now a portable plugin that runs unchanged inside Cursor, Claude Code, or a bare shell with the claude CLI on the path. The cascade model is configurable to any Anthropic CLI-addressable model with sane defaults (haiku for cascade, sonnet for judge). The plugin page documents the three install paths.

The third motivation is methodological transparency. v0.4 commits in advance to four primary hypotheses (H1–H4 per domain), a fixed-effects meta-pool (H5), three mechanism-decomposition hypotheses (H8a/b/c), and a judge-vs-scorer agreement check (H9). Every number on this site comes from a single stats.json with the cost ledger, integrity probes, and per-item judge verdicts

Background

Pratyabhijñā — recognition as the engine of creativity

The Pratyabhijñā school of Kashmir Śaivism (10th–11th c.), brought to canonical form in Abhinavagupta’s Īśvarapratyabhijñāvimarśinī, treats creative cognition as a recognition (pratyabhijñā) event, not a generation event. The classical sequence — cit (luminous awareness), ānanda (impulse), icchā (volition), jñāna (selection), kriyā (rendering), and the reflexive vimarśa that closes the loop — forms what later commentators call the five-śakti cascade. PCE adopts this sequence as engineering vocabulary, not metaphor: each operator has a typed contract, an audit log, and a falsifiable behavioural prediction.

The choice is unusually well-fitted to the mechanism question we want to ask. Vimarśa is precisely the operation of reading one’s own surface and deciding whether revision is warranted; that is the H8a/H8b mechanism. Apohana — exclusion of competing alternatives — is precisely what an icchā stage that operates as best-of-K with negation does; that is the ADR-001 substrate. The vocabulary discharges obligations rather than decorating them.

Active inference and Bayesian Model Reduction

Active inference, in the Friston lineage, casts perception and action as the minimisation of variational free energy. The framework supplies us with two specific primitives that v0.4 uses: a free-energy budget that gates whether the recursive revision pass fires (ADR-003), and a Bayesian Model Reduction step that prunes generative-model components when they no longer earn their complexity cost. We do not claim full variational descent during inference — the OAuth Claude CLI does not expose the sampler, so the cascade approximates Bayesian inversion through prompt-level best-of-K with composite scoring. The paper’s §4 is explicit about this constraint.

The variational identity that holds the framework together is F = E_q[log q(z) − log p(z, o)] = D_KL(q(z) || p(z|o)) − log p(o): a generative surface o is “good” exactly when the cascade’s approximate posterior q(z) over latent candidate continuations is close to the true posterior p(z|o), with low residual surprise over o itself. Creative cognition is naturally cast as F-minimisation when the surface — a quatrain, an interpretation, an alternative use — is what gets inferred. Each PCE operator is one discrete bookkeeping step inside that F-minimisation: cit seeds the candidate posterior, icchā reduces KL via best-of-K with composite scoring, vimarśa performs a second-pass revision that lowers expected surprise on the committed surface.

Bayesian Model Reduction is the operator that prunes posterior components which no longer earn their complexity cost — formally, drops a candidate z_i when its evidence ratio p(o|z_i) / Σ_j p(o|z_j) falls below a threshold scaled by the prior complexity penalty. The cascade’s apohana (negation / exclusion) stage is BMR realised at the prompt level: candidates that share too much surface with the bare reference, or duplicate other candidates, are dropped before jñāna selects. ADR-003’s free-energy budget is the meta-gate over the same machinery: it tracks the marginal F-reduction across the cascade and stops vimarśa from firing another revision once that marginal reduction falls below threshold. Together, BMR-as-apohana and the F-budget make the recursive revision pass principled rather than open-ended — the cascade has a stopping criterion grounded in the same variational bookkeeping that motivates the architecture in the first place.

Why this matters for creative cognition: pratyabhijñā is precisely the moment of F-minimisation when the right candidate is identified — the moment when the posterior collapses onto a surface that the cascade recognises as the right one, rather than generating one from scratch. The same F-minimisation story explains why vimarśa‘s revision pass measurably improves the surface (H8a) and why a learned commit gate beats the v0.3 event gate (H8b): both findings are about getting closer to argmin F. The architecture page walks the F-minimisation interpretation operator-by-operator under “What ‘computation’ looks like in this cascade”, and the results section shows the empirical signatures.

What the substrate is

PCE has a single supported substrate: claude --print over the OAuth-bound Claude CLI. The Anthropic Python SDK code path was removed in Phase 8 (see ADR-007 on the plugin page). For the Phase 7 mechanism pilot, the same CLI was pointed at the managed Anthropic-API substrate (parallel API calls under a quota envelope distinct from the OAuth substrate) so the experiment could parallelise across domains; this is documented as a deliberate substrate-deviation event in §7 of the paper. Day-to-day operation, including the showcase regeneration, runs against the OAuth substrate.

Companion work

PCE is the second project in an author program that grounds agent design in classical Indian darśana. The first, Pratyākṣa (direct perception / context-discipline), addresses hallucination resistance in long-context LLM agents and reports a strong positive Stouffer pooled signal across ten studies. PCE is the recognition+creativity counterpart and reports a smaller, more decomposed effect; the compounding work page contrasts the two empirical signatures honestly.

Architecture

The recursive self-reflexivity layer in PCE is a typed, auditable composition of eight operators. The first six follow the classical pratyabhijñā ordering; the seventh — vimarśa — closes the loop by re-reading the draft against the original prompt; the eighth implements the commit policy multiplexer that v0.4 introduces over v0.3. Every operator has a JSON-serialisable input/output contract, a deterministic seed regime, and an audit log entry per call.

How the operators compose

The diagram below traces a single prompt through the cascade and the closing recognition loop. The shaded backedge marks the BMR-annotated vimarśa → icchā recursion that ADR-003’s free-energy budget gates. The same flow is detailed step-by-step in the operator table below.

Operator-by-operator

The commit-policy multiplexer (v0.4)

v0.3 had a single commit policy: vimarśa fires an event, the revision is committed if and only if the event flag is set (event_gated). v0.4 ships five policies — always_draft, always_revise, event_gated (the v0.3 policy), learned_gate (ADR-002), and an analysis-only oracle upper bound. H8c reports the leaderboard against a bare control; H8b reports the gate calibration. The results section shows the per-policy bars.

Substrate boundary

Everything above the operator boundary is portable: the cascade runs unchanged inside Cursor, Claude Code, or a bare shell. Below the boundary lives the substrate adapter (src/pce/substrate/haiku_lm), which speaks claude --print over the OAuth-bound CLI. The plugin page documents the three install paths and the model-override knobs.

What “computation” looks like in this cascade

Read in active-inference terms (see the background section for the variational identities), every operator is one bookkeeping step inside the same free-energy minimisation. cit seeds the candidate posterior q(z) over K continuations, sampled from the prompt-conditioned generative model. ānanda attaches a novelty signal that biases q(z) away from the bare-arm reference, lowering the KL divergence between q(z) and a posterior that prefers surface-divergent candidates. icchā performs the best-of-K reduction with composite scoring, which is the discrete approximation to a KL-minimising step over the candidate set. apohana is the cascade’s Bayesian Model Reduction stage: it drops candidates whose evidence ratio against the surviving set falls below the apoha threshold.

jñāna commits the selection and emits a structured ΔF score that the ADR-003 free-energy budget reads. kriyā renders the surface verbatim — F is unchanged at this step, only the representation changes. vimarśa is the second-pass operator that reads the draft against the prompt and the constraint set; whether it fires another revision pass depends on whether the marginal F-reduction in the previous pass crossed ADR-003’s threshold. The commit-policy multiplexer below is the final F-comparison: it decides between the draft, the shadow revision, and (in the analysis-only oracle policy) the judge-pair maximum, picking the surface with the lowest residual F under the selected policy. Empirically, the H8a revision-vs-draft contrast and the H8b learned-gate improvement are both evidence that the cascade is moving in the F-minimising direction; the results page shows the per-mechanism numbers.

What is wired but not exercised

The Hopfield ālayavijñāna (long-term store) operators ship in the v0.4 codebase but were not exercised in the Phase 7 pilot — their multi-session dynamics require a longitudinal study that v0.4 does not run. The chandas-aware scorer for Sanskrit prosody is on the v0.5 ladder. Both are noted honestly in the paper’s §10 and on the discussion section.

Methods

Pilot design

The Phase 7 mechanism pilot crossed four domains (poetry generation, poetry interpretation, alternative uses, scientific creativity) with four base arms (haiku_bare, haiku_cascade, haiku_bare_2K_scorer for H6 fairness, haiku_generic_revise_2pass for H7 fairness) and a five-policy multiplex over the cascade arm (always_draft, always_revise, event_gated, learned_gate, oracle). Per-domain n is constrained by the managed-API cost envelope and the judge envelope; the table below summarises pooled per-domain pairs.

Substrate

Both the cascade and the judge ran via parallel API calls against the managed Anthropic-API substrate during the Phase 7 pilot (global.anthropic.claude-haiku-4-5-20251001-v1:0 for cascade, global.anthropic.claude-sonnet-4-5-20250929-v1:0 for judge). The substrate deviation from the OAuth Claude CLI was justified by quota — the managed-API substrate can parallelise across domains where the OAuth substrate cannot. Day-to-day operation, including showcase regeneration, runs against the OAuth substrate. ADR-006 records the deviation and ADR-007 records the SDK code-path removal that accompanies it. The plugin page is the operator-facing reference.

Statistical protocol

Per-domain primary contrasts use paired permutation tests (50 000 permutations) and Wilcoxon signed-rank as a non-parametric backup. Effect sizes are Hedges’ g; intervals are BCa 95% from 10 000 bootstraps. H5 pools H1–H4 via inverse-variance fixed-effects (ADR-005); the pre-registered alternative random-effects DerSimonian–Laird pool is reported alongside as a sensitivity check. Multi-hypothesis correction is Holm. H8a is a paired permutation test on score(revision) − score(draft) over all cascade items; H8b reports binary classifier metrics for each commit gate at the same threshold; H8c pairs each policy against the bare control with Holm correction across the six pairwise contrasts. H9 reports Spearman ρ and sign-agreement between the proxy composite delta and the Sonnet judge delta.

Reproducibility

Every primary number on this site is regenerable from a single command:

pce smoke
pce cascade --prompt "$(cat prompts/anushtubh.txt)" --model haiku --k 4 --seed 4242
python -m benchmarks.figures --version v0.4
python -m benchmarks.autoreport --version v0.4 --strict

See the reproducibility page for the full repro recipe, including the cost ledger, integrity probes, and the §0.5 unmerged-state critique.

Hypotheses

v0.4 pre-registers four primary contrasts (H1–H4), a fixed-effects pool (H5), three mechanism decompositions (H8a/b/c), and one judge agreement check (H9). Two fairness controls (H6 with a 2× scorer budget on the bare arm, H7 with a generic two-pass revision baseline) are reported in the paper appendix. Click any card for the underlying definition; the results page renders these against the live stats.

Primary cascade-vs-bare (H1–H4)

Pooled effect (H5)

Fixed-effects pool of cascade-vs-bare

Methodological flag (H9)

H9 reports Spearman ρ and sign-agreement between the proxy composite scorer and a calibrated Sonnet-4.5 LLM-judge over a held-out subset. Disagreement is treated as a flag against the proxy scorer’s construct validity rather than as a refutation of the cascade. The discussion section §10.4 unpacks this.

Results

9.1 Pilot coverage

The Phase 7 pilot ran via parallel API calls against the managed Anthropic-API substrate, with a deterministic seed regime and two per-model cost ledgers. The Haiku cascade consumed $12.73 across 1,277 CLI calls; the Sonnet judge consumed $0.48 across 23 rows; combined v0.4 spend was $13.21. Per-domain Haiku-cascade pairs are summarised below.

9.2 Per-domain primary contrasts (H1.v4–H4.v4)

None of the four per-domain primary contrasts cross the supported threshold. Effect sizes range from g = -0.32 to g = 0.32. With per-domain n in the single digits, retrospective power is below 0.25 across the board; this is the underpowered-pilot reading rather than a strong null. The forest plot below shows per-domain g and the H5 fixed-effects pool.

9.3 Fixed-effects meta-pool (H5.v4)

9.4 Mechanism panel (H8a / H8b / H8c)

The mechanism panel is where v0.4’s positive findings live. H8a tests the shadow revision pass directly: pair (score(revision), score(draft)) for every cascade item and ask whether the revision is reliably better. The answer is yes — g = 0.65, p = 1.2e-4, n = 27. This is the pratyabhijñā mechanism doing its job.

H8b asks the calibration question: given that the revision is usually better, can we predict which items will benefit? The v0.3 event-driven gate fires on internal vimarśa diagnostics and yields F1 = 0.52. The v0.4 learned gate (ADR-002) trains a small logistic head on the same diagnostics plus the proxy score gap and yields F1 = 0.65 — a real improvement.

H8c places the policies on a single leaderboard against the bare control. always_revise leads, followed by learned_gate; event_gated sits with a CI that crosses zero; always_draft is at the floor. The pairwise gaps between the top two are not significant after Holm correction, which we read as: revision is the right default, and a smarter gate gets closer to the always-revise upper bound.

9.5 Judge-vs-proxy agreement (H9.v4)

H9 stress-tests the proxy composite scorer against a Sonnet-4.5 LLM-judge with a frozen prompt. Spearman ρ on the per-item delta is 0.00; sign-agreement is 56.5% over n = 23 items. We treat this as a methodological flag: the proxy scorer (length × fluency × lexical diversity) is not picking up what a calibrated LLM-judge rewards. The discussion page §10.4 unpacks the implications and the v0.5 metric-design ladder.

Discussion

10.1 The mechanism reading

The single most important shift between v0.3 and v0.4 is conceptual: v0.3 asked does the cascade beat bare and reported a null. v0.4 asks which sub-mechanisms inside the cascade actually do work. The answer is layered. The recursive revision pass — pratyabhijñā’s vimarśa, made operationally concrete as a re-read of the draft against the prompt — is robustly positive on its own (H8a). A learned commit gate (H8b) outperforms the v0.3 event gate at deciding when to commit that revision. The wrapping cascade-vs-bare contrast does not move at this n because the cascade arm runs the same revision step for every item, while the bare arm gets exactly one shot; H8a explains why the cascade should help, and H8c explains which policy realises that help most cleanly.

10.2 Per-operator dissection

Reading the audit logs operator-by-operator: cit alone is not distinguishable from a single claude --print call at the seeds we use; ānanda’s novelty pulse correlates weakly with downstream score gaps; icchā’s best-of-K with composite scoring is responsible for the bulk of the surface variation across the K candidates; jñāna’s selection is dominated by the same composite that the H9 finding flags as misaligned with the LLM-judge; kriyā is a verbatim render in the v0.4 build; vimarśa carries the recursion. The finding is not subtle: the visible signal in H8a is the vimarśa-driven revision step.

10.3 The H8b reading — the gate is the problem, not the cascade

The v0.3 event gate fires on a vimarśa diagnostic (event flag set if the reflexive read finds at least one constraint violation). H8b shows it under-fires: precision is high (1.0) but recall is low — the gate misses items where the revision would improve the surface but no constraint is technically violated. The learned gate (ADR-002) trains a logistic head on the same diagnostics plus the proxy score gap and recovers ~12 F1 points. H8b is a positive finding about gate design, not a refutation of vimarśa: the cascade has the recognition signal; the v0.3 gate just under-uses it.

10.4 The H9 flag

The proxy composite scorer correlates with the Sonnet-4.5 judge at ρ = 0.0 over the per-item delta. Position bias was checked (the judge’s verdict does not flip when arms are swapped); by-quartile breakdown shows the disagreement is not concentrated in any one domain. The honest reading is that the proxy scorer (length × fluency × lexical diversity) and the LLM-judge are measuring different things — the latter weighs thematic coherence and image freshness more heavily. This finding is consistent with the LLM-as-judge calibration literature: an automated judge with a frozen prompt captures dimensions that a feature-based composite cannot. v0.5’s metric-design ladder treats judge-aligned scoring as a first-class concern.

10.5 Pratyabhijñā as engineering vocabulary

Why does the recognition philosophy of Abhinavagupta keep earning its place across this study? Because vimarśa is exactly the operation we ask the cascade to do, and apohana is exactly the move that prunes the candidate set inside the icchā stage. The vocabulary is well-fitted, not decorative. The mechanism reading above survives even if a reader strips the Sanskrit names and reads the operators as “step 1 through step 8.” What the names buy is a pre-existing literature on what each operator is for, which sharpens the engineering choices: vimarśa names the obligation to read one’s own surface, and the H8a/H8b results are the empirical discharge of that obligation.

10.6 Compounding context-engineering work

PCE is the second project in an author program that grounds agent design in classical Indian darśana. The first, Pratyākṣa, addresses the direct-perception axis (context-discipline / hallucination resistance) and reports a strong Stouffer pooled signal. PCE addresses the recognition axis (creativity through reflexive self-recognition) and reports a smaller, more decomposed effect. The contrast is not embarrassing; it is informative. Creativity is harder to move with this kind of mechanism than hallucination is, and the per-mechanism decomposition is the right way to find what does move.

10.7 Threats to validity

The pilot ran via parallel API calls against the managed Anthropic-API substrate with a single judge model (Sonnet-4.5). Per-domain n is in the single digits for the cascade arm, which gives retrospective power below 0.25 on H1–H4. The proxy composite is misaligned with the LLM-judge at ρ = 0.0 (H9), so the H8a finding is conditional on the proxy as a proxy; the v0.5 ladder includes a judge-aligned scorer. Integrity probes and the cost ledger are published alongside this site for forensic audit. Seed regime is deterministic; the per-worker ledger separation is documented in the orchestrator design. The §0.5 unmerged-state critique covering the Phase 7-to-Phase 8 gap is preserved on the reproducibility page as the canonical forensic record.

Showcase — 9 demos with full cascade traces

Nine creative outputs covering three Sanskrit chandas, three English poetry styles, and three scientific creativity prompts. The three Sanskrit demos are live v0.4.1 cascade outputs (source = “live_cascade_v0_4_1”): the cascade was re-run against the prompts in scripts/showcase_specs.toml with --mode live. The tools.sanskrit_chandas validator’s output is reported as an informational note on each Sanskrit page because v0.4 has no chandas-aware composite scorer; the live cascade emits markdown-prose answers, not stripped verse surfaces, so the validator’s ok / count signal does not block release. The v0.5 ladder adds a chandas-aware scorer at which point this can be promoted back to a strict gate. English and scientific demos are real Phase 7 cascade traces with draft, shadow revision, and judge data preserved.

Sanskrit chandas

sanskrit validator: review

Anuṣṭubh — pre-classical 4×8 śloka

Compose a four-pāda anuṣṭubh on the theme of vimarśa (reflective recognition), 32 syllables total.

sanskrit_anustubh revision

sanskrit validator: review

Gāyatrī — 3×8 invocation

Compose a single gāyatrī (24 syllables, three pādas of 8) addressed to citi-śakti as illuminator of cognition.

sanskrit_gayatri revision

sanskrit validator: review

Indravajrā — 4×11 vajra-pattern

Compose a four-pāda indravajrā on the recognition (pratyabhijñā) of the self as already free.

sanskrit_indravajra revision

English poetry

english validator: review

Dickinson slant — ‘the air holds its breath’ (gate miss)

Free-verse poem in the Dickinson tradition: slant rhyme, en-dash mid-thought, anaphora.

english_dickinson_slant revision

english validator: review

Imagist haiku — ‘White feather, iron rails’

Three-line English haiku, imagist constraint (concrete sensory specificity).

english_imagist_haiku revision

english validator: review

Pastoral, traditional metre — ‘Rain on tin’

Traditional pastoral haiku, rain-on-roof image, contemplative register.

english_pastoral_traditional revision

Scientific creativity

science validator: review

Why galaxies have spiral arms (largest revision uplift in pilot)

Explain spiral arms in galaxies via at least two competing physical framings.

science_galaxy_arms revision

science validator: review

Why ice floats — beyond the textbook (gate miss)

Explain why ice floats in a way that goes beyond ‘hydrogen bonding makes ice less dense’, surfacing the geometric and thermodynamic structure underneath.

science_ice_geometry revision

science validator: review

Why mathematics works in physics (vimarśa fired)

Argue, in 400-600 words, why mathematics is unreasonably effective in describing physics, taking a contrarian or non-textbook angle.

science_unreasonable_effectiveness revision

Plugin & CLI — three install paths

PCE v0.4 ships as a portable plugin with three first-class install paths: a Cursor plugin, a Claude Code plugin, and a standalone pce CLI. The cascade itself is host-agnostic; only the manifest and the entry point change per host. A single configuration chain (defaults < repo pce.toml < ~/.config/pce/config.toml < environment variables < CLI flags; later layers override earlier) controls model selection across all three paths.

1. Standalone CLI (recommended for batch / CI use)

# clone, install, smoke
git clone https://github.com/sharathsphd/pratyabhijna
cd pratyabhijna
uv pip install -e .                         # required: registers the pce script
pce smoke
pce config show

# ad-hoc cascade run
pce cascade --prompt "Write a contemporary haiku on attention drift." \
            --constraint "imagism" --k 4 --seed 4242

# judge a pair (the Sonnet judge bridge in benchmarks/judge.py)
pce judge-pair --domain poetry_gen --item-id p07 \
               --treatment-text out/treatment.txt --control-text out/control.txt

The CLI requires only the OAuth-bound claude CLI on the path. No host IDE is required. The pce showcase --regenerate <slug|all> subcommand drives scripts/generate_v0_4_showcase.py end-to-end (six Phase 7 cascade-derived demos plus three Sanskrit live-cascade demos as of v0.4.1; see the showcase index).

2. Cursor plugin

# from a clone of the repo
cursor --install-plugin .

# or list, then enable in the Cursor settings UI
cursor plugin list

The Cursor manifest at plugin/.cursor-plugin/plugin.json mirrors the Claude Code manifest: same MCP tools, same slash commands, same hooks. The plugin runtime is identical because both hosts speak MCP. After install, the /pce-cascade and /pce-judge-pair commands appear in the Cursor command palette.

3. Claude Code plugin

claude plugin install https://github.com/sharathsphd/pratyabhijna
# or, for a local clone
ln -s "$(pwd)" "$HOME/.claude/plugins/pce"

The Claude Code manifest at plugin/.claude-plugin/plugin.json is the canonical reference; the Cursor manifest is generated to match.

Configuring the cascade and judge models

PCE accepts any Anthropic CLI-addressable model. Defaults are haiku for cascade and sonnet for judge. The resolution chain matches PCEConfig.load() in src/pce/config.py: built-in defaults are layered first, then the repo-level ./pce.toml, then the user-level ~/.config/pce/config.toml, then environment variables, and finally CLI flags (which always win).

1. Built-in defaults.

2. Repo-local ./pce.toml at the workspace root.

3. ~/.config/pce/config.toml (XDG-aware: also honours $XDG_CONFIG_HOME/pce/config.toml).

4. Environment variables: PCE_MODEL / PCE_CASCADE_MODEL, PCE_JUDGE_MODEL, PCE_CLI, PCE_TIMEOUT_S, PCE_COST_CAP_USD. Legacy back-compat aliases (PCE_HAIKU_MODEL, PCE_HAIKU_CLI, …) still work; the new names take precedence when both are set.

5. CLI flags: --model, --judge-model, --cli-bin, --timeout-s, --config.

Example ~/.config/pce/config.toml:

[pce]
cascade_model = "sonnet"          # use Sonnet-4.5 for cascade instead of Haiku
judge_model = "opus"              # use Opus for the LLM-judge (when available on your CLI)
cli_bin = "claude"                # binary on PATH
timeout_s = 240
cost_cap_usd = 50.0

Substrate boundary — OAuth CLI only

The Anthropic Python SDK code path was removed in Phase 8 (ADR-007). PCE has a single supported substrate: claude --print over the OAuth-bound CLI. Legacy users who set PCE_USE_SDK=1 will see a clear deprecation error with a one-line remediation path. The Phase 7 mechanism pilot used the managed Anthropic-API substrate through the same CLI’s profile selector; ADR-006 records the deviation.

Reproducibility

Every primary number on this site is regenerable from the open repository. Three install paths (Cursor, Claude Code, standalone CLI) all share the same cascade module (src/pce/cascade.py) and the same statistical pipeline (benchmarks/figures.py+ benchmark/autoreport.py).

Recipe — replicate every number on this site

# 1. clone + install
git clone https://github.com/sharathsphd/pratyabhijna
cd pratyabhijna
uv pip install -e .
pce smoke

# 2. regenerate the figure pack and autoreport
python -m benchmarks.figures --version v0.4
python -m benchmarks.autoreport --version v0.4 --strict

# 3. (optional) regenerate the showcase from cached Phase 7 results
python scripts/generate_v0_4_showcase.py
python tests/test_v0_4_showcase.py    # verifies all 9 demos exist with traces

# 4. rebuild the paper
cd paper && tectonic -X compile main.tex

# 5. rebuild the Astro site
cd docs/site && pnpm install && python ../../scripts/prepare_site_data.py && pnpm build

Audit artefacts

• benchmarks/results_v0.4/stats.json — pre-registered hypothesis statistics.

• benchmarks/results_v0.4/judge.jsonl — per-item LLM-judge verdicts.

• benchmarks/results_v0.4/judge_agreement.json — Spearman ρ and sign-agreement (H9.v4).

• audit/v0.4/cost_ledger_merged.json — managed-API token-cost ledger across the four domains.

• audit/v0.4/integrity_probes_merged.jsonl — substrate integrity probes across the pilot run.

• audit/v0.4/lit_verification.jsonl & lit_new_entries.jsonl — bibliography verification + new-entry log.

• audit/v0.4/phase8_gate_report.json — Phase 8 Ralph gate stack pass/fail summary.

The §0.5 unmerged-state critique

Phase 7 of the v0.4 mechanism study completed via parallel API calls against the managed Anthropic-API substrate on April 30 2026 with the result tree pushed to origin/v0.4-mechanism-study at commit 94ba97e. From that date until Phase 8 landed, the public main branch and the GitHub Pages site told the v0.3 story: results_v0.3/stats.json is what the public surface fetched, the README’s headline block was the v0.3 negative-result summary, and the repository’s hypothesis table read H1.v3–H8.v3.

There are reasonable defences for the branch-only stance. The v0.4 paper, HTML, and release notes were not yet written; a premature merge would have surfaced raw stats without their academic interpretation. The Pages workflow had no v0.4 schema branch and would have either silently rendered v0.3 or broken. The COMPLETION_PROMISES_v0.4.md Phase 8 contract explicitly required the paper, HTML, README, and release notes to be ready before merge, not the other way around.

The costs are visible too. External readers landing on the GitHub Pages site for the first time on May 1 2026 saw results that were by then stale at the headline level (the cascade-vs-bare null without the H8a / H8b mechanism findings); collaborators did not see ADR-005 fixed-effects or ADR-006 typed Haiku errors on the trunk; the branch was at risk of drifting if anything else landed on main; the cost ledgers + integrity probes from a reproducible managed-API pilot run were not visible at main yet, so anyone trying to replicate had to dig through branches.

The Phase 8 mitigation is not a defensive squash but an explicit acknowledgement: the merge happens at the end of Phase 8 in lockstep with the paper, the Astro site (which from day one reads results_v0.4/stats.json), the release notes, the v0.4.0 tag, and the GitHub release. The PR body for the Phase 8 mega-merge cites this section by name. The paper §10.8 opens with the same observation. We do not pretend the gap was costless; we record what it cost and why we accepted the cost.

A v0.5 process change is recorded in the v0.5 PRD: future phases that produce numbers should land a “preliminary results” PR within 48 hours of pilot completion, even if the full paper rewrite is still pending — Pages can run a “draft” badge in those windows.

Compounding work

The author program

PCE is the second project in an ongoing program that grounds agent design in classical Indian darśana. The program treats traditional epistemology not as decoration but as engineering vocabulary that discharges obligations against measurable outcomes. Two axes have been studied so far.

Pratyākṣa — direct perception, context-discipline

The first project, Pratyākṣa (direct perception), addresses hallucination resistance and context-discipline in long-context LLM agents. It reports a strong Stouffer pooled signal (Z = 9.114) across ten studies on RULER, HELMET, NoCha, HaluEval, TruthfulQA, FACTS-Grounding, and SWE-bench Verified. The sister Claude-Code/Cursor plugin is published and reproducible:

• Substack exposition (2026) — accessible writeup.

• Zenodo record (v2) — peer-reviewable archive of the harness + numbers.

• Pratyākṣa Pages site — interactive surface for the harness’s results.

Pratyabhijñā — recognition, creativity

PCE is the recognition+creativity counterpart. Where Pratyākṣa asks can the agent perceive its context faithfully?, Pratyabhijñā asks can the agent recognise its own draft and improve it? The empirical signature is smaller and more decomposed than Pratyākṣa’s, but the framing is the same: classical vocabulary chosen for fit, mechanism-level decomposition, pre-registered hypotheses, public audit artefacts.

Why the two effect sizes differ

Pratyākṣa’s pooled signal is large because hallucination resistance has a clean ground-truth target: either the agent hallucinates an entity or it doesn’t. PCE’s pooled signal is small because creativity has no ground-truth target — the proxy scorer is a composite, the LLM-judge has its own biases (per H9), and small-n pilots have wide CIs. The decomposition (H8a / H8b / H8c) finds the moving parts that a holistic cascade-vs-bare contrast washes out. The smaller effect is not a refutation of the program but a calibration data point: creativity is harder to move with this kind of mechanism than hallucination is.

Cross-citing

The PCE paper cites Pratyākṣa in the related-work section as the companion piece on the direct-perception axis. The Pratyākṣa paper (linked above) cites PCE as the recognition-axis counterpart. Both projects share the same author voice on substrate choice (OAuth Claude CLI), audit conventions, and the discipline of pre-registration.

References

Bibliography for the v0.4 paper. Every entry is verified against Crossref, arXiv, or the official publisher record. The verification log lives at audit/v0.4/lit_verification.jsonl; new entries added during Phase 8 are recorded in audit/v0.4/lit_new_entries.jsonl.

Pratyabhijñā philosophy

1. Abhinavagupta. Īśvarapratyabhijñāvimarśinī, eds. K. A. Subramania Iyer & K. C. Pandey. Motilal Banarsidass, 1986.

2. Singh, J. Pratyabhijñāhṛdayam: The Secret of Self-Recognition. Motilal Banarsidass. ↗ link

3. Lawrence, D. P. Rediscovering God with Transcendental Argument: A Contemporary Interpretation of Monistic Kashmiri Śaiva Philosophy. SUNY Press.

Active inference

1. Friston, K. The free-energy principle: a unified brain theory? Nat. Rev. Neurosci. 11, 127–138 (2010). doi:10.1038/nrn2787

2. Friston, K., & Penny, W. Post hoc Bayesian model selection. NeuroImage 56, 2089–2099 (2011). doi:10.1016/j.neuroimage.2011.03.062

3. Di Paolo, L. et al. Active inference for autonomous LLM agents (2024). ↗ link

LLM-as-judge

1. Zheng, L. et al. Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena. NeurIPS (2023). ↗ link

2. Liu, Y. et al. G-Eval: NLG evaluation using GPT-4 with Better Human Alignment. EMNLP (2023). ↗ link

3. Sellam, T., Das, D., & Parikh, A. P. BLEURT: Learning robust metrics for text generation. ACL (2020). doi:10.18653/v1/2020.acl-main.704

4. Wang, P. et al. Large language models are not fair evaluators (2023). ↗ link

Commit policy

1. Madaan, A. et al. Self-Refine: iterative refinement with self-feedback. NeurIPS (2023). ↗ link

2. Shinn, N. et al. Reflexion: language agents with verbal reinforcement learning. NeurIPS (2023). ↗ link

3. Bai, Y. et al. Constitutional AI: harmlessness from AI feedback (2022). ↗ link

4. Stiennon, N. et al. Learning to summarize from human feedback. NeurIPS (2020). ↗ link

Creativity benchmarks

1. Organisciak, P. et al. Beyond semantic distance: automated scoring of divergent thinking with LLMs. Thinking Skills and Creativity (2023). ↗ link

2. Cao, M. et al. CreativityPrism: a holistic benchmark for LLM creativity (2024). ↗ link

3. Beaty, R. E., & Silvia, P. J. Why do ideas get more creative across time? Psychology of Aesthetics, Creativity, and the Arts 6 (2012). doi:10.1037/a0030672

Computational Sanskrit

1. Hellwig, O. The Digital Corpus of Sanskrit (DCS). University of Düsseldorf. ↗ link

2. Hellwig, O. ByT5-Sanskrit: a Sanskrit segmenter (2023). ↗ link

Hopfield networks

1. Weber, T. et al. Untapped Potential in Self-Optimization of Hopfield Networks (2025). doi:10.48550/arXiv.2501.04007

2. Waldron, W. S. The Buddhist Unconscious: The Ālayavijñāna in the Context of Indian Buddhist Thought. Routledge, 2003. doi:10.4324/9780203451175

Benchmarks

1. Suzgun, M. et al. Challenging BIG-Bench tasks and whether chain-of-thought can solve them. ACL Findings (2023). doi:10.18653/v1/2023.findings-acl.824

2. Tian, X. et al. MacGyver: are large language models creative problem solvers? NAACL (2024). doi:10.18653/v1/2024.naacl-long.297

Philosophy of language

1. Wittgenstein, L. Philosophical Investigations. Trans. G. E. M. Anscombe et al., 4th edition. Wiley-Blackwell, 2009.

Companion

1. Sathish, S. Pratyākṣa: direct perception for long-context LLM agents (2026). ↗ link

An AI coding agent reads a 200-page Django codebase, edits the wrong file with confidence, and tells the user it is done. A research-assistance agent surfaces a withdrawn paper, then a retraction, then forgets the retraction one turn later and answers from the withdrawn one. A customer-service agent quotes a policy that expired in 2023 because that is the version the model was trained on. None of these failures is about a model that is not smart enough. All three are about context that is not engineered.

This is the problem a new open-source plugin called Pratyakṣa sets out to fix — and the surprising part is where the design vocabulary came from.

Bigger windows, dumber agents

Scene — 11:47 pm

The cursor blinks. The diff says +47 / −12. The agent has just committed models/payment.py with a confident message: “Refactored the gateway adapter to handle the timeout case correctly.” Tests are green. CI flipped from red to green in under ninety seconds. The developer reads the diff a second time. The agent has edited the wrong file. The real gateway adapter lives in services/payment_gateway.py, two directories over. The agent knew the right file existed — it had read the import graph in turn 4 — and the path was sitting in its context window the entire time. The test passed because the agent wrote the test against its own bug. This is what context that has not been engineered looks like in production.

The headline numbers keep growing. 200 K-token windows. One-million-token windows. Soon, ten million. The implicit promise is that bigger windows mean smarter agents.

The benchmarks tell a different story. On RULER, frontier models still drop accuracy as the window grows — the Lost-in-the-Middle effect, named in 2023 and unfixed in 2026. On HELMET, where retrieved passages quietly contradict each other, the same models happily return whichever passage they saw first. On HaluEval and TruthfulQA, hallucinations rise the longer the conversation runs.

Retrieval-augmented generation (RAG) is the standard answer, and it helps. But RAG fixes what the model can see. It does not fix how the model decides which of the things it sees are still true. A retrieved passage from 2019 sits in the window next to an authoritative document from 2025, and the model has no principled way to retire the older one. Compaction strategies — the schemes that summarise older turns to make room for newer ones — make this worse, throwing away the very provenance an agent would need to know which version to trust.

Scene — the hallucination of the week

In a Friday standup, an enterprise platform team reviews the week’s incidents. The pattern has its own slot on the agenda. “Customer-onboarding agent contradicted itself again — said the ID-verification step was optional in turn 2, then required in turn 8. Same conversation.” They patch the system prompt. The next Friday, a different agent on a different surface — the HR assistant, the support-triage bot, the legal-document summariser — does the same thing. The pattern is the failure mode. No prompt patch is a fix; the agents need a discipline.

There is a name for the discipline that fixes this. Context engineering: the explicit, auditable management of what an agent knows, why it knows it, and when each piece of evidence should be retired. The field has begun to converge on the phrase. What it has been missing is the vocabulary.

The surprising vocabulary

Scene — Mithila, the 14th century

In a thatched commentary-school in the rice-growing plains of Mithila, the Nyāya logician Gangeśa Upādhyāya is finishing the Tattva-cintāmaṇi, the work that will define Navya-Nyāya for six centuries. He is hammering at a question contemporary AI papers will rediscover in fragments seven hundred years later: what makes a cognition fail? Not “is this proposition true?” — that is metaphysics. What kind of failure is this particular cognition undergoing? Is the perceiver projecting their own state? Is a fresh cognition supposed to retire the older one, and if so, under what condition? Gangeśa’s answer is a relational logic of operators and conditions — aQR, avacchedaka, bādha — refined for centuries by mutually critical schools (Nyāya, Mīmāṃsā, Advaita Vedānta, Sāṃkhya) before reaching technical maturity in his lifetime. The vocabulary he formalised is exactly the vocabulary the modern context-engineering literature has been re-inventing in pieces.

Classical Indian epistemology — the systematic study of what counts as a justified belief, developed across the schools called Nyāya–Vaiśeṣika, Advaita Vedānta, Pūrva Mīmāṃsā, and Sāṃkhya — spent centuries refining a small set of concepts that map almost exactly onto the operations a context-engineered agent needs to perform.

Five concepts do most of the work, and each can be glossed in one sentence.

Avacchedaka (Nyāya–Vaiśeṣika) is the ancient Indian logician’s insistence that every cognition carries its conditions. To say “the cup is on the table” is, in this tradition, never quite enough; the proper form is “the cup is on the table under the conditions C₁ … Cₙ”. In the harness, this becomes typed insertion: every retrieved fact lands in the agent’s working store with the conditions that make it true.

Bādha (Advaita Vedānta and Pūrva Mīmāṃsā) is the technical Sanskrit term for sublation: the operation by which a newer, more authoritative cognition supersedes an older one without deleting it. The older claim survives in the audit trail; it just no longer drives behaviour. This is the precise primitive a modern agent needs and lacks — and there is no comparably tight English term.

Manas and buddhi (Sāṃkhya, cross-mapped in Advaita Vedānta) draw a line between attention and judgement. Manas is the sense-organ that selects which evidence to look at. Buddhi is the determinative faculty that judges on the basis of what Manas surfaces. Selecting and judging are different cognitive acts, and treating them as one is the source of a particular class of hallucination — the kind where an agent confidently invents a function name that fits the surrounding code.

Sākṣī (Advaita Vedānta) is the witness consciousness — the unchanging substrate that observes every cognitive event. In the harness, it becomes a session-stable invariant (working directory, git SHA, model identity, plugin version, hard-coded user policies) that survives every compaction event. The witness is what the agent can never lose.

Khyātivāda is a cross-school debate about the kinds of error a cognition can fall into. The schools disagreed productively about whether a misperception is a non-apprehension (akhyāti), a mis-apprehension (anyathākhyāti), a projection of the perceiver’s own state (ātmakhyāti), and so on. Modern hallucination research has reproduced these categories one by one — without ever talking to the Indian tradition. The harness uses a 6-class typed taxonomy derived from this debate; the classifier achieves Cohen’s κ = 0.736 (“substantial” agreement) on a 3,000-example corpus, with per-class agreement ranging from κ = 0.611 (none) to κ = 0.860 (viparītakhyāti).

The framing here is convergence, not exoticism. Two unrelated traditions converging on the same type signatures is a reason to take the type signatures seriously.

Cognitive neuroscience independently arrived at structurally similar constructs — working-memory schemas, predictive-coding precision, complementary-learning-systems consolidation, prefrontal attention control, event-segmentation. The vocabulary is convergent because the problem is: any cognitive system that wants to keep its beliefs honest under streaming evidence has to solve roughly these five sub-problems.

How the project found this vocabulary

The vocabulary did not arrive by reading Sanskrit. It arrived by running TRIZ — the Soviet-era systematic-innovation toolkit — on a single engineering contradiction: we must keep more information in the agent’s context window to improve recall, but keeping more information degrades the agent’s accuracy on the recall task itself. The TRIZ matrix returned four candidate inventive principles, and the dominant one was #10 Preliminary Action: rather than fight the model at retrieval time, do something to each retrieved item before it enters the visible context. Stamp it with the conditions under which it is true, and the credentials of its source. That required a vocabulary the modern AI literature did not have. The 87-minute session that produced this trajectory burned roughly 38,500 input and 4,200 output tokens of Claude usage; its audit trail lives in the repository. The recognition that the required vocabulary was already developed, fully-formed, in classical Indian epistemology came late — and was the entire point.

What the plugin actually does

The harness ships as a single open-source plugin: pratyaksha-context-eng-harness (v1.0.0, MIT-licensed). It installs into Cursor, Claude Code (CLI and the VS Code extension), and Claude Desktop in roughly thirty seconds. No model fine-tune, no architecture change, no runtime dependency heavier than tiktoken, pydantic, numpy, mcp, and anthropic. The full system specification — every tool signature, every prompt, every reproducibility manifest — lives in the Zenodo preprint.

What it ships is fifteen MCP tools, three sub-agents, three skills, four slash commands, and three lifecycle hooks, organised across six functional families:

The two interesting sub-agents are Manas and Buddhi. Manas is the system-prompt-driven attention agent: it selects evidence, reports what it attended to, and — critically — must never emit a user-visible answer. Buddhi is the determinative judgement agent: it can call sublation, runs the hallucination classifier on its own draft, and is the only sub-agent that emits the user-facing reply. The third sub-agent, Sākṣī-keeper, is a read-only witness that maintains the session invariants and writes every mutation to a JSONL audit log at ~/.cache/pratyaksha/audit.jsonl. A user can tail -f that file during a session and watch exactly what the agent did and why. Three lifecycle hooks divide the turn — session-start seeds the Sākṣī invariants, a pre-tool-use hook gates over-budget calls (advisory by default, hard-deny if PRATYAKSHA_BUDGET_STRICT=1), and a stop hook runs adaptive compaction so pressure does not accumulate across turns.

A worked example, end-to-end

To make this concrete, consider one user turn. The user asks: “How do I cache a user session in Redis?” The agent’s web tool returns four snippets — two from pre-Redis-7 blog posts (which still circulate at the top of search results), two from the official Redis 7 documentation. Without the harness, an unaided agent will often anchor on the first snippet it sees, write code against the older API, and ship the wrong answer with confidence. With the harness:

1. Manas inserts all four snippets into the typed store, each tagged with its source-precision (prec=2 for the blog posts, prec=8 for the official docs).

2. detect_conflict flags a TYPE_CLASH on the (Redis-session, expiry-policy) qualificand.

3. sublate_with_evidence retires the blog posts in favour of the docs — the blog posts remain in the audit log; they no longer drive the answer.

4. Buddhi composes the answer from surviving live items only, classifies it as yathārtha (veridical) with confidence = 0.91, and ships it.

5. Sākṣī appends one immutable JSON line per stage to the audit log.

The discipline is auditable rather than aspirational because every step commits a structured record. Manas names which items it surfaced and at which precisions; Buddhi names the items it used and the sublations it fired. Either record can be replayed.

Scene — tailing the audit log

$ tail -f ~/.cache/pratyaksha/audit.jsonl
{"t":"2026-04-18T11:47:03Z","stage":"manas","op":"INSERT",
 "item":"doc-7-1","qualificand":"redis-session","qualifier":"expiry-policy",
 "source":"redis.io/docs","prec":8}
{"t":"2026-04-18T11:47:03Z","stage":"manas","op":"INSERT",
 "item":"doc-7-2","qualificand":"redis-session","qualifier":"expiry-policy",
 "source":"old-blog-post","prec":2}
{"t":"2026-04-18T11:47:04Z","stage":"buddhi","op":"DETECT_CONFLICT",
 "qualificand":"redis-session","qualifier":"expiry-policy",
 "type":"TYPE_CLASH","items":["doc-7-1","doc-7-2"]}
{"t":"2026-04-18T11:47:04Z","stage":"buddhi","op":"SUBLATE_WITH_EVIDENCE",
 "target":"doc-7-2","by":"doc-7-1","reason":"prec(8)>prec(2) under shared limitor"}
{"t":"2026-04-18T11:47:05Z","stage":"buddhi","op":"CLASSIFY_KHYATIVADA",
 "verdict":"yathartha","confidence":0.91,"surviving_items":["doc-7-1"]}

Five lines. One conflict, one sublation, one verdict, one audit trail an SRE can replay tomorrow morning. The point is not the JSON — the point is that a human can read it.

This is the same operational pattern that drives every result in the next section.

Did it actually work?

The harness was validated across three orthogonal evidence layers. Every figure and table in this section is reproduced from the v2.1.1 preprint (which supersedes the v2.0 Zenodo record). The v2.0 synthetic-fallback omnibus (Layer 1, Layer 3, and the F12/F13 diptych below) is unchanged; the v2.1 live-HF rerun and the v2.1.1 power-extension addendum sit next to it as live companion reads on four headline bundles.

Layer 1 — public benchmarks (v2.0 synthetic-fallback battery)

Seven preregistered hypotheses tested on six widely-used long-context and hallucination benchmarks (RULER, HELMET, NoCha, HaluEval, TruthfulQA, FACTS-Grounding) plus SWE-bench Verified. Each study sweeps two model families (claude-haiku-4-5, claude-sonnet-4-6) across multiple seeds. Across all seven hypotheses, the harness beats the unaided baseline at p ≤ 0.0020. H2 on HELMET-Recall is particularly clean: a 47 % reduction in Brier score and 65 % reduction in expected calibration error on top of the headline accuracy gain.

Layer 1b — live Hugging Face rerun (v2.1 + v2.1.1 power-extension)

The Layer-1 numbers above come from the synthetic-fallback path of each adapter — generator-authored distractors, tuned so per-context-length difficulty curves track the published RULER and HELMET curves, with the real Hugging Face path sampled during development. A reasonable reviewer asks: does the paired delta survive when you force the adapter to actually pull from Hugging Face at the current dataset commit? So we ran a pre-registered, strictly live rerun of four headline bundles — RULER at 8 K and 16 K tokens, TruthfulQA, and SWE-bench Verified — with an adapter-level strict_hf=True flag that converts any load failure into a hard ProvenanceIntegrityError rather than a silent synthetic fallback. After that v2.1 core4 pass we filed a v2.1.1 power-extension amendment (N doubled from 15 to 30 on RULER 16 K and TruthfulQA; SWE-bench CLI subprocess timeout raised 300 s → 900 s as a pure infrastructure fix). The Anthropic rolling window exhausted partway through the extension; we halted and re-scored the checkpoints offline. Table T8 below shows all seven bundles together.

Live-HF reading, v2.1 + v2.1.1 combined. The system clears both preregistered gates (d_z ≥ 0.5 and p ≤ 0.05) on one independently-sourced live surface — RULER 8 K, d_z = 0.547, p = 0.0005 — and clears the p ≤ 0.05 gate on a second — SWE-bench (haiku-only), d_z = 0.488, p = 0.032 — with the explicit caveat that 77 % of haiku attempts aborted at the Claude CLI layer (SessionStart-hook timeout); the full_errors_as_zero pre-registration gives that row a conservative imputation, not a generalizability guarantee. RULER 16 K stays directional but gate-shy under both v2.1 (n = 60, p = 0.117) and the v2.1.1 extension (n = 103, p = 0.064) — the CI tightens to [+0.010, +0.087] and excludes zero, but the gate verdict is unchanged. TruthfulQA is a null under both passes; the v2.1.1 TruthfulQA extension never billed new rows before the quota halted, so that row is the v2.1 null re-reported at the same n = 60 (the 0.739 → 0.736 p-value drift is Monte-Carlo noise between permutation-pool sizes; see footnote). SWE-bench_ext ships a shipped-but-unexercised CLI-timeout fix. We do not claim the full v2.0 omnibus on the live pull — at n ≈ 60–103 per bundle instead of n ≈ 180–700, the statistical floor is simply different. We do claim that the paired-delta direction of the synthetic-fallback path is not an artefact of the generator on the three benchmark families (RULER, SWE-bench, TruthfulQA) we could re-check inside one rolling window. Full v2.1 pre-registration + v2.1.1 amendment + per-bundle commit SHAs + per-model numbers live in Appendix G of the v2.1.1 preprint.

Layer 2 — live case study

Three real GitHub issues drawn from popular Python projects: a Django request-body subtlety, a requests retry-strategy spelling change (the method_whitelist → allowed_methods rename across urllib3 1.26 → 2.0), and a pandas iterrows dtype gotcha. Each is exactly the kind of question a daily-driver agent gets wrong by pulling stale Stack Overflow answers ahead of fresh official documentation. Under identical token budgets, the harness scores 3-of-3 correct; the unaided baseline scores 0-of-3. Seven sublations and three compactions fire across the three cases — exactly the operational footprint the design predicts.

Layer 3 — head-to-head A/B

A 720-pair head-to-head on 120 SWE-bench Verified-style instances, swept across 3 seeds × 2 models under a fixed 512-token research-block budget. Each instance gets a four-snippet trail — two stale (wrong file paths via synthetic typos, superseded APIs), two fresh (correct paths, current APIs) — shuffled so the agent cannot use ordering. The harness anchors on the correct file in 720 / 720 paired runs (100 % in every model × seed cell). The unaided baseline anchors correctly in 362 / 720 runs (50.3 %) — cells split 57, 66, 58, 57, 66, 58, exactly the coin-flip predicted by Lost-in-the-Middle-style anchoring on a shuffled trail. The harness fires 1,440 sublations across the run.

Scene — 720 of 720

The aggregator script returns. The treatment column reads 120 / 120 in every cell. The author reads the row twice, runs git log -1 to confirm the patch simulator still has its audit assertions, then re-runs the experiment from a clean state with the seed swapped from 42 to 1729 to confirm it is not a cache effect. The numbers come back the same. The result is so clean it is suspect, until a spot-check on a single instance confirms what the design predicted: when sublation fires, the wrong-path snippet is retired before the patch simulator ever sees it, and the simulator anchors on the surviving correct-path snippet. The baseline lands at 50.3 %. The unaided agent really does anchor at coin-flip rate when the snippet trail is shuffled.

Aggregate effect across all ten quantitative studies — v2.0 synthetic-fallback omnibus (paper figures F12 + F13). Left: Cohen’s d magnitudes by hypothesis. Right: forest plot of per-hypothesis paired deltas with 95 % CIs. The two structural-100 % rows (H5, H7) are excluded from the mean Cohen’s d. These are the v2.0 synthetic-fallback battery — the four-bundle live-HF rerun is shown separately above (Figure F14). Source: §10.

When all ten quantitative studies are combined via weighted Stouffer-Z, the headline omnibus statistic is:

A combined p of 7.94 × 10⁻²⁰ is sixteen orders of magnitude past the conventional threshold for a well-powered study. The result survives a deliberately hostile re-analysis that drops the two structural-100 % studies (H5 and H7): combined Z = 8.14, combined two-sided p = 3.95 × 10⁻¹⁶ on the eight remaining empirical studies.

The honest caveats

A serious result deserves serious caveats, and the preprint names them. Four of them deserve a paragraph each.

Synthetic-fallback evidence trails on Layer 1 — partially closed by the Layer-1b live rerun. Most L1 hypotheses run the synthetic-fallback path of their adapter — Wikipedia + arXiv distractors load only when a Hugging Face token is configured; CI uses deterministic synthetic generators. This is a deliberate trade-off: the entire validation re-runs on a laptop in under three minutes for full reproducibility, but the burden of “is this benchmark like the published one?” shifts onto the generator. The mitigation: generator parameters were tuned so per-context-length difficulty curves qualitatively matched the published RULER and HELMET curves, the real Hugging Face-loaded path was run during development to verify that treatment/baseline gaps were within ±10 % of synthetic-fallback on a 3,000-example sample, and — as of v2.1 (with a v2.1.1 power-extension addendum) — four headline bundles have been re-run against live Hugging Face data under a strict_hf=True guard (Layer-1b above and Appendix G). That pass clears the combined preregistered gate (d_z ≥ 0.5 and p ≤ 0.05) on RULER 8K and is directional on SWE-bench-haiku at p = 0.032 with d_z = 0.488 just shy of the d gate (amber, not green); the v2.1.1 amendment tightens the RULER 16K CI to [+0.010, +0.087] (excludes zero, both gates still shy at n = 103), leaves the TruthfulQA null unchanged (quota prevented new rows), and ships an unexercised SWE-bench CLI-timeout fix. The synthetic-fallback battery’s per-benchmark effect sizes are therefore claimed as direction-faithful rather than magnitude-identical to live data at large n.

Deterministic patch-simulator on Layer 3. The L3 SWE-bench A/B uses a deterministic PatchSimulator rather than a real LLM-based code generator. This deliberately isolates the system’s contribution as a context discipline rather than as generation quality. A strong real-LLM coder will sometimes recover from a wrong-path anchor that the simulator does not, so the gain on a real-LLM version of P6-C is expected to compress — perhaps to +0.10–0.15 absolute target-path-hit-rate — while remaining significant. That measurement is queued.

Two model families only. The sweep covers claude-haiku-4-5 and claude-sonnet-4-6, both from Anthropic. The system’s design is host- and model-agnostic — its mechanisms are LLM-side prompt discipline plus an MCP-side store, neither of which depends on the model — but the paper has not yet measured it across families. The expected confound is not that the system stops working; it is that the baseline will be stronger on some families and weaker on others, compressing or expanding the delta. A cross-family sweep against GPT-4o-class, Qwen-3, and Llama-3.x is the next planned pass.

Automated-vs-automated κ on the Khyātivāda classifier. The Cohen’s κ = 0.736 is between two automated annotators: a deterministic heuristic and a simulated LLM-as-judge. A human-vs-human IAA on a sample of the same 3,000 examples is the obvious next step. A preliminary 200-example read agreed with the consensus label in 81 % of cases (κ ≈ 0.74) — consistent, but not yet at a scale that would let anyone claim “human-validated”.

None of these caveats touches the central operational claim, with explicit honest exceptions stated per surface: under a fixed token budget, the harness produces a positive directional effect on every live RULER surface tested, and clears the preregistered combined gate (d_z ≥ 0.5 and paired p ≤ 0.05) on RULER 8K. RULER 16K is positive but shy of both halves of the gate at n = 60, and still shy of both halves at the n = 103 power-extension (CI excludes 0, p = 0.064, d_z = 0.225). SWE-bench-haiku passes the p gate but is d_z-shy (d_z = 0.488, just below 0.5) under the CLI-blocked pre-registration. The single live-HF null is TruthfulQA (paired Δ = −0.033, p = 0.74, d_z = −0.091 at n = 60) — reported as a null, not papered over. The hallucination surfaces clear the calibration / Brier-score axis on the synthetic-fallback bands.

Try it yourself

The plugin is open-source (MIT). It installs in two commands and works inside Cursor, Claude Code (CLI and VS Code), and Claude Desktop, because the only inter-process surface is the Model Context Protocol.

# One-time prerequisite: install uv (the Python package runner the plugin uses).
curl -LsSf https://astral.sh/uv/install.sh | sh

Then, inside Cursor or Claude Code:

/plugin marketplace add SharathSPhD/pratyaksha-context-eng-harness
/plugin install pratyaksha-context-eng-harness

Restart the host. The first MCP tool call takes ~30 s while uv downloads dependencies; every call after that is instant. No pip, no virtualenv, no claude mcp add.

Four slash commands cover almost everything a user will want to do interactively:

A 90-second first-turn recipe: open a long-running task — a multi-file refactor, a multi-source research synthesis, a long policy-QA conversation — type /context-status before and after a few turns, and tail -f ~/.cache/pratyaksha/audit.jsonl in a side terminal to watch the sublation events fire.

Context engineering is the new prompt engineering

Three years ago, prompt engineering was a discipline waiting for its name. Practitioners traded recipes; researchers showed that the recipes mattered; within eighteen months the field had a vocabulary, a literature, and a practice.

Context engineering is in the same place now. The failure modes are real, the costs are paid daily by everyone shipping agents into production, and the field is converging on the recognition that a bigger window is not a substitute for a discipline. What has been missing is the type signatures. Avacchedaka is not “metadata”. Bādha is not “delete”. Manas / buddhi is not “two model calls”. Each is a precise relational operator with a centuries-long history of philosophical refinement, and each turns out to have a clean implementation against an LLM context window.

This is also not a coding-agent fix. The same operators apply, unchanged, wherever an agent reads streaming evidence under a fixed token budget — avacchedaka-typed insertion for a customer-service agent that must distinguish “policy as of 2023-Q1” from “policy as of 2025-Q4”; for a research-assistance agent that surfaces a paper and then a retraction; for a document-QA agent navigating versioned documentation; for a multi-tool orchestrator integrating heterogeneous tool outputs whose provenance must remain auditable. Bādha applies wherever newer authoritative evidence must displace older evidence without losing the audit trail. Manas / buddhi applies in any setting in which selecting evidence and judging on the basis of it are different cognitive acts. The Layer-1 evidence already exercises these general settings; the Layer-2 case study spans Django, requests, and pandas; SWE-bench Verified is one coding instance of an agent-level effect that travels.

The Pratyakṣa harness is one delivery vehicle. The plugin will get refined; model families will turn over; the budget gauges will get smarter. The lasting contribution is the recognition that the vocabulary already exists, the schools that built it were thinking carefully about what counts as a justified belief, and a modern context-engineered agent does not have to invent the discipline from scratch.

Install the plugin. Watch the audit log. The vocabulary was waiting.

Pratyakṣa — direct perception. The lasting contribution is the type signatures; the plugin is one delivery vehicle.

Try it, read it, cite it

• Plugin (install + use):github.com/SharathSPhD/pratyaksha-context-eng-harness

• Full harness, paper sources, experiments, validation:github.com/SharathSPhD/context-engineering-harness

• Citable preprint (Zenodo, DOI-backed canonical v2.0 record):zenodo.org/records/19653013

• Download the v2.1.1 preprint PDF(paper with live-HF F14 + F15, cite as the current working version):pratyaksha-v2.1.1-preprint.pdf (GitHub release)

• v2.1.1 release page(plugin zip, paper PDF, F14/F15 figures, checksums):v2.1.1 on GitHub— supersedesv2.0.0

• Project status canvas:canvas.html

• Licence:MIT (code), CC-BY-4.0 (paper text + figures)

Install the plugin →Full harness on GitHub

If you ship an agent into production, install the plugin and watch one long session through the audit log. The numbers speak; the millennia-old vocabulary will start to sound like exactly what you needed.

Sharath Sathish is the author of the Pratyakṣa context-engineering harness. Comments, philological corrections, and replication runs welcome on the GitHub repository.

The big idea: AI systems that can “imagine” possible futures, called world models, have been applied to Atari games, robotics, and board games. But applying them to economic environments like retail pricing has been largely unexplored. DreamPrice takes an initial step into that space. And solving the fundamental problem that makes economics different from physics turns out to require a detour through a 1978 econometrics paper.

The Chess Grandmaster’s Secret

Magnus Carlsen doesn’t just look at the board. He dreams it forward.

Before he moves a single piece, Carlsen runs simulated futures inside his mind. What if I move the knight here? How does my opponent respond? What does that mean three moves later? This ability to imagine ahead, to model the future before committing to any action, is what separates a grandmaster from a competent club player.

Most AI pricing systems today are club players. They look at today’s prices, today’s demand, maybe last week’s promotional data, and they spit out a recommendation. If you ask them what happens to your canned soup sales if you cut the price by 8% for the next six weeks while a competitor is running a promotion, they can’t answer. They don’t have a model of how the future unfolds. They can’t dream.

DreamPrice is a step toward changing that.

It is likely one of the first world models trained directly on retail pricing data. In this work, it’s trained on the canned soup category of the Dominick’s Finer Foods dataset, a historical record of 93 Chicago grocery stores across 400 weeks from 1989 to 1997. It learns store-level dynamics like promotional substitution and stockpiling behaviour, then imagines forward through 13 weeks of simulated retail time before deciding on a price. If you care about the business angle, you can read this as a story about safer price experimentation without needing live A/B tests. If you’re a technical reader, watch for the parts on DreamerV3, Mamba-2, and DML-PLIV.

Getting here required stitching together ideas from three fields that rarely talk to each other: deep reinforcement learning, sequence modelling, and causal inference from econometrics. The result sits at a genuinely underexplored intersection, and the ablation experiments make a reasonable case that every one of those pieces is doing real work.

🎧 Audio: What Is a World Model?

The Largely Empty Quadrant

Here is a simple two-by-two grid that sets up the whole story.

On one axis: is the environment physical (governed by physics and game rules) or economic (governed by human behaviour, competition, and market forces)? On the other axis: is the dynamics model learned from data, or is it structural — hand-coded with explicit equations?

The physical/learned quadrant is packed. DreamerV3, MuZero, IRIS, TD-MPC2 — these systems have collectively mastered Atari, chess, Go, and continuous robotic control. The economic/structural quadrant is also inhabited: the AI Economist uses a rule-based tax environment, DSGE models simulate national economies with programmed equations, and agent-based financial simulators model order books with explicit rules. The economic/learned quadrant has seen very little work. DreamPrice is an initial step into that space.

Why has this quadrant sat empty? It’s not for lack of interest. Retail pricing is a high-stakes decision problem with obvious optimization potential. The answer is that economics has a property that physics doesn’t. A name that strikes fear into econometricians everywhere: endogeneity.

The Chicken-and-Egg Problem That Breaks Naïve Regression

In physics, the laws of motion don’t care about your policy. A ball follows a parabola regardless of who threw it. The transition dynamics are independent of the agent.

In retail, everything is circular. Prices cause demand. But demand also causes prices. A retailer sets prices based on expected demand — if sales are expected to be soft, they run a promotion. Consumers respond to those prices. Competitors respond to both. Unobserved cost shocks hit the entire supply chain and move prices across stores at the same time.

The consequence for naïve machine learning is a real problem. If you train a neural network to predict demand as a function of price using historical supermarket data, it doesn’t learn the causal effect of price changes. It learns a confounded relationship that is a mixture of the true price sensitivity and the retailer’s own pricing strategy, which are tangled together in the data.

Here’s a concrete way to feel the problem: in historical data, you’ll often see high prices correlated with high demand for staple goods like canned soup. Why? Because the retailer raised prices during busy holiday seasons and back-to-school weeks when demand was already going to be high regardless of price. A simple model learns “high price leads to high demand,” which is exactly backwards from the causal reality, and would produce completely wrong predictions for any hypothetical pricing scenario.

This problem is called endogeneity, and the econometrics literature has been wrestling with it since at least the 1970s. The standard solution: find an instrumental variable (IV), something that affects prices but is independent of the local demand shocks you’re trying to isolate.

🎧 Audio: The Endogeneity Problem

Jerry Hausman, in a 1978 paper, provided a framework that DreamPrice exploits almost fifty years later. The insight: if wholesale costs go up for a product, all stores in a chain tend to raise prices simultaneously, because they all source from the same distribution network. That cross-store price correlation is driven by costs, not by whether any particular store is experiencing a local demand shock. So the average price in all your other stores, for the same product and week, makes a reasonable instrument for your own store’s price.

With 83 stores in the Dominick’s dataset, DreamPrice constructs this instrument for every product-week combination. The first-stage F-statistic comes out at 23,381, which is an extremely strong instrument by conventional standards (the usual threshold is 10). That level of instrument relevance makes the subsequent causal estimation reliable.

But identifying price elasticities via instrumental variables is only part of the work. The other part is doing it flexibly while controlling for a high-dimensional set of seasonal effects, store demographics, promotional calendars, and fixed effects. For that, DreamPrice uses Double Machine Learning (DML-PLIV), a framework from Chernozhukov and colleagues (2018) that uses cross-fitting and orthogonalization to get reliable causal estimates even with a large control space. The resulting estimate of price elasticity for canned soup is -0.940: a 1% price increase reduces demand by about 0.94%, roughly unit-inelastic, which is consistent with what the marketing literature expects from shelf-stable staples.

That number gets frozen into the DreamPrice neural network. It cannot change during training. It is not updated by backpropagation. DreamPrice starts from this IV+DML estimate, holds it fixed during world model training, and shields it from being overwritten by confounded gradients. The estimate is identified under standard econometric assumptions; it’s not guaranteed to be perfectly true, but it’s far more credible than anything the network could learn from observational data alone. For canned soup, the IV and naïve OLS estimates happen to be quite close (-0.940 vs -0.931); in categories with heavier promotions and more aggressive competitive pricing, the gap is expected to be larger, and that’s where causal identification matters most.

🎬 Video: The Causal Decoder

Building the Dreaming Machine

With the causal problem handled, DreamPrice can be built as a proper world model. The architecture builds on DreamerV3, modified in three ways.

The Core: A Recurrent State-Space Model (RSSM)

At the heart of DreamPrice is a system maintaining two kinds of memory. A deterministic hidden state captures what the model is confident about: seasonal patterns, long-run price trends, store demographics. A stochastic latent variable represents genuine uncertainty: what are consumers doing right now, what’s the competitive situation we can’t directly observe.

Think of it like a weather forecaster’s mental model. There’s the deterministic part; cold air masses follow well-understood physics, and there’s the stochastic part; whether that front actually triggers a storm depends on chaotic small-scale dynamics that even the best model can’t pin down. Both kinds of information matter, and separating them cleanly is what allows the model to express calibrated uncertainty later.

The model encodes each week’s observations (prices, quantities sold, promotional activity, store demographics) into this latent space, then learns to predict forward through time. During planning, it never works in the original high-dimensional observation space. It reasons entirely in the compact latent space, which is dramatically cheaper.

The Backbone: Mamba-2 Instead of a GRU

Standard DreamerV3 uses a Gated Recurrent Unit as its sequence memory. A GRU processes one timestep at a time, each depending on the previous, so you can’t parallelize across time during training. For short sequences this is fine, but it’s a bottleneck as sequences get longer.

DreamPrice replaces this with Mamba-2, a selective state-space model. The core insight behind Mamba-2 is a mathematical result called structured state-space duality: the same computation a recurrent model does step-by-step can, under certain conditions, be rewritten as a parallel scan over the entire sequence at once. This gives Mamba-2 a practical advantage: during training, it processes sequences in parallel with O(n) complexity; during imagination rollouts, it switches to step-by-step recurrent mode with O(1) cost per step.

For DreamPrice, running 13-week imagination rollouts across thousands of training iterations is where this matters. The ablation confirms it’s not just theoretical: replacing Mamba-2 with a GRU reduces policy return by 28.9% in these experiments, even though the GRU achieves a somewhat lower world model reconstruction loss. The selective gating mechanism in Mamba-2 appears to provide advantages for policy learning that don’t show up in simple prediction error metrics.

The Decoupled Posterior: A DRAMA-Inspired Fix

There’s a subtle training bottleneck in standard RSSMs. Inferring the stochastic latent variable at each timestep normally depends on both the current observation and the previous hidden state, which creates a dependency chain that blocks Mamba-2’s parallel scan from working.

DreamPrice borrows a trick from DRAMA, a recent architecture: make the posterior inference depend only on the current observation, not on the previous hidden state. The hidden state still influences the prior (what the model predicts before seeing the observation), and that prior-posterior gap still provides a training signal. But the posterior computation becomes parallelizable across the full training batch. This is the kind of change that looks minor in a diagram but makes a large practical difference in training speed.

Teaching the Agent to Be Cautious

Here is a failure mode worth taking seriously: reward exploitation in low-data regions.

Say you train a world model on historical supermarket data. Most of that data comes from prices in a relatively normal range, maybe 5% to 15% away from baseline. The model has never seen prices at 40% discount or prices tripled overnight. Its predictions in those regions are extrapolations from a function with no data to anchor it.

Now you train an agent to maximize reward inside this world model. The agent is highly motivated and will find whatever pricing strategy the model thinks is optimal. If the model assigns unrealistically high returns to some extreme pricing configuration because it simply hasn’t seen enough data to know better, the agent will exploit that gap. It will find the model’s weak spots and surf them. The resulting policy, evaluated against any honest measure, performs terribly.

This is the distributional shift problem in offline reinforcement learning, and it’s not theoretical. In the DreamPrice ablation, removing the pessimism mechanism reduces agent return by 85.6% in this setting (from 193.7 to 27.9 in the symlog-transformed reward space, which is a simulated measure rather than real dollars). That is the largest single degradation across all nine ablations tested.

The fix, borrowed from MOPO (Model-based Offline Policy Optimization), is to train five independent reward heads on the same backbone. When all five agree, the model is confident. When they disagree, this is a region the model hasn’t seen enough data to trust. The pessimistic reward that drives actor training becomes:

r_pessimistic = r_mean - lambda_LCB x r_std

With lambda set to 1.0, the agent is penalized by one standard deviation of uncertainty at every step. It pursues high rewards but only in regions where its model is actually reliable. Pessimistic rewards don’t guarantee safety in the real world, but they make the agent systematically conservative where the model is uncertain, which is a meaningful improvement over unconstrained offline RL.

The Numbers

DreamPrice is trained on canned soup in the Dominick’s Finer Foods dataset: 93 Chicago grocery stores, 400 weeks of scanner data from 1989 to 1997, roughly 25 stock-keeping units in the category. After a standard chronological train/validation/test split (no shuffling across time), the trained model achieves a world model ELBO loss of 22.44 after 100,000 training steps. The full training run takes about 2.6 hours on an NVIDIA DGX Spark.

In prediction terms: at a one-week forecast horizon, the model achieves a WMAPE (weighted mean absolute percentage error) of around 72%. That sounds high, but weekly store-SKU-level demand forecasting is genuinely difficult at this granularity, and 70-72% WMAPE is typical in the published literature. More informative is how prediction quality changes with horizon. The Normalized Degradation Rate grows to only 1.057 at a 10-week horizon, meaning prediction error accumulates slowly, which is what you want for stable 13-step imagination rollouts.

The results most encouraging to spend time with are the ablations rather than the baseline comparisons, because the baselines involve two different evaluation protocols that make direct numerical comparison misleading. Rule-based methods (cost-plus markup, competitive matching, XGBoost) are evaluated on real Dominick’s test data and report actual weekly gross margin in dollars. Model-free RL methods (DQN, PPO, SAC) are trained and evaluated inside the learned world model and report simulated episode returns. DreamPrice sits in the second group, evaluated via imagination rollout with pessimistic rewards. The numbers aren’t directly comparable across groups. The more informative takeaway is how each architectural component contributes within a consistent evaluation protocol.

The symlog+twohot ablation is worth dwelling on because the numbers are surprising. “Symlog” is a transformation applied to all continuous values before they enter the network: symlog(x) = sign(x) x ln(|x| + 1). It compresses large values logarithmically while preserving behavior near zero. “Twohot” represents a scalar reward not as a single number but as a probability distribution over 255 bins. These two together address a real problem: retail gross margins range from fractions of a cent to hundreds of dollars per SKU per week. Without them, the world model loss increases 25-fold (573.2 vs 22.44) and policy return drops 67.4%. These aren’t optional refinements. They’re doing structural work.

🎬 Video: What Imagination Looks Like

What the Causal Work Actually Buys You

The causal estimation results reveal something worth thinking about honestly.

For canned soup, the endogeneity problem turns out to be modest: the naïve OLS regression gives an elasticity of -0.931, while the DML-PLIV estimate is -0.940. The difference is 0.009. A reasonable person might ask why all the causal machinery is necessary when the gap is this small.

There are two answers. First, canned soup is a cooperative test case: shelf-stable, price-stable, dominated by brand loyalty rather than aggressive promotional dynamics. Categories like beer or soft drinks, where promotional intensity is higher, are expected to show larger gaps between naïve and causal estimates. Canned soup happens to be a category where the Hausman instrument does most of the heavy lifting to confirm the estimate, but the real validation will come from high-endogeneity categories, which is important future work.

Second, the value of the causal decoder is partly architectural rather than purely numerical. When the price-demand relationship is held fixed by econometric estimation, the neural network’s job changes: instead of trying to learn everything from scratch, it learns the residual — seasonality, demographics, promotion dynamics, latent competitive structure. That’s a cleaner division of labour, and it means the model’s pricing intuitions are grounded in something identifiable and auditable rather than being a black-box correlation.

What This Work Does Not Show Yet

It’s worth being direct about what the current results don’t demonstrate.

The evaluation covers a single category (canned soup) in a single historical dataset that ended in 1997. Retail has changed considerably since then: e-commerce, algorithmic competitors, dynamic pricing at sub-second timescales, and supply chain digitization have all altered the structure of the problem. Whether the learned dynamics generalize beyond this historical benchmark is an open question.

The system is purely offline. It learns from historical data and cannot update its model as new data arrives. Bridging offline learning to an online loop where the world model refines itself is important future work and brings its own set of distributional shift challenges.

The competitive modelling is implicit rather than explicit. DreamPrice learns that prices in the data correlate with competitive dynamics, but it doesn’t directly model what competitors are doing. A proper game-theoretic treatment would require substantially more machinery.

Finally, the ablation results come from a single training seed due to compute constraints. The codebase documents the full multi-seed protocol with stratified bootstrap confidence intervals, but running it completely would require significantly more hardware. The directional conclusions from the ablations are likely robust, but the precise percentage numbers should be read with that caveat in mind.

Why the Gap Matters Beyond Grocery Stores

The significance of DreamPrice isn’t specific to pricing soup.

It’s evidence that a previously underexplored category, learned world models for economic environments, is not empty because it’s impossible, but because it requires bridging disciplines that don’t usually talk to each other. The endogeneity problem is one instance of a much broader phenomenon: in any human-mediated environment, the agent’s actions are entangled with the dynamics it’s trying to learn. Financial markets, labour markets, recommendation systems, advertising auctions all share this structure.

The technical pieces assembled here; causal constraints from econometric estimation, offline pessimism via ensemble uncertainty, efficient sequence modelling via state-space duality aren’t specific to grocery pricing. They’re a plausible template for any domain where a world model needs to operate on endogenous observational data with a limited experimentation budget.

The immediate next steps are clear: test on high-endogeneity categories like beer and soft drinks, add multi-category joint training, and eventually replace the offline actor with inference-time planning. Beyond that, the path runs through contemporary scanner data and online deployment where the world model updates as new data arrives.

The grandmaster’s secret, imagining deeply before committing to a move, turns out to generalize beyond chess. DreamPrice is early evidence that it might generalize into economic environments too, where the dynamics are messier and the stakes are real.

Open Source and Reproducibility

Everything needed to reproduce and extend DreamPrice is publicly available:

Preprint: https://zenodo.org/records/18787266 - on Zenodo

Code and Training Pipeline: github.com/SharathSPhD/dreamprice - full Docker Compose setup for single-command reproducibility.

Dataset: qbz506/dreamprice-dominicks-cso - Pre-processed Dominick’s canned soup data with Hausman instruments and temporal splits on HuggingFace.

Trained Model: https://huggingface.co/datasets/qbz506/dreamprice-dominicks-cso 100K-step checkpoint with configuration files on HuggingFace.

Interactive Demo: https://huggingface.co/spaces/qbz506/dreamprice-demo Gradio application for exploring causal demand curves and the architecture on HuggingFace Spaces.

Experiment Tracking: https://wandb.ai/qbz506-technektar/dreamprice?nw=nwuserqbz506 Full training logs and hyperparameter configurations via Weights and Biases.

A Brief Technical Appendix

For readers who want more depth without reading the full paper.

The ELBO is the objective the world model is trained to maximize. It combines a reconstruction term (how accurately the model predicts observations from the latent state) and a KL divergence term (which prevents the stochastic latent from collapsing to a point estimate, which would destroy uncertainty quantification). The 5:1 ratio between the dynamics KL and the representation KL is a calibrated asymmetry from DreamerV3 that prevents a training failure called posterior collapse.

Symlog normalization was explained above. The inverse transform, symexp, is used whenever the model needs to produce predictions in the original unit scale.

The twohot distribution represents a scalar reward as a categorical distribution over 255 bins. Instead of predicting “the reward is 47.3,” the model predicts a probability distribution over bins that peaks near the correct value. The two closest bins get probability mass proportional to their distance from the true value. This distributional representation provides far better gradient signal than mean-squared-error regression when the reward distribution is skewed or has high variance across products.

The entity-factored encoder is worth noting separately. Rather than flattening all product features into a single vector, DreamPrice encodes each product as a separate entity with its own embedding (for product ID, store, brand, and time), then applies attention across entities to capture cross-product substitution signals. The ablation shows this is worth a 64.5% return improvement over a flat encoder in these experiments, which is larger than the Mamba-2 contribution by itself.

Dr. Sharath is a Data Science & AI leader with deep expertise spanning retail analytics, industrial engineering, and aerospace technologies. Specialized in developing cutting-edge AI/ML solutions for commodity pricing and engineering optimization at bp, while leveraging decades of experience in complex systems engineering.
Previously led breakthrough innovations in aerospace technology at Indian Space Research Organisation (ISRO), developing advanced inertial navigation systems and satellite actuators. Transitioned this precision engineering mindset to GE Research, where I architected AI solutions for industrial asset optimization and led cross-functional teams in turbomachinery development.
PhD researcher and inventor with multiple patents in sustainable energy technologies, particularly focused on supercritical CO2 power systems and waste heat recovery solutions. Proven track record of translating academic research into commercial applications through collaborations with global industry leaders.
Currently driving digital transformation initiatives in retail and energy sectors, combining deep technical expertise with business acumen to deliver measurable impact in pricing optimization and engineering innovation.

Inside the quiet revolution that’s teaching machines to imagine the future — and why it might be the missing piece between today’s chatbots and tomorrow’s truly intelligent agents.

⏱ 18 min read · 🧠 World Models · 🤖 Reinforcement Learning

In this article

1. The Chess Master Problem - Why Prediction Isn’t Enough

2. What Is a World Model? The AI That Dreams Before It Acts

3. The RSSM - The Heart That Keeps Two Kinds of Memory

4. DreamerV3 - One Brain, 150 Games, Zero Specialisation

5. Mamba - The Memory That Scales

6. DRAMA - When the Brain Learns to Run in Parallel

7. The Free Energy Connection - Karl Friston Saw This Coming

8. JEPA - Yann LeCun’s Bet Against Dreaming in Pixels

9. The Unification - All Roads Lead to One Objective

10. Vis-à-vis Transformers - The Giants in the Room

11. The Emerging Architecture of Intelligence

Here is a game that ChatGPT would almost certainly lose. Place it inside a chess engine — not as a language model giving advice, but as the actual player making moves in a live game. Ask it to plan six moves ahead. It would flounder. Not because it doesn’t “know” chess. It knows chess extraordinarily well. But knowing the rules of chess is not the same as being able to simulate a chess game in your head.

This is the difference between having knowledge and having a model. It’s the distinction between a weather app that tells you today’s forecast and a meteorologist who can stand at a window, watch the clouds gathering, and simulate in their mind the pressure systems that will arrive by Thursday. The meteorologist doesn’t just retrieve a fact, they run the world forward.

For most of its history, AI has been extremely good at the first thing and almost completely incapable of the second. That’s changing. A class of architectures called world models combined with a series of breakthroughs in how we represent memory, handle uncertainty, and train agents to imagine before they act is quietly converging on something that looks, from a certain angle, uncannily like the structure of mind itself.

This is a deep dive into that story. We’ll trace it from first principles through the architecture that conquered Minecraft, the mathematical framework that connects AI to neuroscience, the debate between two AI legends about whether machines should dream in pixels or abstractions, and ultimately to the question of whether the large language models we’ve become so attached to are actually just one layer of a much grander cognitive stack.

No prior AI knowledge required. You’ll need only curiosity and perhaps a willingness to be surprised at how often the best ideas about artificial intelligence turn out to be old ideas about biological intelligence, wearing new clothes.

· · ·

What Is a World Model? The AI That Dreams Before It Acts

Imagine you are learning to drive. In your early lessons, you react: brake lights ahead, foot goes to the pedal. But as you become an expert driver, something more interesting happens. You start to anticipate. You see a child on a pavement fifty metres ahead and your foot is already hovering over the brake not because you’ve trained on millions of “child near pavement” examples, but because you have an internal model of how the physical world works. You can run a simulation in your head and see the future a few seconds before it arrives.

World models give AI agents this same capacity.

“Rather than reacting directly to the environment, an AI agent learns an internal ‘mental simulation’ of the world, then uses that simulation to plan ahead imagining consequences of actions before taking them.”

Conceptual foundation of Model-Based Reinforcement Learning

Think of the difference between two chess players. One has memorised thousands of opening positions and plays from pattern recognition alone which is reactive, fast, but shallow. The other closes their eyes between moves and runs the next eight moves like a film, checking outcomes before committing. The second player has a mental world model of chess. Most current AI systems are still the first player.

The technical term for this family of approaches is Model-Based Reinforcement Learning (MBRL). The key advantage it brings is something researchers call sample efficiency — the ability to learn from far fewer real-world interactions by practising in imagination instead. Rather than needing millions of costly real rollouts to learn how to manage, say, retail prices across hundreds of products, an agent with a world model can generate thousands of synthetic “what if” scenarios from inside its own learned simulation.

The first formal world model in deep learning was introduced by Ha & Schmidhuber in 2018, in a paper simply titled World Models. Their agent learned to race a car by developing an internal “dream” of the track so compact and accurate that the agent could be trained entirely inside its own imagination and then deployed into reality. It was a proof of concept. What followed over the next five years would turn that proof of concept into something genuinely general-purpose.

· · ·

The RSSM - The Heart That Keeps Two Kinds of Memory

Every world model needs an answer to the same fundamental question: how do you compress the messy, high-dimensional real world into something compact enough to dream with? The answer that has proven most powerful is called the Recurrent State-Space Model, or RSSM, and it works by keeping two kinds of memory simultaneously.

Think of it this way. Your own memory works on at least two timescales. Right now, in working memory, you hold a precise snapshot of this sentence, this moment. But you also carry a longer-horizon sense of context you know what this article is about, you remember the analogy from earlier, you have a running model of where this is going. The RSSM mirrors this with two kinds of internal state.

The deterministic hidden state (called h_t) is like a diary a running narrative accumulated across time, updated step by step. It captures long-term patterns and trends. The stochastic latent (called z_t) is like a photograph taken right now a sharp, probabilistic snapshot of the current moment that deliberately captures uncertainty about what’s actually happening in the world.

The stochastic part matters enormously. In the real world and especially in environments like financial markets or competitive pricing the future is genuinely uncertain. Multiple futures are possible from the same present moment. Representing this with a deterministic single-valued state would be a lie. Instead, the RSSM samples z_t from a probability distribution, acknowledging that the world could unfold in multiple ways, and letting the agent plan across all of them.

The RSSM also does something clever during training: it runs two parallel inference paths at once. When it has access to real observations, it uses a “posterior” path encoding what actually happened to produce an accurate z_t. But simultaneously, it runs a “prior” path that tries to predict what should have happened based only on history, without peeking at the real observation. The gap between what was predicted and what actually happened is the learning signal. This is, incidentally, almost exactly how predictive coding models of the human brain work but we’ll get to that later.

· · ·

DreamerV3 - One Brain, 150 Games, Zero Specialisation

In 2023, Danijar Hafner and colleagues at Google DeepMind published a result that should have made considerably more headlines than it did. They built a single AI system called DreamerV3 and applied it, with literally no changes to any hyperparameter, to over 150 different tasks. Atari video games. 3D simulated environments. Continuous robotic control. And most famously, collecting diamonds in Minecraft.

DreamerV3 Learning to Play Minecraft from Scratch

Collecting diamonds in Minecraft sounds like a trivial benchmark until you realise what a horizon of strategic depth that had previously defeated every specialised agent thrown at it. DreamerV3 cracked it from scratch, with the same hyperparameters it used everywhere else.

“DreamerV3 is notable for using a single fixed set of hyperparameters across 150+ diverse tasks — from Atari games to 3D environments to collecting diamonds in Minecraft.”— Hafner et al., arXiv 2301.04104

How? The architecture consists of three neural networks trained in parallel: the world model itself (the RSSM), an actor that chooses actions, and a critic that evaluates states. But what makes DreamerV3 actually work in practice is a handful of surprisingly elegant engineering tricks. The tricks that handle the thorniest problems in RL without any domain-specific tuning.

The five key innovations in DreamerV3 address real problems elegantly. The symlog transform — sign(x)·ln(|x|+1) compresses reward signals that might range from fractions of a penny to millions of dollars into a smooth, learnable scale without any manual normalisation. Twohot encoding spreads a scalar target across two adjacent bins in a 255-category softmax, giving the model much richer gradient information than a simple mean-squared error loss. Percentile return normalisation divides rewards by the gap between the 5th and 95th percentiles, preventing sparse rewards from being swamped by noise. Together, these tricks make the algorithm genuinely domain-agnostic.

The training procedure runs in three phases on each batch. In Phase A, the world model is trained on real data from the replay buffer learning to reconstruct observations, predict transitions, and compress experience into latent states. In Phase B, the actor is trained entirely inside the world model’s imagination, unrolling 15 hypothetical steps into the future and maximising a discounted return. In Phase C, the critic learns to evaluate those imagined states. No real environment interaction happens during Phases B and C. The agent is dreaming, and getting better at acting by improving the quality of its dreams.

· · ·

Mamba - The Memory That Scales

There is a hidden bottleneck inside every RSSM. The deterministic hidden state h_t is traditionally updated using a Gated Recurrent Unit (GRU), a type of recurrent neural network that processes sequences one step at a time, passing information forward like a baton in a relay race. This is fine for short sequences and small-scale experiments. But for complex, long-horizon environments, hundreds of time steps, dozens of interacting entities, the GRU becomes a serious constraint.

This is where Mamba enters the picture, and understanding why it matters requires a brief detour into the mathematics of memory.

Classical sequence models, including GRUs and LSTMs, belong to a family called State Space Models (SSMs). They maintain a hidden state vector that is updated at each step using three matrices: one for transitioning the state, one for incorporating the input, and one for generating the output. The fundamental problem with classic SSMs is that these matrices are fixed the same transformation applies regardless of what the input actually is. The model can’t adaptively forget irrelevant information or hyper-focus on something surprising.

Imagine reading a long novel with a fixed reading strategy, you give every sentence exactly the same amount of attention, regardless of whether it’s a tedious description of furniture or the revelation of the murderer’s identity. A fixed SSM reads like that. Mamba, by contrast, is a reader who has learned to skim the boring parts and slow down when something important happens.

Mamba’s key innovation introduced by Albert Gu and Tri Dao in 2023 is making the SSM’s parameters input-dependent, or selective. At each timestep, the model dynamically determines how much of its current hidden state to preserve, how much to forget, and how much emphasis to place on the new input. This is mathematically similar to LSTM gating, but crucially, Mamba can apply this selective mechanism over sequences orders of magnitude longer, with far better computational efficiency.

Mamba-2, the version used in the most advanced world model architectures, adds something called State Space Duality a proof that the selective SSM computation can be rewritten as a structured matrix multiplication. This means the model can process entire sequences in parallel during training (like a Transformer) but still run as a fast step-by-step recurrence during inference and imagination rollouts. It gets the best of both worlds: fast to train, fast to dream.

· · ·

DRAMA - When the Brain Learns to Run in Parallel

In 2024, researchers at ICLR published a paper called DRAMA, the first world model architecture to replace the GRU with Mamba-2 inside the RSSM. The result is more than a performance upgrade. It reveals a subtle but important insight about how world models can be redesigned to take advantage of modern hardware.

The standard DreamerV3 RSSM has a dependency that seems innocuous but creates a fundamental bottleneck: the posterior encoder the part that encodes “what actually happened” at each step depends on the deterministic hidden state h_t, which must be computed sequentially. This means that during training, you cannot parallelise across the time dimension. You must process the sequence one step at a time. For long sequences, this is painfully slow.

DRAMA’s solution is elegant: decouple the posterior from the deterministic state. The posterior encoder is redesigned to depend only on the current observation, not on the hidden state. The latent z_t is computed from what happened right now, not from what happened right now given all of history. This seemingly small change unlocks full parallel training across the entire sequence.

“By removing the dependency of z_t on h_t during training, the entire sequence can be processed in one parallel Mamba-2 forward pass instead of step-by-step. This delivers a 2–9× training speedup.”— Wang et al., DRAMA: Mamba-Enabled Model-Based World Models, ICLR 2025

The analogy here is a historian who normally reads every diary entry in sequence before summarising the month, versus one who hands each entry to a different researcher (processed in parallel), then brings all the summaries together at the end. The parallel approach is dramatically faster and, with the right architecture, produces the same quality result.

The 2–9× speedup matters enormously for a solo researcher or a small lab. The difference between a hyperparameter sweep that takes a week and one that takes a day is the difference between doing and not doing the ablation study that would have caught a critical mistake. This is not merely a performance footnote — it changes what research is feasible.

· · ·

The Free Energy Connection - Karl Friston Saw This Coming

Here is something that will feel surprising at first and then obvious in retrospect: the mathematics inside DreamerV3’s training loop are not a novel invention of machine learning. They are the same mathematics that neuroscientist Karl Friston derived in the early 2000s to describe how biological brains work.

Friston’s Free Energy Principle proposes that every self-organising biological system , including the human brain, resists disorder by minimising something called variational free energy. In simple terms: the brain constantly tries to reduce the gap between what it predicts will happen and what actually happens. Friston formalised this as a bound on “surprise”, negative log model evidence, and showed that perception, action, learning, and even attention could all be understood as different ways of minimising this single quantity.

“In the Free Energy Principle, the brain constantly generates predictions and updates its internal model to minimise prediction error — both by changing what it believes about the world, and by taking actions that make the world match its predictions.”— Karl Friston, “The Free Energy Principle: A Rough Guide to the Brain?”

What Friston derived for biology and what Hafner engineered for AI are, at the mathematical level, the same equation. The ELBO (Evidence Lower Bound) that DreamerV3 maximises is formally identical to the variational free energy that Friston’s agents minimise. The prediction loss minimises reconstruction surprise; the KL term balances prior and posterior. Same objective, different labels.

The structural correspondences run remarkably deep. In Friston’s framework, the brain maintains a “generative model” which is a probabilistic model of how observations are caused by hidden states of the world. This maps directly onto DreamerV3’s world model. The brain’s “recognition model” which is the process of inferring hidden causes from observed effects maps directly onto the RSSM’s posterior encoder. Even the nuanced asymmetry in DreamerV3’s KL balancing (where the dynamic loss is weighted 5× heavier than the representation loss) has a direct Fristonian interpretation: it corresponds to the brain weighting sensory evidence more heavily than prior beliefs when something surprising happens.

The one genuine difference between the two frameworks is philosophically interesting. DreamerV3 uses an external reward signal handed to it from outside. Active inference agents, the AI implementations of Friston’s framework, such as VERSES AI’s AXIOM system, replace reward entirely with something called prior preferences: a probability distribution over desired outcomes. The goal is not to maximise a score; it’s to make the future look like what the model prefers. From this perspective, reward is not fundamental but an emergent consequence of having preferences and taking actions to fulfil them.

· · ·

JEPA - Yann LeCun’s Bet Against Dreaming in Pixels

If Karl Friston represents the neuroscience wing of this story, Yann LeCun (chief AI scientist at Meta and one of the founding figures of modern deep learning), represents a contrarian engineering wing. LeCun agrees with everything we’ve discussed so far about the importance of latent-space prediction and internal world models. His disagreement is about what, exactly, the world model should predict.

DreamerV3 and active inference are both generative models, they can synthesise observations, decode latents back to pixels, and hallucinate full sensory experience. LeCun thinks this is a mistake. His framework, called JEPA (Joint Embedding Predictive Architecture), argues that the right approach is to build world models that predict entirely in abstract representation space, never decoding back to pixels at all.

“The main motivation is that generative models waste enormous capacity predicting high-entropy, unpredictable noise — the exact texture of rippling water, the precise positions of flickering leaves. A JEPA encoder can be invariant to that unpredictable junk, retaining only the low-entropy structural features that actually matter for understanding.”— Yann LeCun, “A Path Towards Autonomous Machine Intelligence,” 2022

The difference between generative and non-generative world models is like the difference between two kinds of navigators. The first one, when planning a route, mentally simulates the entire drive; every lamppost, every crack in the road, every leaf blowing across the windscreen. The second one only simulates the abstract structure: the turns, the distances, the traffic patterns. The second navigator is not less intelligent but are more efficient, because they’ve learned which details actually matter for the task.

JEPA’s variants include I-JEPA for images, V-JEPA for video, and V-JEPA 2-AC for robotics. The last of which is action-conditioned and used for planning, making it structurally identical to the RSSM’s prior head. The predictor takes the current visual state embedding and an action, and outputs the predicted embedding of the world after that action. This is, in all but name, a world model in latent space.

But JEPA faces a challenge that generative models avoid almost automatically: representational collapse. If the encoder learns to map everything to the same constant vector, the prediction error drops to zero — but nothing useful has been learned. DreamerV3 sidesteps this because its decoder loss forces the latents to contain enough information to reconstruct real observations. JEPA must use masking strategies, contrastive objectives, or explicit regularisers to prevent collapse, an ongoing area of active research.

· · ·

The Unification - All Roads Lead to One Objective

At this point, you might be wondering whether we’re looking at a fragmented landscape of competing ideas or a unified field with different dialects. The answer, increasingly clearly, is the latter. In 2009, Karl Friston published a paper with the strikingly direct title: “Reinforcement Learning or Active Inference?” His answer: they are the same thing.

The central insight is that maximising cumulative reward, the objective of classical reinforcement learning, is mathematically equivalent to minimising surprise under a generative model whose prior preferences encode the reward function. You don’t need reward as a primitive. It emerges from inference. And once you see this equivalence, you start to notice that every framework in this article is solving the same problem with different tools.

The degrees of freedom between these frameworks reduce to just three design choices. First: where do you compute prediction error? In pixel space (old generative models), in latent space (JEPA, RSSM), or across hierarchical layers (predictive coding)? Second: how do you represent uncertainty? With stochastic latents (DreamerV3), Bayesian posteriors (active inference), deterministic embeddings (JEPA), or ensembles? Third: where does reward come from? As an extrinsic scalar (RL/DreamerV3), encoded in prior preferences (active inference), or emerging from representation quality alone (JEPA)?

The deepest unification is this: every goal-directed system must solve the same core problem. Given uncertainty about the world, compress history into a belief state, predict consequences of actions, and select actions that bring about preferred outcomes. Whether you call those preferred outcomes “high reward,” “low surprise,” “high model evidence,” or “accurate latent predictions” is a modelling choice, not a fundamental difference.

· · ·

Vis-à-vis Transformers - The Giants in the Room

We cannot finish this story without addressing the most obvious question: if world models are so powerful, why aren’t they everywhere? Why is GPT-4 dominating the AI landscape while DreamerV3 is known mainly to specialists?

The answer is that Transformers and world models are solving fundamentally different problems and for the last five years, the problems that Transformers solve have been the ones that matter most commercially.

LLMs vs World Models

A Transformer’s core operation is scaled dot-product attention: a mechanism for finding, among all the tokens in a context window, which ones are most relevant to the current token. Given enough data and parameters, this turns out to be an extraordinarily powerful universal pattern matcher. It learns the statistical regularities of language, images, code, and structured data, and compresses them into a single forward pass. What it cannot do is inherently sequential, causally grounded, or physically simulated.

“LLMs have word models. Embodied agents need world models.”— A pithy formulation circulating in the RL research community

Recent research has made the Transformer’s structural weakness on sequential tasks quite precise. A paper from 2024 showed that Transformers trained on sequences of length N collapse to near-random performance on state-tracking tasks at length 2N, they cannot perform the discrete recursive updates that a recurrent state naturally handles. They don’t have a compressed, updateable belief state. They diffuse attention across all tokens equally as context grows.

But the most important thing to understand about the Transformer/world-model divide is that it is dissolving. The field is converging rapidly toward hybrid architectures. IRIS, a 2022 paper from EPFL, replaces the RSSM with a GPT-style Transformer as the sequence model and achieves state-of-the-art sample efficiency with 100K environment interactions. Google DeepMind’s Genie 2 uses a Transformer-based world model for interactive video generation. Conversely, LLMs fine-tuned with RL (RLHF, GRPO) are being pushed toward internalising environmental dynamics through multi-turn interaction.

The emerging architecture of intelligence looks increasingly like a three-layer stack. At the top: a large language model for semantic reasoning, instruction parsing, and knowledge retrieval — the strategic advisor. In the middle: a world model (RSSM/Mamba-based) for physical simulation, causal dynamics, and long-horizon planning — the experienced simulator. At the bottom: a reinforcement learning policy for real-time action selection — the motor cortex. This maps almost exactly onto the hierarchical structure that active inference posits for the human brain.

· · ·

The Emerging Architecture of Intelligence

We have covered a lot of ground. From the basic intuition of a world model as a mental simulator, through the elegant RSSM architecture with its two kinds of memory, through DreamerV3’s triumph of generalisation and DRAMA’s parallelisation breakthrough, through the discovery that neuroscience and machine learning have been describing the same mathematics from different directions, through LeCun’s provocative challenge to the generative consensus, and finally to the realisation that reinforcement learning, active inference, JEPA, and predictive coding are all dialects of a single language.

The picture that emerges is not a chaotic landscape of competing ideas. It is a convergence. The field is settling, through independent derivations from neuroscience, from control theory, from information theory, and from empirical machine learning, on a set of core principles: compress history into a belief state; predict consequences of actions in abstract latent space; represent uncertainty explicitly; act so as to make the future match your preferences.

The large language models that currently dominate our experience of AI are extraordinary, but they are missing the middle layer of this stack, the world model that grounds semantic knowledge in causal dynamics. The next generation of AI systems will not replace Transformers; they will build a dynamics layer beneath them and a policy layer below that. The architecture is becoming visible.

Karl Friston observed that every living system, from a single bacterium to a human brain, is essentially doing the same thing: building a model of its environment and acting to keep that model’s predictions accurate. If that’s right, then building artificial intelligence is not about building a new kind of mind, it’s about recreating, in silicon, the architecture that evolution already discovered.

Which raises the question that might keep you thinking tonight: if the architecture of intelligence is converging, and if that architecture turns out to be the same one that the human brain already runs , what exactly is the thing that will emerge when we finally get the engineering right?

Key papers referenced:

• Ha & Schmidhuber, “World Models” (2018)

• Hafner et al., “DreamerV3” (arXiv 2301.04104)

• Wang et al., “DRAMA” (ICLR 2025, arXiv 2410.08893)

• Gu & Dao, “Mamba” (2023)

• Friston, “The Free Energy Principle” (2009)

• LeCun, “A Path Towards Autonomous Machine Intelligence” (2022)

• Micheli et al., “IRIS: Transformers are Sample-Efficient World Models” (2022, arXiv 2209.00588)

Keywords:

World Models, Reinforcement Learning, DreamerV3, Mamba, Active Inference/Free Energy Principle, JEPA, RSSM, AI Architecture

🎧 AUDIO VERSION Prefer to listen? A 12-minute audio walkthrough of this article is embedded below. It covers the key ideas, results, and engineering lessons without needing to read a single equation.

The Problem Nobody Talks About

Steel makes civilisation. The beams in your building, the car you drive, the ships carrying cargo across oceans — all forged in furnaces burning at temperatures most materials can’t survive.

What happens to the heat that doesn’t go into the steel?

It vents to the atmosphere. At temperatures between 200°C and 1,200°C, electric arc furnaces and basic oxygen furnaces exhaust enormous plumes of thermal energy in irregular bursts — cycling every 1 to 15 minutes. The steel industry produces roughly 7–8% of global CO₂ emissions, and a significant fraction of that could theoretically be offset if we could efficiently harvest this waste heat and convert it to electricity.

The engineering challenge is that these heat bursts are unpredictable, intermittent, and violently transient. A conventional steam turbine takes too long to respond. You need a compact, fast, nonlinear system — and you need a controller clever enough to handle thermodynamics that become genuinely bizarre near a very specific physical boundary.

That boundary is the CO₂ critical point. And it’s where this project starts getting interesting.

The Criticality of Operation

Supercritical CO₂ (sCO₂) Brayton cycles are an elegant solution to the waste-heat problem. Above CO₂’s critical point — 31.1°C and 7.38 MPa — the fluid exists in a state that’s neither liquid nor gas, with thermodynamic properties that enable efficiencies of 27–40% at turbomachinery scales roughly 100× more compact than equivalent steam plant. That compactness matters enormously for cost at industrial waste-heat scales.

But operating near the critical point is where physics starts playing tricks.

Imagine a property called specific heat — essentially, how much energy a fluid absorbs per degree of temperature change. For CO₂ near 35°C and 80 bar, specific heat peaks at roughly 29.6 kJ/kg·K, which is more than ten times its ideal-gas value. The fluid becomes extraordinarily sensitive to temperature perturbations in a way that is deeply asymmetric:

• A 1.5°C drop in compressor inlet temperature demands 6% more cooling power

• The same 1.5°C rise requires only 18% less

This asymmetry defeats fixed-gain PID control. A PID controller tuned for the downward response will overreact to the upward one, and vice versa. During furnace transients — when the heat source is swinging by hundreds of degrees in minutes — a conventional controller simply cannot keep up.

There’s also a hard physical constraint that makes this safety-critical rather than just suboptimal: the compressor inlet temperature must never drop below the CO₂ critical temperature (31.1°C). If it does, the fluid enters the two-phase region, the compressor cavitates, and you’ve destroyed expensive turbomachinery. This isn’t a soft performance target — it’s a hard line.

The Digital Twin: Your Training Ground

You can’t train a reinforcement learning agent directly on a real power plant. You’d destroy it in the first exploration phase.

The solution is a physics-faithful digital twin — a simulation accurate enough that a policy trained inside it will actually work in the real world. For this project, the cycle was modelled in OpenModelica using the ThermoPower and ExternalMedia libraries, with CO₂ thermodynamic properties from CoolProp’s Span–Wagner equation of state (the industry reference for CO₂ near the critical point).

The model was exported as an FMI 2.0 Co-Simulation FMU — a Functional Mock-up Unit. Think of an FMU as a black box that takes control inputs, steps forward in time using an embedded stiff ODE solver (CVODE in this case), and returns system states. The RL environment wraps this FMU via FMPy and exposes it as a standard Gymnasium interface.

The cycle exposes four actuator channels to the RL agent:

• Bypass valve opening — controls how much flow bypasses the turbine

• Inlet guide vane (IGV) angle — regulates compressor inlet flow

• Inventory valve position — controls system-wide mass inventory (and thus pressure)

• Cooling flow fraction — manages the precooler

And the agent observes 14 thermodynamic state variables: temperatures at key cycle points, high- and low-side pressures, mass flow rates, power outputs, and cycle efficiency.

Seven Levels of Curriculum

Rather than throwing the agent directly at the hardest scenario (emergency turbine trip during a furnace transient), the framework uses structured curriculum learning — seven progressively harder phases, each requiring mastery before advancement.

Phase Scenario Duration What Makes It Hard 0 Steady-state optimisation 10 min Baseline: converge to setpoint 1 ±30% gradual load following 30 min Slow ramps, needs smooth tracking 2 ±10°C ambient disturbance 60 min Asymmetric nonlinearity kicks in 3 EAF heat-source transients (200–1,200°C) 90 min Wild swings, coupled dynamics 4 50% rapid load rejection 30 min Fast step, risk of overshoot 5 Cold startup through critical region 60 min Safety constraint most at risk 6 Emergency turbine trip 30 min Full isolation, rapid inventory dump

Advancement requires a rolling mean episode reward above a phase-specific threshold over 50 episodes, with a constraint violation rate below 10%. This matters: setting the violation threshold to zero (as the initial config did — more on this in the bugs section) makes learning impossible, since a stochastic policy exploring the boundary regions will occasionally touch the constraint.

The Surrogate Story (Or: R²=1 Isn’t Always Enough)

Training directly on the FMU is slow. The embedded CVODE solver runs at roughly 530 steps per second on 8 parallel CPU workers. For RL, you ideally want millions of environment interactions. At 530 steps/s, 5 million steps takes about 2.6 hours — manageable, but brutal for iteration.

The natural acceleration strategy is a neural surrogate model — train a neural network to approximate the FMU’s transition dynamics, then train the RL policy on the (much faster) neural surrogate running on GPU.

Two surrogate architectures were tried, and their comparison is the most instructive part of the whole project.

The FNO: Beautiful But Wrong for This Job

A Fourier Neural Operator (FNO) — implemented via NVIDIA PhysicsNeMo — was trained on 76,600 trajectory sequences collected from the FMU via Latin Hypercube Sampling. The FNO maps entire trajectories of (state, action) pairs to predicted next-state trajectories.

After training on diverse data, it achieved R²=1 and normalised RMSE of 0.001. Perfect reconstruction. Exactly what you want.

Except it’s completely unusable for RL.

Here’s why: the FNO applies global Fourier convolutions over the entire input sequence. This means it’s non-causal — each output timestep implicitly attends to all input timesteps in frequency space, including future ones. The network was trained to predict trajectory outputs from full trajectory inputs. When you query it one step at a time (which is what RL requires), the spectral content of the single-step input is qualitatively different from what the network saw during training. The predictions become unreliable despite the near-perfect trajectory R².

This is a subtle but important distinction: trajectory fidelity ≠ step-prediction fidelity. An FNO with causal masking applied to its Fourier layers could fix this — it’s on the future work list.

The MLP: Architecturally Correct

The solution was a residual MLP step predictor — a network that takes a single (state, action) pair and predicts the next state:

class ResidualMLPSurrogate(nn.Module):
    """
    Maps (s_t, a_t) -> s_{t+1} via residual prediction.
    Predicts the *delta* from current state, biasing the network
    toward learning small corrections rather than absolute values.
    This dramatically improves data efficiency and training stability.
    """
    def __init__(self, n_state=14, n_action=4, hidden=512, n_layers=4):
        super().__init__()
        in_dim = n_state + n_action
        
        layers = []
        for i in range(n_layers):
            layers += [
                nn.Linear(in_dim if i == 0 else hidden, hidden),
                nn.SiLU(),  # SiLU (Swish) outperforms ReLU for smooth dynamics
            ]
        self.trunk = nn.Sequential(*layers)
        
        # Orthogonal init with small gain: prevents early saturation
        self.head = nn.Linear(hidden, n_state)
        nn.init.orthogonal_(self.head.weight, gain=0.01)
        
    def forward(self, state, action):
        x = torch.cat([state, action], dim=-1)
        delta = self.head(self.trunk(x))
        return state + delta  # Residual: predict correction, not absolute state

Trained on 55 million (s, a, s’) transition tuples extracted from those 76,600 LHS trajectories, this network achieved a validation loss of 5×10⁻⁶ — corresponding to less than 0.007°C mean absolute error on compressor inlet temperature and 0.006 MW on turbine power. Both are well below real sensor noise floors.

The payoff: with 1,024 GPU-vectorised environments backed by this surrogate, PPO training runs at 250,000 steps per second — a 470× speedup over the FMU path. Five million training steps in 23 minutes.

Making Safety Trainable: Lagrangian Constraints

The compressor inlet temperature constraint is safety-critical. The question is how to enforce it during RL training without blocking learning entirely.

The approach used here is Lagrangian relaxation — each safety constraint gets its own trainable multiplier λᵢ ≥ 0, and the training objective becomes:

L(θ, λ) = J_reward(θ) - Σᵢ λᵢ · J_constraint_cost(θ)

Policy parameters θ are updated to maximise L (gradient ascent on reward, gradient descent on violations). Multipliers λᵢ are updated via dual ascent — they increase when violations occur, increasing the cost of violating the constraint, and decrease when the constraint is comfortably satisfied.

The intuition: the multiplier is like a tunable penalty dial that the optimiser adjusts automatically based on how often the agent is violating constraints. You don’t need to hand-tune the constraint penalty weight — it finds the right level on its own. When the agent routinely satisfies the constraint, the multiplier stays low. When it’s close to the edge (Phase 5: cold startup), the multiplier rises, shaping the policy away from dangerous regions.

The primary constraint:

# Compressor inlet must stay ≥ 1°C above CO₂ critical point (31.1°C)
c_critical(s) = 32.1 - T_comp_in(s)  # Violation when > 0

# Hard termination if it drops below 31.5°C 
# (prevents FMU solver divergence in two-phase region)
if T_comp_in < 31.5:
    reward = -100
    terminated = True

What Actually Happened

The FMU-direct training run executed 5,013,504 PPO steps. Here’s the honest version of the results.

The good news: In Phases 0–2 (steady-state, gradual load following, ambient disturbance), the RL agent outperforms Ziegler–Nichols-tuned PID by +30.3%, +30.4%, and +39.0% in cumulative episode reward. The Phase 2 gain is the most telling — the RL agent has implicitly learned the asymmetric near-critical nonlinearity and exploits it predictively. The fixed-gain PID responds reactively.

The honest news: In Phases 3–6 (the hard transient scenarios), RL underperforms PID by 10–62%.

The cause is curriculum imbalance. The agent traversed Phases 0–5 in the first 229,376 steps — about 4.6% of the total training budget. The remaining 4.8 million steps were spent entirely in Phase 6. This is textbook catastrophic forgetting: deep specialisation in one task displaces representational capacity for earlier ones. The Phase 3–6 policies are essentially undertrained.

This is not an RL fundamental limitation. It’s a curriculum engineering problem — easily fixed by allocating at least 10% of training steps per phase, or using continual learning techniques like Elastic Weight Consolidation.

What never degraded: zero constraint violations across all 140 evaluation episodes — including the undertrained phases. The Lagrangian mechanism maintains the safety floor regardless of policy quality. This decoupling of safety from reward is exactly the property you need for industrial deployment.

The Five Bugs That Nearly Broke Everything

This is the section with the most practical value if you’re building RL on FMU-based environments.

Five software defects — none of them algorithmic — collectively prevented a capable policy from demonstrating its capabilities for millions of training steps. They’re documented here because they’ll recur in any Gymnasium-SB3-FMU integration.

Bug 1: VecNormalize Forgot Its Own Statistics

Stable-Baselines3’s VecNormalize wrapper maintains running mean and variance across all observations. These statistics are essential — the policy network’s inputs are normalised to (s - μ)/σ. If the statistics are wrong, the network receives garbage inputs.

The checkpoint code wrote:

# The bug: saving a null placeholder instead of actual statistics
vecnorm_stats = {"obs_rms": None}  # placeholder — never actual stats

On resume, a fresh VecNormalize initialised with μ=0, σ=1 was attached to the pre-trained policy. The policy received differently-scaled observations, made poor predictions, and earned rewards of ~6 instead of the expected ~130. Training stalled at Phase 0 for 2.8 million steps with no obvious error message.

The fix:

# Correct: always save/load VecNormalize alongside policy weights
# On save:
vecnorm.save(checkpoint_dir / "vecnorm_stats.pkl")

# On resume:
vecnorm = VecNormalize.load(checkpoint_dir / "vecnorm_stats.pkl", venv)
model.set_env(vecnorm)

Lesson: Treat the VecNormalize statistics file as a first-class artefact alongside policy weights. Write a smoke test that saves, reloads, and verifies that the first post-resume reward is within ε of the pre-save reward.

Bug 2: Episode Boundaries Never Aligned With Rollouts

SB3’s CurriculumCallback was recording episode completions in on_rollout_end, which fires once per n_steps=2048 environment steps. With episode length 120 steps and 8 parallel environments, ~136 episode terminations occur within each rollout — but on_rollout_end only inspects the final step. The probability of any environment terminating exactly at step 2048 is ~0.8%.

Most episode completions were silently discarded. The curriculum advancement mechanism never saw enough episodes to make a decision. Fix: move episode recording to on_step.

Bug 3: Unit Scaling Applied Twice

The FMU returns power in watts. The FMPyAdapter correctly converts this to megawatts via a 10⁻⁶ factor. But the environment config also contained w_net_unit_scale: 1.0e-6. The reward function ended up seeing power in microwatts, making the tracking reward term ~10⁻⁶ of its intended magnitude — effectively pure noise.

The insidious part: the sign and smoothness of the reward were unchanged. Training appeared to make slow progress rather than obviously failing. Fix: Set w_net_unit_scale: 1.0 and document that the adapter owns unit conversion.

Bug 4: Stale Disturbance Profiles on Phase Transition

When the curriculum advanced mid-episode, the disturbance profile dictionary (built once on reset()) wasn’t rebuilt. Phase 2 tried to read keys like ambient_amplitude that only exist in Phase 2 configs, from a Phase 0 profile. KeyError crashed the worker subprocess silently. Fix: rebuild the disturbance profile atomically whenever the curriculum phase changes.

Bug 5: Zero-Violation Advancement Was Impossible

The initial config required require_zero_constraint_violations: true. This meant a single temperature boundary touch during stochastic exploration permanently blocked curriculum advancement. Since a PPO policy must probe boundary regions to learn where the constraint lives, zero violations during training is structurally unreachable. Fix: Allow up to 10% violations during training; enforce zero violations at deployment via the constraint projection QP.

0.046 ms: From Policy to Plant Edge

The final policy is exported via PyTorch → ONNX → TensorRT FP16. Measured over 1,000 inference iterations on the NVIDIA DGX Spark GB10:

Latency Percentile Value p50 0.024 ms p90 0.028 ms p99 0.046 ms Throughput ~29,600 queries/s

The plant-edge SLA is 1 ms. The deployed policy sits 22× under that threshold, leaving ample headroom for the constraint projection QP that guarantees safety invariants at inference time — a separate quadratic program that runs on each policy output before it reaches the actuators.

What I’d Do Differently

Curriculum allocation first, algorithms second. The Phase 3–6 failure isn’t a PPO problem — it’s a curriculum resource allocation problem. Setting a minimum training step budget per phase (10% of total, minimum) before any phase advancement would have produced a much more balanced policy.

Causal FNO for the surrogate. The FNO achieved R²=1.000 and was then useless for RL. Adding causal masking to the Fourier layers (masking future-attending frequency components) would let the FNO’s superior temporal modelling actually contribute to policy training.

Interleaved replay needs annealing, not a fixed ratio. The 30% interleaved replay experiment produced catastrophic gradient interference. A cosine-annealed schedule starting at ≤5% and warming to 20% over 500K steps would let the policy consolidate Phase 6 skills before aggressive replay gradients destabilise it.

EWC or progressive networks for long-horizon curriculum. Once you’re past Phase 4 or 5, Elastic Weight Consolidation protecting the earlier-phase weights would have preserved performance while allowing Phase 6 specialisation.

Takeaways for Practitioners

If you’re building RL on physics simulation environments, the most portable lessons from this project are:

The FMU-RL integration stack (OpenModelica → FMPy → Gymnasium → SB3) works well but has landmines — the five bugs above are latent in any project using this stack, not just sCO₂ systems.

Surrogate architecture must match the RL query pattern. A surrogate that reconstructs trajectories beautifully may be completely wrong for step-by-step prediction. Check whether your surrogate is causal before building your training loop around it.

Data quality dominates surrogate performance. The FNO achieved R²=−77 on a degenerate 75K dataset (only 2,100 unique initial conditions) and R²=1.000 on 76,600 diverse LHS trajectories. Identical architecture, identical hyperparameters. No amount of model complexity compensates for a degenerate training distribution.

Lagrangian constraints decouple safety from reward. Zero violations across 310 evaluation episodes, even in severely undertrained phases. The safety layer works regardless of policy quality — which is what you need for deployment confidence.

Resources

Code & Paper

• 📦 GitHub: github.com/SharathSPhD/RLpower — full codebase, pre-trained artefacts, MIT licence

• 📄 Full paper: https://zenodo.org/records/18716201

Tools Used

• 🔧 OpenModelica — open-source Modelica simulation environment

• 🔧 FMPy — Python FMU loading, zero-C-extension install

• 🔧 CoolProp — open-source thermophysical property library (Span–Wagner CO₂ EOS)

• 🔧 Stable-Baselines3 — PPO implementation

• 🔧 NVIDIA PhysicsNeMo — FNO implementation

• 🔧 TensorRT — edge inference compilation

Key Papers

• Dostal et al. (2004) — foundational sCO₂ cycle thermodynamics [MIT-ANP-TR-100]

• Li et al. (2021) — FNO for PDEs [arXiv:2010.08895]

• Achiam et al. (2017) — Constrained Policy Optimisation [ICML]

• Schulman et al. (2017) — PPO [arXiv:1707.06347]

• Baek et al. (2025) — RL for sCO₂ load-varying control [Energy, 340]

• Kirkpatrick et al. (2017) — Elastic Weight Consolidation [PNAS]

Related Frameworks

• ModelicaGym — RL on Modelica FMUs

• BOPTEST-Gym — building HVAC RL benchmark

About the Author: Dr. Sharath is a Data Science & AI leader with deep expertise spanning retail analytics, industrial engineering, and aerospace technologies. Specialized in developing cutting-edge AI/ML solutions for commodity pricing and engineering optimization at bp, while leveraging decades of experience in complex systems engineering.
Previously led breakthrough innovations in aerospace technology at Indian Space Research Organisation (ISRO), developing advanced inertial navigation systems and satellite actuators. Transitioned this precision engineering mindset to GE Research, where I architected AI solutions for industrial asset optimization and led cross-functional teams in turbomachinery development.
PhD researcher and inventor with multiple patents in sustainable energy technologies, particularly focused on supercritical CO2 power systems and waste heat recovery solutions. Proven track record of translating academic research into commercial applications through collaborations with global industry leaders.
Currently driving digital transformation initiatives in retail and energy sectors, combining deep technical expertise with business acumen to deliver measurable impact (multi-million-dollar) in pricing optimization and engineering innovation.

Appendix: Full Reward Function

def compute_reward(
    obs: dict,
    action: np.ndarray,
    prev_action: np.ndarray,
    lagrangian_multipliers: dict,
    weights: dict,
) -> tuple[float, dict]:
    """
    Three-term reward: tracking + smoothness - constraint penalties.
    
    All power values in MW (FMPyAdapter handles W -> MW conversion).
    Do NOT apply additional unit scaling here.
    """
    
    # --- Tracking term ---
    # Penalise deviation from net power demand setpoint
    w_net_mw = obs["W_net"]          # Already in MW from FMPyAdapter
    w_demand  = obs["W_demand"]       # MW setpoint from curriculum
    
    r_track = -abs(w_net_mw - w_demand) * weights["w_track"]
    
    # --- Smoothness term ---
    # Penalise rapid actuator movement (prevents actuator wear)
    delta_action = action - prev_action
    r_smooth = -np.dot(delta_action, delta_action) * weights["w_smooth"]
    
    # --- Constraint term (Lagrangian) ---
    # Primary: compressor inlet above CO₂ critical point
    T_comp_in = obs["T_comp_in"]
    T_guard   = 31.1 + 1.0  # 1°C margin above critical point
    
    violation_critical = max(0.0, T_guard - T_comp_in)  # > 0 when violated
    r_constraint = -lagrangian_multipliers["critical"] * float(violation_critical > 0)
    
    # Hard termination check (handled separately in step())
    # if T_comp_in < 31.5: reward = -100, terminated = True
    
    r_total = r_track + r_smooth + r_constraint
    
    info = {
        "r_track": r_track,
        "r_smooth": r_smooth,
        "r_constraint": r_constraint,
        "violation_critical": violation_critical,
    }
    
    return r_total, info


def update_lagrangian_multipliers(
    multipliers: dict,
    violations: dict,
    lr_dual: float = 1e-3,
) -> dict:
    """
    Dual ascent update: increase multiplier when violated,
    decrease when constraint is comfortably satisfied.
    Multipliers are clamped to [0, λ_max] to prevent unbounded growth.
    """
    updated = {}
    for key in multipliers:
        grad = violations.get(key, 0.0)  # Positive = violation occurred
        new_val = multipliers[key] + lr_dual * grad
        updated[key] = float(np.clip(new_val, 0.0, 100.0))
    return updated

When you ask ChatGPT or Claude to solve a logic puzzle, something remarkable happens. The model seems to think, deliberate, and arrive at conclusions. It can even explain its reasoning step by step. But here’s the uncomfortable truth: what looks like reasoning might actually be sophisticated pattern recognition in disguise.

This isn’t just an academic quibble. It’s the difference between a medical AI that has seen millions of similar cases versus one that understands why a diagnosis follows from evidence. It’s the difference between an AI that can pass the bar exam and one that can actually practice law. As AI systems move into high-stakes domains where mistakes carry real consequences, this distinction becomes urgent.

A new research project called Pramana is tackling this problem from an unexpected angle: by teaching modern neural networks to follow the structured reasoning methodology developed by Indian logicians over two millennia ago. The results challenge our assumptions about what AI systems can learn, and suggest a path toward genuinely interpretable artificial intelligence.

The Pattern Recognition Trap

Large language models excel at a specific kind of intelligence: finding patterns in vast amounts of data and using those patterns to generate plausible outputs. When GPT-4 solves a logic problem, it’s essentially recognizing that problems with similar structure typically have solutions that follow certain patterns.

Think of it like the difference between someone who has memorized thousands of chess games versus someone who understands chess principles. The memorizer might play brilliantly against known positions but falter when the board state deviates from their experience. The principled player can reason through novel situations because they understand the underlying logic of the game.

The ancient Indian philosophical tradition makes this distinction explicit through the concept of consciousness levels described in the Taittiriya Upanishad. There’s manomaya (मनोमय), the level of mental processing and pattern recognition, and vijnanamaya (विज्ञानमय), the level of discriminative wisdom and genuine understanding. Current AI systems, no matter how sophisticated, operate almost entirely at the manomaya level. They process, correlate, and generate, but they don’t actually understand in the deeper sense.

This limitation manifests in concrete ways. When researchers test language models on logical reasoning tasks, the models often fail in revealing patterns. They might correctly solve a problem when it’s phrased one way but fail when the same problem is rephrased differently. They struggle to explain where their conclusions come from beyond “the pattern suggests.” They can’t tell you which parts of their reasoning are certain versus probable. Most critically, they can’t systematically check their own reasoning for errors.

The Nyaya Solution: Systematic Epistemology

Around 500 BCE, the Indian philosopher Maharishi Gautama systematized something remarkable: a complete methodology for acquiring reliable knowledge and eliminating false beliefs. This system, called Nyaya-Darshan (न्याय दर्शन), wasn’t just about logic in the narrow sense. It was an integrated epistemological framework that combined formal reasoning with explicit attention to evidence sources, fallacy detection, and epistemic humility.

At its core, Nyaya provides a structured pathway through six distinct phases that transform doubt into definitive knowledge. These aren’t arbitrary steps but a carefully designed progression:

Samshaya (संशय, Doubt Analysis) begins by classifying what type of uncertainty exists. Is it doubt arising from similar properties in different objects? Contradictory properties in the same object? Conflicting testimony from different authorities? Each type of doubt requires different resolution strategies. This phase alone addresses something most AI systems never do: acknowledging that not all uncertainties are the same.

Pramana (प्रमाण, Valid Knowledge Sources) requires explicitly grounding every claim in one of four recognized evidence types. Pratyaksha is direct perception, what can be immediately observed. Anumana is inference based on universal relationships. Upamana is knowledge through comparison with known examples. Shabda is reliable testimony or established principles. By forcing every reasoning step to declare its evidential basis, Pramana creates an audit trail that’s entirely absent from standard neural network reasoning.

Pancha Avayava (पञ्च अवयव, Five-Member Syllogism) constructs formal arguments through five components. You begin with Pratijna, a clear proposition of what you will prove. Then comes Hetu, the logical justification. Critically, you must provide Udaharana, a universal example that everyone would accept as true regardless of their philosophical position. Upanaya applies this universal principle to the specific case. Finally, Nigamana restates the conclusion as proven.

Tarka (तर्क, Counterfactual Reasoning) uses reductio ad absurdum. Assume the opposite of your conclusion. Derive what would logically follow. If those consequences lead to absurdity or contradiction, your original conclusion must be true. This is systematic doubt as a verification tool.

Hetvabhasa (हेत्वाभास, Fallacy Detection) provides a taxonomy of reasoning errors. Is your reasoning erratic, applying in some cases but not others? Does it actually contradict what you’re trying to prove? Is it circular, assuming what it should demonstrate? Is it irrelevant to the question at hand? This phase embeds error-checking directly into the reasoning process.

Nirnaya (निर्णय, Ascertainment) is the final judgment, but with an important requirement: you must distinguish definitive knowledge from working hypotheses that require further verification. This builds in epistemic humility, the ability to say “I don’t have sufficient evidence yet” rather than forcing a confident-sounding answer.

What makes this system powerful for AI isn’t just that it provides structure. It’s that it makes reasoning auditable. Every step declares its evidential basis, makes its logic explicit, checks for errors, and acknowledges uncertainty. These are precisely the capabilities that current AI systems lack.

Teaching Neural Networks Ancient Wisdom

The Pramana project, developed by Sharath Sathish at the University of York, makes a bold claim: these Nyaya principles can be taught to neural networks through fine-tuning. Not just prompted to follow them, but actually learned as an internal reasoning scaffold.

The technical approach is surprisingly straightforward. The researchers created training examples showing how to solve logical problems using the complete six-phase Nyaya methodology. Each example walks through Samshaya analysis, identifies Pramana sources, constructs Pancha Avayava arguments, applies Tarka verification, checks for Hetvabhasa errors, and reaches Nirnaya conclusions.

Example of a Nyaya-structured solution to a simple logic problem

## PHASE 1: SAMSHAYA PARIKSHA (Doubt Analysis)

**Type of Doubt**: Samana Dharma Upapatti (Common attributes)
Multiple solutions satisfy individual constraints, but which 
combination satisfies all constraints simultaneously?

## PHASE 2: PRAMANA PRAYOGA (Evidence Sources)

**Pratyaksha** (Direct Observable Facts):
- Given: Five houses in a row, each different color
- Given: The Englishman lives in the red house
- Given: The Spaniard owns a dog
[continues through all given constraints...]

**Anumana** (Inference):
From "Englishman lives in red house" + "Red house is in position 3"
→ Inferred: Englishman lives in house 3

[continues through all six phases systematically...]

They fine-tuned open-source models (Llama and DeepSeek) using QLoRA, an efficient technique that allows training on consumer hardware. Stage 0 used just 20 examples. Stage 1 expanded to 55 carefully constructed problems spanning different logical reasoning types: constraint satisfaction, Boolean satisfiability, multi-step deduction, transitive reasoning, and set operations.

The entire training cost was under one dollar. Training time was less than twenty minutes on a single A100 GPU. This accessibility is intentional. The goal isn’t to create proprietary systems that only well-funded labs can reproduce, but to demonstrate principles that any researcher can experiment with.

What distinguishes this from previous work on reasoning in language models is the insistence on architectural integration rather than mere prompting. The Nyaya structure isn’t just guidance given to the model at inference time. It’s woven into the model’s learned patterns through supervised fine-tuning. The hypothesis is that this creates different kinds of representations internally, ones that encode epistemic relationships rather than just statistical correlations.

The Results That Challenge Assumptions

When the researchers evaluated their Stage 1 model on held-out test problems, something unexpected appeared in the results. The model achieved 100% semantic correctness—every single answer was logically accurate. But format adherence, the model’s ability to perfectly follow the structured Nyaya template, was only 40%.

At first glance, this might seem like a failure. Isn’t the whole point to follow the structure? But the dissociation between semantic and format performance reveals something profound: the models are learning the reasoning, not just the template.

Think about what this means. If the system were simply memorizing patterns about how to fill in section headers, you’d expect semantic accuracy and format adherence to move together. High format scores with high semantic scores, or low with low. Instead, you see models that consistently get the right answer while sometimes abbreviating sections or reordering phases.

This is evidence that the Nyaya methodology is teaching genuine reasoning principles. The model understands that it needs to check for contradictions (Tarka), even if it doesn’t always put that check in a perfectly formatted section with the Sanskrit header. It knows to identify evidence sources (Pramana), even if it sometimes combines that with other reasoning steps rather than isolating it perfectly.

The failure modes are instructive too. When models do fail at format adherence, it’s usually by treating certain phases as optional (particularly Hetvabhasa fallacy detection) or by using incorrect doubt classifications in the Samshaya phase. These aren’t random errors. They suggest the model has learned a partial schema where some elements are recognized as more critical than others, much like a human student who masters the core logic but gets fuzzy on taxonomic details.

Crucially, the models never show structural collapse. They don’t generate nonsense or give up on the structure entirely. Even when format adherence is partial, they’re clearly attempting to follow the Nyaya progression. This consistency across diverse logical problem types suggests the methodology provides robust cognitive scaffolding.

“The dissociation between semantic correctness (100%) and format adherence (40%) reveals models internalize reasoning content even when strict schema compliance fails. This suggests Nyaya methodology teaches genuine reasoning, not just template-filling.” — From the Pramana research paper

Why This Matters: The Interpretability Crisis

As AI systems deploy in medicine, law, finance, and safety-critical systems, interpretability becomes essential. When an AI suggests a medical diagnosis, we need to know: What evidence supports this? What alternatives were considered? What could make this conclusion wrong? Which parts are certain versus probable?

Current approaches to AI interpretability mostly focus on post-hoc explanations—trying to figure out why a model made a decision after the fact. This is like trying to understand someone’s reasoning by examining their brain activity rather than asking them to explain their thinking. It’s indirect, unreliable, and often misleading.

Pramana offers a different paradigm: interpretability by design. When a model is trained to reason using the Nyaya framework, its reasoning process is inherently transparent. You can see which evidence sources it relied on (Pramana phase). You can verify that its logical arguments follow valid patterns (Pancha Avayava phase). You can check whether it considered counterarguments (Tarka phase). You can identify what reasoning errors it might have made (Hetvabhasa phase). You can assess its epistemic confidence (Nirnaya phase).

This auditability is precisely what’s needed for trustworthy AI. Imagine a medical AI that not only suggests “likely pneumonia” but shows you: “Based on Pratyaksha (observed symptoms: fever, cough, chest pain), and Anumana (inference from chest X-ray opacity), with Tarka verification (assuming no pneumonia would contradict the radiological findings), concluding Nirnaya: high confidence pneumonia diagnosis, though cannot rule out other interstitial lung diseases without additional testing.”

That’s not just more words. It’s a qualitatively different kind of transparency that enables meaningful human oversight.

The project is completely open source. The trained models are available on Hugging Face. The training data is public. The evaluation framework is documented. The complete paper is freely accessible on Zenodo. This isn’t about creating proprietary advantage but about establishing principles that the whole research community can build on.

The Path Forward: Stages of Systematic Reasoning

The current work represents only the foundation. The research roadmap extends through multiple progressive stages, each adding sophistication while maintaining the core Nyaya epistemological grounding.

Stage 2 will scale the training data from 55 to 500 examples using carefully curated synthetic generation. The challenge isn’t just quantity but quality—ensuring every training example demonstrates genuine epistemic reasoning, not just surface pattern matching. This requires what the researchers call “high-skilled labor”: someone who understands both Nyaya philosophy and logical reasoning well enough to create valid examples. The estimated investment is about 250 hours of intensive work, highlighting that teaching AI to genuinely reason requires teaching at the level of knowledge, not just data.

Stage 3 introduces Group Relative Policy Optimization (GRPO), a reinforcement learning technique that can help the model internalize which reasoning patterns lead to reliable conclusions. The innovation here is the reward structure, which won’t just reward getting correct answers but will explicitly reward proper epistemic grounding, complete fallacy checking, and appropriate epistemic humility.

Stage 4 aims for production-hardened systems with constrained decoding that guarantees structural compliance, integration with formal verification tools like Z3 SMT solvers, and multi-agent debate protocols where multiple Nyaya-trained models verify each other’s reasoning. This is where the system becomes truly robust enough for real-world deployment.

The ultimate vision extends beyond logical reasoning to any domain requiring systematic epistemic rigor. Could Nyaya-structured models help with scientific hypothesis formation, requiring explicit grounding in observational data and theoretical principles? Could they improve legal reasoning by forcing clear articulation of precedents, statutes, and argumentation? Could they assist in medical diagnosis by maintaining rigorous separation of symptoms, test results, prior knowledge, and inferential leaps?

Getting Involved: Multiple Entry Points

The Pramana project offers several ways to engage, depending on your background and interests:

For AI/ML Researchers: The complete codebase is available on GitHub. The training infrastructure uses standard tools (QLoRA, Unsloth, vLLM) making replication straightforward. The evaluation framework provides both automated structure checking and semantic correctness metrics. You can experiment with different base models, explore alternative fine-tuning approaches, or extend the methodology to new problem domains.

For Sanskrit Scholars and Philosophers: The project needs expertise in classical Navya-Nyaya texts to ensure the computational formalization remains faithful to traditional epistemology. There are open questions about how to handle subtle distinctions in Nyaya taxonomy, how to incorporate more advanced concepts from later developments of the school, and how to bridge Indian logical traditions with other formal systems.

For Logic and Formal Methods Researchers: The integration of Z3 SMT solver for formal verification is in early stages. There are opportunities to create more sophisticated formal encodings of logical problems, develop automated verification pipelines, and explore how symbolic and neural reasoning can complement each other.

For Educators and Science Communicators: Understanding AI’s reasoning limitations and the potential of epistemological frameworks requires accessible explanation. Creating tutorials, visualizations, and demonstrations that help broader audiences grasp these concepts advances the field significantly.

Resources:

• 📄 Full Paper: Zenodo Preprint (52 pages of comprehensive technical detail)

• 💻 Code Repository: GitHub - TechNektar/pramana

• 🤗 Trained Models: Hugging Face - qbz506/nyaya-llama-3b-stage0 and qbz506/nyaya-deepseek-8b-stage1

• 📊 Training Dataset: Hugging Face - qbz506/pramana-nyaya-stage1

• 🎮 Interactive Demo: Google Colab

Rethinking AI’s Foundation

Most discussions about advancing AI reasoning focus on scaling: bigger models, more data, more compute. The implicit assumption is that reasoning will emerge naturally from sufficient pattern recognition capacity. Pramana suggests something different: that genuine reasoning requires teaching systems explicit epistemological principles, not just showing them more examples.

This isn’t an argument against scaling. Larger models with more capacity might be necessary to implement complex reasoning scaffolds. But scale alone isn’t sufficient. Without systematic methods for grounding claims in evidence, checking for errors, and maintaining epistemic humility, we get increasingly sophisticated pattern matching, not increasingly reliable reasoning.

The choice of Navya-Nyaya as the framework is significant. This isn’t cultural ornamentation applied to AI. The Nyaya system survived and evolved over two millennia precisely because it works as a practical methodology for acquiring reliable knowledge. It embeds principles that Western formal logic often separates: the integration of logic with epistemology, the emphasis on universal examples alongside abstract rules, the built-in error checking, the requirement to state epistemic confidence.

Whether Nyaya ultimately proves the best framework is less important than the broader principle: systematic epistemological structure can be learned by neural networks and provides qualitatively different reasoning capabilities than pure pattern matching. This opens pathways for integrating other rigorous reasoning traditions—Buddhist logic’s sophisticated analysis of negation, Mimamsa’s hermeneutic principles for textual interpretation, Western formal systems’ precise notation.

The work demonstrates that the path to trustworthy AI might require not just engineering but also philosophy. Not just bigger models but wiser models. Not just more data but more structured wisdom.

यत्तत्त्वज्ञानान्निःश्रेयसाधिगमः
(Yat tattva-jñānān niḥśreyasādhigamaḥ)
“Through true knowledge of these [16 elements] comes the attainment of the highest good”
— Nyaya Sutra 1.1.1

The ancient Nyaya philosophers believed that systematic reasoning was the path to liberation from false understanding. Twenty-five centuries later, as we develop artificial minds that will shape our future, perhaps their wisdom about how to achieve genuine knowledge remains as relevant as ever.

About the Author: Dr. Sharath is a Data Science & AI leader with deep expertise spanning retail analytics, industrial engineering, and aerospace technologies. Specialized in developing cutting-edge AI/ML solutions for commodity pricing and engineering optimization at bp, while leveraging decades of experience in complex systems engineering.
Previously led breakthrough innovations in aerospace technology at Indian Space Research Organisation (ISRO), developing advanced inertial navigation systems and satellite actuators. Transitioned this precision engineering mindset to GE Research, where I architected AI solutions for industrial asset optimization and led cross-functional teams in turbomachinery development.
PhD researcher and inventor with multiple patents in sustainable energy technologies, particularly focused on supercritical CO2 power systems and waste heat recovery solutions. Proven track record of translating academic research into commercial applications through collaborations with global industry leaders.
Currently driving digital transformation initiatives in retail and energy sectors, combining deep technical expertise with business acumen to deliver measurable impact (multi-million-dollar) in pricing optimization and engineering innovation.

Share this article if you found it valuable. The more researchers and thinkers engage with these ideas, the faster we can advance toward genuinely interpretable AI systems.

Join the conversation: What other philosophical or epistemological traditions might offer valuable frameworks for AI reasoning? Share your thoughts in the comments.

Special thanks to the open-source AI community and to the classical scholars who have preserved and translated the Nyaya texts that make this work possible.

🎧 Listen Now: ⁠Apple Podcasts⁠ | ⁠Spotify⁠ | ⁠Amazon Music⁠🔥 **Don't forget to like, subscribe, and hit the notification bell for more tech deep dives!**🚀 Follow ⁠TechNektar⁠ on LinkedIn for more

Disclaimer: The characters in Oscillatory Odyssey—Maya, Alex, Daniel, and Sarah—are fictional and serve as storytelling tools to illustrate complex scientific concepts in an engaging and relatable way. While their discussions are inspired by real physics and engineering principles, any resemblance to actual persons is purely coincidental. This podcast is designed for educational and entertainment purposes. The hosts are virtual presenters powered by Google NotebookLM, designed to deliver engaging and informative discussions on physics and engineering.🚀🎙️

🎧 Listen Now: ⁠Apple Podcasts⁠ | ⁠Spotify⁠ | ⁠Amazon Music⁠🔥 **Don't forget to like, subscribe, and hit the notification bell for more tech deep dives!**🚀 Follow ⁠TechNektar⁠ on LinkedIn for more

Disclaimer: The characters in Oscillatory Odyssey—Maya, Alex, Daniel, and Sarah—are fictional and serve as storytelling tools to illustrate complex scientific concepts in an engaging and relatable way. While their discussions are inspired by real physics and engineering principles, any resemblance to actual persons is purely coincidental. This podcast is designed for educational and entertainment purposes. The hosts are virtual presenters powered by Google NotebookLM, designed to deliver engaging and informative discussions on physics and engineering.🚀🎙️

🎧 Listen Now: Apple Podcasts | Spotify | Amazon Music🔥 **Don't forget to like, subscribe, and hit the notification bell for more tech deep dives!**🚀 Follow TechNektar on LinkedIn for more

Disclaimer: The characters in Oscillatory Odyssey—Maya, Alex, Daniel, and Sarah—are fictional and serve as storytelling tools to illustrate complex scientific concepts in an engaging and relatable way. While their discussions are inspired by real physics and engineering principles, any resemblance to actual persons is purely coincidental. This podcast is designed for educational and entertainment purposes. The hosts are virtual presenters powered by Google NotebookLM, designed to deliver engaging and informative discussions on physics and engineering.🚀🎙️

From the swing of a child to the gyroscopes guiding spacecraft, oscillations shape our world in ways we often overlook. This teaser introduces the journey ahead—how the same forces behind medieval cathedrals, pendulums, and space navigation all share a common physics thread.

🎧 Tune in now for an exclusive first listen. Subscribe to TechNektar: Cross-Pollinating Innovation on

Apple Podcasts ⁠https://podcasts.apple.com/us/podcast/technektar-cross-pollinating-innovation/id1796260484⁠

Spotify

https://open.spotify.com/show/1iOFoT62JGQpynlJfCCiJ1?si=cbc23eee1bec449b

Amazon Music

https://music.amazon.co.uk/podcasts/499f31ac-32d1-4bd9-b199-ccb163f3f941/technektar-cross-pollinating-innovation

to catch the full series when it drops!

🚀 Stay curious. Stay inspired. The Oscillatory Odyssey begins soon.