Agentic File System Access

Memory shouldn't be a product you buy. It should be a property of your data.

Today we are launching Agentic File System Access. Most platforms treat memory as a separate product you bolt on. We built it the other way. As bem parses, it builds a knowledge layer, a full semantic graph with entity resolution, embedded in everything bem does. Every document you parse becomes something an agent can walk, and every file access is enhanced by the graph underneath it.

It is one endpoint, eight verbs, and it drops into whatever agent framework you already run.

Walk a real one. We made the Bending Spoons F-1 knowledge graph, 48 entities and 23 relationships resolved by bem in 15.9 seconds, clickable in your browser. Walk the graph, then come back.

The best of both

For years, getting an agent to read your documents meant choosing a lane. Semantic embeddings, which are great at telling you what something is, or handing the model the raw files, which is great at telling you where something lives. Each approach gives up what the other is good at.

Agentic File System Access takes both. As bem parses, semantic understanding resolves a knowledge graph: the same entity, under different names, across your whole corpus, collapsed onto one canonical record. That is the memory. Then we give your agent a filesystem over all of it. It can ls, grep, cat, find, and xref its way through the corpus, reading, deciding what to read next, and reading again. That is the reach.

One endpoint, eight verbs

Everything lives at POST /v3/fs. The body is always {"op": "<verb>", ...} and every response comes back as {op, data, hasMore?, nextCursor?, count?, hint?}. One tool definition for the agent's tool surface, eight verbs.

The doc-level verbs work on every parsed document. The memory verbs, find, open, and xref, run on the knowledge graph that bem resolves as it parses.

The knowledge graph is built in

As bem parses, it resolves the same entity across every document, even when it appears under different names, onto one canonical record. Surface forms like Eucalypt and Eucalyptus, or a company's legal name and its ticker, collapse onto one entity. Your agent can pivot from any surface form to the canonical record to every document that mentions it.

It is a business ontology that assembles itself as your documents flow through. Memory is not a standalone product you wire up next to bem. It is embedded in everything bem does, and it enhances every file access the agent makes.

What it looks like

This is a live account: over 200 parsed documents, 4,668 sections, 1,284 resolved entities. No vector store sits behind any of this. It is plain SQL over the tables the parse pipeline already maintains.

Search the whole corpus:

1curl -s https://api.bem.ai/v3/fs -H "x-api-key: $BEM_API_KEY" \
2  -H 'content-type: application/json' \
3  -d '{"op":"grep","pattern":"London","scope":"sections"}'
4# 29 section hits, each with referenceID, page, and a snippet

Pivot to the knowledge graph:

1curl -s https://api.bem.ai/v3/fs -H "x-api-key: $BEM_API_KEY" \
2  -H 'content-type: application/json' \
3  -d '{"op":"find","filter":{"search":"eucalyptus"}}'
4# canonical "Eucalyptus", surfaceForms ["Eucalypt","Eucalyptus"]

Then ask where it lives across the corpus, in full context, in one round trip:

1curl -s https://api.bem.ai/v3/fs -H "x-api-key: $BEM_API_KEY" \
2  -H 'content-type: application/json' \
3  -d '{"op":"xref","path":"ent_3EZQJsC6p9xzuyHrwfnrrqe8UZr"}'

The agent does the comprehension. /v3/fs just gives it eyes.

What this gives you

• Semantic memory, out of the box. The knowledge graph is built as you parse. No second pipeline to stand up, no vector store to maintain.
• Filesystem reach. grep spans the corpus and xref resolves an entity to every section that mentions it, in full context, in one round trip.
• A higher accuracy ceiling. The limit is the reasoning of the model you already trust, not an indexing config you tune by hand. As models get better, your system gets better, with no migration.
• Answers that trace back to a source. Document, page, section. Verifiable. For anyone operating under audit or regulation, that is the line between a demo and production.

Get started

POST /v3/fs is live in the V3 API today. Point an agent at your own documents and let it navigate. One tool definition, eight verbs, so it drops into any agent loop today. An MCP server is on the way.

This is the production layer for unstructured data, made navigable, with memory. It is one more step toward a verified agentic operating system for the enterprise.

Docs are at bem.ai. Try it on your own corpus today.