Aura Memory

Aura turns fragile prompt-only agents into auditable, memory-aware, production-ready systems

Deterministic · No fine-tuning · No cloud training · <1ms recall · ~3 MB

Your AI model is smart. But it forgets everything after every conversation.

Aura is a local cognitive runtime that runs alongside any frozen model. It gives agents durable memory, explainability, governed correction, bounded recall reranking, and bounded self-adaptation through experience — all locally, without fine-tuning or cloud training.

pip install aura-memory

from aura import Aura, Level

brain = Aura("./agent_memory")
brain.enable_full_cognitive_stack()  # activate all four bounded reranking overlays

# 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"])

# recall — local retrieval with optional bounded cognitive reranking
context = brain.recall("deployment decision")  # <1ms, no API call

# inspect advisory hints produced from stored evidence
hints = brain.get_surfaced_policy_hints()
# → [{"action": "Prefer", "domain": "workflow", "description": "deploy to staging first"}]

No API keys. No embeddings required. No cloud. The model stays the same — the cognitive layer becomes more structured, more inspectable, and more useful over time.

⭐ If Aura is useful to you, a GitHub star helps us get funding to continue development from Kyiv.

Why Aura?

	Aura	Mem0	Zep	Cognee	Letta/MemGPT
Architecture	5-layer cognitive engine	Vector + LLM	Vector + LLM	Graph + LLM	LLM orchestration
Derived cognitive layers without LLM	Yes — Belief→Concept→Causal→Policy	No	No	No	No
Advisory policy hints from experience	Yes — bounded and non-executing	No	No	No	No
Learns from agent's own responses	Yes — bounded, auditable, no fine-tuning	No	No	No	No
Salience weighting	Yes — what matters persists longer	No	No	No	No
Contradiction governance	Yes — explicit, operator-visible	No	No	No	No
LLM required	No	Yes	Yes	Yes	Yes
Recall latency	<1ms	~200ms+	~200ms	LLM-bound	LLM-bound
Works offline	Fully	Partial	No	No	With local LLM
Cost per operation	$0	API billing	Credit-based	LLM + DB cost	LLM cost
Binary size	~3 MB	~50 MB+	Cloud service	Heavy (Neo4j+)	Python pkg
Memory decay & promotion	Built-in	Via LLM	Via LLM	No	Via LLM
Trust & provenance	Built-in	No	No	No	No
Encryption at rest	ChaCha20 + Argon2	No	No	No	No
Language	Rust	Python	Proprietary	Python	Python

The Core Idea: Cheap Model + Aura > Expensive Model Alone

Fine-tuning costs thousands of dollars and weeks of work. RAG requires embeddings and a vector database. Context windows are expensive per token.

Aura gives you a third path: a local cognitive runtime that accumulates structured experience between conversations — free, local, sub-millisecond.

Week 1: GPT-4o-mini + Aura                Week 1: GPT-4 alone
  → average answers                          → average answers

Week 4: GPT-4o-mini + Aura                Week 4: GPT-4 alone
  → recalls your workflow                    → still forgets everything
  → surfaces patterns you repeat             → same cost per token
  → exposes explainability + correction      → no improvement
  → boundedly adapts from experience         → no durable learning
  → $0 compute cost                          → still billing per call

The model stays the same. The cognitive layer gets stronger. That's Aura.

Performance

Benchmarked on 1,000 records (Windows 10 / Ryzen 7):

Operation	Latency	vs Mem0
Store	0.09 ms	~same
Recall (structured)	0.74 ms	~270× faster
Recall (cached)	0.48 µs	~400,000× faster
Maintenance cycle	1.1 ms	No equivalent

Mem0 recall requires an embedding API call (~200ms+) + vector search. Aura recall is pure local computation.

What Ships Today

Aura's full cognitive recall pipeline is active and bounded:

Record → Belief (±5%) → Concept (±4%) → Causal (±3%) → Policy (±2%)

Enable everything in one call:

brain.enable_full_cognitive_stack()   # activates all four bounded reranking phases
brain.disable_full_cognitive_stack()  # back to raw RRF baseline

Or configure individual phases:

brain.set_belief_rerank_mode("limited")   # belief-aware ranking
brain.set_concept_surface_mode("limited") # concept annotations + bounded concept reranking
brain.set_causal_rerank_mode("limited")   # causal chain boost
brain.set_policy_rerank_mode("limited")   # policy hint shaping

Higher layers also expose advisory surfaced output:

get_surfaced_concepts() — stable concept abstractions over repeated beliefs
get_surfaced_causal_patterns() — learned cause→effect patterns
get_surfaced_policy_hints() — advisory recommendations (Prefer / Avoid / Warn)
no automatic behavior influence — all output is advisory and read-only

Aura also ships operator-facing and plasticity-facing surfaces:

explainability:
- explain_recall()
- explain_record()
- provenance_chain()
- explainability_bundle()
governed correction:
- targeted retract/deprecate APIs
- persistent correction log
- correction review queue
- suggested corrections without auto-apply
bounded autonomous plasticity:
- capture_experience()
- ingest_experience_batch()
- maintenance-phase integration
- anti-hallucination guards
- plasticity risk scoring
- purge / freeze controls
bounded v6 cognitive guidance:
- salience:
  - mark_record_salience()
  - get_high_salience_records()
  - get_salience_summary()
- reflection:
  - get_reflection_summaries()
  - get_latest_reflection_digest()
  - get_reflection_digest()
- contradiction and instability:
  - get_belief_instability_summary()
  - get_contradiction_clusters()
  - get_contradiction_review_queue()
- honest explainability support:
  - unresolved-evidence markers in recall explanations
  - bounded answer-support phrasing for agent / UI layers

How Memory Works

Aura organizes memories into 4 levels across 2 tiers. Important memories persist, trivial ones decay naturally:

CORE TIER (slow decay — weeks to months)
  Identity  [0.99]  Who the user is. Preferences. Personality.
  Domain    [0.95]  Learned facts. Domain knowledge.

COGNITIVE TIER (fast decay — hours to days)
  Decisions [0.90]  Choices made. Action items.
  Working   [0.80]  Current tasks. Recent context.

SEMANTIC TYPES (modulate decay & promotion)
  fact          Default knowledge record.
  decision      More persistent than a standard fact. Promotes earlier.
  preference    Long-lived user or agent preference.
  contradiction Preserved longer for conflict analysis.
  trend         Time-sensitive pattern tracked over repeated activation.
  serendipity   Cross-domain discovery record.

One call runs the lifecycle — decay, promotion, consolidation, and archival:

report = brain.run_maintenance()  # background memory maintenance

Key Features

Immutable Evidence Lineage

Aura's cognitive provenance explains how a memory was formed and used. The evidence substrate additionally binds an extracted claim to the exact bytes of an immutable source revision:

use aura::{admission_decision, verify_lineage, AnswerPermission, EvidenceClaim,
           SourceDocument, SourceSpan, VerificationStatus};

let bytes = b"Verified value: 42";
let document = SourceDocument::from_bytes("report", "v1", "file:///report.txt", bytes);
let span = SourceSpan::from_document(&document, bytes, 0, bytes.len())?;
let integrity = verify_lineage(&document, bytes, &span);

VerificationStatus and AnswerPermission are independent gates. A high confidence score never overrides a changed source hash, a superseded claim, or a blocked citation. New Record fields remain backward-compatible with older serialized records.

Evidence-aware research reports are composed only from admitted findings. Free-form synthesis is omitted until the synthesis itself can carry claim-level lineage, preventing blocked source material from being reintroduced indirectly.

Context Capsules

Agents can request a deterministic hot-context projection without maintaining a separate wiki or mutating memory through recall activation:

capsule = brain.build_context_capsule(
    purpose="continue the current institute research",
    token_budget=2000,
    namespace="ask-institute",
)

The bounded capsule prioritizes refutation scars, open evidence debt, active goals, contradictions, outcomes, decisions, and durable domain/identity records. It returns an estimated token count, omitted-record count, selection reasons, and a stable content hash. Blocked records and superseded versions outside their validity interval are never surfaced.

Temporal Memory Versioning

Context answers what an agent needs now; memory also needs to preserve which version of a fact was valid at a particular time. Aura records business-time validity separately from the system time at which a replacement was recorded:

old_id = brain.store(
    "The refund window is 30 days",
    namespace="shop-a",
    valid_from=1_735_689_600,
)
new_id = brain.supersede(
    old_id,
    "The refund window is 14 days",
    namespace="shop-a",
    effective_at=1_751_328_000,
)

historical = brain.recall_as_of(
    "refund window",
    timestamp=1_743_811_200,
    namespace="shop-a",
)

Validity intervals are half-open: valid_from <= time < valid_until. Ordinary recall, search, and context capsules return only records valid now; expired and future versions remain available for audit through get(), history(), version_chain(), and recall_as_of(). recall_at() retains its system-time knowledge cutoff, while recall_as_of() answers the business-time question using everything Aura knows now. Namespace isolation applies to both paths. Supersession is committed as one durable cognitive-journal frame: the old validity boundary, successor, and causal links either replay together or do not apply. On startup Aura also repairs the pending marker written by older releases after an interrupted replacement.

Inspectable Memory Decisions

explain_recall() uses the same retrieval and bounded-reranking pipeline as normal recall, but does not activate or mutate records. In addition to the selected items and their existing score/provenance traces, it reports relevant candidates rejected by memory gates:

decision = brain.explain_recall(
    "refund window",
    top_k=5,
    namespace="shop-a",
)

print(decision["trace_id"])
print(decision["decision_summary"]["rejection_counts"])
for candidate in decision["rejected_candidates"]:
    print(candidate["record_id"], candidate["reasons"])

Current rejection reasons are expired, not_yet_valid, invalid_temporal_bounds, below_strength_threshold, outside_top_k, and suppressed_by_belief_resolution. For belief competition, selected and rejected entries expose the candidate hypothesis, winning hypothesis, both scores, and whether the record belongs to the winning side. Rejected output is bounded and includes omission counts. Candidate discovery is performed only inside the requested namespace scope: records belonging to another tenant are never represented in the trace, even by ID. The generated memory_trace_id, selected count, and rejected count are also attached to the existing OpenTelemetry span without logging the query or record contents.

Governed Promotion and Contradiction Safety

Memory level controls retention, not truth. Aura therefore uses one governed policy for automatic reflection and promotion-candidate surfaces:

Working records may graduate to Decisions through repeated use.
Promotion into Domain or Identity pauses when a record is an explicit contradiction, carries conflict mass, or has volatility of 0.20 or more.
Domain-to-Identity promotion additionally requires at least 20 activations and 0.90 strength.
Expired and not-yet-valid versions are never promoted.

During maintenance, conflict and volatility are refreshed before promotion. Explicit contradicts/conflict links form competing belief hypotheses rather than collapsing both sides into one bucket. Hypothesis recency uses business validity (valid_from) or creation time—not last_activated—so retrieving a stale rule cannot make its evidence fresh again. When a belief is resolved, the winning hypothesis is admitted to current recall and the losing side stays available through history and explain_recall() as suppressed evidence. Aura only resolves an explicit conflict graph as two competing sides when the graph is one connected bipartite component. Odd cycles, multiple independent components, isolated claims, and conflict sets without a defensible binary topology remain Unresolved; no record receives a synthetic winning vote.

Use promotion_block_reason(record_id) to inspect why a record cannot advance. For a genuine rule replacement, prefer supersede(..., effective_at=...); use an explicit contradicts relationship when both claims must remain auditable as competing evidence.

Core Cognitive Runtime

Fast Local Recall - Multi-signal ranking with optional embedding support
Two-Tier Memory — Cognitive (ephemeral) + Core (permanent) with decay, promotion, and archival
Semantic Memory Types — 6 roles (fact, decision, trend, preference, contradiction, serendipity) that influence memory behavior and insighting
Phase-Based Insights — Detects conflicts, trends, preference patterns, and cross-domain links
Background Maintenance — Continuous memory hygiene: decay, reflect, insights, consolidation, archival
Namespace Isolation — namespace="sandbox" keeps test data invisible to production recall
Pluggable Embeddings - Optional embedding support: bring your own embedding function

Trust & Safety

Trust & Provenance — Source authority scoring: user input outranks web scrapes, automatically
Source Type Tracking — Every memory carries provenance: recorded, retrieved, inferred, generated
Auto-Protect Guards — Detects phone numbers, emails, wallets, API keys automatically
Encryption — ChaCha20-Poly1305 with Argon2id key derivation

Adaptive Memory

Feedback Learning — brain.feedback(id, useful=True) boosts useful memories, weakens noise
Temporal Semantic Versioning — brain.supersede(old_id, new_content, effective_at=...) with validity intervals and full version chains
Snapshots & Rollback — brain.snapshot("v1") / brain.rollback("v1") / brain.diff("v1","v2")
Agent-to-Agent Sharing — export_context() / import_context() with trust metadata

Enterprise & Integrations

Multimodal Stubs — store_image() / store_audio_transcript() with media provenance
Prometheus Metrics — /metrics endpoint with 10+ business-level counters and histograms
OpenTelemetry — telemetry feature flag with OTLP export and 17 instrumented spans
MCP Server — Claude Desktop integration out of the box
WASM-Ready — StorageBackend trait abstraction (FsBackend + MemoryBackend)
Pure Rust Core — No Python dependencies, no external services

Advisory Cognitive Overlays

Belief-Aware Recall Rerank — bounded production influence with strict guardrails
Concept Overlay — surfaced concepts, per-record annotations, and optional bounded concept-aware reranking
Causal / Policy Overlays — advisory surfaced output only, no automatic control path
Cross-Namespace Analytics — read-only digest for tags, concepts, structural overlap, and canonical causal signatures across namespaces

Explainability & Governed Adaptation

Explainability APIs — inspectable selected/rejected decisions through explain_recall(), plus explain_record(), provenance_chain(), and explainability_bundle()
Correction Governance — correction log, correction review queue, suggested corrections, namespace governance status
Autonomous Cognitive Plasticity — extraction → ingest → maintenance loop for bounded self-adaptation without changing model weights
Plasticity Safety Bounds — generated-confidence ceiling, risk throttling, purge/freeze controls, operator-visible risk state

Cognitive Guidance

Salience Layer — bounded significance weighting for preservation, reminders, ranking, and operator review
Maintenance Reflection — bounded reflection summaries and digests produced inside the normal maintenance pipeline
Contradiction Governance — instability summaries, contradiction clusters, and bounded operator review queues for unresolved evidence
Honest Answer Support — non-anthropomorphic phrasing hints for significance, uncertainty, contradiction, and reflection context

Quick Start

Trust & Provenance

from aura import Aura, TrustConfig

brain = Aura("./data")

tc = TrustConfig()
tc.source_trust = {"user": 1.0, "api": 0.8, "web_scrape": 0.5}
brain.set_trust_config(tc)

# User facts always rank higher than scraped data in recall
brain.store("User is vegan", channel="user")
brain.store("User might like steak restaurants", channel="web_scrape")

results = brain.recall_structured("food preferences", top_k=5)
# -> "User is vegan" scores higher, always

Pluggable Embeddings (Optional)

from aura import Aura

brain = Aura("./data")

# Plug in any embedding function: OpenAI, Ollama, sentence-transformers, etc.
from sentence_transformers import SentenceTransformer
model = SentenceTransformer("all-MiniLM-L6-v2")
brain.set_embedding_fn(lambda text: model.encode(text).tolist())

# Now "login problems" matches "Authentication failed" via semantic similarity
brain.store("Authentication failed for user admin")
results = brain.recall_structured("login problems", top_k=5)

Without embeddings, Aura continues to use its local recall pipeline - still fast, still effective.

Encryption

brain = Aura("./secret_data", password="my-secure-password")
brain.store("Top secret information")
assert brain.is_encrypted()  # ChaCha20-Poly1305 + Argon2id

Semantic Memory Types

brain = Aura("./data")

# Decisions are treated as higher-value memory
brain.store("Use PostgreSQL over MySQL", semantic_type="decision", tags=["db"])

# Preferences persist longer than generic working notes
brain.store("User prefers dark mode", semantic_type="preference", tags=["ui"])

# Contradictions are preserved for conflict analysis
brain.store("User said vegan but ordered steak", semantic_type="contradiction")

# Search by semantic type
decisions = brain.search(semantic_type="decision")

# Cross-domain insights surface higher-level patterns
insights = brain.insights(phase=2)
# Example:
# [{'insight_type': 'preference_pattern', 'description': 'Preference cluster around ui', ...}]

Namespace Isolation

brain = Aura("./data")

brain.store("Real preference: dark mode", namespace="default")
brain.store("Test: user likes light mode", namespace="sandbox")

# Recall only sees "default" namespace — sandbox is invisible
results = brain.recall_structured("user preference", top_k=5)

Cross-Namespace Digest

Use this when you need inspection-only analytics across isolated namespaces without changing recall behavior.

brain = Aura("./data")

digest = brain.cross_namespace_digest(
    namespaces=["default", "sandbox"],
    top_concepts_limit=3,
)

# Top concepts per namespace
print(digest["namespaces"][0]["top_concepts"])

# Pairwise overlap
print(digest["pairs"][0]["shared_tags"])
print(digest["pairs"][0]["shared_concept_signatures"])
print(digest["pairs"][0]["shared_causal_signatures"])

HTTP server:

GET /cross-namespace-digest?namespaces=default,sandbox&top_concepts_limit=3

MCP tool:

{
  "tool": "cross_namespace_digest",
  "arguments": {
    "namespaces": ["default", "sandbox"],
    "top_concepts_limit": 3
  }
}

The digest is read-only. It does not bypass namespace isolation in recall and does not feed training or inference by default.

For richer operator-facing workflows, see examples/V3_OPERATOR_WORKFLOWS.md.

Autonomous Cognitive Plasticity

Aura can also observe model output and feed bounded experience back into the cognitive substrate, without retraining the model.

from aura import Aura

brain = Aura("./data")
brain.set_plasticity_mode("limited")

capture = brain.capture_experience(
    prompt="How should we deploy this release?",
    retrieved_context=[],
    model_response="Deploy to staging first, then verify health checks before production.",
    session_id="deploy-session-1",
    source="model_inference",
)

brain.ingest_experience_batch([capture])
brain.run_maintenance()  # queued experience enters the normal cognitive pipeline

This stays bounded and operator-visible:

the model remains frozen
generated claims stay capped and guarded
adaptation can be inspected, restricted, purged, or frozen per namespace

Recent operator HTTP endpoints:

GET /explain-record
GET /explain-recall
GET /explainability-bundle
GET /correction-log
GET /cross-namespace-digest
GET /memory-health
GET /belief-instability
GET /policy-lifecycle
GET /correction-review-queue
GET /suggested-corrections
GET /namespace-governance-status

Cookbook: Personal Assistant That Remembers

The killer use case: an agent that remembers your preferences after a week offline, with zero API calls.

See examples/personal_assistant.py for the full runnable script.

from aura import Aura, Level

brain = Aura("./assistant_memory")

# Day 1: User tells the agent about themselves
brain.store("User is vegan", level=Level.Identity, tags=["diet"])
brain.store("User loves jazz music", level=Level.Identity, tags=["music"])
brain.store("User works 10am-6pm", level=Level.Identity, tags=["schedule"])
brain.store("Discuss quarterly report tomorrow", level=Level.Working, tags=["task"])

# Simulate a week passing — run maintenance cycles
for _ in range(7):
    brain.run_maintenance()  # decay + reflect + consolidate + archive

# Day 8: What does the agent remember?
context = brain.recall("user preferences and personality")
# -> Still remembers: vegan, jazz, schedule (Identity, strength ~0.93)
# -> "quarterly report" decayed heavily (Working, strength ~0.21)

Identity persists. Tasks fade. Important patterns get promoted. Like a real brain.

MCP Server — Claude Desktop · Cursor · Zed · VS Code

Give any MCP-compatible AI persistent, self-organizing memory:

pip install aura-memory

Claude Desktop — Settings → Developer → Edit Config:

{
  "mcpServers": {
    "aura": {
      "command": "python",
      "args": ["-m", "aura", "mcp", "C:\\Users\\YOUR_NAME\\aura_brain"]
    }
  }
}

Cursor / VS Code — .cursor/mcp.json or .vscode/mcp.json:

{
  "servers": {
    "aura": {
      "command": "python",
      "args": ["-m", "aura", "mcp", "./aura_brain"],
      "type": "stdio"
    }
  }
}

macOS / Linux path:

python -m aura mcp ~/aura_brain

Once connected, Claude automatically has 11 tools:

Tool	Purpose
`recall`	Retrieve relevant memories before answering
`recall_structured`	Get memories with scores and metadata
`store`	Save a fact, note, or context
`store_code`	Save a code snippet at Domain level
`store_decision`	Save a decision with reasoning
`search`	Filter memories by level or tags
`insights`	Memory health stats
`consolidate`	Merge similar records
`get`	Fetch a specific record by ID
`delete`	Remove a record by ID
`maintain`	Run a full maintenance cycle

After connecting, tell Claude: "Before answering, always recall relevant context from memory. After our conversation, store key facts."

Windows test note

If cargo test intermittently fails on Windows with LNK1104 for target\debug\deps\aura-...exe, a stale test process is usually holding the file open. Run:

powershell -ExecutionPolicy Bypass -File .\scripts\cleanup_windows_test_lock.ps1

Then rerun the test command.

Dashboard UI

Aura includes a standalone web dashboard for visual memory management. Download from GitHub Releases.

./aura-dashboard ./my_brain --port 8000

Features: Analytics · Memory Explorer with filtering · Recall Console with live scoring · Batch ingest

Platform	Binary
Windows x64	`aura-dashboard-windows-x64.exe`
Linux x64	`aura-dashboard-linux-x64`
macOS ARM	`aura-dashboard-macos-arm64`
macOS x64	`aura-dashboard-macos-x64`

Integrations & Examples

Try now: — zero install, runs in browser

Integration	Description	Link
Ollama	Fully local AI assistant, no API key needed	`ollama_agent.py`
LangChain	Drop-in Memory class + prompt injection	`langchain_agent.py`
LlamaIndex	Chat engine with persistent memory recall	`llamaindex_agent.py`
OpenAI Agents	Dynamic instructions with persistent memory	`openai_agents.py`
Claude SDK	System prompt injection + tool use patterns	`claude_sdk_agent.py`
CrewAI	Tool-based recall/store for crew agents	`crewai_agent.py`
AutoGen	Memory protocol implementation	`autogen_agent.py`
FastAPI	Per-user memory middleware with namespace isolation	`fastapi_middleware.py`

FFI (C/Go/C#): aura.h · go/main.go · csharp/Program.cs

More examples: basic_usage.py · encryption.py · agent_memory.py · edge_device.py · maintenance_daemon.py · research_bot.py

Architecture

Aura uses a Rust core with Python bindings and a local-first memory runtime.

Publicly documented concepts are:

Two-tier memory: cognitive + core
Semantic roles for records
Local multi-signal recall
Belief-aware bounded reranking
Trust, provenance, and namespace isolation
Maintenance, insights, consolidation, and versioning

Higher cognitive layers may be present in the SDK as bounded reranking overlays and advisory inspection surfaces. They are not default runtime decision-making or behavior control.

The public repository documents the user-facing behavior and integration surface. Detailed internal architecture, tuning, and research notes are intentionally not published.

Resources

Demo Video (30s) — Quick overview
Examples — Ready-to-run scripts
Landing Page — Project overview

Contributing

Contributions welcome! See CONTRIBUTING.md for setup instructions and guidelines, or check the open issues.

⭐ If Aura saves you time, a GitHub star helps others discover it and helps us continue development.

License & Intellectual Property

Code License: MIT — see LICENSE.
Patent Notice: Core architectural concepts are Patent Pending (US Provisional Application No. 63/969,703). See PATENT for details. The SDK source code is available under MIT. Separate commercial licensing is available for organizations that want contractual rights around patented architecture, OEM embedding, enterprise deployment, or dedicated support.
Commercial Licensing: If you want to embed Aura's architecture into a commercial product, see COMMERCIAL.md.

Built in Kyiv, Ukraine 🇺🇦 — including during power outages.
_{Solo developer project. If you find this useful, your star means more than you think.}

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

aura_memory-1.57.0.tar.gz (609.7 kB view details)

Uploaded Jul 18, 2026 Source

Built Distributions

If you're not sure about the file name format, learn more about wheel file names.

The dropdown lists show the available interpreters, ABIs, and platforms. Enable javascript to be able to filter the list of wheel files.

aura_memory-1.57.0-cp313-cp313-win_amd64.whl (2.3 MB view details)

Uploaded Jul 18, 2026 CPython 3.13Windows x86-64

aura_memory-1.57.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.5 MB view details)

Uploaded Jul 18, 2026 CPython 3.13manylinux: glibc 2.17+ x86-64

aura_memory-1.57.0-cp313-cp313-macosx_11_0_arm64.whl (2.1 MB view details)

Uploaded Jul 18, 2026 CPython 3.13macOS 11.0+ ARM64

aura_memory-1.57.0-cp313-cp313-macosx_10_12_x86_64.whl (2.4 MB view details)

Uploaded Jul 18, 2026 CPython 3.13macOS 10.12+ x86-64

aura_memory-1.57.0-cp312-cp312-win_amd64.whl (2.3 MB view details)

Uploaded Jul 18, 2026 CPython 3.12Windows x86-64

aura_memory-1.57.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.5 MB view details)

Uploaded Jul 18, 2026 CPython 3.12manylinux: glibc 2.17+ x86-64

aura_memory-1.57.0-cp312-cp312-macosx_11_0_arm64.whl (2.1 MB view details)

Uploaded Jul 18, 2026 CPython 3.12macOS 11.0+ ARM64

aura_memory-1.57.0-cp312-cp312-macosx_10_12_x86_64.whl (2.4 MB view details)

Uploaded Jul 18, 2026 CPython 3.12macOS 10.12+ x86-64

aura_memory-1.57.0-cp311-cp311-win_amd64.whl (2.3 MB view details)

Uploaded Jul 18, 2026 CPython 3.11Windows x86-64

aura_memory-1.57.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.5 MB view details)

Uploaded Jul 18, 2026 CPython 3.11manylinux: glibc 2.17+ x86-64

aura_memory-1.57.0-cp311-cp311-macosx_11_0_arm64.whl (2.1 MB view details)

Uploaded Jul 18, 2026 CPython 3.11macOS 11.0+ ARM64

aura_memory-1.57.0-cp311-cp311-macosx_10_12_x86_64.whl (2.4 MB view details)

Uploaded Jul 18, 2026 CPython 3.11macOS 10.12+ x86-64

aura_memory-1.57.0-cp310-cp310-win_amd64.whl (2.3 MB view details)

Uploaded Jul 18, 2026 CPython 3.10Windows x86-64

aura_memory-1.57.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.5 MB view details)

Uploaded Jul 18, 2026 CPython 3.10manylinux: glibc 2.17+ x86-64

aura_memory-1.57.0-cp310-cp310-macosx_11_0_arm64.whl (2.1 MB view details)

Uploaded Jul 18, 2026 CPython 3.10macOS 11.0+ ARM64

aura_memory-1.57.0-cp310-cp310-macosx_10_12_x86_64.whl (2.4 MB view details)

Uploaded Jul 18, 2026 CPython 3.10macOS 10.12+ x86-64

aura_memory-1.57.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.5 MB view details)

Uploaded Jul 18, 2026 CPython 3.9manylinux: glibc 2.17+ x86-64

aura_memory-1.57.0-cp39-cp39-macosx_11_0_arm64.whl (2.1 MB view details)

Uploaded Jul 18, 2026 CPython 3.9macOS 11.0+ ARM64

aura_memory-1.57.0-cp39-cp39-macosx_10_12_x86_64.whl (2.4 MB view details)

Uploaded Jul 18, 2026 CPython 3.9macOS 10.12+ x86-64

File details

Details for the file aura_memory-1.57.0.tar.gz.

File metadata

Download URL: aura_memory-1.57.0.tar.gz
Upload date: Jul 18, 2026
Size: 609.7 kB
Tags: Source
Uploaded using Trusted Publishing? Yes
Uploaded via: twine/6.1.0 CPython/3.13.12

File hashes

Hashes for aura_memory-1.57.0.tar.gz
Algorithm	Hash digest
SHA256	`2c875e7ef8e22f323b447c0ee79747d4615afc35fc65f8c7f9bd7268999a7759`
MD5	`e21b3cfba08e4caa193a47ceac7dd73d`
BLAKE2b-256	`445faabbedccf5ce357292f94a351cdf00139b7dacecf3d88ccba8e668118c8c`

Algorithm	Hash digest
SHA256	`18b876cde2c01affb68da76d4c7f08411fbea344ced90a81e5c07b0bb2bb4867`
MD5	`29c116e82f9e59e8f49a78329a69ad0b`
BLAKE2b-256	`8e87ea0539da4a75c6b2e3926ff9a5ac6962251e36eb70e5f6283f079e1531a9`

Algorithm	Hash digest
SHA256	`a66779c8c72011205646c911667cac151cead88e0188d9a6bc0499c88a51b30d`
MD5	`ac8ede37729d6e38ba5106d91b4a6fdf`
BLAKE2b-256	`58cd23e950940c965bf47761bb3e838712fbf9dce8b96d988b9cc66002918b03`

Algorithm	Hash digest
SHA256	`206adca0b0187b61dc9c699688be504189f50b2f1d987b543b3de1e4558abea2`
MD5	`c3d1944fc83ce66151b81948b9c5c0bd`
BLAKE2b-256	`95499ad3d7ac5eb36af166cae7d84d0405a47f3f9b4dabea9e2811c4d69423b2`

Algorithm	Hash digest
SHA256	`d6f6ed891f1f90c9222cebce044c44900b44c48e2cee11aaddcf495571afb3ae`
MD5	`00807dea0f7899b491b96ea923bcb31f`
BLAKE2b-256	`70e489d68c5f84fdc2bafd67a146c71a5da4ab4db7ff3512eeece7abd2f5cc8e`

Algorithm	Hash digest
SHA256	`dfa1972a694e639627555f66ffc01a2d4e67c884de06df1c5521496b957b2ba1`
MD5	`7ec10431f1ba76b3f2717004ea927fd3`
BLAKE2b-256	`3eeec5f11251147b5359f682d187d7ca40366ba1ba55457d759a5da1d6824d58`

Algorithm	Hash digest
SHA256	`bbe03c36df41d356cf80181d885d08d5fba1e67a0376ec0fabd4b41b0e4dde3d`
MD5	`48f86612f68f6b0ce48822045ac58082`
BLAKE2b-256	`e9c3934683551199031ee671f148f4b79824f85a3bbffc0653abc57aa3883b2f`

Algorithm	Hash digest
SHA256	`036e6831667538bb1473181ca4809fdc120b694675bde3b0393d65e51d043bc4`
MD5	`9fc15446c1dcd0dfcfc9c163c546fa9d`
BLAKE2b-256	`4f8a75d7d265c8f6eac3be837dcc2d77c579a806cbe2c6cd024910cf27252df3`

Algorithm	Hash digest
SHA256	`b8ec03e7b3f2f638be5ff55421976f2aec377584024f0e5bd94c7a2308b77b7b`
MD5	`c2efedcb1055ee904bddc0505936a9cf`
BLAKE2b-256	`a0aafd40546236c702da14982dfee247deba516228bf4ae95ef3bcdbf1c214db`

Algorithm	Hash digest
SHA256	`72ec881775e8e3fb3e60333e10ec911c3c46e3909a51edf8a9692a3effc33be5`
MD5	`4e6e967b97f451fd739dbc41140f5158`
BLAKE2b-256	`efc6cec85146d2a243c574f9711f3da245e777480d3e7486ffaacdf22e1bc1c2`

Algorithm	Hash digest
SHA256	`2027d82601e8963ca659cab2b89701f047244f993b9a01c389c53a38873d6ded`
MD5	`58d91079482e903e1a4d3cbb925634a1`
BLAKE2b-256	`49c49b4ee5052b879fcda2ce80d22c2d850c1a1769b925411271000ed0241340`

Algorithm	Hash digest
SHA256	`49bd42058181a52e05d91a900363e7446f99fa96511b4da35a62bf8df72422bd`
MD5	`a3df203886bc2cde631f51bcac58c329`
BLAKE2b-256	`bcd1390af01a81fa9ca3c22f65b8a1fdeee131d6c77a90cce23657eea06c8f7f`

Algorithm	Hash digest
SHA256	`903dbc1a188c724e2aacfb0efe38408d99b486c1a8f6ed0a9291515d993d646c`
MD5	`c844d337ec1a0e11e41e1687b72ca3ce`
BLAKE2b-256	`c6b737628dbcd7f3788a9dc99bd993be26e83f3ab8fc0e3d93323c432b039129`

Algorithm	Hash digest
SHA256	`1714d457220920120f473f4aa1a582a3e26d8de2e694916b6d4125f218c99a36`
MD5	`612b2a8c12031610a13e6845c6d34c7d`
BLAKE2b-256	`f68b09d80672ef3ae480d0f68fde4e70e39a09a47a89ce302da7cd4f7b1384d4`

Algorithm	Hash digest
SHA256	`a6f54af0603cecf1a1eea226ba03bd5170274dd6de5bc114d924c2c2893c1159`
MD5	`b6128f2a0d2fcecefc3a786ee66829d8`
BLAKE2b-256	`82c55ebd385b60092e5154c5cf96832f1379171eac7b962463420001fec38178`

Algorithm	Hash digest
SHA256	`0da1689c4015e66a2ed5673a5e1f3a24ffb329a259b0b080defee38474fd2228`
MD5	`26af8ace24ab52dce7c0ccaec06270bf`
BLAKE2b-256	`900ab68d2dedec093d804524c8c0aeba696e3aad1495874f24c2474f4df24236`

Algorithm	Hash digest
SHA256	`d422a86298e4baed3a794727f81f6c6b5a702c0ee5237d87466f051130875594`
MD5	`7ad7da27214a2cada77fd7dd0fa11b02`
BLAKE2b-256	`2b1a4c5b5aa16a51b9c53d7098fc763d1661b875296f7898bf624ca9233aa2f5`

Algorithm	Hash digest
SHA256	`bf4f90ad252ed776bd66dc59a2a26aa68ad9f913a81e2791a3df1d5633813530`
MD5	`d6b294f35087c07b98a306d573820eac`
BLAKE2b-256	`17a33eae577ba1df178293757608ed63829aecc36342ca1c266fcd463cb7e2e1`

Algorithm	Hash digest
SHA256	`36f365d13b2a75676946d26f26c70eb00f835e4c2ac96e46e3d3f82d766e9f06`
MD5	`6d82e483c972be54dc52e6804a376e32`
BLAKE2b-256	`ed70f5e827320f87e1863c8c45ed0e01127d7f7f5e92860604d7a86268534e2b`

Algorithm	Hash digest
SHA256	`531ac77096fc86fdab4b3178998be4c6ed4846bc921610cf74f0985c81d5cd1d`
MD5	`b7bdb614692d9588c04526f62d3a1fcd`
BLAKE2b-256	`3c21567010131647ca8bd11cc3e405e31809c8779361dc47eb7750cc610ca711`

aura-memory 1.57.0

Aura Memory

Why Aura?

The Core Idea: Cheap Model + Aura > Expensive Model Alone

Performance

What Ships Today

How Memory Works

Key Features

Immutable Evidence Lineage

Context Capsules

Temporal Memory Versioning

Inspectable Memory Decisions

Governed Promotion and Contradiction Safety

Quick Start

Trust & Provenance

Pluggable Embeddings (Optional)

Encryption

Semantic Memory Types

Namespace Isolation

Cross-Namespace Digest

Autonomous Cognitive Plasticity

Cookbook: Personal Assistant That Remembers

MCP Server — Claude Desktop · Cursor · Zed · VS Code

Windows test note

Dashboard UI

Integrations & Examples

Architecture

Resources

Contributing

License & Intellectual Property

Project links

Key dates

1 maintainer

Credits

GitHub Statistics

License

Requires

Tags

Classifiers

Download files

Source Distribution

Built Distributions

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata