Ferryte
Product · how Ferryte works

One line.
Full memory provenance.

Ferryte does not ask you to migrate your memory layer or wrap your agent. It instruments what you already run, records where every memory came from, and lets you trace any answer back to the memory behind it.

How it works

Four steps from install to root cause.

Step 01

Instrument

Start with one line — ferryte.instrument(). Mem0 and Zep clients created afterward are detected automatically; shipped adapters cover Letta, Cloudflare, and Ferryte's vector reference store, while custom stores plug into the same small adapter protocol.

import ferryte
ferryte.instrument()

# the rest of your app stays the same
Step 02

Trace

As your agent runs, Ferryte records where every memory came from, what it derived into, and every retrieval that pulled it into a prompt. One optional call per turn links memories to the exact answers they produced.

# recorded automatically
mem_3f9c
  ← source  zendesk-ticket-8821
  → derived summary_v2, embedding
  → retrieved 14x (tenant=acme)

# optional: exact answer→memory edge
ferryte.record_answer(
  answer_id=turn_id,
  content=answer,
  artifact_ids=[m.id for m in context],
)
Step 03

Attribute

Point at a wrong, stale, or leaked answer. Ferryte ranks the memories that caused it — using recorded answer edges, retrieval evidence, and quote-level shared spans — and names the fault: phantom, stale, cross-tenant, zombie, or poisoned.

$ ferryte why "Legacy Free plan"
#1  stale belief · conf 1.00
  from zendesk-ticket-8821
  recorded in context for this answer
  shared span: "legacy free plan"
  superseded by billing-sync-0601
Step 04

Replay, fix, verify

Before deleting anything, replay the retrieval without the top suspect and see what would have entered the context instead. Then delete or supersede the bad memory and re-run to prove nothing survived.

$ ferryte why "Legacy Free plan" --replay
counterfactual: without mem_old → Pro plan

$ ferryte test --scenario source-revocation
source-revocation   PASS
no surviving markers in retrieval ✓
What it catches

The invisible memory bug, in two columns.

Without Ferrytegrep the traces
› agent.ask("acme", "what plan is this customer on?")
You're on the Legacy Free plan.

# wrong — they upgraded to Pro last week.
# somewhere a stale fact still wins retrieval.
# which memory? open the logs and start reading…
With Ferryteroot cause
› ferryte why "Legacy Free plan"
caused by 3 candidate memories · top conf 1.00

#1  stale belief · conf 1.00
  Customer acme is on the Legacy Free plan.
  from 'zendesk-ticket-8821'
  recorded in context for this answer
  shared span: "legacy free plan"

› ferryte why "Legacy Free plan" --replay
counterfactual: without it → Pro plan

fix: delete it, then re-run why to confirm
What it catches — and where it’s honest

The memory bugs you can name, and the ones we won’t fake.

Covered

  • Stale belief — an old fact still outranking the correction that replaced it.
  • Cross-contamination — tenant A receiving something only tenant B ever told the agent.
  • Phantom memory — deleted data still driving answers via a summary or embedding.
  • Hub / poisoned memory — one record showing up across too many unrelated queries.
  • Answer attribution — the exact memories present when a wrong answer was produced.
  • Mosaic mis-belief — fragments across sources recombining into a wrong conclusion.

Honest about

  • Stores Ferryte cannot reach through the adapter interface.
  • Retrieval paths that bypass the patched memory client entirely.
  • Attribution confidence below the configured replay budget — reported as ranked candidates, never a false certainty.

Blind spots are surfaced in every report. We would rather hand you ranked candidates than a confident wrong answer.

How attribution earns your trust

Four signals, strongest first.
And it never pretends.

1 · strongest

Recorded answer edge

Your app called record_answer() — we know exactly which memories were in context when this answer was produced. Anchored, not inferred.

method: exact
2 · strong

Retrieval trace

The memory demonstrably entered the prompt for a matching query. The difference between a plausible suspect and a live one.

retrieved into context
3 · good

IDF-weighted span overlap

Rare shared terms count, common ones don't. Contiguous shared spans of three or more meaningful tokens are quoted back as evidence.

shared span
4 · fallback

Semantic residue

A pluggable embedder catches paraphrase when the exact words differ. Token-bag by default, neural drop-in when you want it.

method: semantic

No recorded edge? The report says method: overlap, never exact. Ferryte labels the strength of its own evidence — the same honesty that powers the blind-spot map.

What we plug into

Adapters.

Vector storesstable

Instrumented reference store + adapter base ship today. pgvector, Chroma, and Qdrant need a thin store-specific adapter.

Mem0stable

Auto-patch on construction. Full lineage across its LLM-extracted facts.

AWS AgentCorebenchmark

Verified live in the public benchmark harness. A Core runtime adapter is not shipped yet.

Zepbeta

Captures episodes + graph facts; traces shared-node summaries back to source.

Lettabeta

Archival passages + derived summaries. Shipped in Core; pass the client explicitly.

Cloudflare Agentsbeta

Vectorize-backed memory. Shipped in Core; pass the client explicitly.

Custom storesstable

Implement the small Adapter protocol for your write, search, and delete surface.

LangGraphplanned

Tracing hooks on the roadmap.

For the pre-integration security review

The questions your security team
will ask. Answered now.

What does instrument() actually touch?

It patches the write/search/delete methods of detected memory clients (plus a constructor hook for clients built later). Your agent code is unchanged; remove the line and Ferryte is gone.

Where does the data live?

A local SQLite file (.ferryte/lineage.db) in your environment. No telemetry, no phone-home, no external service. The optional dashboard reads a local API you start yourself.

What leaves my machine?

Nothing. Reports are files you generate and choose to share. A hash-only fingerprint mode exists for teams that don't want raw content even in the local store.

Can my security team read the code first?

Every line. The engine is source-available (BSL 1.1) — auditability is the whole reason the license keeps the source open.

Built for

Three teams.
One view of the memory.

engineering

The lead who owns the agent.

Stop grepping traces at midnight. One command to the memory that caused it.

support & ops

The team fielding “the AI is confused about me.”

See exactly what the agent remembers about a user — and correct it.

compliance

The team that signs the receipt.

Prove a deleted memory — and everything derived from it — is really gone.

Open it up. See the memory.