# Can Your AI Analyst Keep a Secret? - Aaron Linsky, Bridgewater & Nikhil Benesch, turbopuffer

Nikhil Benesch, turbopuffer · Aaron Linsky, Bridgewater Associates

[Talk page](https://ai.engineer/talks/u_jvuCjuvEk-your-ai-analyst-keep-secret) · [Video](https://www.youtube.com/watch?v=u_jvuCjuvEk)

## Can Your AI Analyst Keep a Secret?

Bridgewater’s Vault holds about 100 million documents with different access rules. Aaron Linsky and Nikhil Benesch explain why those permissions complicate vector search, and how turbopuffer combines permission indexes with vector clusters to keep retrieval fast.

![The analyst diagram sends a question to a language model that searches two collections. The public web is open to everyone. Private documents carry individual permissions.](https://ai.engineer/api/talk-essay-media/7271c43aaf1f6b3724a20a52842ee98dfbca15061ad627ae57002758e1bc1ce5)

The analyst diagram sends a question to a language model that searches two collections. The public web is open to everyone. Private documents carry individual permissions.

### The analyst’s search results depend on who is asking

[0:12](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=12s)

An AI analyst receives a question: why have token prices fallen so much in the last month? The model begins investigating and searches for facts to guide its next steps. Public web pages can enter that investigation regardless of which employee asked the question. Internal emails, meeting notes and research reports require a different decision: is this particular user allowed to see this particular document?

That is the search problem Aaron Linsky, head of product engineering at Bridgewater Associates, and Nikhil Benesch, CTO of turbopuffer, develop in this talk. A document can grant access to an individual, a group, or some combination of them. The analyst needs relevant evidence drawn from the documents its user can access. Finding nearby vectors is only part of that job; the search also has to respect a different permitted collection for each user.

### The Vault brings research and permissions together

[2:07](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=127s)

Bridgewater’s research process starts with observations about markets and economies and turns tested ideas into systems that trade. Its 1980 bond system was a set of if-then statements on a yellow legal pad. The implementation moved through Excel, Scala and Python, while the learning process kept humans at its center: perceive what is happening, form a hypothesis, investigate it, systemize and integrate successful ideas, then industrialize them so they run every day.

![The Vault example shows a user with an ID and group memberships beside three documents. Highlighted entries distinguish a direct grant from access through a group.](https://ai.engineer/api/talk-essay-media/5fbca7dc59b7a3ea62372cb1c72f0f59cd877cb6e7cdeac4fa54fa61531a6916)

The Vault example shows a user with an ID and group memberships beside three documents. Highlighted entries distinguish a direct grant from access through a group.

Moving machines toward the center of that process makes access to research material essential. Bridgewater has spent decades building DeLorean, its bitemporal macro time series database. The Vault supplies the unstructured side: about 100 million documents that Bridgewater indexes, organizes and secures. It combines research from 135 external sources with internal writing, meeting recordings and reports. External sources have their own access restrictions, so bringing material into one database does not make it available to everyone.

Investors and AI agents both read from the Vault, and the new content they create goes back into it. Search therefore serves an expanding research collection. In Linsky’s simplified permissions example, user 1 belongs to groups B and C. A document may be accessible through a direct grant to that user or through one of those groups. A vector query has to combine similarity with those access conditions.

The first implementation appeared to work. Then the growing document collection overwhelmed it—Linsky’s description is that it “fell over.” He looked for other providers and tested turbopuffer. The failure establishes the practical requirement for the rest of the talk: permission logic that looks simple in a query must remain affordable when the collection reaches tens of millions of documents.

### Cheap storage still needs a way to skip work

[6:25](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=385s)

turbopuffer stores data directly in object storage such as S3, GCS or Azure Blob Storage. Data begins cold there; queries cause the needed data to move into SSD or memory caches. An untouched namespace—or an untouched region within a namespace—can stay in cheaper storage. Frequently accessed data becomes hot and can serve faster searches. Benesch attributes the system’s cost advantage to this arrangement, with the performance comparison to traditional disk-based search systems explicitly depending on the data being hot.

![A table estimates the time to scan collections from ten thousand to one hundred million documents. Each column assumes a different source of bandwidth.](https://ai.engineer/api/talk-essay-media/a84dc20a9559cd0fc494c9a9390d88e7d5656da3ebec4c5e0ec2c0647528cf4f)

A table estimates the time to scan collections from ten thousand to one hundred million documents. Each column assumes a different source of bandwidth.

The engine supports keyword, regular-expression and vector search. Benesch focuses on vector search to explain the indexing problem, beginning with the simplest possible implementation: store everything in a list and inspect every item for every query. His engineering preference is to earn complexity with napkin math before introducing it.

Assume each document occupies only one kilobyte. Even an embedding can consume that much: 1,024 dimensions at one byte per dimension already amounts to roughly a kilobyte, before larger document contents enter the calculation. At the assumed scan rate of 20 gigabytes per second, 100 million one-kilobyte documents take about five seconds to inspect, even when all the data is resident in memory. That misses the roughly 100-millisecond response time Benesch says search users commonly want.

At 10,000 documents, the same calculation gives about half a millisecond, so a scan can be perfectly reasonable. Scale changes the decision. At 10 million or 100 million documents, the representation must let a query avoid most of the collection. For 100 million documents, the table estimates 50 seconds for “S3 (many)” at 2 GiB/s and 1,000 seconds for “S3 (1)” at 100 MiB/s. A cache hit avoids fetching that data from S3. An index reduces how much data the query needs to access.

### Vector search narrows the neighborhood

[9:43](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=583s)

An embedding represents a concept numerically so that similar concepts can lie near one another. Red shoes and maroon sandals make an intuitive pair; a concrete block is much less similar. The teaching example reduces vectors to two dimensions so they can be plotted. Those axes are not established semantic labels such as size and color—Benesch offers those only as an intuition. Real embeddings commonly have 1,024 dimensions, and may have thousands.

What work does the index let the query avoid? In the two-dimensional example, red shoes and maroon sandals occupy the upper-left region, while concrete block lies toward the lower right. A query marked Q for red shoes can search its local neighborhood instead of examining the whole plot. Nearby vectors supply plausible results because proximity represents conceptual similarity. The spatial relationship explains the saving: searching around Q avoids spending the same effort on distant concepts.

![A two-dimensional scatterplot illustrates the vector index. Beside it, example vector values represent red shoes, maroon sandals and a concrete block.](https://ai.engineer/api/talk-essay-media/913292104ae79195236f1184221f18df3214c568841c659c3b1d0ec2829a547e)

A two-dimensional scatterplot illustrates the vector index. Beside it, example vector values represent red shoes, maroon sandals and a concrete block.

turbopuffer builds a vector index automatically once the stored data is large enough to justify it. A query might then inspect only 10,000 vectors, which Benesch estimates can take a millisecond or two. Permissions disturb this useful shortcut. In the next version of the example, plus signs mark documents the user may access and minus signs mark documents they may not. A neighborhood can be close to Q yet contain few usable results.

### Filtering before or after search creates different failures

[12:19](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=739s)

Two straightforward strategies choose a different starting point:

- **Post-filtering:** Find nearby vectors first—perhaps the closest 10,000—then discard documents whose permissions do not match.
- **Pre-filtering:** Find every document the user can access first, then scan those documents to determine which vectors are closest to the query.

Why can a nearest-neighbor search miss the nearest accessible results? Suppose the user can access only documents in the lower-right region of the example. Searching around Q first spends its effort on forbidden points. Expanding outward may eventually reach accessible documents, but the search has a time budget. It can stop after a couple of seconds with only 40 of the requested top 100 results—or with none. A user searching for red shoes may know that an accessible maroon-sandals document exists and still fail to retrieve it. This is the recall problem: relevant, permitted documents are missing from the returned set.

![The pre-filtering example connects the query to accessible documents across the plot. The query plan calculates their distances before selecting the nearest results.](https://ai.engineer/api/talk-essay-media/38de8651ad0ca1bcd6e963caedea9d2bb3a13ebc7f5d56e159f0fe2cba3a1205)

The pre-filtering example connects the query to accessible documents across the plot. The query plan calculates their distances before selecting the nearest results.

Pre-filtering avoids spending similarity calculations on forbidden documents, but the permitted set can itself be enormous. If Aaron can access 50 million of the Vault’s 100 million documents, scanning the permitted half brings back the original bandwidth problem. The filter index has found the right population; it has not used vector proximity to make that population cheap to search. One strategy risks running out of useful candidates, while the other risks doing far too much work.

### Native filtering removes empty clusters before searching nearby ones

[14:09](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=849s)

turbopuffer combines the two approaches through a clustered vector index. Similar vectors are grouped together. The permission indexes also identify which clusters contain at least one document the user may access. That gives the query a useful middle level between individual documents and the entire collection: it can eliminate a whole cluster when none of that cluster’s documents could become a permitted result.

Which clusters survive for Aaron? In Benesch’s example, clusters 5 and perhaps 2 contain documents he can access, while clusters 3 and 0 contain none. The latter can be discarded before similarity search. Among the surviving clusters, the engine searches the closest ones and scans sequentially inside them. A surviving cluster means that at least one document qualifies; it does not grant access to every document in the cluster. The combination still has to return documents that satisfy the permission filter.

![In the native filtering example, the query plan drops clusters without accessible documents, then searches nearby qualifying clusters and checks individual documents.](https://ai.engineer/api/talk-essay-media/9611da76bf1a86c7552540ff6bdf253bd1026d8514416e784e79b54db4c31185)

In the native filtering example, the query plan drops clusters without accessible documents, then searches nearby qualifying clusters and checks individual documents.

turbopuffer calls this native filtering. Searching only selected clusters saves work, but it can miss a permitted document that belongs in the nearest results. The slide shows about 95% recall for native filtering. Scanning every matching document considers every permitted candidate.

At the time of the talk, clusters contain about 200 documents. Benesch describes that size as a tuning choice and expects it may increase to maximize throughput. The essential mechanism is the combination of permission-aware cluster selection and local scanning; 200 is the reported configuration, not a necessary constant of the design.

Permissions prune clusters; similarity selects where to scan
An eligible cluster contains at least one accessible document. Eligibility keeps it in consideration; it does not authorize every document inside it.
- User’s permission filter — Identify clusters containing at least one document Aaron can access.
- Clusters 3 and 0 — Contain no accessible documents; exclude them from the search.
- Clusters 5 and possibly 2 — Contain accessible documents; remain candidates for similarity search.
- Closest eligible clusters — Use vector proximity to select among the surviving clusters.
- Scan inside selected clusters — Examine local vectors while applying document permissions.
- User’s permission filter → Clusters 3 and 0 (No accessible documents)
- User’s permission filter → Clusters 5 and possibly 2 (At least one accessible document)
- Clusters 5 and possibly 2 → Closest eligible clusters (Search nearest surviving clusters)
- Closest eligible clusters → Scan inside selected clusters (Scan sequentially within)

### The application supplies the access rule

[15:23](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=923s)

The reported result is 120 milliseconds at P90 across the deployment’s namespaces, for a collection of about 100 million documents. P90 describes the latency at the ninetieth percentile, rather than a maximum for every query. The deployment held hundreds of millions of vectors. The application-facing question remains much simpler than the indexing work: how does user 1’s membership in B and C become a search filter? The displayed example uses `viewers Contains 1` and `groups ContainsAny B C`.

![A filter example combines a direct viewer grant with group membership. The slide lists nested groups and changes in group membership as limitations.](https://ai.engineer/api/talk-essay-media/c7281fe3296345b0c1d491636a58fc64021c934fa1913fdb642c91575d2948d3)

A filter example combines a direct viewer grant with group membership. The slide lists nested groups and changes in group membership as limitations.

The displayed query combines the permission rule with a deletion check.

```text
eligible(document) =
    document.deleted equals false
    AND (
      document.viewers contains 1
      OR document.groups contains
         any of [B, C]
    )
```

Either a direct grant or a grant through one of the user’s groups satisfies the permission rule. The deletion check applies to both paths.

The application expresses that permission logic in turbopuffer’s filter language, and the engine handles query planning underneath it. This division lets the application retain its conceptual access model without implementing the clustered search strategy itself. Benesch describes searches in the roughly 100–200-millisecond range even at 100-million-document scale.

The slide identifies two costs of maintaining the permission data. Nested groups amplify the metadata updates the application must push to turbopuffer. Changes in group membership can require rewriting all affected documents, which the slide describes as slow. Benesch invites teams with nested groups to work through them with turbopuffer.

### Permissions are one level of search isolation

[17:00](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=1020s)

The ending widens the requirement from document visibility to what Benesch calls an “isolation-native search engine.” Fine-grained permissions operate within namespaces, but organizations can also need controls over where data resides and who controls its protection:

- **Regional placement:** Keep data in a particular region to meet security or regulatory obligations.
- **Network placement:** Keep data inside the organization’s own VPC.
- **Encryption control:** Support keys controlled by the organization, potentially extending that control to its customers.

Benesch presents turbopuffer as having solutions at each of these levels, though this talk explains the mechanics of permission filtering rather than those deployment controls. Bridgewater’s case makes the retrieval requirement concrete: an analyst needs a large shared research collection, yet its useful search space changes with the user. Native filtering makes those access rules part of deciding where to search, allowing the engine to skip work before the document scan becomes prohibitively large.

## Key takeaways

- Permission-aware retrieval must find relevant documents within the user’s accessible collection. Nearby vectors alone do not identify usable results.
- Post-filtering can miss accessible results when forbidden documents dominate the nearest neighborhood. Pre-filtering can require scanning tens of millions of permitted documents.
- Native filtering eliminates clusters with no accessible documents, searches the closest surviving clusters, and scans locally while retaining document-level permission checks.
- The deployment reports 120-millisecond P90 search latency at about 100 million documents. Applications express the permission predicate; nested groups remain a complication.

## Related talks

- [The Investor's Edge Lives in Their Head — Anekha Sokhal, Moshi](https://ai.engineer/talks/UHbODjuviAU-investors-edge-lives-in-their-head-anekha) — 
- [AI’s Jurassic Park Period](https://ai.engineer/talks/1lgFGaHoGq8-ais-jurassic-park-period) — 

## Slides

### Can your AI analyst keep a secret?

Nikhil Benesch of turbopuffer and Aaron Linsky of Bridgewater introduce how to build an AI analyst that can keep a secret, with permissions as a central concern.

[0:12](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=12s) [Talk title with presenters Nikhil Benesch and Aaron Linsky and their organizational roles.](https://assets.ai.engineer/sites/aiecode2025/sha256/b19a1f87a2927ef48b41ab1fea4b8b44e34c2241de6567d3e80b155fe76ca6c1.webp)

can your AI analyst
keep a secret?

AI ENGINEER NYC
01/17

Nikhil Benesch
CTO, turbopuffer

Aaron Linsky
Head of Product Engineering, Bridgewater

turbopuffer

OCTOBER 14, 2026
BREAKOUT SESSION
Shannon Room

Interface text:
Can your AI analyst keep a se
 docs.google.com/presentation/d/[illegible]/edit?slide=id.p&pli=1#slide=id.p
Ask Google

### What is an AI analyst? (oversimplified)

An LLM investigates a user's question by searching public and private documents. Public documents are available to everyone; the colored private documents carry different permissions that retrieval must respect for each user.

[0:30](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=30s) [A user questions an LLM that searches public web documents and private documents with complex permissions.](https://assets.ai.engineer/sites/aiecode2025/sha256/79d61ebb936ded76eb7e952056859ab278755861f3bc4d6eeb7c890437fcc691.webp)

what is an AI analyst? (oversimplified)

AI ENGINEER NYC
02/17

user
ID: 1
question →

LLM
thinking
search

public web
no permissions → “easy”

private docs
complex permission sets → “hard”

turbopuffer

OCTOBER 14, 2026
BREAKOUT SESSION
Shannon Room

Interface text:
Can your AI analyst keep a se[illegible]
docs.google.com/presentation/d/[illegible]/edit?slide=id.ha8edcdd4092b7d3_3_32&pli=1#slide=id.ha8edcdd4092b7d3_3_32
Ask Google

### What is the Vault?

Bridgewater’s Vault brings research from 135 external sources together with internal writing, meetings and reports. It indexes, organizes and secures about 100 million documents for investors and AI agents to read.

[4:10](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=250s) [External and internal sources feed a Vault of approximately 100 million indexed, organized, secured documents used by investors and an AI analyst.](https://assets.ai.engineer/sites/aiecode2025/sha256/32de05eff5a963355fc14de6faca87b1fcf21f749a264fcd2842a9a6070590b3.webp)

what is the Vault?

AI ENGINEER NYC
05/17

external sources
135 sources
around the world

internal sources
our own writing,
meetings & reports

the Vault
~100M documents

indexed
organized
secured

humans
investors

agents
AI analyst

turbopuffer

For illustrative purposes only. Please review the “Important Disclaimers and Other Information at the end of this presentation.

Interface text:
Can your AI analyst keep a se[illegible]
docs.google.com/presentation/d/[illegible]
Ask Google
OCTOBER 14, 2026
BREAKOUT SESSION
Shannon Room

### Permissions in the Vault

In this simplified example, user 1 can see doc 1 through direct viewer permission and doc 2 through membership in groups B and C. Doc 3 stays hidden because neither permission matches.

[5:12](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=312s) [A simplified user searches documents; direct viewer permission or group membership makes two documents visible while another remains hidden.](https://assets.ai.engineer/sites/aiecode2025/sha256/b9626669aaf733d8fa06d8854088c89148df4c2bf82fcaef3f61aecaeed5bfbd.webp)

permissions in the Vault

AI ENGINEER NYC
06/17

user
ID: 1
groups: B,C

search →

documents
          viewers   groups
doc 1     1, 5      A
doc 2     -         B,C
doc 3     2         A

✓ visible: view
✓ visible: group
× hidden

turbopuffer

For illustrative purposes only. Please review the “Important Disclaimers and Other Information at the end of this presentation.

OCTOBER 14, 2026
BREAKOUT SESSION
Shannon Room

Interface text:
Can your AI analyst keep a se[illegible]
docs.google.com/presentation/d/[illegible]/edit?slide=id.ha8edcdd4092b7d3_3_207&pli=1#slide=id.ha8edcdd4092b7d3_3_207
Ask Google

### How this looks in code

The query requests 10 nearest vector matches, allowing documents where user 1 is a viewer or the document belongs to group B or C. An additional filter excludes deleted documents.

[5:41](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=341s) [A vector query returns ten results filtered by viewer permission or group membership, excluding deleted documents.](https://assets.ai.engineer/sites/aiecode2025/sha256/6d4286400b0af6e8ffdd924a84454590585051b1a305aad8f03ef11c72030cb6.webp)

how this looks in code

AI ENGINEER NYC
07/17

ns.query(
    rank_by=("vector", "ANN", query_vector),
    top_k=10,
    filters=("And", (
        ("Or", (
            ("viewers", "Contains", 1),
            ("groups", "ContainsAny", ["B", "C"]),
        )),
        ("deleted", "Eq", False),
    )),
)

turbopuffer

For illustrative purposes only. Please review the “Important Disclaimers and Other Information at the end of this presentation.

OCTOBER 14, 2026
BREAKOUT SESSION
Shannon Room

Interface text:
Can your AI analyst keep a se[illegible]
docs.google.com/presentation/d/[illegible]
Ask Google

### turbopuffer: fast search on object storage

turbopuffer stores data in object storage and pulls queried data into an SSD/RAM cache. Keeping only hot data in cache lowers costs and makes repeat queries fast. It supports vector, keyword, and regex search.

[6:28](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=388s) [A client connects through an API to turbopuffer, with an SSD and RAM cache backed by object storage. Notes list vector, keyword, and regex search and describe hot-data caching.](https://assets.ai.engineer/sites/aiecode2025/sha256/efe81f76c738c88132a07270834ee3bf3ec2344e8295590ca7919bf4904d1b57.webp)

turbopuffer: fast search on object storage

AI ENGINEER NYC
08/17

client ↔ API ↔ turbopuffer
Inside turbopuffer:
./tpuf ↔ Cache (SSD/RAM) ↔ Object Storage (S3/GCS)

vector, keyword, regex search
cheap: only keep hot data in cache
hot queries fast, cold queries tolerable

turbopuffer

OCTOBER 14, 2026
BREAKOUT SESSION
Shannon Room

Interface text:
Can your AI analyst keep a se[illegible]
docs.google.com/presentation/d/[illegible]/edit?slide=id.[illegible]
Ask Google

### Search over 100M documents

At 1 kB per document, a full scan of 100M documents takes 5s in memory, 50s across many S3 connections, or 1,000s with one. Even memory misses the 100–200ms target, explaining why search at scale needs more than full scans.

[7:53](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=473s) [Table comparing scan times across memory, SSD and object storage, with a target latency of 100–200 milliseconds.](https://assets.ai.engineer/sites/aiecode2025/sha256/b38393aee5c687e1d9aa14a52dfece6dc86a5e72ddc792043b1b00e3ae949b65.webp)

search over 100M docs: a hard systems problem

AI ENGINEER NYC
09/17

1 kB per doc
(very conservative)

target latency
100-200ms

docs | data | memory 20 GiB/s | SSD 8 GiB/s | S3 (many) 2 GiB/s | S3 (1) 100 MiB/s
10k | 10 MB | 0.5ms | 1.25ms | 5ms | 100ms
100k | 100 MB | 5ms | 12.5ms | 50ms | 1s
1M | 1 GB | 50ms | 125ms | 500ms | 10s
10M | 10 GB | 500ms | 1.25s | 5s | 100s
100M | 100 GB | 5s | 12.5s | 50s | 1,000s

turbopuffer

Interface text:
Can your AI analyst keep a se[illegible]
docs.google.com/presentation/d/[illegible]
Ask Google
OCTOBER 14, 2026
BREAKOUT SESSION
Shannon Room

### Vector index

Nearby vectors represent similar concepts, so an index can narrow the search. But the diagram places Q near documents that fail the filter; documents matching the permissions sit farther away.

[9:40](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=580s) [Vector-space diagram showing a query and documents matching or failing a filter, beside example embeddings and a note about 1024 dimensions.](https://assets.ai.engineer/sites/aiecode2025/sha256/13423b4ca9b86b939e522bfcb72dfc47561e37b3565835a336ab2438f0b37c51.webp)

vector index

AI ENGINEER NYC
11/17

vector space
Q
Document markers: −, +

legend:
Q: query vector
+: document matching the filter
-: document not matching the filter

example vector embeddings

red shoes:      [0.023, -0.147, ...]
maroon sandals: [0.027, -0.122, ...]
concrete block: [-0.71, 0.94, ...]

commonly ~1024 dimensions

turbopuffer

OCTOBER 14, 2026
BREAKOUT SESSION
Shannon Room

Interface text:
Can your AI analyst keep a se[illegible]
docs.google.com/presentation/d/[illegible]
Ask Google

### Bad strategy #1: postfiltering

Postfiltering finds nearby vectors, then removes documents the user cannot access. The orange circle contains only nonmatching documents; accessible results sit farther away, so fast vector search can still miss relevant results.

[12:17](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=737s) [A circle around the query contains documents failing the filter; the query plan explains fast vector-index search with poor recall.](https://assets.ai.engineer/sites/aiecode2025/sha256/c77713b916933448dd4a5d13864d9841a99b325326d7bceb37c4a9258aa1da5f.webp)

bad strategy #1: postfiltering

AI ENGINEER NYC
11/17

vector space
Q

legend:
Q: query vector
+: document matching the filter
-: document not matching the filter

query plan:
1. find nearest neighbors
2. evaluate filter
3. sort by distance asc
4. return top k

good: fast, uses vector index
bad: poor recall

the nearest neighbors don’t
match the filter!

turbopuffer

OCTOBER 14, 2026
BREAKOUT SESSION
Shannon Room

Interface text:
Can your AI analyst keep a se
 docs.google.com/presentation/d/[illegible]
Ask Google

### Bad strategy #2: prefiltering

Prefiltering computes the distance from Q to every document matching the filter, then returns the nearest matches. It achieves 100% recall, but bypasses the vector index: scanning many permitted documents can be slow.

[13:18](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=798s) [Lines connect the query to filter-matching documents; the query plan describes full recall but slow scanning without the vector index.](https://assets.ai.engineer/sites/aiecode2025/sha256/f3e8c465deba65dc6a499b459227b775b34d183a0e745db1bf5c642499308c93.webp)

bad strategy #2: prefiltering

AI ENGINEER NYC
10/17

vector space

legend:
Q: query vector
+: document matching the filter
-: document not matching the filter

query plan:
1. find docs that match filter
2. compute distance to each one
3. sort by distance asc
4. return top k

good: 100% recall
bad: slow

does not use vector index!

turbopuffer

OCTOBER 14, 2026
BREAKOUT SESSION
Shannon Room

Interface text:
Can your AI analyst keep a se[illegible]
docs.google.com/presentation/d/[illegible]/edit?slide=id.ha8edcdd4092b7d3_3_71&pli=1#slide=id.ha8edcdd4092b7d3_3_71
Ask Google

### Isolation beyond permission

Document permission filters sit inside namespace, cluster and organization controls. The nested boxes show how isolation extends to encryption, private networking, dedicated compute and regional data residency.

[16:57](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=1017s) [Nested organization, cluster, namespace and document boundaries list isolation controls, including encryption, networking, customer-managed keys and permission filters.](https://assets.ai.engineer/sites/aiecode2025/sha256/1c5c897dc511816ab7adbfef57f63950bcb7fc840cda6caa313c94d3b5c1bd7d.webp)

isolation beyond permission

AI ENGINEER NYC
16/17

org
IP allowlisting    SSO    API keys

cluster
encryption at rest/cache encryption
private networking
single-tenant/dedicated compute
regional data residency
BYOC    BYOB
namespace isolation

namespace
CMEK

document
permission filters

turbopuffer

OCTOBER 14, 2026
BREAKOUT SESSION
Shannon Room

Interface text:
Can your AI analyst keep a se[illegible]
docs.google.com/presentation/d/[illegible]/edit?slide=id.ha8edcdd4092b7d3_3_113&pli=1#slide=id.ha8edcdd4092b7d3_3_113
Ask Google

### Fast, isolation-native search at 100M+ scale

The closing slide highlights isolation-native search at 100M+ scale. The speakers frame this as the result of turbopuffer and Bridgewater working together.

[17:38](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=1058s) [Closing slide reads fast, isolation-native search at 100M+ scale, with isolation-native highlighted in orange and a thank-you message below.](https://assets.ai.engineer/sites/aiecode2025/sha256/e01857a4a0c04793fee73a619c2718d01c3b848d57bdaf994e03ccf5e68c1e6a.webp)

fast, isolation-native
search at 100M+ scale

thank you!

AI ENGINEER NYC
17/17

turbopuffer

Engineering the future of AI

Interface text:
Can your AI analyst keep a se[illegible]
docs.google.com/presentation/d/[illegible]
Ask Google

### Important Disclosures and Other Information

Bridgewater closes with disclosures limiting the research to informational and educational use, outlining investment risks and data limitations, and noting distribution restrictions and potential financial interests.

[17:49](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=1069s) [Text disclosure page covering research purposes, investment risks, data sources, distribution restrictions and potential financial interests.](https://assets.ai.engineer/sites/aiecode2025/sha256/c38ae159982e2b790c060c62838c89b8fb77b07c823c9fdb8711084b344b0690.webp)

Important Disclosures and Other Information:

This research is prepared by and is the property of Bridgewater Associates, LP and is circulated for informational and educational purposes only. There is no consideration given to the specific investment needs, objectives, or tolerances of any of the recipients. Additionally, Bridgewater's actual investment positions may, and often will, vary from its conclusions discussed herein based on any number of factors, such as client investment restrictions, portfolio rebalancing and transactions costs, among others. Recipients should consult their own advisors, including tax advisors, before making any investment decision. This material is for informational and educational purposes only and is not an offer to sell or the solicitation of an offer to buy the securities or other instruments mentioned. Any such offering will be made pursuant to a definitive offering memorandum. This material does not constitute a personal recommendation or take into account the particular investment objectives, financial situations, or needs of individual investors which are necessary considerations before making any investment decision. Investors should consider whether any advice or recommendation in this research is suitable for their particular circumstances and, where appropriate, seek professional advice, including legal, tax, accounting, investment, or other advice. No discussion with respect to specific companies should be considered a recommendation to purchase or sell any particular investment. The companies discussed should not be taken to represent holdings in any Bridgewater strategy. It should not be assumed that any of the companies discussed were or will be profitable, or that recommendations made in the future will be profitable.

The information provided herein is not intended to provide a sufficient basis on which to make an investment decision and investment decisions should not be based on illustrative information that has inherent limitations. Bridgewater makes no representation that any account will or is likely to achieve returns similar to those shown. The price and value of the investments referred to in this research and the income therefrom may fluctuate. Every investment involves risk and in volatile or uncertain market conditions, significant variations in the value or return on that investment may occur. Investments in hedge funds are complex, speculative and carry a high degree of risk, including the risk of a complete loss of an investor’s entire investment. Past performance is not a guide to future performance, future returns are not guaranteed, and a complete loss of original capital may occur. Certain transactions, including those involving leverage, futures, options, and other derivatives, give rise to substantial risk and are not suitable for all investors. Fluctuations in exchange rates could have material adverse effects on the value or price of, or income derived from, certain investments.

Bridgewater research utilizes data and information from public, private, and internal sources, including data from actual Bridgewater trades. Sources include AERIC INC, BCA, Bloomberg Finance L.P., Candeal, Carbon Arc, CEIC Data Company Ltd., Ceras Analytics, China Bull Research, Citibank, Clarus Financial Technology, CLS Processing Solutions, Consensus Economics Inc., Consumer Edge, CRU Group, DTCC Data Repository, Ecoanalitica, Energy Aspects Corp, Enverus, EPFR Global, Eurasia Group, Evercore ISI, FactSet Research Systems, The Financial Times Limited, Finaeon, Inc., FINRA, GaveKal Research Ltd., GlobalSource Partners, Goldman Sachs, Harvard Business Review, Haver Analytics, Inc., IEA, Institutional Shareholder Services (ISS), The Investment Funds Institute of Canada, ICE Derived Data (UK), Investment Company Institute, International Institute of Finance, JP Morgan, JTSA Advisors, LSEG Data and Analytics, MarketAxess, Metals Focus Ltd, MSCI, Inc., National Bureau of Economic Research, Neudata, Organisation for Economic Cooperation and Development, Pensions & Investments Research Center, Pitchbook, Political Alpha, Renaissance Capital Research, Rhodium Group, RP Data, Rubinson Research, Rystad Energy, S&P Global Market Intelligence, Sentix GmbH, SGH Macro, Shanghai Metals Market, Smart Insider Ltd., Swaps Monitor, Tradeweb, United Nations, US Department of Commerce, Visible Alpha, Wells Bay, Wind Financial Information LLC, With Intelligence, Wood Mackenzie Limited, World Bureau of Metal Statistics, World Economic Forum, and YieldBook. While we consider information from external sources to be reliable, we do not assume responsibility for its accuracy. Data leveraged from third-party providers, related to financial and non-financial characteristics, may not be accurate or complete. The data and factors that Bridgewater considers within its investment process may change over time.

This information is not directed at or intended for distribution to or use by any person or entity located in any jurisdiction where such distribution, publication, availability, or use would be contrary to applicable law or regulation, or which would subject Bridgewater to any registration or licensing requirements within such jurisdiction. No part of this material may be (i) copied, photocopied, or duplicated in any form by any means or (ii) redistributed without the prior written consent of Bridgewater® Associates, LP.

The views expressed herein are solely those of Bridgewater as of the date of this report and are subject to change without notice. Bridgewater may have a significant financial interest in one or more of the positions and/or securities or derivatives discussed. Those responsible for preparing this report receive compensation based upon various factors, including, among other things, the quality of their work and firm revenues.

## Full transcript

[0:12](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=12s) All right. Hello, everyone. Thank you all for coming. I'm Nikhil, CTO of TurboPuffer.

[0:18](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=18s) And I'm Aaron Linsky, the head of product engineering at Bridgewater Associates.

[0:23](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=23s) And we're here to talk to you today about how you build an AI analyst that can keep a secret. And I'll explain a bit more about what that means here. Now, this is a very oversimplified view of how you would go about building an AI analyst, but it is meant to capture an important dimension around permission. So in this diagram, you're a user interacting with this AI agent. You start with a question, maybe something like, "Why have token prices come down so much in the last month?" And you feed that question

[0:53](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=53s) into an LLM, which will begin thinking about that question, investigating, researching. And as it does that investigation, it's going to search for facts to ground its information, to lead its investigation. Some of those facts might come from the public web, but other facts might come from private documents in your organization. Now, the public web is, on one dimension, much easier to search than the information that's private to your organization. By definition, the public web is public. Everyone in your organization can see

[1:22](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=82s) exactly the same documents. So there's no permission issue there. Every public web document can be immediately fed into the AI analyst, no matter who's asking the question. But the information internal to your organization looks very different. Every email, every meeting note, every report might have a completely different set of permissions attached to it, belonging to different groups, maybe individual permissions assignments on those docs. And you can see here, we've got different colors here reflecting the fact that every document in that private dataset has a different set of permissions.

[1:53](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=113s) And this is a classically hard problem in information retrieval, and it's something we explicitly designed TurboPuffer to solve. But before I get into that, I'm gonna hand it over to Aaron to talk about why this private information is so important to Bridgewater's AI analyst.

[2:07](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=127s) Great. Thank you. Oh, there we go. So first, I'm gonna go talk a little bit about wh-what-- who Bridgewater is, what we do, and then we get into how, uh, how we're using TurboPuffer and, and the needs there. So for the past fifty years, we've, at Bridgewater, have pursued the best understanding of how markets and economies work. We then encode that systematically with logic into a system that we can then trust test over

[2:37](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=157s) time. What you see here are on the, on the left with the yellow legal pad, that is our bond system from nineteen eighty. It's a set of if-then statements that we used to trade bonds back then. Over the next few decades, we've evolved that process from a yellow legal pad to Excel to eventually Scala and now Python, um, to, uh, to a different learning process with humans at the center.

[3:08](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=188s) This five-- f- this research circle is what we call it, has five steps. Perception, that's seeing what's going on in the outside world. Hypothesis, which is coming up with ideas of why that might be true. Investigation, which is the research of seeing is that thing true. If it is true, we then systemize and integrate it with our system and industrialize and run that every day and trade on that. That's been our learning process. I've been at Bridgewater for about twenty years. That's been what we've been do-doing for twenty years with humans at the center.

[3:38](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=218s) We're now moving towards putting machines at the center and running that process. In order for even, you know, for both humans and machines, in order for that to work well, we need access to high-quality data. We need both time series data, which we've spent decades, uh, decades creating a great bitemporal macro time series database, which we call DeLorean. And more recently, we've been creating a

[4:08](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=248s) unstructured database, which we call the Vault. And so what is the Vault? Um, today it's about a hundred million documents, which we index, organize, and secure that we think represent some of the best third-party and external-- third-party external research and also our internal research. So we've sourced with a hundred and thirty-five different external sources, which is a huge deal for both legal and our data team to actually nego-negotiate and get them in.

[4:38](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=278s) And all of, all of those sources have, um, some sorts of permissions around it where it might not be open to everyone at Bridgewater. And then, of course, we also have our interm- internal sources of unstructured data. That's our own writing, our meeting recordings, and, and our internal reports as well. And both-- That those all go into the Vault, and then both humans, investors, and our AI agents read out of the Vault. What I haven't shown here is actually it circles back. So the investors and, uh, a- and the agents will

[5:08](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=308s) create new, new content that goes back into the Vault. So it's constantly improving. And so here's a very high-level view of what permissions in the Vault look like. So I have a user, w- we'll just say their ID is user one. They're in groups B and C. This is incr- incredibly simplified, unfortunately. Um, and there's a set of all of our documents where it could be either, um, uh, permission to them

[5:38](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=338s) via groups or directly. And then here we have the actual code of us going ahead and creating a query to try to look for some data with whatever that, uh, query vector was that matches the viewers and groups. And so this is simple in one way, and actually when we first implemented this without TurboPuffer- We thought it worked fine. Um, but then

[6:08](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=368s) pretty quickly as we started to add more and more documents to the vault, it fell over, um, tremendously. And so what I did then was I looked for other possible providers. We found TurboPuffer, tested them out, and they had a solution which Nikhil is gonna go over right now.

[6:25](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=385s) Awesome. Thank you, Aaron.

[6:29](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=389s) Let me very quickly talk about what TurboPuffer is. We are an extremely fast, extremely scalable, extremely cheap search engine built entirely on top of object storage. And what that means is we write directly to S3 or GCS or Azure Blob Storage, whatever your hyperscaler provides, and that gives us S3 economics. So by default, your data is inert, cold on S3. Only when you start querying it do we pull it into more expensive storage mediums like SSD or

[6:59](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=419s) memory. And this is really powerful because once a query is hot, once the data a query is accessing is in the cache, it's fast. But if you're not accessing a particular namespace or a particular region of a namespace, that data can just hang out on object storage where you pay rock bottom prices for it. So this architecture allows TurboPuffer to scale cheaply to terabytes of data, which would cost tens of millions of dollars in, in other systems, and we can often do it at a tenth of the cost at performance

[7:29](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=449s) that's comparable once you get the data hot, uh, to what you get with traditional disk-based search systems. And we support all types of search. We support keyword search, we support regex search, and what Aaron was showing earlier, vector search. Um, so we're really not, uh, opinionated about how you search your data in TurboPuffer. We wanna do search generically. But for the rest of this talk, I'm going to focus on vector search because, uh, it's, it's good to zoom in and go deep on

[7:59](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=479s) one particular type of search. Let's do a little bit of napkin math. That's something we love to do at TurboPuffer. It helps us anchor in the simplest possible solution. We never want to introduce complexity to TurboPuffer that's not justified. One of the justifications for taking on complexity is if you need it for performance. The absolute simplest way to do search is to put everything in a list, and every time somebody shows up saying, "I want queries that match this. I want documents that match this query," you look at every single piece

[8:29](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=509s) of data. Let's conservatively say that every document that you store in TurboPuffer is one kilobyte. This is incredibly conservative. A vector embedding is often 1,024 dimensions, so if you're using just a byte per dimension, that's a kilobyte right there. Uh, in practice, documents are often larger than this. But for the sake of example, let's say it's a kilobyte per doc. Even if you had all of that data resident in memory and you were ripping through it as fast as you possibly could, which on modern hardware is about twenty gigabytes a second,

[9:00](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=540s) once you get up to a hundred million docs, that's gonna take five seconds. And for most search workloads, that's way too slow. What we see in practice is most people want their search results to be about a hundred milliseconds. So the naive solution here does not work. If you've only got ten K docs, great. That's gonna take half a millisecond. TurboPuffer can do literally anything and it will be fast enough. But as you get to scale, once you're at ten million or a hundred million, you really need to start thinking about how you represent your data so that you're not crunching through all of that. And of course, I gave you the n-

[9:30](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=570s) the numbers from memory here. That's only if the cache is hot. If that data's on S3, you're looking at a minute or more to pull that data off S3. So this just isn't viable at the scale that Bridgewater operates.

[9:43](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=583s) So step one in TurboPuffer is to build a vector index, and this is something that we handle under the hood for you. When you store vectors in TurboPuffer, we automatically build this index behind the scenes once you get enough data to, to justify it. Vector embeddings, if you're not familiar, are the internal numeric representation of concepts in LLM space. And we like to use this example of red shoes and maroon sandals. You as a human know that these are very similar concepts and much more similar

[10:13](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=613s) to one another than concrete block is. Maybe you're thinking about shape and size and texture and, and weight. The LLM can translate that into this numeric vector. Here I've only got two dimensions shown so that we can think two-dimensionally, but in practice there's often thousands of dimension. 1,024 dimensions is a very common size. Thinking multidimensionally like that is very hard, so for the sake of example, we're just going to imagine that there are two dimensions here. Now we don't actually know what those dimensions represent, but

[10:43](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=643s) again, you can think of it as like size and color. And then you can plot that on a coordinate system. So red shoes might be at the top left along with maroon sandals, and then concrete block is gonna be down at the bottom right. And I'm gonna simplify wildly here, but a very, uh, workable vector index in two dimensions is just to plot things on a graph, and then you can zoom in. If you're looking for red shoes, that's the Q on this diagram, you plot that on this two-dimensional graph and

[11:13](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=673s) you zoom in and you look for the vectors around it. And because of the way these vectors are created by the LLM, vectors that are near each other represent similar concepts, represent good search results to return. So if we were just doing similarity search, great. We look in our two-dimensional coordinate grid, we find some nearby vectors, we return them, and life is good. And this saves us a lot of time. We don't have to search the whole vector space. We can zoom right in to the documents that are gonna be relevant to the query.

[11:43](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=703s) So that napkin math from earlier we can, we can ignore. We're maybe only looking at ten thousand vectors here, and we know we can do that in a millisecond or two. The problem is when you add in these permissions. Not all of the documents that are most relevant for a given query are going to match those permissions. And you can see in this diagram here the minuses don't match the permissions while the pluses do match the permissions. So our vector index is not immediately helpful to us, and we've invested a lot of

[12:13](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=733s) time and energy at TurboPuffer into solving this problem.

[12:19](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=739s) Naively, you might try a post-filtering strategy, and the way that works is the query comes in, you get maybe the 10,000 closest vectors, and then you throw away all the ones that don't match. This does not work very well because it doesn't provide the results that you're looking for. If I'm the user that only has access to that data on the bottom right and I search for Q, I still wanna see the documents that

[12:49](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=769s) were closest to Q from my perspective, that include the results that I can see. But when you do post-filtering, you kinda spiral outwards, and then at some point you have to give up because it's been a couple seconds and you haven't found any docs that match, or you haven't found the top 100 docs that match. Maybe you were only able to find 40. And this makes users unhappy because they might know that a doc exists with maroon sandals, and they were searching for red shoes, and you don't turn it up. So you have very poor recall.

[13:20](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=800s) So instead of starting with the vector index, what if we start with the filters? TurboPuffer builds an index of all of the documents that match the filters. So Aaron can show up and say, "Hey, show me all of the documents that I have access to." And then TurboPuffer can scan over all of those documents and see which of them are closest to the query vector. But what if Aaron has access to 50 million out of the 100 million documents in the vault? Now we're back to square one. We're

[13:50](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=830s) back in that napkin math problem where it's going to take multiple seconds, if not minutes, to get through all of that data. We're not actually using the vector index. If you look here, you can see we're just finding all the docs that match the filters and then scanning through them sequentially. So this also doesn't work very well.

[14:09](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=849s) And the trick to doing well on this problem is to do both. So TurboPuffer's vector index automatically clusters similar vectors. So you can see there's a group of documents here that are similar, labeled five, and another group labeled zero, and another group labeled one. And when we build these permissions indexes, we say, "Well, Aaron has access to documents in cluster five and maybe cluster two, but he doesn't have access to any documents in cluster three or any

[14:39](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=879s) documents in cluster zero. So we can just throw those clusters out. We don't have to consider them at all." So first, we find all of the clusters that Aaron has access to, uh, i.e. he has access to at least one doc in those clusters, and then we search the closest clusters, and then we just scan sequentially inside those clusters. And in TurboPuffer right now, the clusters have about 200 documents. This is something we're always tuning. Over time, we'll probably increase that number to, to maximize throughput. But this

[15:08](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=908s) basic strategy fundamentally makes search at scale with permissions possible, and the trick is to combine pre- and post-filtering into what we call native filtering.

[15:23](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=923s) And this is the result. Across 450 million vectors, those 100 million documents turn into 400 million vectors, TurboPuffer's able to get 120-millisecond searches. That's the P90 latency across all of those namespaces, by employing this sophisticated native filtering strategy.

[15:47](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=947s) So with TurboPuffer, you show up with your permissions logic and your conceptual model, and you do what I think is a very simple translation of those permissions into TurboPuffer filter language. And hopefully you can directly map this code sample here, viewers Contains one, uh, viewers Contains one, groups ContainsAny B C. Hopefully you can see how you would project that onto your organization's own permission structure, and that turns into this very complicated systems engineering

[16:17](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=977s) challenge under the hood. But TurboPuffer hides that all away from you so that you don't have to think about it. You can just express the logical filters that represent your permissions in a fairly direct way, and we handle the complicated query planning under the hood to make that search come back in one to 200 milliseconds, even at 100 million document scale. Now, we're engineers at TurboPuffer, so there are some limitations here. In particular, when you have nested groups, things get tricky. I'm not gonna have time to go into that in too much detail. But

[16:47](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=1007s) if you have problems that look like that, please come talk to us. Uh, we have a lot of experience working through these, and we're always looking for ways to improve the product so that stuff is handled more automatically.

[17:00](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=1020s) So permission filters are really just the tip of the iceberg in TurboPuffer. We're trying to build an isolation-native search engine. That means whether you have fine-grained permissions within namespaces, whether you have security, regulatory compliance obligations that force you to regionally lock data, keep that data in your own VPC, encrypt that data, potentially not just with an encryption key you control, but that your own customers control, TurboPuffer has solutions for all of those levels of

[17:30](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=1050s) isolation. So permission filtering is just one piece of the puzzle in building isolation-aware search in TurboPuffer.

[17:40](https://www.youtube.com/watch?v=u_jvuCjuvEk&t=1060s) So that's all we got. That's how TurboPuffer and Bridgewater work together to do fast isolation-native search at 100 million scale. Thank you, everyone.
