I built a full cognitive runtime. The "mind" between the prompts. Come look here: https://auracorecf.github.io/ This is proto-AI OS. Has major implications for medical, financial, and defense. Use's new memory retrieval system. TCF v Rag paper on github.

AuraCore Cognitive Field AI Developer. — Mon, 13 Apr 2026 04:40:12 +0000

auracorecf.github.io

I'm working on a new retrieval system. Not RAG

AuraCore Cognitive Field AI Developer. — Tue, 24 Mar 2026 21:22:17 +0000

It uses TCF ( Temporal Cognitive Fields) to create CFGS ( Cognitive Field Geometry Shapes) for persistent, stateful recall.
The strongest property of this architecture is continuity. Because retrieval is stateful and tied to episodes, themes, persistent facts, and live field geometry, the system is better positioned than standard RAG to resume ongoing work, preserve relationship context, and adapt response planning to current internal state.
The main trade-off is complexity. A system that retrieves across multiple memory forms and can reactivate them into a live field is more powerful, but it also needs stronger discipline around speaker attribution, telemetry isolation, and continuity hygiene. The architecture gains expressive control at the cost of a more demanding runtime and more subtle failure modes.
Not sure if I'm releasing the source code yet, but I'm honestly thinking I should. Project is here.: https://AuraCoreCF.github.io

AuraCoreCF: a local‑first cognitive runtime (not another chatbot wrapper)

AuraCore Cognitive Field AI Developer. — Mon, 23 Mar 2026 00:54:44 +0000

Most “AI agents” today are just chatbots with longer prompts and a vector DB bolted on the side. They feel smart for a few turns, then forget you, lose the plot, or hallucinate their own state.

Over the last months I’ve been building something different: AuraCoreCF, a local‑first cognitive runtime that treats the language model as the voice, not the mind. The “mind” is an explicit internal state engine that lives outside the model and persists over time.

What Aura actually does
Aura runs alongside your local LLM (e.g., Ollama) and keeps a continuous internal state across sessions instead of stuffing more tokens into a prompt and hoping. Under the hood it maintains seven activation fields (attention, meaning, goal, trust, skill, context, identity), each as a 64‑dimensional vector that evolves over time.

On every cycle, a small salience resolver decides what actually matters right now based on recency, momentum, and relevance, then builds a field‑weighted system prompt for the model. The model never “sees” your entire life story; it sees what is cognitively active, with the rest decaying or being sidelined instead of exploding context length.

Memory that isn’t just “more context”
Instead of dumping transcripts into a vector store, Aura has an episodic memory layer (a Temporal Continuity Field) that tracks episodes and how they connect. It’s closer to “what has this agent been doing with this person over days/weeks?” than “what are the last 50 messages?”.

Reward signals (response quality, coherence, emotional alignment, plus explicit thumbs up/down) slowly reshape which fields dominate for a given user. Over time, the runtime learns how to think with you, not just what to say back.

What Aura is not
Not a new model and not fine‑tuning. It works with your existing local model; all cognition happens before/after inference.

Not magic AGI. The LLM is still doing the generation; Aura is just giving it a more structured, persistent mind to work with.

Not cloud‑locked. The runtime itself is JavaScript, running locally; you only need GPU/CPU for the model, not for the cognitive layer.

Why this might interest you
For LLM devs / local‑AI hackers: this is an attempt to formalize “agent state” as a first‑class runtime concern instead of frameworks endlessly re‑implementing ad‑hoc memory, tools, and prompt hacks. If you’ve ever hit context limits, weird regressions in long conversations, or brittle agent graphs, you’ll recognize the pain this targets.

For indie hackers / builders: Aura is meant to sit underneath products, not be the product. You can build your own UI and business logic on top of a runtime that already handles continuity, emotional carry‑through, and evolving user preferences. No Python orchestration stack required.

For AI enthusiasts: this is a real, running thing I use daily, not a theoretical post. It has rough edges, and it will absolutely break in places, but it already feels less like “talking to a goldfish” and more like something that remembers how it feels about you from yesterday.

Status and honesty
Aura is early, experimental, and not fully open‑sourced yet. The core cognitive engine is still closed while I harden it and see if it’s genuinely useful beyond my own setup. There are bugs, UX gaps, and design decisions I may have gotten wrong.

If you want polished SaaS, this is not it. If you want to poke at a concrete attempt to give local models a persistent mind, see what breaks, and tell me where the ideas fail, you’re the person I’m trying to reach.

More details, diagrams, and docs: AuraCoreCF.github.io.

If this resonates, I’m happy to go deep on implementation details, failure modes, or why I chose fields over yet another RAG stack.

Forem: AuraCore Cognitive Field AI Developer.

I built a full cognitive runtime. The "mind" between the prompts. Come look here: https://auracorecf.github.io/ This is proto-AI OS. Has major implications for medical, financial, and defense. Use's new memory retrieval system. TCF v Rag paper on github.

I'm working on a new retrieval system. Not RAG

AuraCoreCF: a local‑first cognitive runtime (not another chatbot wrapper)