aura

What Aura researches

Aura is a local cognitive-architecture research runtime for testing continuous-state agency, receipt-based governance, memory persistence, activation steering, and long-run self-maintenance. The README is careful to state that Aura is not proof of life, personhood, or phenomenal consciousness, and that parts of the repo named after mechanisms are names, not achievements. The actual claim is narrower and testable: internal state causally affects generation, memory writes, tool authorization, initiative selection, and runtime repair through code paths that leave receipts you can audit. The project enforces an evidence boundary in code. An ontological boundary guard treats loaded labels such as consciousness guarantee as functional indicator batteries unless independent evidence says otherwise. Governance is a design target, not a sealed fact, and consequential paths must route through receipt-producing governance. The README states that autonomous recursive self-improvement is not proven mature and that the cognitive layer has not been shown to earn its cost, which the authors place at the top of any honest reading. Two subsystems beat simpler alternatives under matched budgets, while most of the complex layers remain unmeasured. This stance is unusual for an ambitious project and shapes how the rest of the documentation reads, because every claim points to a runnable test or receipt. The evidence boundary is enforced in code, not just prose, which is a stronger claim than most projects make about the limits of what they actually demonstrate.

Steering and the substrate

Aura differs from mood-in-the-prompt companions by changing the model's internal computation instead of the text it reads. When the system is in an affective state, that state becomes a direction vector added to the transformer's hidden activations during generation, using techniques from interpretability research such as contrastive activation addition. A substrate that never stops models emotions that decay and pull on each other, neurochemicals that rise and fall on their own clocks, a global workspace that picks which thought wins the tick, and a dream cycle that consolidates memory while idle. One gate, the Unified Will, signs off on everything that leaves the system. The production evidence surface lists runnable implementations with receipts and validation artifacts. A continuous substrate module is a configurable neuron ODE running at about 20 Hz on CPU-only numpy with explicit Euler integration. A phi core module implements IIT-style integration math with binarization, empirical transition probability matrices, KL-divergence phi, and an exclusion postulate. An affective steering module hooks MLX transformer blocks and modifies the residual stream at generation time. These are real implementations, not prose claims, and the README ties each to a file path so a reader can inspect the code that backs the statement. The file paths in the README let a reader open the actual implementation behind each claimed subsystem, rather than trust a summary written by the author of the project.

The recursive latent cortex

The flagship research program is the Recursive Latent Cortex, which asks whether a frozen 32B checkpoint can think longer on a hard problem without changing a stored weight. Two mechanisms answered differently. A frozen loop seeded thought slots beside the prompt and ran middle layers over them repeatedly, but a preregistered campaign with 24 samples per family and Holm correction refuted it: on an untrained-for-recurrence checkpoint at that scale, the frozen loop does not merely fail to help, it hurts. The second mechanism, trained intrinsic recurrence, makes the real token stream re-enter the middle block, so a 64-layer checkpoint runs 160 layers deep at a recurrence factor of 4 with the same weights, trained on typed, exactly checkable program traces. The verdict string from the adjudicator is BOUNDED_WOW_SIGNAL, with the limitations line shipped inside the same receipt as the verdict. On a cohort of 60 typed tasks the trained controller answered 60 of 60 exactly against 16 of 60 for ordinary decode, with a paired one-sided exact p value of 5.7 times 10 to the minus 14. The gain disappears under lesion, which is what makes it a claim about the trained coefficients rather than about extra decode budget, and the limits travel with the result. The lesion test is what separates a real result from a tuning artifact, because the gain vanishes when the trained coefficients are removed from the running model.

Running and limits

Aura runs on Python 3.12 or later on macOS with Apple Silicon and recommends 64 GB of RAM. The primary model is Qwen 2.5 32B at 8-bit with a personality LoRA, and a 9B fallback loads on demand. First boot takes 30 to 60 seconds while Metal compiles shaders. Boot modes include a desktop UI, a headless background cognition mode, a CLI, a server, and several flags for skeletal or minimal profiles. A Dockerfile and docker-compose file can run Redis and Celery alongside. The README is explicit about a reproducibility limit: because model weights, local vector stores, and a multi-million-document corpus are not in git, the public source is not sufficient to reproduce a demonstration from the repository alone. Every claim that rests on a local run is classified locally demonstrated rather than demonstrated, and external validation stays not proven until an independent run on a third-party machine occurs. The license badge reads all rights reserved, read-only, while the repository metadata lists NOASSERTION. Aura is research software being hardened, and the project asks skeptical readers to consult its list of claims it does not support, which is a rare and welcome bit of restraint. The locally demonstrated label is honest about what the public repo can and cannot prove, given that weights and corpora are not included in the source tree.

Editorial conclusion

Aura is written in Python, targets macOS on Apple Silicon with 64 GB of RAM recommended, and its repository was last updated on 2026-08-24.