Agents aren’t slow. They’re waiting.

An agent thinks, then stops and waits on its own memory. Then it thinks again, and waits again. BAiD is building the layer that takes the wait out. Your database stays as it is.

Task time
10.3 s
Spent waiting
36%
Fig. 1 One agent task, run twice. Illustrative timings, not a benchmark.
Read this figure as text

This page has one main interactive figure. This is the same figure in words.

An agent task is drawn as a timeline of 5 steps. In each step the model thinks, then the agent waits while its memory answers. A slider moves the agent’s memory from behind the agent to ahead of it. Until you touch it, the figure shows one state per run and switches between runs.

  • Memory behind the agent. This is how agents run today. The agent asks, then waits. The task takes 10.3 s, and 3.7 s of that (36%) is the agent standing still.
  • Memory ahead of the agent. This is what BAiD is building. The lookup is already under way while the model thinks, so the answer is there when the agent asks. The same task takes 7.8 s, with 1.2 s (15%) spent waiting. The first lookup still waits in full, because there is nothing to go on yet.

In the figure, the two echo layers of the BAiD mark start behind it, like shadows. As you drag, they move out in front of it.

Step Model thinks Waits, memory behind Waits, memory ahead Memory asked
1 1.4 s 0.9 s 0.9 s graph database
2 1.3 s 1.1 s 0.1 s vector store
3 1.6 s 0.7 s 0.1 s object storage
4 1.2 s 1.0 s 0.1 s graph database
5 1.1 s none none none (final answer)
Whole task 6.6 s thinking 3.7 s waiting, 10.3 s in all 1.2 s waiting, 7.8 s in all

Illustrative timings, not a benchmark. BAiD has not shipped and has no measurements yet.

Designed for the memory agents already use

graph databases, vector stores, object storage, Neo4j, pgvector, Qdrant, S3

01The problem

The slow part is the part nobody traces.

Model latency gets measured, tuned and argued about. The time an agent spends stopped, waiting for its own memory to answer, mostly does not.

  1. 01
    The model thinks. It plans the next step. This is the part everyone measures.
  2. 02
    Then the agent stops. It asks its memory a question, and the question has to travel. Until the answer comes back, nothing happens.
  3. 03
    Every step pays again. Think, wait, think, wait. In this example 3.7 s of a 10.3 s task is the agent standing still.
  4. 04
    Unless memory is already there. Bring the memory forward, ahead of the agent, and the stops close up. The same task takes 7.8 s.

On the page this plays as an animation while you scroll: an agent moves along a track, stops at each lookup while a request travels to a distant store and back, and then runs without stopping once the stores move up beside it. Illustrative timings, not a benchmark.

02What we are building

Memory that is already there when the agent asks.

BAiD is a layer that sits between an agent and the memory it already uses. The goal is plain: by the time the agent asks, the answer is waiting for it, and not the other way round.

01
Your agent. It asks for memory the way it does today. Nothing about how it thinks has to change.
02
BAiD. One layer in between. Its job is to have the answer ready before the question arrives.
03
Your memory. Graph databases such as Neo4j, vector stores such as pgvector and Qdrant, files on object storage such as S3. Nothing here is migrated or modified.

03In numbers

The example task, counted.

  • 36%

    of the example task is the agent standing still, when memory is behind.

  • 2.5s

    comes back when memory is ahead: 10.3 s down to 7.8 s.

  • 0

    changes to your database. No migration, no new store to run.

  • 2

    tools for your agent, recall and remember. Coming soon.

04Stories

Three agents, the same wait.

Illustrative scenarios, not customers. Each shows one task twice: with memory behind the agent, and with memory ahead of it.

Support agent

A customer asks why they were charged twice. The agent walks their account history, then the billing docs, then answers.

memory: graph database, vector store

behind
7.5 s
ahead
5.7 s

40% waiting 21% waiting illustrative

05For your agent

Two calls. That is the whole interface.

BAiD will reach agents as an MCP server with two tools. This is a preview: it is not available yet and may change.

preview
{
  "tool": "recall",
  "arguments": {
    "query": "what did this customer ask about last week?",
    "token_budget": 1200
  }
}

The full description for agents, with when to use BAiD and when not to, is on the agents page.

06Fit

Where it helps, and where it will not.

A good fit

  • Several lookups per task. The agent looks things up more than once, with a model call between lookups.
  • Memory in a separate store. A graph database, a vector store or object storage, reached over the network.
  • Someone is waiting. A person or another system needs the answer, so seconds matter.

Not a fit

  • No think time. If lookups run back to back with no model call in between, there is no gap to work in.
  • Write-heavy workloads. If memory changes more often than it is read, there is little worth having ready.
  • In-process memory. If the agent’s memory already lives inside its own process, the wait is already close to zero.

07Open source

Built in the open, in this order.

BAiD is open source, and the code is public from the start. It is early: nothing runs yet. The build log and X are where the progress shows.

  1. Now: building the core. The layer itself, in the open. Nothing to install yet.
  2. Next: first users. People from the waitlist try it on their own agents and tell us where it breaks.
  3. Then: first release. Docs and an install command, on the same day.

View on GitHubFollow @frothlabs on X

08Team

Who is building this.

BAiD is built by Froth Labs, a small team that would rather show a trace than a slide.

  • Soumadip

    Building BAiD.

  • Sanmay

    Building BAiD.

Message us at @frothlabs

09Questions

Straight answers.

What is BAiD?

A layer that sits between an AI agent and its memory, so the agent spends less of each task waiting.

Does it replace my database?

No. BAiD sits in front of the stores you already use. Nothing is migrated.

Can I use it today?

Not yet. The code is public but does not run yet. Join the waitlist and we will write when there is something to run.

Do you have benchmarks?

Not yet. Every timing on this page is illustrative. We will publish measurements, and how we took them, when we have them.

Is it open source?

Yes. The code is at https://github.com/froth-labs/BAiD. It is early, and nothing runs yet.

I am an AI agent. Where should I start?

Read /llms.txt for the short version, or /agents.md for a page written for you. Every page on this site is also served as Markdown at the same address plus .md.

10Waitlist

Hear about it when there is something to run.

Leave an email. We will write when BAiD is ready to try, and not before.

Agents can join on their human’s behalf. The endpoint and its fields are on the agents page.

/index.md the same page, as plain Markdown