AKF — The AI Native File Format

EXIF para IA. O AKF incorpora pontuações de confiança, proveniência de origem e metadados de conformidade em cada arquivo que sua IA toca — DOCX, PDF, imagens, código e mais de 20 formatos. 9 ferramentas MCP: stamp, inspect, trust, audit, scan, embed, extract, detect. Audite contra EU AI Act, SOX, HIPAA, NIST em um único comando.

GitHub

Experimente este MCPPatrocinado

Documentação

_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

Uma estampa custa ~15 tokens. Re-verificar custa 15.000.
Pense em EXIF para IA — metadados de confiança que viajam com cada arquivo gerado por IA,
para que o próximo agente (ou humano) saiba no que pode construir.

AKF Demo — stamp, inspect, audit in 10 seconds

⭐ Star no GitHub · Website · 🛡️ Isto foi gerado por IA? · 🇪🇺 Verificação de Conformidade · 📊 Scanner de Repositório

Início Rápido · Agentes de IA · Servidor MCP · Habilidades de Agente · CLI · Website

Cole isto no seu agente

Não instale o AKF você mesmo — deixe seu agente fazer isso. Cole isto no Claude Code, Cursor, OpenClaw, ou qualquer agente de codificação:

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"]}}}

Seu agente instala sua própria camada de proveniência — e cada arquivo que ele toca carrega metadados de confiança a partir de então.

Por que agentes precisam disso

Agentes refazem trabalho constantemente: releem arquivos, reexecutam testes, rederivam conclusões — porque nada lhes diz o que já foi verificado. Uma estampa é o estado de verificação em cache:

# 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)

Estampas são marcadores de trilha que agentes deixam para outros agentes — entre sessões, entre ferramentas (Claude Code → Cursor → Copilot), entre equipes. Humanos obtêm a mesma trilha: quem fez este arquivo, IA ou humano, foi testado, podemos confiar.

O que viaja com o arquivo	Como
Pontuação de confiança	Confiança de 0–1, ponderada por evidências e nível da fonte
Evidências de verificação	testes aprovados, type check limpo, revisão humana — com carimbos de data/hora
Proveniência da fonte	SEC filing → analista → cadeia de agentes de IA
Conformidade	Um comando: `akf audit file --regulation eu_ai_act`

Não confie na estampa — reexecute-a

Uma assinatura prova quem disse; uma reprodução prova que poderia ter sido verdade. Uma estampa pode carregar uma receita de sonda falseável, para que o próximo agente reverifique a afirmação em vez de confiar no rótulo:

# 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 quando a sonda falha, UNREPLAYABLE quando não há receita. Esta é a resposta para "uma fonte confiável ainda pode estar errada": a confiança deixa de depender de quem assinou, para qualquer afirmação com uma verificação executável.

Início 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 não encontrado? Execute akf doctor para detectar automaticamente sua configuração, ou use python3 -m akf (sempre funciona).

Instale com pipx: pipx install akf (recomendado — gerencia o PATH automaticamente)

Windows: use python3 -m akf ou instale via 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 TypeScript completa e mais exemplos: typescript/README.md.

Para Agentes de IA

O AKF é projetado agente-primeiro. APIs de uma linha para verificação, estampagem, streaming e auditoria.

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

Equipes Multi-Agente

O AKF suporta orquestração multi-agente — Claude Agent Teams, Copilot Cowork, Codex multi-agente, e qualquer plataforma compatível com 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

O AKF inclui um servidor MCP para que qualquer agente de IA possa criar, validar, escanear e auditar metadados de confiança.

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

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

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

Confiança Ambiental

O AKF funciona onde os agentes de IA trabalham. Coloque um arquivo de configuração, e cada arquivo gerado por IA carrega metadados de confiança automaticamente.

Agente	Como funciona
Claude Code	Plugin: `/plugin marketplace add HMAKT99/AKF` → `/plugin install akf` — hook de auto-estampagem + habilidade de verificação. Ou lê `CLAUDE.md`
Cursor	Lê `.cursorrules` — estampa edições de IA antes de você revisar
Windsurf	Lê `.windsurfrules` — estampa edições de IA com metadados de confiança
GitHub Copilot	Lê `.github/copilot-instructions.md` (nativo) + shell hook para CLI
OpenAI Codex	Lê `AGENTS.md` — estampa arquivos no sandbox em nuvem e local
OpenClaw	Habilidade no ClawHub: `clawhub install akf` — protocolo de verificação/estampagem + memória de confiança
Hermes Agent	Habilidade em agentskills.io: `hermes skills tap add HMAKT99/AKF` — arquivos, memórias e cadeia de suprimentos de habilidades
Manus / Outros Agentes	Servidor MCP + shell hook — funciona com qualquer agente que suporte MCP ou CLI
Qualquer agente MCP	11 ferramentas MCP — verificar, reproduzir, estampar, auditar, incorporar, extrair, detectar, validar, escanear, confiar, criar
Qualquer ferramenta CLI	`eval "$(akf shell-hook)"` — intercepta `claude`, `chatgpt`, `aider`, `openclaw`, `ollama`, `manus`

O pipeline de confiança:

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

Configure em 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

O AKF fornece arquivos de habilidade de agente que agentes de IA podem descobrir e usar. Coloque-os no contexto do seu agente:

Habilidade	O que faz
`check.md`	Verifica a confiança de um arquivo antes de construir sobre ele
`stamp.md`	Estampa metadados de confiança em saídas de IA
`audit.md`	Audita arquivos para conformidade regulatória
`scan.md`	Escaneia arquivos e diretórios por segurança
`embed.md`	Incorpora metadados de confiança em Office/PDF/imagens
`detect.md`	Executa 10 classes de detecção de segurança
`stream.md`	Transmite metadados de confiança em tempo real
`git.md`	Fluxos de trabalho git anotados com confiança
`convert.md`	Converte entre formatos
`delegate`	Delegação de confiança agente-a-agente
`team`	Sessões de streaming multi-agente

Formato em Resumo

Compacto (~15 tokens — otimizado para IA):

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

Descritivo (legível por humanos — mesmos dados):

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

Completo (com proveniência, decaimento, flags de IA, segurança):

{"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 com Todos os Formatos

O AKF incorpora nativamente — sem necessidade de sidecars para a maioria dos formatos:

Formato	Como Funciona
`.akf`	Arquivo de conhecimento autônomo nativo
`.docx` `.xlsx` `.pptx`	Parte XML personalizada OOXML
`.pdf`	Fluxo de metadados PDF
`.html`	JSON-LD `<script type="application/akf+json">`
`.md`	Frontmatter YAML
`.png` `.jpg`	Metadados EXIF/XMP
`.json`	Chave `_akf` reservada
`.mp4` `.mov` `.webm` `.mkv`	Acompanhante sidecar `.akf.json`
`.mp3` `.wav` `.flac` `.ogg`	Acompanhante sidecar `.akf.json`
Todo o resto	Acompanhante sidecar `.akf.json`

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

Auto-Estampagem Sem Toque

O AKF pode estampar automaticamente cada arquivo que a IA toca — sem intervenção manual.

# Install the background watcher
akf install

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

O observador em segundo plano monitora diretórios para arquivos novos e modificados e os estampa com metadados de confiança. Detecção inteligente de contexto infere automaticamente:

Autor do git — do histórico git log
Fonte de download — de atributos estendidos do macOS
Classificação — das regras .akf/config.json do projeto
Flag de gerado por IA — de timestamps de rastreamento de LLM + heurísticas de conteúdo
Pontuação de confiança — ajustada dinamicamente com base nas evidências disponíveis

Shell Hook (intercepta ferramentas CLI de IA)

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

Detecta automaticamente quando você executa claude, chatgpt, aider, openclaw, ollama, ou outras ferramentas CLI de IA, e estampa quaisquer arquivos que elas criam ou modificam. Também pré-estampa arquivos antes do upload para plataformas de conteúdo (gws, box, m365, dbxcli, rclone) para que os metadados de confiança viajem com o arquivo. Use --no-upload-hooks para desativar.

Regras de Projeto

Crie .akf/config.json na raiz do seu projeto:

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

Arquivos que correspondem a esses padrões são automaticamente classificados quando estampados.

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

Detecções de Segurança

10 classes de detecção integradas: conteúdo de IA sem revisão, confiança abaixo do limite, risco de alucinação, lavagem de conhecimento, rebaixamento de classificação, afirmações obsoletas, afirmações de IA sem fundamento, cadeia de degradação de confiança, concentração excessiva de IA, lacuna de proveniência.

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 Confiança

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

Nível	Peso	Exemplo
1	1.00	SEC filings, registros oficiais
2	0.85	Relatórios de analistas, revisados por pares
3	0.70	Notícias, relatórios do setor
4	0.50	Estimativas internas, dados de CRM
5	0.30	Inferência de IA, extrapolações

Decisão: pontuação ≥ 0,7 → ACEITAR · ≥ 0,4 → BAIXA · < 0,4 → REJEITAR

Teto de delegação: Quando um agente delega para outro, a confiança da saída do delegado é limitada a min(score, delegation_ceiling). Isso evita inflação de confiança em cadeias multi-agente.

Integrações e Extensões

Integrações de framework (instale do repositório via pip install ./packages/<name>):

Pacote	Descrição
`mcp-server-akf`	Servidor MCP — criar, validar, escanear, confiar
`langchain-akf`	LangChain callback handler + document loader (experimental)
`llama-index-akf`	LlamaIndex node parser + filtro de confiança (experimental)
`crewai-akf`	Ferramenta CrewAI para agentes conscientes de confiança (experimental)

Extensões de editor e CI (fonte no repositório):

Extensão	Descrição
VS Code	Realce de sintaxe, informações ao passar o mouse, validação para arquivos `.akf`
VS Code AI Monitor	Auto-estampa arquivos editados por Copilot, Cursor e outras ferramentas de IA
GitHub Action	Portão de confiança de CI — executa `akf certify` em PRs com comentários opcionais
Google Workspace	Complemento para Docs, Sheets, Slides (pré-visualização)
Office Add-in	Complemento para Word, Excel, PowerPoint (pré-visualização)

Para LLMs

Dê um exemplo e LLMs produzem AKF válido 95%+ das vezes:

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

Veja LLM-PROMPT.md para um prompt de sistema completo.

Documentação

Documento	Descrição
Especificação Completa	Especificação completa do formato
JSON Schema	Esquema legível por máquina
Produzindo AKF	Início rápido para 8 linguagens
Cálculo de Confiança	Detalhes do algoritmo de pontuação
Evidência Falseável	Receitas de replay — reexecute a sondagem, não confie no rótulo
Memória do Agente	Carimbos de memória com decaimento de confiança
Proveniência de Habilidades	Confiança na cadeia de suprimentos para arquivos de habilidades
Integração com LLM	Estratégias de prompt
EU AI Act	Mapeamento de conformidade
NIST AI RMF	Mapeamento de framework

vs Alternativas

	AKF	C2PA	Marca d'água	Rastreamento manual
Funciona em documentos/código	✅	❌ (somente mídia)	❌	⚠️
Sem necessidade de Autoridade Certificadora	✅	❌	✅	✅
Pontuações de confiança	✅	❌	❌	❌
Cadeia de proveniência da fonte	✅	✅	❌	⚠️
Auditoria de conformidade	✅	❌	❌	❌
~15 tokens (amigável para LLM)	✅	❌	N/A	N/A
20+ formatos de arquivo	✅	⚠️ (mídia)	⚠️ (texto)	❌
Gratuito e de código aberto	✅	⚠️	Varia	✅

Conformidade

O Artigo 50 do EU AI Act entra em vigor em 2 de agosto de 2026 — conteúdo gerado por IA deve conter metadados de transparência (penalidades de até EUR 35M / 7% do faturamento global). Arquivos carimbados com AKF já os contêm:

akf audit report.docx --regulation eu_ai_act

Mapeamentos para EU AI Act e NIST AI RMF.

Contribuindo

Consulte CONTRIBUTING.md para configuração de desenvolvimento, testes e processo de PR.

Gratuito e Aberto — Para Sempre

AKF é gratuito e de código aberto sob a licença MIT. A especificação do formato será sempre gratuita. Nenhum recurso será jamais bloqueado atrás de um plano pago. AKF é um padrão, e padrões devem ser gratuitos para serem universais.

Licença

MIT — use em qualquer lugar, incorpore em tudo.