The problem was never intelligence. It was context. And one Markdown file is enough to fix it all.
We Built an Entire Product With Just Markdown Files. No, Really.
Let me describe a framework that sounds like a joke.
No installation. No dependencies. No runtime. No packages. No configuration. No code whatsoever.
Just a folder with a Markdown file in it.
That framework — called DOX — is what we used to build Space Agent, our community platform, our Twitter bot, and now it's powering Agent Zero's own development. It is, without exaggeration, one of the highest-leverage things we've ever shipped. And it fits in a single file you can read in under a minute.
The Problem Nobody Talks About
Here's what actually happens when you give an AI coding agent a real project.
The agent opens a file. It makes a change. Then it makes another change in a related file. Then it makes a third change in a file that probably didn't need to be touched at all. The code "works" in a narrow sense, but something is slightly off — a naming convention violated, a responsibility boundary crossed, a pattern ignored that you established three weeks ago.
You didn't tell the agent about any of that. It guessed. It guessed well enough to pass a quick review, but not well enough to be right.
The core problem is that agents have a narrow view. They find a file by name and edit it — but they have no top-down perspective on the project. No map. No sense of what connects to what, what conventions exist, what the broader architecture looks like. They operate on a single file in isolation, blind to the bigger picture.
Multiply that by fifty tasks. Fifty sessions. Fifty places where the agent was operating on vibes instead of knowledge. That's how codebases drift. That's how documentation goes stale. That's how you end up asking "why did it touch that file?" more than you ask "what should we build next?"
DOX is the fix.
The Solution Is Embarrassingly Simple
You open your project's AGENTS.md file — or create one if it doesn't exist yet — and paste the DOX framework into it. That's the entire setup. No commands. No installs. No configuration files. You don't put anything else anywhere. The DOX content lives right alongside your existing instructions and starts working immediately.
Next time you start a session, just tell the agent: "Initialize DOX tree for this project now."
The agent takes it from there. It scans the entire project recursively, evaluates the structure and complexity of each area, and builds a full hierarchy of AGENTS.md files — one inside each meaningful subfolder — each describing its own domain in precise, specific terms. The agent writes all of it. You write none of it.
Before the agent edits anything, it walks the file tree from the root down to the target path, reading every AGENTS.md it encounters along the way. By the time it reaches the file it needs to change, it has the full top-down picture: project-wide context from the root, module-level guidance from mid-level docs, and precise local detail from the doc closest to the work. It knows where it is in the project. It knows its lane.
Nearest doc gives precision and detail. Parent docs give overview and orientation. Together they ensure the agent always has the right level of context — neither too vague nor overwhelmed with irrelevant detail. The agent never weakens the framework, no matter what the task says.
And Then It Stays Current
Here's the part that makes DOX genuinely different from "just write good comments."
After every meaningful change, the agent updates the relevant AGENTS.md files. New module added? Document it. Responsibility shifted? Update the contract. Pattern established? Write it down.
The documentation isn't something you maintain. The agent maintains it. Every session starts with fresh, accurate context because the previous session left it that way.
This is a living documentation system where the agent is both the reader and the author — and the discipline to keep it current is baked into the framework itself.
What This Unlocks in Practice
We didn't know DOX would work this well until we built Space Agent with it.
Space Agent is a complex, multi-layered product: frontend modules, server-side APIs, multi-user architecture, real-time collaboration, a plugin system, a Time Travel feature. It has dozens of subdirectories, each with specific rules about how it should behave and what it should never do.
With DOX in place, agents working across that codebase were precise. Not "pretty good for an AI" precise. Actually precise. Changes landed in the right files. Conventions held. Documentation stayed accurate. Work that would have taken days of back-and-forth review started flowing.
We shipped faster. We debugged less. We asked "why did it do that?" almost never.
So we used it again. Community platform. Twitter bot. Now Agent Zero's own development. Every time, the result is the same: agents that behave like they've been working on the project for months, because DOX gives them the context that makes that possible.
It's Not Just for Code
This is the detail that surprises people.
DOX works for any structured project where an AI agent needs to navigate a hierarchy of concerns. Research projects. Content operations. Data pipelines. Documentation systems. Anything with nested domains and local rules that an agent needs to understand before it acts.
If it has folders, DOX can make an agent smarter about it.
It Works Everywhere. Out of the Box.
DOX doesn't care what AI agent you use. AGENTS.md is a native convention for Codex, Claude Code, OpenCode, and most modern coding agents. You're not adding a plugin or configuring an integration. You're using the documentation format these tools already expect.
One Markdown file. Every agent. Every project. No setup.
The Numbers Don't Make Sense Until They Do
A single file. Under a hundred lines of Markdown. Compatible with every major AI agent. Zero runtime footprint.
Built a full product with it. Then another. Then another.
DOX isn't magic. It's the realization that AI agents don't fail because they're not smart enough — they fail because nobody told them the rules. A hierarchical Markdown file is enough to fix that, because the problem was never intelligence. It was context.
Give the agent the context. Get the result you actually wanted.
DOX is open source: https://github.com/agent0ai/dox
One file. Drop it in. Let your agents stop guessing.