There's something worth noticing about the current moment in AI agent design. A year ago, the dominant conversation was about RAG pipelines, vector embeddings, and semantic similarity search. Today, the conversation has quietly shifted back to something much older: folders, files, and directory traversal.
People are building "skills folders." They're storing agent memory in structured file trees. They're having models navigate repositories to find context rather than retrieving it from a vector index.
The funny thing is — this isn't a regression. It might actually be progress.
Why File Systems Work So Well for Agents
The reason is, when you think about it, straightforward. Large language models like Claude were trained on enormous quantities of code. Not just code as isolated snippets, but code in context — repositories with directory hierarchies, README files, config structures, import graphs, nested modules. For much of their training, these models were essentially doing one thing: reasoning over structured file systems.
So when we give an agent a file system to explore, we're not asking it to generalize to some new domain. We're putting it back in an environment that closely resembles the one it spent most of its training in. The navigation patterns, the inference about what a folder named utils/ probably contains, the ability to read a SKILL.md file and understand how to apply it — none of that requires a new trick. It matches the training distribution almost perfectly.
This is a pattern I find genuinely interesting, and I think it has implications beyond just agent architecture. The field keeps drifting toward what models are already good at — not because researchers set out to find that alignment, but because what works in practice keeps pointing back to it. The "winning" architecture isn't always the most theoretically elegant one. It's often the one that most closely resembles the conditions under which the model learned.
A Broader Principle
There's a lesson here that I think applies more generally. When you're designing systems that incorporate capable AI models, one of the highest-leverage questions you can ask is: what does this model's training distribution actually look like? Not in the abstract, but concretely. What kinds of inputs did it see billions of times? What reasoning patterns got reinforced?
Vector databases and semantic retrieval are genuinely useful. But they ask the model to operate on pre-digested, decontextualized chunks — embeddings stripped of the structural relationships that give them meaning. File systems preserve that structure. They let the model reason about where something lives relative to everything else, which turns out to be deeply informative.
Sometimes the right architectural decision isn't more innovation. It's better alignment with what the model already knows how to do.
This is also, incidentally, exactly why approaches like Koi sit at an interesting intersection right now. Cybersecurity — particularly the kind that involves exploring real, messy software ecosystems at scale: extensions, packages, configs, scripts — is precisely the domain where this strength compounds. These aren't clean, well-labeled datasets. They're the kind of sprawling, structurally complex environments that look a lot like the codebases models spent their training inside.
As the field continues to rediscover the value of structure, search, and exploration, it's worth pausing to notice: the models were already built for this. We're just finally learning to ask them to do what they're good at.