u/SeveralSeat2176

You can now give Hermes Agent infinite memory.

The three-tier architecture is the cleanest I've seen in any open-source agent. The Tier 1 cap is the constraint.

MEMORY md file is 2,200 chars. USER md file is 1,375 chars. Hit 80% and consolidation kicks in: the agent merges related entries into denser versions, which is lossy. The longer you run Hermes, the more your earlier context gets compressed away.

Tier 2 (SQLite FTS) is unlimited capacity but every retrieval needs an LLM summarization pass. Tokens and latency on the critical path.

Tier 3 is the plug-in slot. That's where agentmemory fits.

What it adds on top of the existing design:

→ Hybrid retrieval: BM25 + vector + knowledge graph, fused with RRF
→ Ebbinghaus decay so unused memories fade gracefully instead of getting consolidated out
→ Token-budgeted injection that keeps Tier 1 clean
→ Benchmarked on LongMemEval
→ 90% savings

Same numbers as the Claude Code benchmarks: ~92% fewer tokens at 240 observations. 200x more tool calls before hitting context limits.

Hermes already exposes the slot. agentmemory is the obvious thing to plug in.

https://github.com/rohitg00/agentmemory

I got frustrated with AI courses that either drown you in theory or skip straight to model.fit() without explaining what's happening underneath.

So I built something different.

This is an AI-native GitHub repo learning files with 503+ lessons across 22 phases. 35,000 GitHub Stars. Start at linear algebra. End at autonomous agent swarms.

Every lesson follows the same pattern:

1. Build it from scratch in pure Python (no frameworks)
2. Use the real framework (PyTorch, sklearn, etc.)
3. Ship a reusable tool (prompt, skill, agent, or MCP server)

By the end, you don't just "know AI." You have a portfolio of tools you actually built.

What's covered:

- Math foundations (linear algebra, calculus, probability, Fourier transforms, graph theory)
- Classical ML (regression through ensemble methods, feature selection, time series, anomaly detection)
- Deep learning (backprop, activation functions, optimizers, regularization - all from scratch before touching PyTorch)
- LLMs from scratch (tokenizers, pre-training a 124M parameter GPT, SFT, RLHF, DPO, quantization, inference optimization)
- LLM engineering (RAG, advanced RAG, structured outputs, context engineering, evals)
- Agents and multi-agent systems
- Infrastructure (model serving, Docker for AI, Kubernetes for AI)

Some specifics that might interest you:

- The quantization lesson covers FP8/GPTQ/AWQ/GGUF with a sensitivity hierarchy (weights are least sensitive, attention softmax is most sensitive - never quantize that)
- The inference optimization lesson explains why prefill is compute-bound and decode is memory-bound, then builds KV cache, continuous batching, and speculative decoding from scratch
- The DPO lesson shows you can skip the reward model entirely - same results as RLHF with one training loop
- Context engineering lesson: "Prompt engineering is a subset. Context engineering is the whole game."

It's AI-native:

The course has built-in Claude Code skills. Run /find-your-level and it quizzes you across 5 areas to tell you exactly where to start. Run /check-understanding 3 after Phase 3 and it tests what you actually learned.

84% of students use AI tools. 18% feel prepared. This is the bridge.

Where to start:

- Already know Python but not ML -> Phase 1
- Know ML, want deep learning -> Phase 3
- Know DL, want LLMs/agents -> Phase 10
- Senior engineer, just want agents -> Phase 14

Website: https://aiengineeringfromscratch.com
Repo: https://github.com/rohitg00/ai-engineering-from-scratch

It's free, MIT licensed, and open source. 35,000+ stars, PRs welcome - I merge every good contribution and the contributor gets full credit.

Three big launches:

- Cursor iOS app

- Origin, an agentic replacement of Git

- A new model is in the works in collaboration with spaceX

- SpaceX to acquire Cursor

Learn creating your GPT from scratch: https://aiengineeringfromscratch.com

This is what we are building at iii, Check out this is open source: https://github.com/iii-hq/workers/tree/main/console

Disclosure: I’m the author.

I’m not sure if this is mature enough for this subreddit yet, so please remove if it is not a fit.

I’m building AKBP, an alpha local-first protocol/reference implementation for agent knowledge bases:

https://github.com/rohitg00/akbp

It is not a hosted SaaS and not a production-ready app yet.

The goal is to let coding agents maintain a local, file-backed knowledge base with:

- typed claims

- source hashes

- audit logs

- review-gated writes

- SQLite FTS5 search

- import/export validation

- conformance checks

The reason I thought it may be relevant here:

A lot of agent memory systems are tied to hosted products or opaque storage. I wanted something portable, inspectable, and local-first.

Current limitations:

- alpha

- no stable release yet

- needs more real-world dogfooding

- needs clearer migration/versioning policy

If you self-host agent/devtool workflows, I’d be curious:

Would a local file-backed knowledge base be useful, or would you rather have a server/API/database-first design?