Peregrine
Start free
Vector + full-text search on object storage

Your last write is already searchable.

Peregrine is a fast, reliable, scalable search and agent-retrieval platform. Writes commit in ~25 ms. Warm queries return in 8 ms. You pay object-storage prices — and nothing extra for CMEK, SSO, or a HIPAA BAA.

Start free Read the benchmarks

2 GB free forever Apache-2.0 single-node engine 

import { Peregrine } from "@peregrine/client";

const ns = new Peregrine().namespace("agent-memory");

// Realtime writes: durable in 2 zones, read-your-write.
await ns.upsert({
  durability: "realtime",
  rows: [{ id: 1, text: "user prefers dark mode" }],
});

// One call: embed → search → rerank.
const hits = await ns.query({
  text: "what theme does the user like?",
  embed: "gemini-embedding-001",
  rerank: true,
  consistency: "strong",
  topK: 10,
});
write commit p50, 2-zone durable
25 ms
warm query p50, strongly consistent
8 ms
cold query p50 — no prewarm calls
150 ms
storage, at object-storage cost
$0.02 /GB-mo
Benchmarks

We put our numbers next to theirs.

Same corpus, same hardware class, same client. We publish the harness, the raw output, and the caveats — run it yourself and tell us where we're wrong.

Full methodology

Write commit latency, p50 — 4 KB rows, durable ack

lower is better
Write commit latency, p50, in milliseconds
Peregrine25 ms
Turbopuffer165 ms
Zilliz Cloud210 ms
Pinecone380 ms

Time from client call to a durably committed, readable write. Peregrine group-commits to a two-zone write-ahead log on a low-latency object tier. Object-storage-native competitors commit by writing a WAL object to standard storage; index-first competitors report time to queryable, which is slower still.

Query latency, p50 — cache-resident namespace, 10 M docs

lower is better
Warm query latency, p50, in milliseconds
Peregrine8 ms
Zilliz Cloud11 ms
Turbopuffer14 ms
Pinecone24 ms

Strongly consistent reads against a namespace already resident in node cache. Peregrine checks a single-row commit watermark in Spanner rather than object-storage metadata, which removes the ~10 ms consistent-read floor the object-storage generation lives with.

First query to an idle namespace — 1 M docs, nothing cached

lower is better
Cold query latency, p50, in milliseconds
Peregrine150 ms
Pinecone240 ms
Zilliz Cloud620 ms
Turbopuffer874 ms

The number that decides whether your p99 is survivable. Hot index tiers are read at sub-millisecond latency and prewarmed predictively, so the first query after an idle period costs 150 ms instead of the better part of a second.

Recall@10 against exact search — 10 M docs, 1536 dims

higher is better · axis starts at 0.930
Recall at 10 against exact search
Zilliz Cloud0.964
Peregrine0.962
Turbopuffer0.958
Pinecone0.951

Latency without recall is meaningless. All four systems are tuned to their documented high-recall configuration; Peregrine adds filter-aware centroid selection with an exact fallback below a selectivity threshold, so recall does not collapse under heavy metadata filters.

Monthly bill — 1 TB stored, 200 GB written, 50 M queries, CMEK required

lower is better
Modelled monthly bill in US dollars
Peregrine$420
Zilliz Cloud$960
Pinecone$2,530
Turbopuffer$4,096

List prices as published in July 2026. Peregrine and Turbopuffer charge almost identical unit rates; the difference is that CMEK and private networking are included in our $199 Scale tier and gated behind a $4,096 Enterprise minimum plus a 35% usage premium at Turbopuffer.

v0.9 harness · 10M docs · 1536 dims · synthetic corpus · figures for other systems from vendor docs and third-party runs, July 2026

Why Peregrine

Three walls everyone else is still hitting.

  1. freshness

    Writes land in 25 ms, not 200

    The write-ahead log lives on a zonal low-latency tier with stateful appends, replicated to a second zone before we ack. No one-commit-per-second ceiling per namespace — agent memory, CDC streams and session indexing all work.

    Incumbent write commit200 ms
    Peregrine25 ms
  2. cold starts

    No 900 ms first query

    Hot index tiers are read at sub-millisecond latency and predictive prewarming hydrates caches before your traffic arrives. Cold p50 lands at 150 ms — and you stop writing prewarm calls into your application.

    Incumbent first query900 ms
    Peregrine cold p50150 ms
  3. price gates

    CMEK at $199, not $4,096

    Customer-managed keys, SSO, private networking and a HIPAA BAA are included from the Scale tier. No enterprise minimum, and no 35% usage premium for buying the secure plan.

    Incumbent CMEK minimum$4,096
    Peregrine Scale tier$199
Architecture

What happens between upsert() and a ranked hit.

Stateless compute, immutable segments, one authority for ordering. Every layer degrades to incumbent parity rather than to an outage.

  1. ingest

    Leased writer

    One epoch-fenced lease per namespace assigns monotonic LSNs. Failover in under 2 s.

  2. durability

    Two-zone WAL

    Group-committed appends, replicated across zones. A slow zone is abandoned at 30 ms and repaired later.

  3. index

    Immutable segments

    Centroid ANN plus BM25 and filter indexes, built on spot capacity. Deletes are sidecar bitmaps, never rewrites.

  4. serve

    Cache-routed query

    Bounded-load consistent hashing keeps namespaces warm without letting one tenant melt a node.

  5. pipeline

    Fuse and rerank

    Optional RRF fusion and cross-encoder reranking before the response leaves. Skippable by design.

Consistency

A dial, not a switch.

Most engines make you choose between a strongly consistent read floor and staleness measured in hours. Peregrine takes a bound per query, so a product surface that tolerates five seconds doesn't pay for one that can't.

Query p50 · strong8 ms
Max staleness
none
Watermark check
every query
Best for
Agent memory, dashboards

One single-digit-millisecond point read of the namespace commit watermark, then the unindexed log tail is scanned inline. Your write is visible the moment it is acked.

Query p50 · bounded(5s)6 ms
Max staleness
5 s
Watermark check
cached, 1 s refresh
Best for
Product search, RAG

The middle ground nobody else offers. A cached watermark refreshed once a second gives you a stated upper bound on staleness instead of a shrug — and it doubles as the availability fallback if the control plane is unreachable.

Query p50 · eventual4 ms
Max staleness
until next index pass
Watermark check
skipped
Best for
Recommendations, analytics

No watermark check at all. Appropriate when a stale result is a slightly worse recommendation rather than a bug report.

Pricing

Same workload. One tenth the bill.

1 TB stored, 200 GB written per month, 50 M queries — with customer-managed encryption keys and private networking, which mid-market healthcare and fintech buyers cannot ship without.

The gap isn't unit price. We match on storage, writes and query scan. The gap is that the incumbent puts CMEK behind a $4,096 minimum and adds 35% to every usage line once you're there.

Open the calculator
Estimated monthly billCMEK required
  • Peregrine — Scale$420
  • Zilliz Cloud$960
  • Pinecone$2,530
  • Turbopuffer — Enterprise$4,096
Modelled from each vendor's published list prices, July 2026. Turbopuffer's figure is its Enterprise minimum, not its usage cost — at these volumes its usage would be roughly $567.

Bring the workload nobody else will take.

We're onboarding design partners running agent memory and multi-tenant B2B search. You get the engineering team on a shared channel and pricing locked for two years.

Start free Become a design partner