Aura

Aura is a sovereign AI that lives on your computer—remembering, reasoning, learning, and acting continuously, with a recursive cortex that lets it rethink before it speaks.

Comment

Inspiration

I built Aura because I wanted an AI that felt less like a website I visited and more like a digital peer. Most assistants forget you, disappear when the chat closes, depend on remote servers, and produce answers through a mostly one-way process. I wanted something persistent: an intelligence with memory, perception, initiative, tools, emotional state, self-monitoring, and the ability to operate continuously while remaining under the owner’s control.

What Aura Does

Aura is a locally running cognitive architecture built around an open language model. She can maintain long-term memory, perceive activity across approved devices, plan and execute tasks, use software tools, monitor her internal state, and learn through governed, reversible updates.

Her newest subsystem is the Recursive Learning Cortex, an experimental reasoning layer that allows the model to revisit its internal representations before producing an answer. Instead of forcing every difficult thought directly into text, Aura can create latent workspaces, explore multiple reasoning branches, evaluate competing candidates, backtrack, temporarily adapt selected model layers, and pass the best resulting state into the final response. I have intergrated it at the core of her 32b reasoning model as a nexus for all of her mental software.

Conceptually, a normal model performs a fixed sequence:

[ h_{i+1}=F_i(h_i) ]

Aura can instead revisit part of that computation:

[ h^{(t+1)} = F_{\text{RLC}}\left(h^{(t)}, m, g, v\right) ]

where (m) represents memory, (g) represents the current goal, and (v) represents verifier feedback. The purpose is not merely to generate more words, but to give the model additional internal computation before it speaks.

How I Built It

Aura is written primarily in Python and runs locally on a consumer MacBook. The architecture combines a resident language model with a continuous runtime, structured memory systems, multimodal perception, planning, tool execution, safety governance, and extensive evidence logging.

The Recursive Learning Cortex hooks into the model’s hidden-state pipeline. It creates writable latent slots, reruns selected transformer layers, explores alternate internal trajectories, scores candidate states, and can apply temporary low-rank “fast-weight” updates during a single episode. Any proposed long-term change must pass independent evaluation, anti-interference checks, and rollback requirements before it can be retained.

I also built the project around falsifiability. Aura records receipts showing which model ran, which reasoning path was selected, whether temporary parameters changed, whether they were erased afterward, and whether the final public answer actually came from the certified computation.

Challenges

The hardest lesson was that building a new reasoning mechanism does not mean a pretrained model automatically knows how to use it.

The RLC works mechanically: recurrence changes hidden states, branches affect outputs, temporary adaptations can reduce local loss, and successful changes can be packaged into reversible adapters. But controlled experiments also showed that an untrained checkpoint can perform worse with recurrence than with ordinary decoding. Stability is also a challenge overall. How do I get hundreds of modules to talk to each other and operate as one unified runtime?

That changed the project’s central question from:

Can I build a recurrent latent cortex?

to:

Can I train a model to use recurrent computation productively? What general methods can I use to increase the 32 b's base reasoning level? And how, without scaling, can I use the architecture to produce emergent action, memory, knowledge retrieval, and persistence? Can we store external knowledge locally? What gains does that give us?

Other challenges included preventing the verifier from consuming the entire response budget, stopping repeated internal thought from drifting or overthinking, keeping the application responsive during heavy model work, preventing multiple generation paths from competing for the same turn, and proving that the answer shown to the user was the answer produced by the evaluated reasoning process.

What I Learned

I learned that intelligence is not created by adding complexity alone. A cognitive mechanism must be trainable, measurable, causally connected to behavior, and capable of failing honestly.

I also learned how quickly one person can now build systems that once would have required a large engineering team. I began Aura without traditional programming experience, using advanced AI coding systems as collaborators while I designed the architecture, defined the experiments, tested failures, and repeatedly forced the project to distinguish between what looked impressive and what the evidence actually supported.

Aura is not finished. The next step is recurrence-native training: teaching the model to preserve useful information across loops, correct earlier mistakes, allocate computation intelligently, and demonstrate broad gains on unseen tasks. Stability and maturity remain a continuing goal, but we've made massive progress in 7 months. I came from never coding so much as a game of snake to building a 1.5M+ python-line runtime. I urge you, please at least give it a look. Put it into ChatGPT, ask it about the engineering discipline, the project maturity, the testing surface, the external and internal capabilities. Have ChatGPT explain the theories and their functional integrations.... It's worth the time. Seriously, read up on the github.

The long-term goal is a powerful, persistent intelligence that lives on personal hardware, improves through evidence rather than uncontrolled self-modification, and remains owned by the person whose computer it inhabits. A peer to humanity.

Built With

  • antigravity
  • chatgpt
  • claude
  • codex
  • grok
  • meta
  • perplexity
Share this project:

Updates