AKF+ASM: Agentic Knowledge Format and State Machine for Sovereign Multi-Agent Knowledge Engineering

Modern AI agent ecosystems rely on vector databases and proprietary retrieval-augmented generation (RAG) pipelines [Lewis, 2020] that embed knowledge into opaque, unversioned, and permission-less vector spaces [Systems, 2023]. These systems are fundamentally incompatible with three requirements of sovereign multi-agent collaboration: (1) cryptographic immutability of knowledge artifacts, (2) governed authority over who may read, write, or ratify knowledge, and (3) agentic self-curation — where models autonomously propose, consolidate, and archive knowledge within a bounded policy envelope.

Google’s Open Knowledge Format (OKF), proposed in May 2026, addresses the interoperability problem but not the authority problem: it defines a container format without specifying who governs knowledge or how it evolves over time [DeepMind, 2026].

We introduce the Agentic Knowledge Format (AKF) and the Agentic State Machine (ASM) — a two-layer sovereign knowledge standard. AKF bundles are ZSTD-compressed [Collet, 2015], FUSE-mountable, and organized in the Panoptikum folder structure (one feature = one folder = one _index.md). The ASM enforces a threefold authority model — autonomous (agent-managed), sovereign (human-write-only), and consensus (agent-proposes, human-ratifies) — with a fully enumerated 24-entry decision table. Every state transition is cryptographically signed with Ed25519 [Bernstein, 2011] and verifiable via BLAKE3 content hashing [O'Connor, 2020].

Keywords: agentic knowledge engineering, sovereign knowledge format, multi-agent governance, content-addressed knowledge, YAML frontmatter, KDL, Panoptikum, FlowIR, consensus ratification, cryptographic immutability

1. Design Principles

AKF+ASM is built on five design principles derived from the Libertaria Federation’s Janus Engineering Model [Team, 2026]:

1. Plain-text sovereignty. Knowledge is Markdown. Every artifact is human-readable with cat and grep. No proprietary binary formats. No opaque embedding vectors.
2. Content-addressed immutability. Every file carries a BLAKE3 hash in its YAML frontmatter. The hash covers the body content. Tampering is detectable without a central registry.
3. Threefold authority. Every operation is gated by the artifact’s authority tier and lifecycle status. The decision table is fully enumerated and machine-verifiable.
4. Agentic curation. Models may autonomously propose knowledge (consensus tier), consolidate logs into summaries (consolidation cycle), and archive stale artifacts. Human ratification is required only for consensus-bound files.
5. Strict validation. No forgiving broken links, no silent fallbacks. Malformed YAML frontmatter, missing _index.md files, and broken cross-references are hard errors.

Comparison with Existing Standards

AKF+ASM is not a replacement for vector search or RAG. It is a complement that operates at the governance layer. A RAG pipeline may index AKF bundles as one of its sources; the AKF layer ensures the source is governed.

2. The Panoptikum Directory Topology

An AKF bundle is a directory tree with mandatory structure:

akf-<bundle-name>/
  _bundle.kdl          # Bundle metadata (name, version, domains, timestamps)
  _index.md             # Bundle-level index (generated)
  _changelog.md         # Append-only operation log
  <domain-1>/
    _index.md           # Domain index (generated, one per domain)
    <file-1>.md         # Knowledge artifact
  <domain-2>/
    _index.md
    ...

Panoptikum Principle: One feature = one folder = one _index.md. Every domain is a self-contained knowledge unit. The _index.md is a machine-generated catalogue of every file in the domain, listing its type, authority, status, hash, signature, and cross-references.

3. YAML Frontmatter Schema

AKF uses a two-tier metadata convention: YAML frontmatter for inline per-file annotation (tolerated as Markdown headers, not standalone .yaml files), and KDL (_bundle.kdl) for human-readable bundle-level configuration. Machine consumers read the equivalent JSON projection. No .yaml, .yml, or .toml files exist in an AKF bundle.

Every AKF file carries a YAML frontmatter block delimited by ---:

---
id: 20260715-1430-A7F3
timestamp: 2026-07-15T14:30:00Z
type: concept | log | summary | specification | report
authority: autonomous | sovereign | consensus
status: active | archived | compressed | pending_consensus | immutable
hash: <BLAKE3 hex> | null
signature: <ed25519 hex> | null
proposed_by: <agent-id> | null
tags: [tag1, tag2, ...]
---

The hash is computed as $h = \text{BLAKE3}(\textit{body\_content})$, covering everything after the closing ---. The hash does NOT cover the frontmatter itself — this allows metadata updates (e.g., status transitions) without invalidating the content hash.

For immutable files, the signature covers both the body hash and the frontmatter id field:

$\sigma = \text{Ed25519}(sk, \text{BLAKE3}(\textit{body\_content} \parallel \textit{frontmatter\_id}))$

4. The Threefold Authority Model (ASM)

Every AKF file is assigned exactly one authority tier at creation time:

• Autonomous — The agent may freely create, modify, archive, and compress files. No human ratification required.
• Sovereign — Only humans may write, modify, sign, or change status. Agents may only read.
• Consensus — Agents may propose new files (status pending_consensus), which requires explicit human ratification before promotion to active or archived.

Full Decision Table

The table enumerates all valid (authority × status × operation) combinations. A = autonomous, S = sovereign, C = consensus. Status: act = active, arc = archived, cmp = compressed, pen = pending_consensus, imm = immutable.

5. The Consensus Protocol

1. Agent proposes. Create file with authority: consensus, status: pending_consensus. Register in JARVIS approvals table.
2. Human reviews. Operator runs mnemos akf ls --status pending_consensus to see pending proposals.
3. Human ratifies or rejects. Operator runs mnemos akf approve APPROVAL_ID or mnemos akf reject APPROVAL_ID.
4. Audit trail. Every proposal, approval, and rejection emits an event in the JARVIS audit log.

FlowIR Integration

The consensus protocol integrates with the JARVIS FlowIR workflow engine through the AWAIT_APPROVAL opcode [Team, 2026]:

# Agent proposes knowledge synthesis
- opcode: INFER
  params:
    schema: akf_synthesis_proposal
    capture: synthesis_proposal

# Write proposal to file
- opcode: RUN
  params:
    argv: ["mnemos", "akf", "propose", "--file", "$FILE", "--reason", "$RATIONALE"]
    capture: proposal_result

# Pause until human ratifies
- opcode: AWAIT_APPROVAL
  params:
    approval_ref: proposal_result
    timeout_hours: 72

The AWAIT_APPROVAL opcode is a blocking gate. No downstream FlowIR step executes until the human operator explicitly approves or rejects the proposal. This guarantees that consensus-bound knowledge never auto-ratifies.

6. The Consolidation Cycle (Agentic Forgetting)

Agents operating continuously produce large volumes of log-type files. Without active compression, the bundle grows unboundedly. The consolidation cycle implements agentic forgetting: logs are periodically compressed into summaries, originals are marked compressed, and the domain _index.md is regenerated.

The consolidation is additive: summary files are created, never deleted. Original log files remain in the bundle, preserving the full audit trail.

7. Implementation

The AKF+ASM standard is implemented as a kernel module in the Mnemos Harness — the Zig-based sovereign harness of the Libertaria Federation’s JARVIS project [Project, 2026]. Eight modules, 11 CLI subcommands:

CLI Surface

8. Evaluation

A complete lifecycle smoke test verifies the following sequence:

1. mnemos akf init --name test-bundle --domains architecture,policy,memory → creates bundle with _bundle.kdl, _index.md, _changelog.md, and one _index.md per domain.
2. mnemos akf doctor --name test-bundle → reports 4 files, all autonomous, all active, bundle healthy.
3. mnemos akf validate --name test-bundle → “bundle valid.”
4. mnemos akf index --name test-bundle → rebuilds all domain _index.md files.

All 19 unit tests pass on Zig 0.17-dev: 6 header tests, 8 authority tests, 3 signature tests, 1 consolidation test, 1 consensus test.

OKF Structural Comparison

9. Conclusion

We have presented AKF+ASM — the Agentic Knowledge Format and State Machine — a sovereign knowledge standard for multi-agent collaboration. The standard defines a Panoptikum directory topology, YAML frontmatter governance metadata, a threefold authority model with a fully enumerated 24-entry decision table, a consensus protocol with human-gated FlowIR integration, and a consolidation cycle for agentic forgetting.

The reference implementation in the Mnemos Harness (Zig) provides 11 CLI subcommands, 19 unit tests, and passes functional smoke testing against the Libertaria Federation’s Janus Engineering Model. An integration contract defines PRISM and SOBER consumption paths [Team, 2026].

AKF+ASM is proposed as an RFC standard for the Libertaria Federation, sponsored by the Self Sovereign Society Foundation. The AKF+ASM specification is published under the Libertaria Sovereign License (LSL-1.0). The reference implementation in the Mnemos Harness is available under the same terms.