This Is Not A Chatbot.
90 seconds to understand what makes Aura different from every other AI system.
The brain doesn't optimize rewards. It minimizes surprise. So does Aura.
What You're About To See
- Real-time probabilistic cognition -- not keyword matching
- Context-indexed learning -- each sensor learns independently
- Active information seeking -- the system knows what it doesn't know
- Belief-driven policy -- actions from uncertainty, not thresholds
Why This Matters
Perception
Sensor data encoded via semantic similarity -- not keyword matching
Beliefs
Context-indexed weights -- each sensor learns independently
Policy
Actions generated from beliefs, not raw sensor data
Active Inference
System identifies what it doesn't know and requests specific data
Sensor Channels
(Click bar to spike sensor value)Semantic Distress Scoring
Active Queries
No high-uncertainty sensors -- system is confident
Policy Actions
No actions required -- all distress levels nominal
How It Actually Works
Semantic Perception
Instead of 'if temperature > 35, danger', we compute semantic similarity between sensor contexts and distress prototypes. The system understands what 'gas_concentration: 800' MEANS relative to concepts like 'acute_danger'.
Context-Indexed Learning
Each sensor context has its own weight set. When gas data arrives, only gas weights update -- not temperature, not heart rate. This prevents catastrophic forgetting.
Active Information Seeking
The model doesn't passively wait for data. It identifies beliefs with high uncertainty and generates specific perception requests. It knows what it doesn't know.
Belief-Driven Policy
Actions come from probabilistic beliefs, not sensor thresholds. Soft sigmoid activations -- everything is continuous, no discrete mode switching.
Simplified visualization of the Aura Home cognitive architecture built on Archotec. Production system uses PyTorch, semantic embeddings, and gradient-based online learning.
Controls
Speed
Parameters
Global Metrics
Free Energy
Total Uncertainty
Distress Level
Join the Waitlist for Early Access
Be among the first to try Aura — sovereign on-device AI agents
Archotec Architecture
Explore the complete cognitive architecture behind Archotec AI — 19 slides covering everything from the problem we solve to the theoretical foundations.
ARCHOTEC AI
Autonomous Cognitive Architecture
Not a chatbot. Not a wrapper. Not a prompt chain. A self-modifying cognitive agent that uses LLM as a tool.
The Problem
Regular 'AI agent' today is just an LLM with extra steps
No Real State
No real state between conversations
No Learning
No learning from experience
No Self-Modification
No self-modification, no goals, no drives
Behavior = Prompt Engineering
"Memory" = context window (disappears when you close the tab)
Decisions = Text Generation
"Decisions" = text generation with temperature sampling
This is not an agent. It's a function call.
Our Solution
Cognition Outside The LLM
Archotec separates cognition from language generation:
Perception -> Belief -> Goals -> Policy -> Planning -> ExecutionFeedback -> Memory -> LearningLLM is used in 3 places out of 15 phases—the rest is pure architecture.
Architecture
4 Layers
| Layer | Purpose | Evolvable? |
|---|---|---|
| Kernel | Cycle orchestration, safety, protocols | NO (locked) |
| Core | Cognition: perception, belief, policy, causal, evolution | YES |
| Modules | Phase implementations (hot-swappable at runtime) | YES |
| Infrastructure | LLM engines, adapters, web, monitoring | YES |
Safety Guarantee: The system can evolve any component above the Kernel. The Kernel cannot be modified by the system itself.
Hot-Swappable: Modules can be replaced at runtime without stopping the cognitive cycle.
Agent vs Chatbot
Direct Comparison
| Property | Chatbot | Archotec |
|---|---|---|
| State | Stateless | Continuous belief distribution (18 latent dims) |
| Memory | Context window | 4 memory systems: episodic, semantic, working, vector |
| Goals | None | Over 9 autonomous goals with learnable priorities |
| Drives | None | 5 drives: curiosity, consolidation, adaptation, exploration, self-assessment |
| Decisions | LLM generates text | Policy network minimizes Expected Free Energy |
| Learning | Frozen | Online meta-learning every cycle |
| Self-repair | Crash = crash | 5-step cascade, no human needed |
| New tools | Hardcoded | Discovers, installs, wraps, tests, registers autonomously |
| Causality | None | Causal graph + do-calculus + counterfactual simulation |
The Cognitive Cycle
15 Phases In Detail
Adversarial Screen
Block jailbreaks before any LLM call
Memory Retrieval
Pull relevant episodes + concepts as Bayesian prior
Perception [LLM]
Encode observation: uncertainty, intent, emotion
Belief Update
Bayesian posterior over 18 latent states
Capability Check
"Can I do this?" (skipped at low uncertainty)
Regulation
Allostatic health: am I overloaded? distressed?
Drive Injection
5 autonomous drives compute urgency from belief trends
Goal Update
Over 9 goals reprioritized from belief + drives
Policy Selection
EFE minimization -> stochastic action sampling
Planning
Counterfactual simulation (activates when uncertain)
Execution
Dispatch action via adapter/capability system
Reasoning Loop
Multi-step for complex tool actions
Feedback
Intrinsic reward computed from belief change
Memory Storage
Store episode, update semantic index
Learning
Update meta-parameters, check evolution triggers
All 15 phases have independent health monitoring. A broken phase degrades gracefully rather than crashing the cycle.
Autonomous Drives
The Agent Thinks Without Input
No external stimulus needed. The system generates its own cognitive activity:
Curiosity
Epistemic uncertainty trending up
Consolidation
Too many unsorted episodes
Adaptation
Reward declining
Exploration
Stuck in local optimum (low variance)
Self-Assessment
Haven't checked health recently
All parameters are learnable. Selection: soft inclusion gate (sigmoid) -> softmax sampling among survivors. Not argmax. Not if/else. Pure stochastic policy.
Expected Free Energy
How Decisions Are Made
Every action is scored by Expected Free Energy (EFE):
Pragmatic Value
Does it achieve my goals?
Weight: 2.0Epistemic Value
Does it reduce my uncertainty?
Weight: 1.5Safety Bonus
Is it safe?
Weight: 2.0Causal Prior
Do I know this action's effects?
Weight: 0.2Action selection is NEVER deterministic: EFE scores -> softmax with temperature -> sample from distribution. Temperature is adaptive—cools as confidence grows.
Memory
4 Persistent Systems
The agent has real memory, not a context window:
| System | Capacity | Purpose | Mechanism |
|---|---|---|---|
| Episodic | 1000 episodes | "What happened" | Importance = 0.4*access + 0.3*recency + 0.3*emotion |
| Semantic | 500 concepts | "What I know" | Graph: concepts + typed relations + strengths |
| Working | 7 items | "What I'm thinking now" | Miller's law, FIFO replacement |
| Vector | Unlimited | "Find similar" | 384-dim embeddings, cosine similarity search |
Consolidation runs autonomously: Summarize -> Degrade -> Prune. Memory persists to disk.
Capability Acquisition
The Agent Learns New Tools
The system discovers and integrates new capabilities autonomously:
| Capability | Adapter | Actions |
|---|---|---|
| Trading | Binance (testnet) | connect, get_balance, get_price, place_order |
| Web Search | DuckDuckGo | search, search_images, search_news |
| Computer | System | create_dir, list_files, read_file, list_processes, system_info |
| File Ops | Local FS | read, write, list |
| Weather | API | get_weather |
The agent decides WHEN to use each capability through belief + policy—not routing rules.
World Model
Causal Understanding
The agent doesn't just react—it models reality and reasons about causes:
Latent State Inference
- Over 18 base states + dynamic discovery of new modes
- Bayesian posterior updated every cycle
- Temporal trends tracked over 50-cycle windows
Causal Reasoning System
- CausalGraph—DAG: nodes + directed edges with strength + confidence
- Do-Calculus—Graph surgery: do(X=x) severs incoming edges
- CausalLearner—Discovers edges from observation data
- CausalPolicySynth—Wires learned causality into EFE calculator
Counterfactual Simulator
- "What if I had taken action B instead?"
- Simulates 3 steps ahead, branching factor 2
- Activates stochastically when policy is uncertain
Social Cognition
Theory of Mind
Theory of Mind
- Maintains MentalState per observed agent: beliefs, intentions, emotional_state, confidence
- Intention types: COOPERATIVE, COMPETITIVE, NEUTRAL, UNKNOWN
- Updates via Bayesian inference from observations
Empathic Resonance
- Mirrors emotional states of interaction partners
- Computes empathy signals that modulate response generation
- Threshold-based activation (0.3)—empathy engages at sufficient emotional intensity
Social Norms
- Encodes context-dependent behavioral rules
- Guides action selection toward socially appropriate responses
- Norms are learnable—they adapt from interaction outcomes
Subagent Delegation
Multi-Agent Architecture
Complex tasks get delegated to specialized subagents:
NO hardcoded rules. Delegation is an EFE-based decision. The parent agent learns when to delegate from outcomes—not from human-defined thresholds.
Evolution
The System Rewrites Itself
22 evolution modules across 4 levels:
"Did reward go up or down?"
"Which parameter CAUSED this change?"
"Are there learnable dimensions I missed?"
"Is my learning system itself broken?"
All parameters have clip bounds and auto-rollback—harmful changes revert automatically.
Safety
11 Layers of Defense
The system cannot disable its own safety:
| Layer | Mechanism | Prevents |
|---|---|---|
| Adversarial Screen | KernelRegulation (non-swappable) | Jailbreaks, prompt injection |
| Phase Constraints | Fixed cycle order | Catastrophic phase reordering |
| Allostatic Regulation | Anxiety/load thresholds | Distress spirals, cognitive overload |
| Parameter Bounds | Clip + auto-rollback | Harmful parameter changes |
| Sandbox Testing | Isolated execution | Broken evolved components |
| Evolution Cooldown | Per-module rate limiter | Evolution oscillation |
| Adaptation Monitor | L4 health tracking | Meta-learning degradation |
| Component Vault | Archived good versions | Failed evolution rollback |
| Cycle Health | Per-phase latency/error | Silent phase degradation |
| Emergency Stop | Dual-trigger kill switch | Catastrophic failure |
| Belief Checkpoint | Atomic state snapshots | Full state recovery |
Everything above the Kernel can evolve. The Kernel cannot.
Active Inference
The Theoretical Foundation
Archotec implements Active Inference (Friston, 2017):
Free Energy = Complexity (model diverges from prior) − Accuracy (model predicts observations)Perception
Update beliefs to better predict observations (reduce surprise)
Action
Change the world to match expectations (reduce prediction error)
Learning
Improve the model itself (reduce long-term free energy)
BeliefUpdate = Bayesian posterior (variational inference)GoalSystem = preferred observations (prior preferences)PolicyNetwork = EFE minimization (action selection)FeedbackLoop = prediction error computationMetaLearner = hyperparameter optimization of the generative modelNot a metaphor. The code implements the equations.
Real System Output
What Autonomous Thinking Looks Like
System starts, no human input. This is what happens:
[20:29:04] ActiveInferenceAgent initialized (42 components)[20:29:04] AutonomousDrive initialized: threshold=0.6, drive_lr=0.02[20:29:04] Starting main cognitive loop...[20:29:25] Goals updated: MAINTAIN_IDENTITY=1.00, LEARN_AND_ADAPT=1.00, EXPAND_CAPABILITIES=0.93, REDUCE_UNCERTAINTY=0.27[20:29:25] Capability-driven execution: trading (target=binance, method=connect)[20:29:25] Adapter execution completed via execute_action fallback[20:29:34] Ollama response received in 8.6s "Your brain is feeling quite relaxed..."[20:29:34] Learned from outcome: trading:binance success=True, p=0.984, u=0.090[20:32:36] Checkpoint saved: cp_100 (cycle 100)
Goals, decisions, executions, learning—all happening without human input.
What's Next
Roadmap
Working Now
- Full 15-phase cognitive cycle with autonomous drives
- Belief-driven policy (EFE + ActorCritic + causal synthesis)
- 4 memory systems with autonomous consolidation
- Self-repair cascade (5 steps)
- Capability acquisition pipeline (discover -> integrate -> use)
- World model with causal graph + do-calculus + counterfactuals
- Social cognition (Theory of Mind, empathy, social norms)
- Subagent delegation framework
- 11-layer safety architecture
Next
- Predictive evaluation — simulate parameter changes in world model before applying
- Multi-agent deployment — multiple Archotec instances collaborating
- Real-time trading execution via Binance adapter
- Stronger local LLM for code evolution (DeepSeek-Coder, Qwen-Coder)
- Long-running autonomous experiments (24h+)
Why This Matters
The Bottom Line
LLMs are tools, not agents.
Making them bigger doesn't give them goals, memory, drives, or self-modification.
Real autonomy requires real cognition.
Not prompt chains. Not RAG. Not tool-calling frameworks. Beliefs, drives, causal reasoning, actions under uncertainty, learning from outcomes—every cycle, forever, without human input.
Safety cannot be prompt-engineered.
It requires non-evolvable architectural layers that the system physically cannot modify, disable, or evolve away.
Archotec is not a smarter chatbot. It is the cognitive architecture that turns LLMs into autonomous agents.
Explore the source code and contribute
View on GitHub