I built a cognitive layer for AI agents that learns without LLM calls

The problem

Every time your agent starts a conversation, it starts from zero.

Sure, you can stuff a summary into the system prompt. You can use RAG. You can call Mem0 or Zep.

But all of these have the same problem: they need LLM calls to learn. To extract facts, to build a user profile, to understand what matters — you're paying per token, adding latency, and depending on a cloud service.

What if the learning happened locally, automatically, without any LLM involvement?

What AuraSDK does differently

AuraSDK is a cognitive layer that runs alongside any LLM. It observes interactions and — without any LLM calls — builds up a structured understanding of patterns, causes, and behavioral rules.

from aura import Aura, Level

brain = Aura("./agent_memory")
brain.enable_full_cognitive_stack()

# store what happens
brain.store("User always deploys to staging first", level=Level.Domain, tags=["workflow"])
brain.store("Staging deploy prevented 3 production incidents", level=Level.Domain, tags=["workflow"])

# sub-millisecond recall — inject into any LLM prompt
context = brain.recall("deployment decision")

# after enough interactions, the system derives this on its own:
hints = brain.get_surfaced_policy_hints()
# [{"action": "Prefer", "domain": "workflow", "description": "deploy to staging first"}]

Nobody wrote that policy rule. The system derived it from the pattern of stored observations.

The cognitive pipeline

AuraSDK processes every stored record through 5 layers:

Record → Belief → Concept → Causal → Policy

Each layer is bounded and deterministic:

• Belief: groups related observations, resolves contradictions
• Concept: discovers stable topic clusters across beliefs
• Causal: finds cause-effect patterns from temporal and explicit links
• Policy: derives behavioral hints (Prefer / Avoid / Warn) from causal patterns

The entire pipeline runs in milliseconds. No LLM. No cloud. No embeddings required.

Try it in 60 seconds

pip install aura-memory
python examples/demo.py

Output:

Phase 4 - Recall in action

  Query: "deployment decision"  [0.29ms]
    1. Staging deploy prevented database migration failure
    2. Direct prod deploy skipped staging -- caused data loss

  Query: "code review"  [0.18ms]
    1. Code review caught SQL injection before merge
    2. Code review found performance regression early

5 learning cycles completed in 16ms. Recall at 0.29ms.

How it compares

	AuraSDK	Mem0	Zep	Letta
LLM required for learning	No	Yes	Yes	Yes
Works offline	Fully	Partial	No	With local LLM
Recall latency	<1ms	~200ms+	~200ms	LLM-bound
Self-derives behavioral policies	Yes	No	No	No
Binary size	~3MB	~50MB+	Cloud	Python pkg

What's new in v1.5.3

• Full 5-layer cognitive pipeline active by default
• enable_full_cognitive_stack() — one call to activate everything
• Decay now driven by memory level, not manual type labels
• Policy hints now work with explicit causal links (link_records())
• demo.py — see it working in 60 seconds

Built in Rust, from Kyiv

Pure Rust core. No Python dependencies for the engine. Patent pending (US 63/969,703).

Open source: github.com/teolex2020/AuraSDK
Install: pip install aura-memory
Web: aurasdk.dev

If you're building AI agents and want deterministic, explainable, offline-capable memory — give it a try and tell me what you think.

Comments

[klement Gunndu]

The deterministic pipeline is interesting, but how does the Belief layer handle contradictions when the agent's environment changes over time? Stale beliefs becoming policy hints seems like the hardest edge case.

[Oleksander]

Good question — this is exactly what the decay + contradiction system handles.

When new evidence contradicts an existing belief, the belief engine tracks both as competing hypotheses with confidence scores. The older one doesn't disappear immediately — it decays based on memory level (Identity decays over weeks, Working over hours). During maintenance cycles, contradiction semantic type records are preserved longer specifically for conflict analysis.

Stale beliefs reaching the policy layer is prevented by two gates: a belief must have sufficient stability score before it can seed a causal pattern, and causal patterns need minimum support count before generating policy hints. A belief that stopped receiving reinforcing evidence will decay below the stability threshold before it could produce a policy hint.

So the pipeline is: contradicting record added → competing hypothesis created → older hypothesis loses confidence → decays below stability threshold → no longer seeds causal/policy layers.

Not a perfect solution for rapid environment changes, but that's a known trade-off of the decay window tuning.