AKF — The AI Native File Format

EXIF para IA. AKF incorpora puntuaciones de confianza, procedencia de origen y metadatos de cumplimiento en cada archivo que tu IA toca — DOCX, PDF, imágenes, código y más de 20 formatos. 9 herramientas MCP: stamp, inspect, trust, audit, scan, embed, extract, detect. Audita contra la Ley de IA de la UE, SOX, HIPAA, NIST en un solo comando.

GitHub

Prueba este MCPPatrocinado

Documentación

_akf: '{"v":"1.0","claims":[{"c":"Trust metadata for README.md","t":0.7,"id":"1979cbeb","src":"unspecified","tier":5,"ver":false,"ai":true,"evidence":[{"type":"other","detail":"updated certify and github action references","at":"2026-03-18T04:21:48.869226+00:00"}]}],"id":"akf-c33254656fc5","agent":"claude-code","at":"2026-03-18T04:21:48.870623+00:00","label":"public","inherit":true,"ext":false,"sv":"1.1"}'

AKF — The AI Native File Format

Un sello cuesta ~15 tokens. Re-verificar cuesta 15,000.
Piensa en EXIF para IA — metadatos de confianza que viajan con cada archivo generado por IA,
para que el próximo agente (o humano) sepa sobre qué puede construir.

AKF Demo — stamp, inspect, audit in 10 seconds

⭐ Star en GitHub · Sitio web · 🛡️ ¿Esto fue generado por IA? · 🇪🇺 Verificación de cumplimiento · 📊 Escáner de repositorios

Inicio rápido · Agentes de IA · Servidor MCP · Habilidades de agente · CLI · Sitio web

Pega esto a tu agente

No instales AKF tú mismo — deja que tu agente lo haga. Pega esto en Claude Code, Cursor, OpenClaw, o cualquier agente de codificación:

Install AKF (pip install akf, or pipx install akf) and set it up: run `akf init --git-hooks`.
From now on:
- After you create or modify a file, stamp it:
    akf stamp <file> --agent <your-id> --evidence "<what you verified, e.g. 42/42 tests passed>"
- Before building on any existing file, check it first:
    akf check <file>
  OK = fresh stamp with verified evidence, skip re-verification. STALE/LOW/UNSTAMPED = verify before trusting.
If you support MCP, also register the server: {"mcpServers":{"akf":{"command":"python","args":["-m","mcp_server_akf"]}}}

Tu agente instala su propia capa de procedencia — y cada archivo que toca lleva metadatos de confianza a partir de entonces.

Por qué los agentes necesitan esto

Los agentes rehacen trabajo constantemente: releen archivos, re-ejecutan pruebas, re-derivan conclusiones — porque nada les dice qué ya fue verificado. Un sello es estado de verificación en caché:

# Session 1 — agent fixes auth, tests pass
$ akf stamp auth.py --agent claude-code --evidence "42/42 tests passed"

# Session 2 — tomorrow, any agent, any tool
$ akf check auth.py
OK trust=0.65 agent=claude-code evidence=test_pass age=1d claims=1
# → build on it, skip re-verification

# Someone edits auth.py without re-testing
$ akf check auth.py
STALE trust=0.65 agent=claude-code evidence=test_pass age=1d claims=1 reason=modified_after_stamp
# → re-verify before trusting (exit code 1 — gate CI or hooks on it)

Los sellos son marcadores de ruta que los agentes dejan para otros agentes — entre sesiones, entre herramientas (Claude Code → Cursor → Copilot), entre equipos. Los humanos obtienen la misma ruta: quién hizo este archivo, IA o humano, fue probado, podemos confiar en él.

Qué viaja con el archivo	Cómo
Puntuación de confianza	Confianza 0–1, ponderada por evidencia y nivel de fuente
Evidencia de verificación	pruebas aprobadas, verificación de tipos limpia, revisado por humanos — con marcas de tiempo
Procedencia de la fuente	presentación SEC → analista → cadena de agentes de IA
Cumplimiento	Un comando: `akf audit file --regulation eu_ai_act`

No confíes en el sello — vuelve a ejecutarlo

Una firma prueba quién lo dijo; una reproducción prueba que podría haber sido verdad. Un sello puede llevar una receta de sonda falsable, para que el próximo agente re-verifique la afirmación en lugar de confiar en la etiqueta:

# Stamp with a recipe that can be re-run
$ akf stamp auth.py --agent claude-code --evidence "42/42 tests passed" --replay "pytest -q"

# Later — re-run the probe instead of trusting the stamp
$ akf replay auth.py --run
CONFIRMED inputs=intact

# A dependency moved since the stamp was written
$ akf replay auth.py --run
CONFIRMED_DRIFTED inputs=drifted   # probe still passes, but against a changed world — re-check

REFUTED cuando la sonda falla, UNREPLAYABLE cuando no hay receta. Esta es la respuesta a "una fuente confiable aún puede estar equivocada": la confianza deja de depender de quién firmó, para cualquier afirmación con una verificación ejecutable.

Inicio rápido

pip install akf    # Python
npm install akf-format    # TypeScript / Node.js

akf doctor         # Check your install — detects PATH issues and guides setup

akf comando no encontrado? Ejecuta akf doctor para auto-detectar tu configuración, o usa python3 -m akf (siempre funciona).

Instala con pipx: pipx install akf (recomendado — maneja PATH automáticamente)

Windows: usa python3 -m akf o instala vía pipx

# The core loop — stamp what you verified, check before you trust
akf stamp auth.py --agent claude-code --evidence "42/42 tests passed"
akf check auth.py        # OK trust=0.65 agent=claude-code evidence=test_pass age=0d

import akf

# Same loop from Python
akf.stamp_file("auth.py", agent="claude-code", evidence=["42/42 tests passed"])
result = akf.check_file("auth.py")
print(result.summary_line())   # OK trust=0.65 agent=claude-code evidence=test_pass age=0d claims=1

# Embed into Office docs, PDFs, images — any format
akf.embed("report.docx", claims=[...], classification="confidential")

# Audit for compliance (EU AI Act, HIPAA, SOX, GDPR, NIST AI, ISO 42001)
result = akf.audit("report.akf", regulation="eu_ai_act")
print(f"Compliant: {result.compliant}")

TypeScript / Node.js (akf-format):

import { create, validate, effectiveTrust, stampFile } from 'akf-format';

// Create a trust-stamped unit from any AI output
const unit = create('Revenue was $4.2B, up 12% YoY', 0.98, {
  source: 'SEC 10-Q',
  agent: 'claude-code',
});

// Validate against the AKF schema
const { valid } = validate(unit);

// Compute effective trust for a claim
const trust = effectiveTrust(unit.claims[0]);
console.log(`valid: ${valid}, score: ${trust.score}, decision: ${trust.decision}`);

// Stamp trust metadata directly into a file (markdown, json, code, …)
stampFile('report.md', { agent: 'claude-code', evidence: 'tests pass' });

API completa de TypeScript y más ejemplos: typescript/README.md.

Para Agentes de IA

AKF está diseñado agente-primero. APIs de una línea para verificar, sellar, transmitir y auditar.

import akf

# Check before you trust — can I build on this file without re-verifying?
result = akf.check_file("auth.py")
if result.status == "OK":      # fresh stamp, verified evidence
    ...                        # skip re-verification, save the tokens
# LOW / STALE / UNSTAMPED → verify before trusting

# Stamp with evidence (auto-detected: test_pass, type_check, human_review, etc.)
akf.stamp("Fixed auth bypass", kind="code_change",
          evidence=["42/42 tests passed", "mypy: 0 errors"],
          agent="claude-code", model="claude-sonnet-4-20250514")

# Stream trust metadata in real-time
with akf.stream("output.md", model="gpt-4o") as s:
    for chunk in llm_response:
        s.write(chunk)

# Trust-annotated git commits (uses git notes)
akf.stamp_commit(content="Refactored auth module", kind="code_change",
                 evidence=["all tests pass"], agent="claude-code")
print(akf.trust_log(n=10))  # + ACCEPT  ~ LOW  - REJECT  ? none

Equipos Multi-Agente

AKF soporta orquestación multi-agente — Claude Agent Teams, Copilot Cowork, Codex multi-agente, y cualquier plataforma compatible con A2A.

import akf

# Agent-to-agent delegation with trust ceiling
policy = akf.DelegationPolicy(
    delegator="lead-agent", delegate="research-bot",
    trust_ceiling=0.7, allowed_actions=["search", "summarize"]
)
result = akf.delegate(parent_unit, policy)

# Multi-agent streaming session
with akf.TeamStream(["research", "writer", "reviewer"]) as ts:
    ts.write("research", "Found 3 sources", confidence=0.8)
    ts.write("writer", "Drafted summary", confidence=0.75)
    ts.write("reviewer", "Approved with edits", confidence=0.9)
    scores = ts.aggregate()  # per-agent + team trust

# Cross-platform agent identity
card = akf.create_agent_card(name="Research Bot", platform="claude-code",
                             capabilities=["search", "summarize"])
akf.verify_agent_card(card)  # SHA-256 hash verification

# Team certification (per-agent breakdown)
report = akf.certify_team("src/", min_trust=0.7)
# report.all_agents_certified — each agent must individually pass

CLI:

akf agent create --name "Bot" --platform claude-code --capabilities search,summarize
akf agent list
akf agent verify <id>
akf agent export-a2a <id> --output card.json   # A2A protocol bridge
akf agent import-a2a card.json
akf certify src/ --team                         # Per-agent breakdown

Servidor MCP

AKF incluye un servidor MCP para que cualquier agente de IA pueda crear, validar, escanear y auditar metadatos de confianza.

# Install from the repo
pip install ./packages/mcp-server-akf

{
  "mcpServers": {
    "akf": {
      "command": "python",
      "args": ["-m", "mcp_server_akf"]
    }
  }
}

11 herramientas MCP: check_file · replay_file · create_claim · validate_file · scan_file · trust_score · stamp_file · audit_file · embed_file · extract_file · detect_threats

Confianza Ambiental

AKF funciona donde trabajan los agentes de IA. Coloca un archivo de configuración, y cada archivo generado por IA lleva metadatos de confianza automáticamente.

Agente	Cómo funciona
Claude Code	Plugin: `/plugin marketplace add HMAKT99/AKF` → `/plugin install akf` — hook de auto-sellado + habilidad de verificación. O lee `CLAUDE.md`
Cursor	Lee `.cursorrules` — sella ediciones de IA antes de que revises
Windsurf	Lee `.windsurfrules` — sella ediciones de IA con metadatos de confianza
GitHub Copilot	Lee `.github/copilot-instructions.md` (nativo) + hook de shell para CLI
OpenAI Codex	Lee `AGENTS.md` — sella archivos en sandbox de nube y local
OpenClaw	Habilidad en ClawHub: `clawhub install akf` — protocolo de verificación/sellado + memoria de confianza
Hermes Agent	Habilidad de agentskills.io: `hermes skills tap add HMAKT99/AKF` — archivos, memorias y cadena de suministro de habilidades
Manus / Otros Agentes	Servidor MCP + hook de shell — funciona con cualquier agente que soporte MCP o CLI
Cualquier agente MCP	11 herramientas MCP — verificar, reproducir, sellar, auditar, incrustar, extraer, detectar, validar, escanear, confiar, crear
Cualquier herramienta CLI	`eval "$(akf shell-hook)"` — intercepta `claude`, `chatgpt`, `aider`, `openclaw`, `ollama`, `manus`

El pipeline de confianza:

Agent writes code → Git commit stamped → CI runs akf certify → Team reviews with context

Configuración en 60 segundos:

# 1. Agent stamps its own work (already in this repo)
cat CLAUDE.md        # or .cursorrules / .windsurfrules / AGENTS.md / .github/copilot-instructions.md

# 2. Git hooks stamp every commit
akf init --git-hooks

# 3. CI certifies trust on every PR
#    uses: HMAKT99/AKF/extensions/github-action@main

# 4. Shell hook intercepts AI CLI tools
eval "$(akf shell-hook)"

Habilidades

AKF proporciona archivos de habilidad de agente que los agentes de IA pueden descubrir y usar. Colócalos en el contexto de tu agente:

Habilidad	Qué hace
`check.md`	Verifica la confianza de un archivo antes de construir sobre él
`stamp.md`	Sella metadatos de confianza en salidas de IA
`audit.md`	Audita archivos para cumplimiento regulatorio
`scan.md`	Escaneo de seguridad de archivos y directorios
`embed.md`	Incrusta metadatos de confianza en Office/PDF/imágenes
`detect.md`	Ejecuta 10 clases de detección de seguridad
`stream.md`	Transmite metadatos de confianza en tiempo real
`git.md`	Flujos de trabajo git anotados con confianza
`convert.md`	Convierte entre formatos
`delegate`	Delegación de confianza agente-a-agente
`team`	Sesiones de transmisión multi-agente

Formato de un Vistazo

Compacto (~15 tokens — optimizado para IA):

{"v":"1.0","claims":[{"c":"Revenue was $4.2B","t":0.98,"src":"SEC 10-Q"}]}

Descriptivo (legible por humanos — mismos datos):

{"version":"1.0","claims":[{"content":"Revenue was $4.2B","confidence":0.98,"source":"SEC 10-Q"}]}

Completo (con procedencia, decaimiento, banderas de IA, seguridad):

{"v":"1.0","by":"sarah@acme.com","label":"confidential","inherit":true,
 "claims":[
   {"c":"Revenue $4.2B","t":0.98,"src":"SEC 10-Q","tier":1,"ver":true,"decay":90},
   {"c":"H2 will accelerate","t":0.63,"tier":5,"ai":true,"risk":"AI inference"}
 ],
 "prov":[
   {"hop":0,"by":"sarah@acme.com","do":"created","at":"2025-07-15T09:30:00Z"},
   {"hop":1,"by":"copilot-agent","do":"enriched","at":"2025-07-15T10:15:00Z"}
 ]}

Funciona con Cada Formato

AKF se incrusta nativamente — sin necesidad de archivos laterales para la mayoría de formatos:

Formato	Cómo funciona
`.akf`	Archivo de conocimiento independiente nativo
`.docx` `.xlsx` `.pptx`	Parte XML personalizada OOXML
`.pdf`	Flujo de metadatos PDF
`.html`	JSON-LD `<script type="application/akf+json">`
`.md`	Frontmatter YAML
`.png` `.jpg`	Metadatos EXIF/XMP
`.json`	Clave `_akf` reservada
`.mp4` `.mov` `.webm` `.mkv`	Acompañante lateral `.akf.json`
`.mp3` `.wav` `.flac` `.ogg`	Acompañante lateral `.akf.json`
Todo lo demás	Acompañante lateral `.akf.json`

# One API for all formats
akf.embed("report.docx", claims=[...], classification="confidential")
meta = akf.extract("report.docx")
akf.scan("report.docx")

Auto-Sellado Sin Intervención

AKF puede sellar automáticamente cada archivo que la IA toca — sin necesidad de intervención manual.

# Install the background watcher
akf install

# Or run in foreground
akf watch ~/Downloads ~/Desktop ~/Documents

El vigilante de fondo monitorea directorios para archivos nuevos y modificados y los sella con metadatos de confianza. Detección de contexto inteligente infiere automáticamente:

Autor de Git — del historial de git log
Fuente de descarga — de atributos extendidos de macOS
Clasificación — de reglas de .akf/config.json del proyecto
Bandera de generado por IA — de marcas de tiempo de seguimiento de LLM + heurísticas de contenido
Puntuación de confianza — ajustada dinámicamente según la evidencia disponible

Hook de Shell (intercepta herramientas CLI de IA)

# Add to ~/.zshrc or ~/.bashrc
eval "$(akf shell-hook)"

Detecta automáticamente cuando ejecutas claude, chatgpt, aider, openclaw, ollama, u otras herramientas CLI de IA, y sella cualquier archivo que creen o modifiquen. También pre-sella archivos antes de subirlos a plataformas de contenido (gws, box, m365, dbxcli, rclone) para que los metadatos de confianza viajen con el archivo. Usa --no-upload-hooks para deshabilitar.

Reglas de Proyecto

Crea .akf/config.json en la raíz de tu proyecto:

{
  "rules": [
    {"pattern": "*/finance/*", "classification": "confidential", "tier": 2},
    {"pattern": "*/public/*", "classification": "public", "tier": 3}
  ]
}

Los archivos que coinciden con estos patrones se clasifican automáticamente al sellarse.

CLI

# ── Quick start ──
akf                          # Welcome + quick start
akf quickstart               # Interactive demo
akf doctor                   # Check installation health

# ── Stamp & create ──
akf create report.akf \
  --claim "Revenue $4.2B" --trust 0.98 --src "SEC 10-Q" \
  --by sarah@acme.com --label confidential

# ── Check before you trust ──
akf check auth.py            # One line: OK / LOW / STALE / UNSTAMPED
akf check auth.py --json     # Structured output; exit codes 0/1/2 for gating
akf replay auth.py           # Inspect the stamp's falsifiable probe recipe
akf replay auth.py --run     # Re-run it: CONFIRMED / CONFIRMED_DRIFTED / REFUTED

# ── Validate & inspect ──
akf validate report.akf
akf inspect report.akf
akf trust report.akf

# ── Certify (aggregate pass/fail gate) ──
akf certify report.akf                        # Trust + detection + compliance
akf certify src/ --min-trust 0.8              # Custom threshold
akf certify . --evidence-file results.xml     # Attach test evidence
akf certify . --format json --fail-on-untrusted  # CI-friendly output
akf certify src/ --team                       # Per-agent trust breakdown

# ── Compliance ──
akf audit report.akf                          # Compliance readiness check
akf audit report.akf --regulation eu_ai_act   # EU AI Act
akf audit report.akf --trail                  # Audit trail

# ── Universal format commands ──
akf embed report.docx --classification confidential \
  --claim "Revenue $4.2B" --trust 0.98
akf extract report.docx
akf scan report.docx
akf scan ./docs/ --recursive
akf scan . --badge badge.json     # shields.io endpoint: "14% stamped · trust 0.76"

# ── Auto-stamping ──
akf install                                   # Install background watcher
akf watch ~/Downloads ~/Documents             # Watch directories
akf shell-hook                                # Print shell hook code
akf shell-hook --no-upload-hooks              # Without content platform hooks
akf uploads                                   # View upload stamp log

# ── Git integration ──
akf stamp <file> --agent claude-code --evidence "tests pass"

# ── Agent identity & teams ──
akf agent create --name "Bot" --platform claude-code
akf agent list
akf agent verify <agent_id>
akf agent export-a2a <id> --output card.json  # A2A protocol bridge
akf agent import-a2a card.json

# ── Knowledge Base ──
akf kb stats ./kb
akf kb query ./kb --topic finance

Detecciones de Seguridad

10 clases de detección integradas: contenido de IA sin revisión, confianza por debajo del umbral, riesgo de alucinación, lavado de conocimiento, degradación de clasificación, afirmaciones obsoletas, afirmaciones de IA sin fundamento, cadena de degradación de confianza, concentración excesiva de IA, brecha de procedencia.

from akf import run_all_detections
report = run_all_detections(unit)
for finding in report.findings:
    print(f"[{finding.severity}] {finding.detection}: {finding.message}")

Cálculo de Confianza

effective_trust = confidence × authority_weight × temporal_decay × (1 + penalty)

Nivel	Peso	Ejemplo
1	1.00	Presentaciones SEC, registros oficiales
2	0.85	Informes de analistas, revisados por pares
3	0.70	Noticias, informes de la industria
4	0.50	Estimaciones internas, datos de CRM
5	0.30	Inferencia de IA, extrapolaciones

Decisión: puntuación ≥ 0.7 → ACEPTAR · ≥ 0.4 → BAJA · < 0.4 → RECHAZAR

Techo de delegación: Cuando un agente delega a otro, la confianza de salida del delegado está limitada a min(score, delegation_ceiling). Esto previene la inflación de confianza en cadenas multi-agente.

Integraciones y Extensiones

Integraciones de frameworks (instala desde el repositorio vía pip install ./packages/<name>):

Paquete	Descripción
`mcp-server-akf`	Servidor MCP — crear, validar, escanear, confiar
`langchain-akf`	Manejador de callbacks de LangChain + cargador de documentos (experimental)
`llama-index-akf`	Analizador de nodos de LlamaIndex + filtro de confianza (experimental)
`crewai-akf`	Herramienta CrewAI para agentes conscientes de confianza (experimental)

Extensiones de editor y CI (fuente en el repositorio):

Extensión	Descripción
VS Code	Resaltado de sintaxis, información al pasar el cursor, validación para archivos `.akf`
Monitor de IA de VS Code	Auto-sella archivos editados por Copilot, Cursor y otras herramientas de IA
Acción de GitHub	Puerta de confianza de CI — ejecuta `akf certify` en PRs con comentarios opcionales de PR
Google Workspace	Complemento para Docs, Sheets, Slides (vista previa)
Complemento de Office	Complemento para Word, Excel, PowerPoint (vista previa)

Para LLMs

Proporciona un ejemplo y los LLMs producen AKF válido más del 95% de las veces:

Output knowledge as AKF:
{"v":"1.0","claims":[{"c":"<claim>","t":<0-1>,"src":"<source>","tier":<1-5>,"ai":true}]}

Consulta LLM-PROMPT.md para un prompt de sistema completo.

Documentación

Doc	Descripción
Especificación completa	Especificación completa del formato
JSON Schema	Esquema legible por máquina
Producir AKF	Inicio rápido para 8 lenguajes
Cálculo de confianza	Detalles del algoritmo de puntuación
Evidencia falsable	Recetas de reproducción: re-ejecuta la sonda, no confíes en la etiqueta
Memoria del agente	Sellos de memoria con decaimiento de confianza
Procedencia de habilidades	Confianza en la cadena de suministro para archivos de habilidades
Integración con LLM	Estrategias de prompting
EU AI Act	Mapeo de cumplimiento
NIST AI RMF	Mapeo de marco de referencia

vs Alternativas

	AKF	C2PA	Marcas de agua	Seguimiento manual
Funciona en documentos/código	✅	❌ (solo medios)	❌	⚠️
No requiere Autoridad Certificadora	✅	❌	✅	✅
Puntuaciones de confianza	✅	❌	❌	❌
Cadena de procedencia de fuente	✅	✅	❌	⚠️
Auditoría de cumplimiento	✅	❌	❌	❌
~15 tokens (compatible con LLM)	✅	❌	N/A	N/A
Más de 20 formatos de archivo	✅	⚠️ (medios)	⚠️ (texto)	❌
Gratuito y de código abierto	✅	⚠️	Varía	✅

Cumplimiento

El Artículo 50 de la EU AI Act entra en vigor el 2 de agosto de 2026 — el contenido generado por IA debe llevar metadatos de transparencia (sanciones de hasta 35 millones de EUR / 7% de la facturación global). Los archivos sellados con AKF ya los incluyen:

akf audit report.docx --regulation eu_ai_act

Mapeos para EU AI Act y NIST AI RMF.

Contribuciones

Consulta CONTRIBUTING.md para la configuración de desarrollo, pruebas y proceso de PR.

Gratuito y Abierto — Para Siempre

AKF es gratuito y de código abierto bajo la licencia MIT. La especificación del formato siempre será gratuita. Ninguna función estará nunca restringida detrás de un nivel de pago. AKF es un estándar, y los estándares deben ser gratuitos para ser universales.

Licencia

MIT — úsalo en todas partes, intégralo en todo.