Top AI Product

Every AI documentation assistant in 2025 worked the same way: user asks a question, the system fires a vector search, returns the top-K chunks, and hopes the answer is somewhere in there. It mostly worked. Until it didn’t. Multi-page answers? Missed. Exact code syntax buried in the wrong chunk? Gone. The retrieval wasn’t broken — the abstraction was.

Mintlify, the documentation platform used by Anthropic, Microsoft, and Coinbase, just shipped something that reframes the entire approach. ChromaFs is a virtual filesystem that lets AI agents browse documentation using grep, cat, ls, and find — standard UNIX commands that every LLM already knows how to use. No sandboxes, no embedding pipelines, no top-K prayers. The result: session creation dropped from 46 seconds to 100 milliseconds, and the marginal cost per conversation went to effectively zero.

The Hacker News post hit 164 points and 85 comments in a day. Developers are paying attention because this isn’t just an optimization — it’s a philosophical shift in how we think about giving AI access to information.

Why Filesystems Beat Embeddings for Documentation

The core insight is almost embarrassingly simple. LLMs are trained on massive amounts of code. They know how to use bash. grep, cat, ls, find — these aren’t just tools, they’re part of the model’s native vocabulary. When you give an agent a filesystem interface, you’re not teaching it a new API. You’re speaking its language.

ChromaFs maps every documentation page to a file and every section to a directory. An agent that needs to find authentication details doesn’t fire a semantic search and hope the right chunk floats to the top. It runs something like find /auth and then cat /auth/oauth.mdx. It reads the full page, sees the structure, makes decisions about what to read next. It behaves like a developer exploring a codebase, not a search engine guessing at intent.

The technical foundation comes from Vercel Labs’ just-bash, a TypeScript reimplementation of bash with a pluggable filesystem interface. ChromaFs hooks into this interface and translates every filesystem call into a query against Mintlify’s existing Chroma vector database. The directory tree bootstraps from a gzipped JSON file loaded into memory — subsequent sessions use cached trees, so ls, cd, and find operations require zero network calls.

For grep, they built a two-stage filtering system. First, a coarse filter where Chroma identifies candidate files using $contains for fixed strings or $regex for patterns. Those matching chunks get prefetched to Redis. Then grep reruns in-memory for precise, line-level results. Write operations return EROFS — read-only filesystem — keeping everything stateless and preventing cross-session corruption.

The Numbers Tell the Real Story

Before ChromaFs, Mintlify’s assistant needed to spin up a sandbox for every conversation. That meant cloning docs from GitHub, setting up the environment, and running the retrieval pipeline. The p90 session creation time was 46 seconds. With ChromaFs, it’s 100 milliseconds. That’s a 460x improvement.

Cost dropped just as dramatically. Each sandbox conversation cost roughly $0.0137 — small per session, but Mintlify handles 850,000 conversations monthly across 30,000+ daily interactions. At scale, sandbox infrastructure was running north of $70,000 a year. ChromaFs reuses the existing Chroma database that Mintlify already maintains for documentation search. The marginal compute cost per new conversation is essentially zero.

There’s also a security benefit that doesn’t get enough attention. The path tree includes isPublic and groups fields. Before a session starts, the system prunes unauthorized paths and applies access filters to all Chroma queries. Per-user RBAC comes built-in, without spinning up isolated sandboxes for each user. For enterprise customers with private docs, this is a big deal.

Mintlify itself has been on a tear. The company raised an $18M Series A led by Andreessen Horowitz in late 2024, hit an estimated $10M ARR by end of 2025 (10x growth from $1M), and onboarded over 10,000 companies. They acquired Trieve in July 2025 and Helicone in March 2026. ChromaFs is the kind of infrastructure bet that makes sense when you’re scaling this fast — you can’t afford $70K/year sandbox bills when conversation volume is doubling.

What the Developer Community Actually Thinks

The Hacker News thread is worth reading because the debate cuts to something deeper than one company’s engineering choice.

The strongest pushback came from users like tensor, who argued that “going back to grep and a filesystem is going back to the 60s level of search tech.” Databases can index content in any way you want — full-text, vector, graph, hybrid. Why constrain yourself to a filesystem metaphor?

But the most upvoted rebuttal, from shaial, nailed the counterpoint: “You replaced RAG’s interface, not RAG itself. The retrieval was never the bottleneck — the abstraction was.” ChromaFs still uses Chroma under the hood. The vector database is still there. What changed is how the agent interacts with it. Instead of receiving pre-selected chunks and hoping for the best, the agent explores, decides what’s relevant, and reads exactly what it needs.

Another commenter, wahnfrieden, raised a point that explains why this works better than you’d expect: “Agents are trained on bash grep/ls/find, not on tool-calling grep/ls/find.” When you give a model custom tool definitions, it’s using a learned-at-fine-tuning interface. When you give it bash commands, it’s using patterns baked in from pre-training on millions of codebases. The difference in reliability is real.

The skeptics raised valid concerns too. slp3r warned about latency: “Every ls and grep the agent decides to run is a separate inference cycle. You’re trading RAG context-loss for severe multi-step latency.” And kenforthewin asked the question everyone wants answered: “Where are the evaluations showing this ChromaFs approach is performing better than vectors?” Mintlify published the infrastructure metrics but hasn’t released comparative answer-quality benchmarks. That gap matters.

Others pointed out that the approach works best for well-structured content. Documentation has natural hierarchy — pages, sections, subsections. That maps cleanly to files and directories. Try the same thing with a messy knowledge base where information is scattered across Notion pages, Slack threads, and random PDFs, and the metaphor starts to break.

Where This Fits in the Bigger Picture

ChromaFs is part of a broader trend that’s been building throughout 2025 and into 2026: the realization that RAG’s problem was never the retrieval — it was the interface between the retriever and the agent.

Agentic RAG frameworks like LangChain’s Deep Agents give models the ability to retrieve, reason about gaps, refine queries, and retrieve again. Graph RAG adds knowledge graph layers for multi-hop reasoning. Contextual AI’s metadata search enables reference traversal without building explicit graphs. These are all variations on the same theme: stop giving the agent a bag of chunks and start giving it tools to explore.

What makes ChromaFs interesting is how minimal the approach is. No new infrastructure. No graph databases. No multi-step retrieval chains. Just a filesystem interface on top of what they already had. softwaredoug’s comment on the HN thread captured it well: people are “rediscovering forms of search we’ve known about for decades” that happen to be “more interpretable to agents.”

The bet is that as models get better at tool use and multi-step reasoning, the advantage of agent-driven exploration over pre-computed retrieval will only grow. A model that can run find, grep for what it needs, and cat the right files will outperform a model that receives five chunks and has to make do. That bet is looking increasingly solid.

For anyone building AI-powered documentation or knowledge tools, the takeaway from Mintlify’s ChromaFs is worth sitting with: maybe the problem with your RAG pipeline isn’t the R, the A, or the G. Maybe it’s the fact that you’re not letting the agent do the retrieval itself.

You Might Also Like

• Mcp2cli the Tool That Cuts mcp Token Costs by 99 Just hit Hacker News
• 685 Hacker News Upvotes in one day why Canirun ai Struck a Nerve With Local ai Enthusiasts
• Tempo Machine Payments Protocol 500m 100 Partners and a Bold Play to own the ai Agent Economy
• Claude Channels Scores 375 Points on Hacker News Anthropics Play to Replace Openclaw
• George Hotz Wants to Sell you a 12000 ai Supercomputer and 221 Hacker News Comments Cant Stop Arguing About it