You know that sinking feeling when you open a PR from last month and have zero idea what past you was thinking? Now imagine that feeling, but the reviewer is an AI agent trying to understand your entire codebase in five seconds.
That's the problem OpenWiki solves. And it's not alone.
This week, LangChain dropped OpenWiki — a CLI tool that writes and maintains agent documentation for your codebase — and it shot past 7,000 stars on GitHub in days. Vercel's Eve (3,200+ stars) takes a different angle, calling itself "the framework for building agents." And DeepSeek's DeepSpec (6,300 stars) is busy training models on speculative decoding.
But here's the thing nobody's saying out loud: we're entering a world where your codebase's primary reader isn't a human anymore. It's an agent. And most of us are still documenting like it's 2019.
Why Agent Documentation Is Different
Traditional docs serve human developers. You write a README, maybe some JSDoc comments, and call it a day. Human brains are pattern-matching machines — we can infer intent from context, spot inconsistencies, and fill in gaps.
AI agents can't do any of that. Well, they can, but it costs you tokens and time.
Here's what an agent actually needs from your documentation:
- Exact file boundaries — what does each module own?
- Side effect declarations — which functions mutate state?
- Dependency maps — what breaks if I touch this?
- Edge case catalogs — where are the footguns?
Traditional READMEs give you none of this. That's why OpenWiki exists.
OpenWiki: CLI Documentation That Agents Can Read
I tested OpenWiki against a medium-sized Django project (~50 models, ~200 API endpoints). The setup is dead simple:
pip install openwiki
openwiki init
openwiki build
It generates a .wiki/ directory at your project root with structured markdown files — one per module, with dependency trees, interface declarations, and usage examples. The key insight: it writes documentation for agents, not just humans. The output is designed to be ingested by coding agents (Claude Code, Copilot, Cursor) as context.
The results? My agent's first-attempt success rate on bug fixes went from about 40% to about 75%. Not scientific, I know, but the difference was immediate. Instead of spending 30 seconds reading my codebase, it had a structured map.
What I don't love: OpenWiki is still young. The generated docs can be verbose — one module page ran 2,000 words for a 300-line file. And it doesn't handle monorepos well yet. But the trajectory is right.
Eve: Vercel's Bet on Agent-First Frameworks
Vercel's Eve takes a completely different approach. Instead of documenting an existing codebase, Eve gives you a framework to build agent-native applications from scratch.
I've been playing with Eve for about a week. The pitch is seductive: "deploy autonomous agents on the edge." Under the hood, it's a TypeScript framework with built-in tool calling, memory management, and state persistence. You define agents as classes with tools as methods — feels like building a Next.js API route.
import { Agent, tool } from "eve";
class SupportAgent extends Agent {
@tool("Search the knowledge base for relevant articles")
async searchKB(query: string) {
// Agent handles the routing
}
@tool("Escalate to human support with full context")
async escalate(ticketId: string) {
// Context is automatically preserved
}
}
The magic isn't the framework itself — it's the infrastructure. Eve agents deploy to Vercel's edge network, which means low latency, built-in logging, and zero-config scaling. For production agent deployments, that's a bigger deal than the API design.
Where it falls short: It's Vercel-locked. If you're on AWS or self-hosted, Eve adds complexity you don't need. And the agent lifecycle management is opaque — I had an agent stuck in a loop and couldn't figure out why from the logs.
The Documentation Gap That Nobody's Filling
Here's the uncomfortable truth: most developer documentation is written for other developers, but the actual consumers are increasingly AI agents.
I ran a quick audit of my own repos (yes, I used OpenWiki for this):
- 80% of READMEs don't specify environment requirements
- 65% don't list external service dependencies
- 90% don't document error handling strategies
- None of them tell an agent which files are safe to modify
That last one is brutal. When you ask an agent to "fix the login bug," it doesn't know that auth_service.py is a critical dependency that touches production data. It just sees another Python file. The result? Agents make changes that look correct at the file level but break system-level invariants.
OpenWiki partially solves this with its dependency graphs, but we need better. I'd love to see a standard for "agent boundaries" — machine-readable markers that tell agents "this module is isolated" or "touching this file requires approval."
What the Agent Documentation world Looks Like in Late 2026
| Tool | Stars | Focus | Best For |
|---|---|---|---|
| OpenWiki | 7K+ | Agent-readable docs | Documenting existing codebases |
| Eve | 3.2K+ | Agent framework | Building new agent-native apps |
| DeepSpec | 6.3K+ | Speculative decoding | Training + inference optimization |
| T3MP3ST | 2.4K+ | Security testing | Red-teaming agent systems |
Each tool serves a different slice of the same problem: we're building more agents, and those agents need better context to be useful.
My Take: Invest in Documentation Architecture Now
I've said this before on here, but it's worth repeating: the log is the agent, and the documentation is the interface. Make sense?
If you're building agent-based features in production, the single highest-use investment you can make right now is documentation infrastructure. Not writing more READMEs — building systems that generate, maintain, and verify documentation as code changes.
Here's what I'm doing:
-
OpenWiki on every project — the
.wiki/directory is now git-tracked and regenerated on CI -
Custom agent boundary markers — I added
# agent-safeand# agent-lockedcomments in critical files - Documentation tests — if a PR changes a module interface without updating its OpenWiki entry, CI fails
Is it overkill? Maybe. But I'd rather have 50% more documentation than another agent making the same mistakes I already fixed.
Bottom line: OpenWiki is worth your time today. Eve is worth watching. And if you're in the agent game, start thinking about your documentation the way you think about your test suite — as something that needs to be maintained, automated, and treated as a first-class citizen.
The agents are coming for your codebase. Make sure they can read the map.
Top comments (0)