Facts Without Sources Are Just Guesswork — Evidence-Linked Memory for Hermes Agent - Outros Tutoriais - Download Free Software Gratis e Completos Webmaster Mocambique

Facts Without Sources Are Just Guesswork — Evidence-Linked Memory for Hermes Agent

Tópico: Facts Without Sources Are Just Guesswork — Evidence-Linked Memory for Hermes Agent
Categoria: Tutoriais | Programação & Tecnologia
Idioma Principal: Português (Conteúdo de Tecnologia)

Descrição do Conteúdo / Informações:
-------------------------------------------------------------------------

Memory With Receipts: Evidence-Linked Recall for AI Agents

Description: A local, no-model-required memory benchmark for AI agents where every extracted fact points back to the transcript event that produced it.

Most agent memory demos answer one question:

Can the agent remember?

I wanted to answer a harder one:

Can the agent prove where the memory came from?

Because when an agent remembers the wrong thing, retention is not the only problem. The real problem is debugging trust.

Was that memory from the current session? An old transcript? A stale summary? A manual note? A hallucination that got repeated until it sounded real?

If the agent cannot point back to the source, you do not have memory. You have vibes in a database.

That is what argobrain-memory is built to fix.

The One-Liner

argobrain-memory is a portable, evidence-linked memory core for AI agent sessions. It keeps raw transcripts authoritative, extracts typed facts as derived artifacts, and gives every fact a pointer back to the source event that produced it.

The pitch is simple:

Every useful memory should carry its receipt.

The Moment It Clicks

This is what a memory often looks like in a basic memory store:

Memory: "use SQLite over PostgreSQL"

That may be useful, but it is not auditable. You cannot tell where it came from, whether the wording changed, or whether it was still true.

argobrain-memory stores the memory as a typed fact with evidence:

Fact: "use SQLite over PostgreSQL"
Type: decision
Evidence: session-2026-05-15.jsonl#event=42
Quote: "let's go with SQLite instead of PostgreSQL for this project"
Status: active

Now the agent has a paper trail.

You can open the original transcript, jump to the event, and inspect the conversation that created the fact. If the memory is wrong, stale, or incomplete, you have a place to start debugging.

That is the difference between "the agent says so" and "the agent can show its work."

Why This Matters

Agent memory usually fails in quiet ways.

It does not always forget everything. Sometimes it remembers almost everything, but loses the small operational details that make continuation work possible:

• the path that mattered;

• the command that verified the fix;

• the decision that changed the design;

• the blocker that was still unresolved;

• the user preference that should survive compression.

Summaries are helpful, but summaries are not authority. A summary can omit details, blend sessions together, or accidentally promote a temporary idea into doctrine.

argobrain-memory uses a stricter contract:

• The raw transcript or event log is the source of truth.

• Episodes and typed facts are derived memory.

• Summaries and SQLite indexes are rebuildable views.

• Every extracted fact points back to evidence.

• Benchmarks compare memory modes before adoption.

The result is not just recall. It is recall you can audit.

What It Extracts

From a session transcript, argobrain-memory currently extracts five high-value fact types:

Type
What it captures
Why it matters

decision
Explicit choices made during the session
Prevents old debates from restarting

blocker
Unresolved problems
Gives the next agent a real continuation point

preference
User or workflow preferences
Preserves working style across sessions

path
Files, directories, and artifact locations
Keeps concrete references from vanishing

command
Commands that were run or should be rerun
Makes verification reproducible

Each fact records:

•
evidence, such as fixtures/demo-session/session.jsonl#event=0;

•
fact_type, such as decision, blocker, path, or command;

•
status, currently active;

•
scope, such as session or benchmark;

•
extracted_by, currently argobrain-memory.heuristic-v1;

• operational context like what_for and why_it_matters.

The extractor is intentionally simple today: regex-based, deterministic, and dependency-free. That makes it fast, local, and easy to test before adding heavier model-assisted extraction later.

The Demo

The repo includes a synthetic demo fixture and a replay benchmark that runs with no model and no API keys.

It does not call OpenAI, Ollama, Hermes, or any external service. It uses the included synthetic transcript fixture, deterministic extraction, and local SQLite FTS5 indexing. That means anyone can clone the repo and verify the artifact model immediately.

I ran:

PYTHONPATH=src python3 -m argobrain_memory.cli benchmark \
--fixture fixtures/demo-session \
--mode all \
--output /tmp/argobrain-memory-post-check

Current result on the included fixture:

Mode Retention Matched
off 0.0% 0/5
baseline 100.0% 5/5
cortex 100.0% 5/5
external 100.0% 5/5

The retention score is not the whole story. On a tiny synthetic fixture, several approaches can retain the expected strings.

The important difference is the artifact model.

The cortex mode writes a memory root like this:

memory-root/
active-derived-summary.md
facts.jsonl
recall.sqlite
episodes/
<episode-id>.json

facts.jsonl is the ledger. episodes/ preserves compaction episodes. recall.sqlite is only a rebuildable FTS5 index. The raw transcript remains authoritative.

That structure is the point: memory should be inspectable, replayable, and rebuildable.

How It Fits Hermes Agent

Hermes Agent work often involves long-running sessions, compression, continuation, and handoff between agents. That is exactly where silent memory drift hurts.

argobrain-memory is designed as the memory artifact layer for that world:

• ingest a Hermes-style session transcript;

• extract typed facts before or after compression;

• preserve evidence pointers back to source events;

• build an active derived summary for quick continuation;

• build a SQLite FTS5 recall index for local search;

• benchmark retention across memory modes.

It is not claiming that the final live Hermes MemoryProvider wrapper is done. The current release is the OSS-clean core: portable artifacts, deterministic extraction, replay benchmarks, and a clean path toward live integration.

That boundary matters. I would rather ship a small auditable core than pretend a bigger integration is finished.

Why I Think This Is Useful

The feature that matters most is not fancy retrieval.

It is accountability.

If an agent is helping with code, infrastructure, security, legal research, finance workflows, or anything else with real consequences, "I remember" is not enough.

I want the agent to be able to say:

I remember this, and here is the exact event where I learned it.

That gives humans a debugging handle. It gives future agents a safer continuation point. It makes memory less magical and more inspectable.

Code

GitHub:

github.com/KeyArgo/argobrain-memory

Run the demo:

git clone https://github.com/KeyArgo/argobrain-memory.git
cd argobrain-memory
PYTHONPATH=src python3 -m argobrain_memory.cli benchmark \
--fixture fixtures/demo-session \
--mode all \
--output /tmp/argobrain-memory-demo

The project is MIT licensed, Python 3.10+, and has zero runtime dependencies.

What Is Next

The next steps are clear:

• live Hermes MemoryProvider wrapper;

• stronger contradiction and supersession handling;

• confidence evolution based on repeated evidence;

• richer extraction beyond deterministic heuristics;

• fresh-clone release gate before PyPI publication.

The Ask

If you are building agents with memory, try this benchmark against your own session transcript model:

For every memory the agent uses, can you trace it back to the exact source event?

If the answer is no, that is the gap argobrain-memory is trying to close.

Memory is useful.

Memory with receipts is something you can actually debug.