Executive brief · grounded in the "Bento Under Test" evaluation
An open-source, self-hostable memory & retrieval layer for AI agents. It makes them stay current when data changes, cost ~40% less on repeat work, and stop repeating mistakes — proven with executable graders, losses published, not hidden.
Proof at a glance — all measured, all reproducible
What it saves — measured, then modeled
Cost per recurring multi-step task · at equal accuracy (1.00)
From wrong / stale → right / current
On conflicting docs, memory takes accuracy 0.46→0.78 (+0.32). After an update, bento serves the current answer (1.00) where a non-invalidating cache goes stale (0.61).
Estimated cost savings — apply the measured −42% to your spend
| Monthly inference spend on applicable workload* | Token/compute saved | Est. saving / month | Est. saving / year |
|---|---|---|---|
| $10,000 | −42% | $4,200 | $50,400 |
| $50,000 | −42% | $21,000 | $252,000 |
| $200,000 | −42% | $84,000 | $1,008,000 |
*Illustrative, transparent math: bento cut tokens 42% (and latency 34%) at equal accuracy on a recurring multi-step workload (measured). The table applies that 42% to the portion of your monthly agent-inference spend that is recurring/multi-step — where bento's recall applies. Single-shot or novel queries see less; your savings scale with how repetitive your traffic is. Not counted (additional upside): −34% latency → fewer SLA breaches, better UX, more throughput per GPU; and avoided wrong-answer / stale-answer incidents.
Tailored to the seat
Every company is shipping agents; the demo always works, production goes stale, expensive, and wrong. Bento fixes those three — open source (adoption flywheel, no lock-in objection) with a hosted option for revenue.
A FastAPI layer composing graph retrieval, supersession-backed currency, code-aware chunking, and extraction — on PostgreSQL + Valkey. No new vector DB to operate. Open source, so your team can audit the exact code behind every claim; self-hostable, so data stays in your boundary.
Each common production complaint maps to a measured fix (table below). Honest maturity line so you can plan against reality:
Support, ops/SRE, research, and dev-tools teams paying for token bills, latency SLAs, and wrong-answer incidents. The lines that close:
| The complaint you hear | What bento does | Measured |
|---|---|---|
| "Our assistant quoted last quarter's price." | Update the source; bento serves the new answer. A naive cache keeps answering the old one. | +0.31 vs stale cache |
| "Our research agent is slow and burns tokens on repeat questions." | Recalls the resolved answer instead of redoing the multi-step lookup. | −34% latency · −42% tokens |
| "Support gives wrong answers when our docs contradict." | Accumulates verified facts and trusts them over noisy docs. | 0.46 → 0.78 (+0.32) |
| "Our coding copilot returns half a function." | Code-aware chunking keeps whole functions intact. | 2.4× complete top-hits |
| "Our ops agent keeps making the same blocked call." | Remembers the recovery procedure and applies it. | −75% repeated failures |
| "It can't answer 'who owns the service X depends on'." | Graph traversal connects facts across documents. | wins multi-hop where vector/keyword can't |
Match the agent to the capability it needs. Every row maps to a measured result above.
| Agent / workload | Primary capability | Measured |
|---|---|---|
| Support & RAG assistants | Currency + correctness on messy docs | +0.31 vs stale cache · 0.46→0.78 |
| Research / analyst agents | Cost-reuse on recurring multi-hop questions | −42% tokens / −34% latency |
| Ops / SRE / incident agents | Procedural memory + the self-recovery loop | −75% repeated failed ops |
| Developer-tool / coding copilots | Code-aware chunking + self-recovery loop | 2.4× whole-function hits |
| Knowledge-base / compliance | Point-in-time version replay | as_of returns the historical version |
| Multi-document reasoning | Graph retrieval | wins multi-hop with no lexical bridge |
Self-hosted, single-tenant (Dedicated). The whole stack runs on your own PostgreSQL + Valkey, inside your boundary — data never leaves. The default for regulated buyers.
Managed / hosted (Shared). We run it; you call one API. Fastest path to a pilot, no ops burden.
Drop-in behind one API. No new vector database to stand up — bento composes its four ingredients behind a single backend-for-frontend, so you add memory to an existing agent without re-architecting.
Distill model is a deployment decision. For cross-session currency, point the distill step at a capable temperature-0 instruct model, not a coder model — that single choice moved stale-sibling retention from 1.0 to 0.1 in our test.
Illustrative end-to-end scenarios (composite, not named customers) — each step is a capability measured above.
Support agent on a live pricing/policy KB. Prices update mid-day → the agent serves the new number, not last quarter's (a non-invalidating cache is wrong about a third of the time). Recurring tier-1 questions resolve from one recalled answer (−42% tokens). When two source docs disagree, accumulated verified facts win (0.46→0.78).
Ops / coding agent in CI. A session hits python3 script.py → ModuleNotFoundError, recovers with uv run python script.py. The loop records it once; every later session reads the correction and skips the doomed call — ~27 ms plus a wasted model turn saved each time, 75% fewer repeated blocked operations across the fleet. Corrections that would cost more context than they save are dropped, so the always-loaded block stays small.
Compliance review. "Show me what our retention policy said on March 1" → an as_of query returns the version current on that date, not today's.