Agent-Maintained Tech Docs. Zero Drift.

Etchblok builds a deterministic map of your codebase so our agents generate and update tech docs grounded in system truth.

Become a Founding PartnerSee generated docs

60-second setup. Generation in minutes.

Flyte SDK

Documented ~70K lines of Python across ~500 files. v2.2.0.

See generated docs

FastAPI

Documented ~400K lines of Python across ~3,000 files. v0.136.1.

See generated docs

Flask

Documented ~40K lines of Python across ~200 files. v3.2.0.dev.

See generated docs
Etchblok handled flyte-sdk, our complex open source SDK, remarkably well. It produced accurate documentation with meaningful usage examples, despite the depth and complexity of our codebase. This is the kind of documentation experience fast-moving engineering teams need.
Union.AI
Haytham AbuelfutuhCTO & Co-Founder, Union.AI

How Etchblok works

Supports Python. JavaScript and TypeScript next.

Deterministic call-graph map
Step 01

Creates deterministic map of codebase

Etchblok parses your code into an AST, resolves cross-file imports, and constructs your actual call graph.

Read why we chose structural reasoning over generative inference →
Agents writing documentation
Step 02

Agents write the tech docs

Agents write the docs against the deterministic map — every explanation grounded in the actual code structure, not pattern-matched from training data.

Change-detection and PR updates
Step 03

Etchblok’s agents monitor codebase for updates

When a code change is merged, Etchblok’s agents open a PR with the doc updates. Your team reviews and merges — or you can enable auto-merge to skip the review.

Etchblok’s agents reason over your codebase to decide which guides your users need. Then they write them.

Overviews, getting started docs, tutorials, how-to guides, architecture explanations, and key concept breakdowns — all generated by our agents.

See a getting started guide for Flask generated by Etchblok →
Generated guides — Flask documentation

Architecture docs built from your actual dependency graph.

We build a deterministic map of your system first, then our agents generate the architecture docs. Etchblok’s agents produce living Mermaid diagrams and narrative guides that track actual system behavior as the system evolves. No tracing call hierarchies manually. No hand-drawn diagrams. No writing syntax in markdown files.

See an architecture overview for Flyte SDK generated by Etchblok →
Architecture docs — Flyte SDK dependency diagram

API references that know what’s actually public.

Most tools document everything they find, including internal methods, private helpers, and deprecated endpoints that were never meant to be public. Etchblok’s agents resolve your call graph to determine what’s truly public, trace cross-file inheritance, and generate references that reflect your actual API surface.

See API references for Flyte SDK generated by Etchblok →
API reference — Flyte SDK build_image method

Other AI tools document your syntax. Etchblok documents your architecture.

How it understands your code
Other AI tools
Feeds your raw code into an LLM and infers meaning from text — interprets your code like a document and writes plausible output based on a probabilistic model of natural language.
Etchblok
First builds a deterministic map of your system — then AI agents use that map to ground every generated doc in your actual code structure.
API visibility
Other AI tools
Documents what it finds — public, private, deprecated, and internal endpoints treated the same.
Etchblok
Resolves imports and exports to identify your actual public API surface for external tech docs.
When code changes
Other AI tools
Reads the diff and generates updates for what visibly changed — but has no structural context. Downstream documentation implications across dependent files are missed because the tool doesn’t know they’re connected.
Etchblok
Re-traces the call graph from the changed node outward — catching downstream documentation surfaces affected by the change, not just the file where the change occurred.
Cross-file dependencies
Other AI tools
Each file documented in isolation — dependencies and inherited behavior frequently missed or wrong.
Etchblok
Resolves imports across your entire codebase — dependencies and inherited behavior fully traced.
Output accuracy
Other AI tools
Variable. The LLM sees what changed, not the full structural context of why it changed or what depends on it.
Etchblok
High and grounded. The LLM sees your real dependency graph, not just raw text.
Architecture documents
Other AI tools
No auto-generated architecture documents. Mermaid diagrams must be manually written by an engineer.
Etchblok
AI agents generate architecture documents with Mermaid diagrams derived directly from your dependency graph. When your underlying logic changes, the diagrams and docs update with it because they’re grounded in a deterministic map of your system.
Hallucination over complex code
Other AI tools
Confidence degrades silently — the more complex the codebase, the more the LLM’s probabilistic generation fills gaps with plausible-sounding words that hallucinate function names, parameters, and call paths that aren’t in the code.
Etchblok
Structural analysis scales linearly regardless of codebase size — symbols, signatures, and dependencies are resolved deterministically before any text is generated, eliminating the most dangerous class of hallucinations.

What Etchblok delivers

Agent-Ready Output
Coding agents are only as good as the context you feed them. Etchblok publishes docs as llms.txt for direct ingestion — no scraping, no manual context packing. Native MCP server coming soon.
Agent-ready output — llms.txt + MCP
Zero-Friction Adoption
Setup takes 60 seconds — three steps. Install the GitHub app, select your repo, hit generate. No manual tagging. No custom YAML.
When your code changes, Etchblok detects it and drafts the update in your docs branch. Push it directly, or have it land as a PR for review — your call. Either way, the doc update process uses your existing GitHub workflow. No new tools. No new processes.
Zero-friction adoption — PR workflow
Zero Drift
When a PR is merged, Etchblok re-traces the call graph from every changed node outward — catching downstream docs that a diff alone would miss. If a change in one file affects documented surfaces across three others, Etchblok finds all three.
Zero drift — call graph tracing
Full Editorial Control
After generation, edit in GitHub or in our built-in editor — your choice. Review, refine, and publish.
Full editorial control

Supports Python. JavaScript and TypeScript next.

Why Continuous Documentation?

Across every team shipping with AI assistance, one quiet shift has reshaped engineering: the comprehension layer has fallen behind the generation layer.

Code now moves at machine speed. Documentation produced by hand can’t keep up. The gap shows up on the P&L — in lost prospects at the evaluation stage, in support tickets that route to engineering, in silent churn.

And it’s about to get worse. AI agents have begun consuming tech docs as infrastructure, treating it as ground truth they act on. Accuracy is no longer a courtesy to human readers — it’s a prerequisite for machines.

Just like we moved from manual testing to CI/CD, we’re moving from manual documentation to Continuous Documentation.

Read the full thesis →
Continuous Documentation pipeline: code, parse, run diff, write, merge, monitor

Founding Partners Program

We’re being deliberate about who we work with this early. We’re working with a small group of Series A–C companies whose operations depend on highly accurate documentation and who want to eliminate doc drift. Founding Partners aren’t beta testers — they’re the engineering teams working directly with us to shape what Etchblok becomes.

The program is paid. We think that’s important: it means we’re accountable to you as customers, not just early users, and you’re committed enough to give us the kind of feedback that actually moves the product forward. Founding Partners pay a founding rate to join, locked in even after GA.

We are accepting applications from teams with Python codebases and will limit selection to 10 teams so we can engage deeply. To ensure we are architecting the product to solve the highest-leverage documentation challenges, we will prioritize teams who maintain complex, rapidly evolving software architectures and tech docs where accuracy is non-negotiable.

Vik Advani and Irena HsuFounders, Etchblok
Become a Founding Partner

Ship fast. Document accurately.