Every lookup is a pause in your pipeline. forefetch learns your agents' rhythm: who runs after whom, what each one reaches for. It moves context to the agent's side while the previous agent is still thinking.
Scroll, and time moves. The top lane is every memory product today. The bottom lane is forefetch.
The next need resembles what just happened. Every event an agent records re-aims its staged context at where the work is going.
Sessions tend to open the same way. When one ends, forefetch pre-warms the next with what past sessions actually fetched first.
After one agent acts, the next one reads, nearly always. forefetch counts those edges and warms the successor before it runs.
One key, one tenant: your own memory engine and your own database file on the server. Cross-tenant access has no code path.
An agent's own past answers fuel prediction but are never quoted back as facts: a memory that can't get high on its own supply.
Anticipation changes when content is ready, never what a query returns. A missed prediction wastes a little staging, never an answer.
Latest end-to-end run on the live API (a 4-agent team over production-sized documents): 89–94% of what each agent asked for was staged before it asked, and after each agent's first lookup, every lookup was served warm. Every number is scored by exact row identity, so a hit can never be a similarity-guess artifact.
Supermemory, Zep and full-context columns are from Supermemory's own published report. The forefetch column was measured on 12 Aug 2026 on the same benchmark, all 500 questions, scored against gold session ids with no LLM judge. Retrieval recall is not the same thing as answer accuracy; we claim only the retrieval numbers, head to head against the published retrieval numbers. Yes, Supermemory wins one row; the table stays as measured.
Recall looks backward. For the forward half, prefetch, no public benchmark existed, so we wrote and open-sourced one: JANUS, deterministic workloads with an exact best-possible ceiling and no judge. It is the standard we hold every forefetch number to.
Each stream simulates one agent whose sessions lean toward a particular topic, some strongly, one not at all (that one is a control: nothing should score much above Random there, and nothing does). "Best non-forefetch" is the strongest system we could build that looks for the same kind of pattern without using forefetch itself. forefetch beats it on two streams and trails it slightly on two others, and both stay well clear of Random and the no-bias control on every row. The forefetch column is the real, unmodified product, and ceiling is the best score mathematically possible given how the streams were generated. We built this benchmark and ran every column ourselves, so treat it as our own measurement, not an independent one. Full methodology and code are in the same JANUS repo above.
pip install forefetch-client. One dependency. Nothing else to run.
One line around the team you already have, with the API key we send you.
Nothing else changes. Check what memory did with report().
from forefetch_client.agno import remember_team
team = Team(members=[triage, resolver]) # your team, exactly as it is
team = remember_team(team, "https://api.forefetch.com", api_key=KEY)
team.print_response("I was charged twice for invoice INV-2291.")
# use it exactly as before. memory learns, stages, and hands off underneath.
team.forefetch["resolver"].report() # how often was context ready early?Each agent gets its own isolated memory stream. Upstream conclusions arrive downstream as labeled hints. Your prompts and delegation logic don't change. Read the step-by-step guide →
def run_with_memory(memory, agent_fn, task):
ctx = memory.retrieve(task, k=4, full_suggestions=True)
hints = memory.suggest(k=3)
context = [i["text"] for i in ctx["items"]] + \
[f"[{h['kind']} from {h.get('from_stream', 'memory')}] {h['text']}"
for h in hints]
answer = agent_fn(task, context) # your framework's call, unchanged
memory.observe(f"concluded: {answer[:400]}", derived=True)
return answerThe same three moments on any stack: retrieve + hints before the agent runs,
observe after it acts, end_session() when the task is done.
Read the step-by-step guide →
Your key works on both endpoints below. Same server binary, one with every prediction disabled. Run your pipeline against both; the delta between the two built-in scorecards is what anticipation buys your workload, measured by you.
A small number of partner slots. You get the hosted service and direct support from us; we ask for your scorecards and your honest complaints.