[D] antaris-suite 3.0 (open source, free) — zero-dependency agent memory, guard, routing, and context management (benchmarks + 3-model code review inside)

So, I picked up vibe coding back in early 2025 when I was trying to learn how to make indexed chatbots and fine tuned Discord bots that mimic my friend’s mannerisms. I discovered agentic coding when Claude Code was released and pretty much became an addict. It’s all I did at night. Then I got into agents, and when ClawBot came out it was game over for me (or at least my time). So I built one and starrt using it to code pretty much exclusively, using DIscord to communicate with it. I’m trying to find a way out of my current job and I’m hoping this opens up some pathways.

Well the evening/early morning after Valentines Day, when I was finally able to sneak away to my computer and build, I came back to a zombified agent and ended up losing far more progress from the evening before than I’d like to admit. (Turns out when you us discord as your sole method of communication, exporting your entire chat history or even just telling it to read back to a certain time-stamp works really well for recovering lost memory).

Anyways, I decided to look into ways to improve its memory, and stumbled across some reddit posts and articles that seemed like a good place to start. I swapped my method from using a standard markdown file and storing every 4 hours + on command to a style of indexing memories with the idea of building in a decay system for the memories and a recall and search function. (Nothing new in the space, but it was fun to learn myself). That’s how my first project was born- Antaris-Memory. It indexes its memories based on priority, and uses local sharded JSONL storage. When it need to recall something, it utilizes BM25 and decay-weighted searching, and narrows down the top 5-10 memories based on the context of the conversation. That was my first module. No RAG, no Vector DB, just persistent file based memory.

Now I’m on V3.0 of antaris-suite, a six Python packages that handles the infrastructure layer of an agent from memory, safety, routing, and context using pipeline coordination and shared contracts. Zero external dependencies on the core packages. No pulling memories from the cloud, no using other LLMs to sort through them, no API keys, nothing. Which, it turns out, makes it insanely fast.

“`bash
pip install antaris-memory antaris-router antaris-guard antaris-context antaris-pipeline
“`

If you use OpenClaw: there’s a native plugin. openclaw plugins install antaris-suite — memory recall and ingest hook into every agent turn automatically, no code changes. Includes compaction-aware session recovery so long-running agents don’t lose context across memory resets.
—

**What each package actually does:**

**Antaris-Memory**

• Sharded storage for production scalability (20,000+ memories, sub-second search)
• Fast search indexes (full-text, tags, dates) stored as transparent JSON files
• Automatic schema migration from single-file to sharded format with rollback
• Multi-agent shared memory pools with namespace isolation and access controls
• Retrieval weighted by recency × importance × access frequency (Ebbinghaus-inspired decay)
• Input gating classifies incoming content by priority (P0–P3) and drops ephemeral noise at intake
• Detects contradictions between stored memories using deterministic rule-based comparison
• Runs fully offline — zero network calls, zero tokens, zero API keys
• Not a vector database, not a knowledge graph, not semantic by default not LLM-dependent, and not infinitely scalable without a database.

**Antaris-Guard**

• PromptGuard — detects prompt injection attempts using 47+ regex patterns with evasion resistance
• ContentFilter — detects and redacts PII (emails, phones, SSNs, credit cards, API keys, credentials)
• ConversationGuard — multi-turn analysis; catches threats that develop across a conversation
• ReputationTracker — per-source trust profiles that evolve with interaction history
• BehaviorAnalyzer — burst, escalation, and probe sequence detection across sessions
• AuditLogger — structured JSONL security event logging for compliance
• RateLimiter — token bucket rate limiting with file-based persistence
• Policy DSL — compose, serialize, and reload security policies from JSON files
• Compliance templates for enterprise — GDPR, HIPAA, PCI-DSS, SOC2 preconfigured configurations

**Antaris-Router**

• Semantic classification — TF-IDF vectors + cosine similarity, not keyword matching
• Outcome learning — tracks routing decisions and their results, builds per-model quality profiles
• SLA enforcement — cost budget alerts, latency targets, quality score tracking per model/tier
• Fallback chains — automatic escalation when cheap models fail
• A/B testing — routes a configurable % to premium models to validate cheap routing
• Context-aware — adjusts routing based on iteration count, conversation length, user expertise
• Multi-objective — optimize for quality, cost, speed, or balanced
• Runs fully offline — zero network calls, zero tokens, zero API keys

-**Antaris-context**

• Sliding window context manager with token budget enforcement.
• Turn lifecycle API

**Antaris Pipeline**

• The orchestration layer for the full antaris-suite within OpenClaw. It wires together memory recall, safety checking, model routing, and context management into a single event-driven lifecycle.

**Antaris-Contract**

• Versioned state schemas,
• failure semantics,
• concurrency model docs,
• debug CLI for the full Antaris Suite.

—

**Benchmarks (Mac Mini M4, 10-core, 32GB):**

The Antaris vs mem0 numbers are a direct head-to-head on the same machine with a live OpenAI API key — 50 synthetic entries, varying corpus sizes (50, 100, 100,000, 500,000, 1,000,000,10 runs averaged. Letta and Zep were measured separately (different methodology — see footnotes).

Even with a full pipeline turn of guard + recall + context + routing + ingest antaris measured at 1,000-memory corpus. mem0 figure = measured search p50 (193ms) + measured ingest per entry (312ms).

LangChain ConversationBufferMemory: its fast because it’s a list append + recency retrieval — not semantic search. At 1,000+ memories it dumps everything into context. Not equivalent functionality.

Zep Cloud measured via cloud API from a DigitalOcean droplet (US-West region). Network-inclusive latency.

Letta self-hosted: Docker + Ollama (qwen2.5:1.5b + nomic-embed-text) on the same DigitalOcean droplet. Each ingest generates an embedding via Ollama. Not a local in-process comparison.

Benchmark scripts are in the repo. For the antaris vs mem0 numbers specifically, you can reproduce them yourself in about 60 seconds:

“`bash
OPENAI_API_KEY=sk-… python3 benchmarks/quick_compare.py –runs 10 –entries 50
“`

**Engineering decisions worth noting:**

– Storage is plain JSONL shards + a WAL. Readable, portable, no lock-in. At 1M entries bulk ingest runs at ~11,600 items/sec with near-flat scaling (after bulk_ingest fix).
– Locking is `os.mkdir`-based (atomic on POSIX and Windows) rather than `fcntl`, so it works cross-platform without external dependencies still.
– Hashes use BLAKE2b-128 (not MD5). Migration script included for existing stores.
– Guard fails open by default (configurable to fail-closed for public-facing deployments).
– The pipeline plugin for OpenClaw includes compaction-aware session recovery: handoff notes written before context compaction, restored as hard context on resume (this is still one of my favorite features.

—

GitHub: https://github.com/Antaris-Analytics/antaris-suite
Docs: https://docs.antarisanalytics.ai

Website: https://antarisanalytics.ai/

Original README and the original idea for the architecure. At the time we believe this to be a novel solution to the Agent Amnesia problem, and also we’ve discovered a lot of these idea have been discussed before, good amount of them never have, like our Dream State Processing.

┌─────────────────────────────────────────────┐ │ MemorySystem │ │ │ │ ┌──────────┐ ┌───────────┐ ┌────────────┐ │ │ │ Decay │ │ Sentiment │ │ Temporal │ │ │ │ Engine │ │ Tagger │ │ Engine │ │ │ └──────────┘ └───────────┘ └────────────┘ │ │ ┌──────────┐ ┌───────────┐ ┌────────────┐ │ │ │Confidence│ │Compression│ │ Forgetting │ │ │ │ Engine │ │ Engine │ │ Engine │ │ │ └──────────┘ └───────────┘ └────────────┘ │ │ ┌──────────────────────────────────────┐ │ │ │ Consolidation Engine │ │ │ │ (Dream State Processing) │ │ │ └──────────────────────────────────────┘ │ │ │ │ Storage: JSON file (zero dependencies) │ └─────────────────────────────────────────────┘ 

Happy to answer questions on architecture, the benchmark methodology, or anything that looks wrong.

<3 Antaris