Google escribió la especificación de lo que yo hacía mal

El 12 de junio de 2026, Google Cloud publicó una especificación llamada Open Knowledge Format. La leí un martes por la noche y tardé unos veinte minutos en darme cuenta de que llevo meses construyendo exactamente eso, mal.

No mal en el sentido de roto. Mal en el sentido de que funcionaba para mí y no habría funcionado para nadie más, y yo no tenía forma de notarlo.

Qué es OKF, sin adornos

Un directorio de archivos Markdown con frontmatter YAML, enlazados entre sí con enlaces Markdown normales. Eso es todo.

Un archivo es un concepto. La ruta del archivo es su identidad. Los enlaces entre archivos forman un grafo de relaciones explícitas, en vez de relaciones inferidas por similitud de vectores.

La regla obligatoria es una sola: todo archivo lleva frontmatter con un campo type no vacío. El resto es opcional, y la especificación obliga a los consumidores a tolerar campos que no conocen, tipos que no conocen y enlaces rotos.

Cabe en una página. Está en GitHub.

Vale la pena aclarar algo, porque he visto varios artículos afirmando lo contrario: OKF no reemplaza una base de datos vectorial. Es un formato de contenido, no un sistema de recuperación. Un bundle OKF se ingiere sin problema en Pinecone o en Qdrant. Lo que cambia es que las relaciones entre conceptos están escritas, no adivinadas.

Lo que ya coincidía

Llevo meses operando un sistema de decisión que es, literalmente, un directorio de Markdown: un archivo por concepto, enlaces entre ellos, un archivo de historia al que solo se agrega al final, y un índice que resume y enlaza en vez de duplicar.

Cuando leí la especificación, cinco de sus seis convenciones ya estaban ahí. No por visión: porque son las que aparecen solas cuando trabajas a diario con un agente y te cansas de repetirte.

Eso fue lo agradable de la lectura. Lo útil vino después.

Error 1: todo mi estado vive en prosa

Mis archivos marcan el estado de cada afirmación: HECHO, INFERENCIA, SUPUESTO, EVIDENCIA PENDIENTE. Estoy convencido de que es la mejor decisión de diseño que tomé, y la sigo defendiendo.

El problema es dónde la puse: dentro del texto.

Para saber si un archivo mío es fiable hay que abrirlo y leerlo. OKF pone esos mismos datos en el frontmatter, donde se pueden consultar sin leer el cuerpo. La diferencia parece cosmética hasta que tienes cuarenta archivos y un agente con ventana finita: entonces es la diferencia entre poder decidir qué cargar y tener que cargarlo todo para averiguarlo.

Yo había resuelto el problema correcto en el lugar equivocado.

Error 2: nada caduca

OKF v0.2 tiene un campo llamado stale_after: una fecha después de la cual el concepto se considera vencido.

Mi sistema exige fecha de evaluación a toda idea que se guarda sin ejecutar. Estaba orgulloso de esa regla. Pero solo la aplico a las ideas.

Mi archivo de conocimiento personal dice «última actualización» y esa fecha lleva meses igual. Mis prioridades tienen fecha de revisión, pero nada me avisa. Es decir: construí un sistema que distingue con precisión entre un hecho y una suposición, y que no distingue en absoluto entre un hecho de esta semana y uno de hace cinco meses.

Un hecho viejo se lee exactamente igual que uno reciente. Esa es la forma más silenciosa de estar equivocado.

Error 3: no distingo quién escribió qué

Este es el que me dejó incómodo.

OKF v0.2 usa una convención de actor. Cuando algo lo produjo o lo confirmó una persona, se anota como human:<id>. Cuando lo produjo un agente, se anota con el nombre y la versión del modelo. De ahí se derivan tres niveles: sin verificar, confirmado por máquina, revisado por humano.

En mis archivos, una conclusión que escribí yo después de pensarla una semana y una que redactó un agente en cuatro segundos se ven idénticas.

Y cada vez escribo yo una proporción menor. Este año delegué buena parte de la redacción de mi propio contexto a agentes, que es justo lo que se supone que hay que hacer, y en el camino perdí la capacidad de saber qué revisé de verdad.

No es un problema teórico. Un agente puede escribir una inferencia razonable a partir de datos incompletos, guardarla, y leerla tres semanas después como antecedente propio. Sin la marca de quién la produjo, el sistema no tiene forma de darse cuenta. Yo tampoco.

Lo que voy a hacer, y lo que no

No voy a migrar nada esta semana. Estoy en mitad de otro experimento y cambiar la estructura de mi contexto mientras mido otra cosa es la manera perfecta de no aprender ninguna de las dos.

Lo que sí hice fue registrarlo con fecha de evaluación, que es la regla que acababa de reconocer que aplico a medias.

Cuando lo haga, el orden es este:

1. generated y verified, porque distinguir mi criterio del de un agente es lo que más me duele hoy.
2. stale_after en los archivos que envejecen: conocimiento personal, prioridades, cifras.
3. type en todo, que es la única regla obligatoria y la más fácil.

Deliberadamente al revés del orden de dificultad. Primero lo que arregla el fallo que ya me está costando algo.

La parte que no esperaba

Llevaba meses convencido de que mi sistema estaba bien porque a mí me funcionaba.

Una especificación escrita por gente que no me conoce, para un problema que yo creía particular, me mostró tres agujeros en veinte minutos. Ninguno era de implementación. Los tres eran de diseño, y los tres llevaban meses ahí.

Esa es la parte que vale de que existan estándares abiertos, y la razón por la que recomiendo leerla aunque no vayas a adoptarla: no te dice cómo hacer lo que ya haces. Te muestra lo que dejaste de mirar.