Formato de Conocimiento Abierto: Memoria portátil para agentes de programación de IA
El formato Open Knowledge almacena lo que aprenden los agentes de codificación como archivos Markdown enlazados. Cómo difiere de CLAUDE.md y MCP, y cómo comenzar a usarlo hoy.
Fuentes: Google Just Quietly Released the Missing Piece for AI Agents. It’s Called OKF.
El formato Open Knowledge es un estándar diseñado para hacer que la memoria de los agentes sea portable, esté versionada y sea legible por todas las herramientas del entorno de desarrollo.
El problema de empezar de cero cada mañana
Cualquiera que utilice un agente de programación basado en IA se ha encontrado con este mismo obstáculo. La sesión finaliza y, al día siguiente, el agente no recuerda nada. Debe redescubrir el proceso de autenticación, adivinar nuevamente el razonamiento detrás de una decisión arquitectónica tomada hace tres años y volver a leer los mismos cinco archivos para reconstruir el contexto que tomó una hora explicar el día anterior.
La solución habitual es un archivo CLAUDE.md o AGENTS.md, un documento de contexto que se carga al inicio de cada sesión. Se trata de herramientas rudimentarias: incluyen todo en cada ejecución, independientemente de si es relevante o no, están diseñadas para un único agente en una sola plataforma y no son muy flexibles. Además, mezclan instrucciones de comportamiento como “siempre escribir pruebas” con datos concretos como “la tabla de pedidos se relaciona con los clientes mediante customer_id”, lo que provoca rápidamente un desorden.
El 12 de junio de 2026, Google Cloud publicó una especificación destinada a resolver esta deficiencia, llamada Open Knowledge Format, o OKF. Es hasta ahora la respuesta más ordenada al problema de la memoria de los agentes.
Dónde reside el conocimiento hoy en día
Supongamos que un agente debe responder cómo se calculan los usuarios activos semanales a partir de un flujo de eventos. La respuesta está distribuida en al menos cuatro lugares:
+-----------------------+--------------------------------------------+
| WHERE IT LIVES | WHAT'S THERE |
+-----------------------+--------------------------------------------+
| Metadata catalogs | Table schemas (but vendor-locked APIs) |
| Wiki / Notion | Runbooks, metric definitions |
| Code comments | Docstrings, inline notes |
| People's heads | Join paths, deprecation warnings |
+-----------------------+--------------------------------------------+
Nada aquí evoluciona junto con el código y nada sobrevive a una nueva ventana de contexto. Cada creador de agentes debe resolver nuevamente el mismo problema de ensamblaje de contexto, y cada proveedor de catálogos diseña sus propios esquemas.
OKF cree que lo que falta es un formato y no otra plataforma más.
Qué es el formato
La versión 0.1 del Open Knowledge Format es una especificación abierta y neutral con respecto a los proveedores, licenciada bajo Apache 2.0. El conocimiento se almacena como un directorio de archivos markdown, cada uno con información preliminar en formato YAML. Suena simple porque lo es, y eso es intencional.
No existe un registro de esquemas, ni un motor de ejecución, ni un SDK obligatorio. Cualquier herramienta que pueda usar cat para leer un archivo puede hacerlo, y cualquier herramienta que pueda ejecutar git clone en un repositorio puede distribuirlo. Toda la especificación cabe en una sola página y cuenta con exactamente un campo obligatorio, mientras que todo lo demás es opcional o queda a criterio del creador.
Anatomía de un paquete
Un paquete es simplemente una carpeta, y la ruta del archivo sirve como identificador de su concepto.
.okf/
+-- index.md <- progressive entry point
+-- log.md <- dated change history, newest first
+-- services/
| +-- index.md
| +-- auth-api.md <- one concept = one file
| +-- payments-service.md
+-- datasets/
| +-- index.md
| +-- orders-db.md
+-- metrics/
| +-- index.md
| +-- weekly-active-users.md
+-- decisions/
+-- index.md
+-- why-we-use-postgres.md
En cada paquete están reservados dos nombres de archivo:
index.mdse encarga de la divulgación progresiva. Los agentes recorren el paquete leyendo el índice en cada nivel y solo descienden cuando la tarea lo requiere. Ese es el mismo método de carga por etapas que permite que Claude Skills utilice tokens de manera eficiente.log.mdes un historial de cambios con fechas en formato ISO, mostrando la entrada más reciente primero. Tanto los humanos como los agentes que mantienen el paquete añaden nuevos registros cuando cambian los conceptos.
Cada otro archivo es un documento de concepto, identificado por su ruta. El único campo obligatorio en un concepto es un campo type que no esté vacío.
---
type: Service
title: "Auth API"
description: "Issues and verifies short-lived access tokens."
resource: https://github.com/acme/auth
tags: [auth, platform]
timestamp: 2026-06-14T10:00:00Z
---
El cuerpo luego contiene markdown ordinario, incluidas las tablas.
## Endpoints| Method | Path | Description |
|--------|----------|---------------------------|
| POST | /token | Exchange creds for a JWT. |
| GET | /verify | Validate a token. |## Why This ExistsSee the decision at [decisions/why-we-separated-auth.md](../decisions/why-we-separated-auth.md).
Joins with [datasets/orders-db.md](../datasets/orders-db.md) for user scoping.
El siguiente paso importante en el diseño es el siguiente. Los conceptos se vinculan entre sí mediante enlaces estándar de Markdown. Eso convierte al directorio en un grafo, un conjunto de conocimientos tipificados y con referencias cruzadas que presentan relaciones explícitas que se pueden recorrer, en lugar de ser simplemente un montón de documentos planos.
[auth-api.md]
/ \
links links
/ \
[decisions/why-separated-auth.md] [datasets/orders-db.md]
|
links
|
[datasets/customers-db.md]
Una herramienta capaz de seguir un enlace de markdown puede recorrer el grafo, y un agente con acceso a archivos puede leerlo y escribir en él.
Dado que solo se requiere el type, el productor elige qué tipos existen (Service, Dataset, Metric, Decision, Runbook, etc.), qué campos opcionales utilizar y qué secciones del cuerpo incluir. OKF define la interoperabilidad y no los modelos de contenido.
Productores y consumidores
El formato funciona de la misma manera en ambos extremos, por lo que cambiar el productor o el consumidor no interrumpe la información compartida.
PRODUCERS CONSUMERS
--------- ---------
Human authors ----> AI agents
BigQuery pipelines ----> HTML visualizers
LLM-generated ----> Search indexes
Wiki exports ----> Other agents / tools
No existe una cuenta propietaria, ni SDK ni registro central. El valor aumenta con la amplitud de su adopción y no mediante el encierro del usuario en un proveedor específico. Eso sigue la filosofía detrás de git, markdown y JSON, formatos que perduraron porque no exigían nada para ser utilizados.
Relación con CLAUDE.md y MCP
La mayor parte de la confusión surge aquí. OKF no reemplaza las herramientas ya en uso; simplemente cubre una brecha específica.
+---------------------+---------------------------+---------------------------+
| TOOL | PURPOSE | SCOPE |
+---------------------+---------------------------+---------------------------+
| CLAUDE.md | How the agent behaves | Per-project, one agent |
| AGENTS.md | Repo instructions | Per-repo, tool-specific |
| Karpathy LLM wiki | Agent-maintained notes | Pattern, not a spec |
| MCP | Live tool access | Runtime connections |
| OKF | What the team knows | Cross-project, any agent |
+---------------------+---------------------------+---------------------------+
Un modelo mental claro separa tres preguntas:
- CLAUDE.md indica cómo debe comportarse el agente.
- OKF indica qué sabe el equipo sobre este sistema.
- MCP indica qué herramientas en tiempo real puede utilizar el agente en este momento.
Estos elementos se combinan. Una línea de CLAUDE.md podría indicar que se debe leer .okf/metrics/ antes de realizar cualquier tarea de análisis. El paquete OKF proporciona entonces el conocimiento estructurado al que se refiere CLAUDE.md, y las conexiones MCP ofrecen las fuentes de datos en tiempo real que describen los documentos de OKF.
La idea de wiki a la que hace referencia
Andrej Karpathy, quien acuñó el término “vibe coding” y ahora prefiere la expresión “agentic engineering”, publicó un resumen en wiki sobre LLM que acumuló más de 5,000 estrellas. Su argumento es sencillo: la gente abandona los wikis cuando su mantenimiento se vuelve una tarea tediosa, pero los agentes no se cansan de ello, no olvidan las referencias cruzadas ni tienen dificultades para editar 15 archivos de una sola vez.
Ese mismo patrón aparecía una y otra vez de forma independiente: en Obsidian junto con agentes de programación, en repositorios repletos de archivos AGENTS.md, así como en archivos index.md y log.md en decenas de proyectos. La gente estaba reinventando algo similar. Lo que aporta OKF es un acuerdo sobre qué campos contiene cada documento y qué significan los nombres de los archivos, de modo que wikis separados e incluso una exportación del catálogo de BigQuery pueden colaborar sin necesidad de traducción.
La relación entre ambos niveles tiene tres capas:
KARPATHY LAYER OKF EQUIVALENT
-------------- --------------
Raw sources (immutable) --> External datasets, docs, APIs
(OKF bundles are the compiled layer)
Wiki (LLM-maintained) --> OKF bundle (*.md + frontmatter)
(OKF adds type, resource, tags, timestamp)Schema (CLAUDE.md) --> Producer/consumer conventions + okf/SPEC.md
(org-wide spec replaces per-vault bespoke rules)
Tanto el enfoque de Karpathy como OKF reservan index.md y log.md para las mismas tareas, y esa convergencia no fue casualidad.
Qué incluyó Google
OKF es una especificación, pero Google lanzó tres herramientas prácticas junto con ella:
- Un agente de enriquecimiento para BigQuery. Dirigido a un conjunto de datos, elabora un documento conceptual OKF para cada tabla y vista, y luego realiza una segunda pasada con un LLM que agrega citas, esquemas y rutas de unión extraídas de la documentación. El resultado para un almacén de datos es un directorio
.okf/completo. - Un visualizador HTML estático. Convierte cualquier paquete OKF en un gráfico interactivo en un único archivo HTML autónomo, sin necesidad de servidor backend y sin que nada salga de la página. Los conceptos aparecen como nodos y los enlaces de Markdown como aristas; al hacer clic en un nodo se abre un panel de estilo wiki con Markdown renderizado y enlaces de retroceso etiquetados como “Enlaces a / Citado por”.
- Paquetes de ejemplo. Tres paquetes reales en GitHub utilizan conjuntos de datos públicos de BigQuery:
+--------------------+----------------------------------+
| BUNDLE | WHAT IT DOCUMENTS |
+--------------------+----------------------------------+
| GA4 e-commerce | Analytics tables and metrics |
| Stack Overflow | Public dataset concepts |
| Bitcoin | Blockchain dataset structure |
+--------------------+----------------------------------+
Funcionan tanto como plantillas iniciales para copiar como prueba de que el formato funciona en diferentes dominios.
Cuándo OKF es la elección adecuada
Es la opción adecuada cuando el problema de conocimiento se parece a uno de estos:
- Las mismas explicaciones se repiten en cada nueva sesión del agente. Si un bloque de contexto se sigue pegando en CLAUDE.md, pertenece a OKF.
- El conocimiento abarca varios proyectos o equipos. CLAUDE.md está vinculado a un proyecto y a un agente, mientras que OKF permite agrupar elementos que se mueven entre repositorios, agentes y herramientas.
- Los documentos del proyecto deben ser versionables. OKF se encuentra en git junto al código que describe; cada cambio se muestra en un diff y una solicitud de integración puede incluir actualizaciones de conocimiento junto con cambios en el código.
- La plataforma utilizada es Google Cloud y BigQuery. Existe una integración directa con el Knowledge Catalog de Google, que recibe los paquetes y los transfiere a los agentes de GCP.
- Se necesita un grafo de conocimiento y no una wiki plana. El grafo de enlaces en Markdown permite establecer relaciones tipadas entre conceptos sin necesidad de una base de datos de grafos.
Es la elección incorrecta en algunos casos:
- Se requieren datos en tiempo real, lo que implica el uso de MCP.
- Las reglas de comportamiento necesitan codificación, tarea que corresponde a CLAUDE.md.
- El proyecto es pequeño y cabe en una sola sesión, en cuyo caso CLAUDE.md por sí solo es suficiente.
Comenzar
El proceso de configuración está diseñado para ser mínimo.
Con Claude Code
El complemento okf-skills incluye tres habilidades. /okf:okf crea y mantiene los paquetes, /okf:validate verifica que un paquete cumpla con los requisitos y /okf:visualize genera el gráfico interactivo. Instálalo con:
/plugin marketplace add scaccogatto/okf-skills
/plugin install okf@scaccogatto
Cualquier agente, incluyendo Claude Code, Cursor, Codex y más de veinte otros, puede utilizar npm en su lugar:
npx skills add scaccogatto/okf-skills
Luego ejecute las habilidades:
/okf:okf produce .okf # create your first bundle
/okf:validate .okf --strict # check conformance
/okf:visualize .okf # generate viz.html
Para mantener las cosas actualizadas automáticamente, de modo que Claude lea .okf/ antes de las tareas y registre lo que aprendió posteriormente, copie el plantilla templates/CLAUDE-okf.md al archivo CLAUDE.md del proyecto. Nada obliga a realizar este paso.
Escribirlo a mano
Cree un directorio .okf/ y agregue un archivo index.md. Luego añada un archivo de concepto para cada cosa importante que haga el sistema. Un registro de decisión se ve así:
---
type: Decision
title: "Why we use Postgres over MySQL"
description: "JSONB support and row-level security were decisive."
timestamp: 2026-03-01T00:00:00Z
tags: [infrastructure, database]
---
El cuerpo sigue:
## ContextIn early 2026 we evaluated both options. MySQL's JSON support was insufficient for our metadata schema...## DecisionPostgres 16. See [datasets/primary-db.md](../datasets/primary-db.md) for schema docs.
Eso es todo lo que se necesita. Cualquier agente con acceso al archivo puede leerlo de inmediato, y se puede revisar en una PR y comparar sus diferencias en git.
Toda la estructura
Así es como OKF se integra con todo lo demás en una sesión:
+--------------------------------------------------+
| AGENT SESSION |
+--------------------------------------------------+
| CLAUDE.md / AGENTS.md |
| (behavioral rules - how agent acts) |
+--------------------------------------------------+
| OKF BUNDLE (.okf/) |
| (curated team knowledge - what we know) |
| - index.md: entry points per domain |
| - concepts/*.md: services, datasets, decisions |
| - log.md: change history |
+--------------------------------------------------+
| AUTO-MEMORY (memory.md) |
| (what the agent picked up implicitly) |
+--------------------------------------------------+
| MCP CONNECTIONS |
| (live tool access - what the agent can do) |
+--------------------------------------------------+
| SKILLS (.claude/skills/) |
| (reusable SOPs - how to do specific tasks) |
+--------------------------------------------------+
Cada capa responde a su propia pregunta. No se superponen, sino que se complementan.
Lo que deja abierto v0.1
Google denomina abiertamente a v0.1 un punto de partida, con la interoperabilidad resuelta primero. Quedan varias cuestiones de diseño:
- Contradicciones. Cuando dos documentos OKF difieren en un mismo hecho, aún no existen semánticas de fusión.
- Conocimiento obsoleto. Dado que OKF se basa en archivos, un documento que permanece sin cambios cuando el sistema evoluciona representa un fallo de proceso y no de formato.
- Relaciones tipadas. La especificación actual utiliza enlaces simples de markdown, mientras que tipos de relaciones más avanzados como contradice, extiende o sustituye están siendo desarrollados por la comunidad.
- Búsqueda facetada. Algunos profesionales desean más etiquetas de las que ofrece la especificación mínima.
La versión v0.2 probablemente abordará varios de estos problemas según los comentarios recibidos, y el repositorio de especificaciones es público y acepta problemas y propuestas de mejora.
Por qué ganan los formatos aburridos
Los formatos que se convierten en infraestructura suelen ser poco interesantes. JSON ganó porque era lo más simple que funcionaba y no costaba nada adoptarlo, no porque fuera ingenioso. Markdown ganó de la misma manera.
OKF encaja en esa descripción. No se necesita nada para leerlo ni para escribirlo, y funciona con cualquier herramienta que maneje archivos. Su valor aumenta con la cantidad de productores y consumidores, y las decisiones de un solo proveedor no influyen en él. Además, registra un patrón que la gente ya había desarrollado por su cuenta, a través de Karpathy’s gist, los hábitos de AGENTS.md y las jerarquías manuales de index.md, lo cual es la mejor prueba de que se está resolviendo un problema real.
El punto de Karpathy es que los agentes mantienen las wikis mejor que los humanos porque no se aburren. El punto de OKF es que una wiki solo aumenta en valor si puede ser compartida. Juntas, estas dos ideas podrían convertirse en un elemento fundamental para el desarrollo asistido por agentes en unos años. Construirla ahora, mientras es algo nuevo, traerá beneficios tanto para usted como para cada agente al que instruya.
Leer más
- Pasando a Claude Opus 5.5: Cinco cambios importantes detrás del ID del modelo — Una guía para cambiar a claude-opus-5-5: pensamiento continuo, elección forzada de herramientas, bloques de pensamiento vinculados al modelo, herramientas para usar la computadora y un flujo de progreso silencioso.
- Estructurando proyectos de Claude Code para que los agentes se mantengan enfocados en repositorios grandes — Seis patrones para grandes bases de código: archivos CLAUDE.md en capas, habilidades, subagentes, reglas de denegación, árboles de trabajo dispersos y complementos de language-server que mantienen el contexto del agente limpio.
- ¿AGENTS.md o CLAUDE.md? Qué contienen realmente los 592 repositorios más importantes — Una encuesta de 592 de los principales repositorios de GitHub muestra que CLAUDE.md es en su mayoría un enlace a AGENTS.md, y que los hooks, la capa de aplicación de reglas, son mucho menos comunes que los documentos.
- Notas prácticas: Los desarrolladores de TypeScript están usando Zod de forma incorrecta. No es solo eso — Guía detallada de las Notas prácticas: Los desarrolladores de TypeScript están usando Zod de forma incorrecta. No es solo eso: contratos, verificaciones y espacios de código listos para usar para equipos que implementan este patrón.