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.
Recall quality holds at 98.2% R@15 on LongMemEval-S. Every number is scored by exact row identity, so a hit can never be a similarity-guess artifact.
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 the author; we ask for your scorecards and your honest complaints.