Join preview

The agent-native search database.

Your agents are really good at grep. Now they can do it across terabytes, in milliseconds.

Join preview Docs soon
recall
100%
precision
100%
regex p90 on TBs
<100ms
query cost when idle
$0
An agent runs a regex over 920 million call transcript utterances and gets every match back in 34 milliseconds.

agent › flag every call where a customer hinted at churning

tool  › search(regex=r"cancel|switch(ing)? to|too expensive")

calls/**/*.vtt1.3 TB

utterances scanned
920,000,000
matches
186
elapsed
34 ms
  1. 1calls/2026-10/acme-renewal.vtt:412CUSTOMER: honestly it's too expensive for what we use
  2. 2calls/2026-09/globex-support.vtt:87CUSTOMER: we're looking at switching to another vendor

+ 184 more

Why grep, not vectors.

  1. Models got good at grep.

    Claude Code has no vector index. It greps, and so does Cursor. Grepvine runs the same search over terabytes.

    A coding agent is asked why payments fail. It greps the repo and finds 2 matches, then runs the same pattern over 2.1 TB of logs with Grepvine and gets 2,311 matches in 61 ms.

  2. The model decides what’s similar.

    An embedding fixes “similar” once, at index time. An agent decides per question, then refines on what it finds.

    Asked for customers upset about late deliveries, a vector database returns the top 5 chunks by similarity: 4 are off topic, like a late fee or a late checkout, and it never ranks “still hasn’t arrived”. An agent with Grepvine searches for phrasings, narrows to orders and packages, then searches other languages, and finds 903 complaints.

  3. Automation needs every match.

    A person can skim the top five. An agent acting on results needs all of them.

    A chatbot answers a question with the top 5 results by similarity, which is enough for a person to read. An erasure job needs every record for one email address, and erases all 39.

  4. No embeddings to pay for.

    Finding one order ID shouldn't take chunking, an embedding model and 4.6× the storage.

    Storage for 1 GB of orders. A vector database stores 4.6 GB: 1.15 GB of chunk text with overlap plus 3.45 GB of embeddings. Grepvine stores 1.25 GB: your 1 GB as is plus a 0.25 GB index.

Scales to zero.

  • No clusters to size
  • No shards to rebalance
  • No query bill while your agents sleep
Over 24 hours, an always-on cluster bills for peak capacity every hour. Grepvine bills queries only as agents run them, so the overnight query bill is zero. Storage bills by the GB-month either way. always-on cluster 00:00 12:00 24:00
grepvine bills these queries a cluster bills this too

Price your workload

$0.50 per GB-month. $0.01 per 1,000 API calls, reads or writes. No minimum.

100 GB
10M (~4 queries/second)

grepvine 10× less

storage 125 GB × $0.50
$62.50
API calls 10M × $0.01/K
$100.00

per month$162.50

vector DB, serverless

storage 460 GB × $0.33
$151.80
queries 9M × 10 RU × $16/M
$1,440
writes 1M × 8 WU × $4/M
$32.00
embeddings 512M tokens × $0.02/M
$10.24

per month$1,634

How the vector database bill is estimated
  • Grepvine side: the index adds 25% to the bytes you send, and storage bills on both. 1 GB of text becomes 1.25 GB stored.
  • Vector side: 512-token (~2 KB) chunks with 15% overlap, 1,536-dimension float32 embeddings, chunk text kept as metadata. 1 GB of text becomes 4.6 GB indexed.
  • A vector query bills 1 read unit per GB of the namespace it searches. We assume namespaces of up to 10 GB, so a vector query covers at most 10 GB while a grepvine call covers everything. This favors the vector DB. Nine in ten calls are reads.
  • A write is one ~2 KB document: an 8 KB record (8 write units) plus 512 tokens of embedding.
  • Serverless vector DB list prices, October 2026: $0.33 per GB-month, $16 per million read units, $4 per million write units, $50 monthly minimum. Embeddings at $0.02 per million tokens. Excludes embedding the corpus the first time.

Made by the team behind lakeFS.

Building petabyte-scale AI infrastructure since 2020.

github.com/treeverse/lakeFS

Built for agent traffic.

One agent task can fire off dozens of searches. Grepvine handles tens of thousands a second across billions of documents, and answers in milliseconds.

One agent branches into many searches, each reaching its exact matches in a field of billions of documents. 1 agent searches billions of documents

FAQ.

  • Is Grepvine a vector database?

    No. A vector database embeds your data once and returns the top-k chunks nearest your query. Grepvine returns every literal or regex match, and your agent decides what counts as similar: it writes the patterns, reads the matches and searches again. No embeddings, no chunking, no approximate index.

  • What makes it serverless search?

    There are no clusters, shards or replicas to run. You pay $0.50 per GB-month and $0.01 per 1,000 API calls. When your agents stop searching, the query bill stops too.

  • How do AI agents search with Grepvine?

    With a tool call, like the grep coding agents already run. One task fans out into dozens of searches, and each returns the complete result set in milliseconds, over terabytes.

  • When is a vector database the better fit?

    When a person reads the answer and a few similar passages are enough, as in a chatbot. When an agent acts on results, like erasing records or retrying failed requests, it needs every exact match.

Give your agents exact search.

Private preview. First query in minutes.

Join preview 
from grepvine import Grepvine

db = Grepvine().index("orders")

hits = db.search(
    literal="CUS-48211",
)
for hit in hits:
    agent.refund(hit.id)