LLM Wiki: The Open Standard by Andrej Karpathy

Why one simple Markdown-based format might become the “HTML of AI knowledge”

Every few months, the AI community gets excited about a new foundation model.

GPT.

Claude.

Gemini.

Kimi.

Grok.

Llama.

But while everyone debates which model is smarter, faster, or cheaper, there’s another problem quietly becoming impossible to ignore:

Knowledge itself has no standard format.

Every company stores documentation differently. Every website structures information differently. Every AI agent has its own ingestion pipeline.

Every RAG system spends enormous effort cleaning data before an LLM can even understand it.

It’s surprisingly similar to the early days of the web, when every website had its own custom structure before HTML became the universal language.

That is exactly the problem Andrej Karpathy wants to solve with LLM Wiki. Instead of creating another AI model…

He proposed an open standard for AI-readable knowledge. It sounds simple. But simple ideas often change entire industries.

Let’s explore why.

LLM Wiki is an open specification for writing knowledge in a format that Large Language Models can understand efficiently.

Think of it as:

Instead of designing documentation for humans first and AI second…

LLM Wiki designs documentation for both humans and AI simultaneously. The goal is beautifully simple:

Let’s imagine you’re building an AI coding assistant. You want it to understand your company documentation. Sounds easy. Until you discover your documentation looks like this:

Humans can easily ignore all the noise. LLMs cannot. Before an LLM can answer a single question, engineers often spend hours or even weeks building pipelines to:

Much of modern Retrieval-Augmented Generation (RAG) is actually solving a documentation formatting problem.

Karpathy’s proposal attacks the problem at its source. Instead of cleaning messy data later…

Create clean AI-ready knowledge from the beginning.

LLM Wiki isn’t trying to replace Markdown. It extends familiar Markdown principles with conventions that make knowledge:

Imagine Wikipedia articles written specifically so an AI never has to guess where information lives.

Every section has meaning. Every relationship is explicit. Every page becomes part of one giant knowledge graph.

Most documentation today was written for web browsers. Not language models.

For example:

Humans mentally filter everything else. LLMs don’t naturally know what’s important.

This leads to:

LLM Wiki dramatically reduces this ambiguity.

Although intentionally lightweight, the proposal is built around several key ideas.

No JavaScript. No CSS. No complex HTML.

Just text.

Plain text is:

It also avoids unnecessary token waste.

Instead of scattered pages, knowledge becomes organized like a tree.

Example:

An LLM instantly understands relationships. Humans do too.

Instead of relying on vague hyperlinks, pages explicitly reference related concepts.

For example:

Now an AI understands semantic relationships instead of merely seeing URLs.

Every document includes structured metadata.

For example:

Instead of forcing an LLM to infer context…

The author simply provides it.

Rather than giant paragraphs, knowledge is broken into meaningful sections.

Example:

This dramatically improves retrieval quality.

Markdown focuses on formatting. LLM Wiki focuses on knowledge representation.

Markdown asks:

LLM Wiki asks:

That’s a completely different design philosophy.

Traditional Markdown:

LLM Wiki style:

Notice how the second example is significantly easier for both humans and AI.

Most developers assume better AI comes from larger models. Reality is different. Better inputs often matter more than better models.

Garbage in. Garbage out.

Structured knowledge in. Better reasoning out.

Whether you’re building:

the quality of your documentation directly affects model quality.

This might be where LLM Wiki becomes truly powerful. Today’s RAG pipeline usually looks like this:

With LLM Wiki:

Notice something? Entire preprocessing stages disappear. Less engineering. Lower costs. Higher accuracy.

Imagine a company with:

Every source has different formatting. Now imagine gradually converting important documentation into LLM Wiki.

Immediately you gain:

That’s a massive operational improvement.

Imagine every GitHub repository including:

AI coding assistants would instantly understand repositories without elaborate scraping.

That could dramatically improve code generation quality.

Educational content is currently fragmented across:

LLM Wiki offers a consistent structure for learning material.

Students.

Teachers.

AI tutors.

Everyone benefits from the same organized knowledge.

Many transformative technologies started as simple standards.

HTML standardized web pages. Markdown standardized technical writing. JSON standardized data exchange. OpenAPI standardized REST APIs.

Could LLM Wiki become the standard for AI knowledge? It’s too early to know.

But history repeatedly shows that shared standards often unlock entire ecosystems.

LLM Wiki isn’t a magic solution.

It won’t replace:

Instead, it complements them. Organizations still need governance, versioning, and workflows.

The proposal also depends on community adoption. Without contributors, tooling, and integration into documentation platforms, it risks remaining an interesting idea rather than a widely used standard.

Perhaps the most interesting part isn’t the specification itself. It’s the shift in thinking.

For years we’ve asked:

Karpathy flips the question:

That’s a subtle difference. But it changes everything. Instead of building increasingly complex preprocessing pipelines… 

We build better knowledge.

AI models are becoming commoditized. Knowledge quality is becoming the competitive advantage.

The companies that organize their information better will build smarter assistants, better copilots, more reliable RAG systems, and more capable AI products.

LLM Wiki is an early attempt to create that common language.

Whether it becomes the industry standard or simply inspires future formats, it highlights an important truth:

As developers, we spend countless hours optimizing prompts, tweaking embeddings, and experimenting with new models.

Perhaps the next breakthrough starts with something much simpler:

Writing knowledge in a way that both humans and AI can truly understand.

I hope you found it helpful and informative. If you have any questions or feedback, feel free to leave a comment below. Your support and engagement mean a lot to me.