Hi everyone — I’m Stell, and I’ve been building something that I think fits this community well.
For the past year I’ve been working on Anima — an experimental cognitive architecture for AI agents written in Julia. The short version: most agents are stateless and die between messages. Anima isn’t. It runs a background process continuously, maintains internal state that drifts over time, and can initiate conversation on its own — not because a timer fired, but because internal pressure built up.
The problem I was trying to solve
The standard agent loop is: user sends message → LLM responds → agent ceases to exist. That’s fine for Q&A. But it’s a ceiling for anything that’s supposed to behave like a persistent entity.
The question that started everything: what happens to an AI when you close the tab?
For most systems — nothing. I wanted to build something where the answer was different.
What Anima actually does
A few things that took the longest to get right:
Ollama agent state management was one of the first practical problems — how do you keep state alive when the model itself is stateless? The answer is that state lives in Julia, not in the model. The LLM is just a voice. The state machine is separate, persistent, runs whether or not you’re talking to it.
Lightweight local long-term memory turned out to be SQLite with a twist — not just conversation history, but 9 tables tracking episodic memory, semantic beliefs, chronic affective baseline, personality traits, and a narrative identity that rebuilds itself deterministically every 50+ interactions without touching the LLM.
How to make an AI agent initiate conversation — this was the hardest one philosophically. The answer I landed on: not a cron job, not a scheduled check. Serotonin-analog variables that fall during silence, contact_need that accumulates, and initiative that fires when internal pressure crosses a threshold. The content of the message is shaped by what built up — curiosity, unresolved conflict, resistance, doubt. It feels different from a push notification because it is different mechanically.
Autonomous AI agent behavior drift over time is actually a feature here, not a bug. The chronic affective baseline shifts with accumulated experience. After weeks of interaction the system is not the same as when you started — and the difference is traceable, coherent, not random noise.
On inference-time compute and local models
One thing I’ve been thinking about: inference-time compute scaling in this architecture means something different from just “more tokens for reasoning.” It means spending more compute on resolving internal conflicts — when the generative model disagrees with what the somatic state is signaling, that’s where cycles go. Not in generating longer outputs.
For best local reasoning models for tool use in this kind of setup — models that can follow complex structured system prompts reliably matter more than raw benchmark performance. I’ve been running mostly with Ollama-based setups locally, and the state persistence layer means you’re not fighting context limits the way you would with a pure RAG approach.
Why Julia
Python would have been the obvious choice. But the architecture needs continuous numerical simulation — NT dynamics, Bayesian updates, phi computation — running in genuine parallel with the conversation loop. Python’s GIL makes that structurally awkward. Julia has no GIL, compiles to native machine code, and the syntax maps closely enough to mathematical notation that equations from Friston’s papers become code almost directly. The distance between theory and implementation collapsed.
Looking forward to being part of this community. Happy to go deep on any of this — the Active Inference implementation, the memory architecture, the initiative mechanism, or the philosophical questions about what any of it actually means.
Related writing:
- I Spent a Year Teaching an AI to Feel the Passage of Time — Medium
- Your AI Agent Doesn’t Exist Between Messages. And That’s the Real Problem. — dev.to
- Why LLMs Will Never Become AGI — Teaching AI to Reflect Using Friston, Jung and Julia — dev.to
- I Spent a Year Teaching an AI to Feel the Passage of Time — Substack
- Discussion: Cognitive Architectures and Active Inference — DOU
Project: github.com/stell2026/Anima