◎ OS PUB Apache 2.0 ← All specifications

P174 — AIEP — Reasoning-Ready Evidence Package Protocol

Publication Date: 2026-03-27 Status: Open Source Prior Art Disclosure Licence: Apache License 2.0 Author/Organisation: Phatfella Ltd Schema: AIEP_OS_SPEC_TEMPLATE v1.0.1 — https://aiep.dev/schemas/aiep-os-spec-template/v1.0.1

Framework Context

[0001] This disclosure operates within an Architected Instruction and Evidence Protocol (AIEP) environment as defined in United Kingdom patent application number GB2519711.2, filed 20 November 2025, the entire contents of which are incorporated herein by reference.

[0002] The present disclosure defines a protocol for assembling, serialising, and delivering batches of evidence artefacts as EvidencePackages — self-contained, signed bundles optimised for consumption by AIEP reasoning chains — comprising the canonical EvidenceNode representations, their ClassificationVectors, CitationRecords, ProvenanceChain digests, and ValidityCertificates, in a format that minimises latency between evidence retrieval and reasoning readiness without requiring a reasoning chain to perform individual artefact lookups.

Field of the Disclosure

[0003] This disclosure relates to evidence packaging and delivery protocols optimised for consumption by governed artificial intelligence reasoning chains.

[0004] More particularly, the disclosure concerns an EvidencePackage schema, a PackageAssembler component, package serialisation formats (compact binary and JSON-LD), a package signature and integrity verification mechanism, a streaming package delivery mechanism for large packages, and an EvidencePackageManifest enabling a reasoning chain to verify the completeness and integrity of an assembled package before use.

Background

[0005] AIEP reasoning chains require evidence artefacts to be in a specific, fully processed state before reasoning can begin: content must be normalised (P10), classified (P160), cited (P157), and have a verified ProvenanceChain (P150). A reasoning chain that must retrieve each of these fields separately for each artefact — querying the evidence index (P133) for content, querying the citation index (P157) for metadata, querying the provenance ledger (P150) for chain digests — experiences significant retrieval latency before it can begin productive reasoning.

[0006] Pre-assembled EvidencePackages reduce this latency by batching all required artefact fields into a single delivery unit, pre-verified and signed by the assembling node. The reasoning chain receives a ready-to-use bundle rather than assembling the required data itself from multiple sources.

[0007] Self-contained packages also support air-gapped or constrained-connectivity reasoning deployments: a package can be assembled on a well-connected node and transferred to a reasoning node operating without index access for local reasoning over the package contents.

Summary of the Disclosure

[0008] EvidencePackage Schema: An EvidencePackage is a structured container comprising:

  • package_id — SHA-256 of canonical serialisation of all other fields
  • assembled_by — node fingerprint (P46) of the assembling node
  • assembled_at — ISO 8601 timestamp
  • package_purpose — free text description of the reasoning query or task this package serves (informational; not used for verification)
  • items — ordered list of EvidencePackageItem (see [0009])
  • manifest — an EvidencePackageManifest (see [0010])
  • package_signature — cryptographic signature by the assembling node

[0009] EvidencePackageItem Schema: Each item in the package corresponds to one evidence artefact:

  • deid — Distributed Evidence Identity (P162)
  • content_canonical — working-language text content (P159)
  • classification — ClassificationVector (P160)
  • citation — CitationRecord (P157)
  • volatility — VolatilityRecord (P163) summary (class only, not full record)
  • trust_score — trust score assigned by the assembling node at assembly time (P124)
  • freshness_score — freshness score at assembly time (P147)
  • provenance_digest — SHA-256 of the full ProvenanceChain (P150) at assembly time (not the full chain — see [0013] for chain inclusion options)
  • conflict_status — CLEAR (no open conflicts), CONFLICT_PENDING:{conflict_id} (open conflict record), CONFLICT_SUPERSEDED (this artefact is marked as superseded)
  • access_basis — the token_id (P166) under which the assembling node has READ access to this artefact

[0010] EvidencePackageManifest: The Manifest enables a receiving reasoning chain to verify package integrity:

  • item_count — total number of EvidencePackageItems
  • item_deid_list — ordered list of DEIDs in the package (for completeness checking)
  • assembly_corpus_scope — the TaxonomyQuery or DEID list from which items were selected
  • minimum_freshness_score — the lowest freshness score of any item in the package
  • minimum_trust_score — the lowest trust score of any item in the package
  • conflict_clear_count — count of items with conflict_status = CLEAR
  • package_hash — SHA-256 of canonical serialisation of all items

[0011] PackageAssembler: The PackageAssembler accepts an AssemblyRequest specifying: corpus_scope (TaxonomyQuery or DEID list); minimum_freshness_score; minimum_trust_score; include_provenance_chains (boolean; whether to include full ProvenanceChains for each item); exclude_conflict_statuses (list of conflict statuses to exclude, e.g. ["CONFLICT_SUPERSEDED"]); and max_items. It resolves each artefact in scope, applies the filters, assembles the EvidencePackageItems and Manifest, and signs the package.

[0012] Serialisation Formats: Packages are serialised in one of two formats:

  • AIEP_COMPACT_BINARY — length-prefixed binary fields for minimum wire size; preferred for streaming delivery
  • AIEP_JSON_LD — JSON-LD with AIEP schema context URIs; preferred for interoperability with third-party reasoning systems

[0013] Full ProvenanceChain Inclusion: Where include_provenance_chains = true in the AssemblyRequest, each EvidencePackageItem includes a provenance_chain field containing the full serialised ProvenanceChain (P150). This increases package size but enables the receiving reasoning chain to verify artefact lineage without ledger access — required for air-gapped deployments.

[0014] Streaming Delivery: For packages exceeding a configurable size threshold (default: 10 MB), the PackageAssembler delivers the package as a stream of PackageChunk messages, each containing a subset of items. The receiving node reassembles chunks into a complete EvidencePackage and verifies the package_hash and package_signature against the assembled content before use.

ASCII Architecture

AssemblyRequest
(corpus_scope, filters, format)
        │
        ▼
┌───────────────────────────┐
│  PackageAssembler         │
│  - resolve artefacts      │
│  - apply score filters    │
│  - fetch required fields  │
│  - check conflict status  │
└──────────┬────────────────┘
           │ EvidencePackageItems
           ▼
┌───────────────────────────┐    ┌─────────────────────────┐
│  EvidencePackageManifest  │    │  Sign (P46)             │
│  (counts, hashes, scope)  │───▶│  package_signature      │
└───────────────────────────┘    └─────────────────────────┘
           │
    ┌──────┴───────────────────┐
    │                          │
    ▼                          ▼
AIEP_COMPACT_BINARY      AIEP_JSON_LD
(streaming delivery)     (interop delivery)
           │
           ▼
   Reasoning Chain
   (verify Manifest + signature before use)

Operational Detail

[0015] Package Freshness Bound: Where a package is assembled and then consumed by a reasoning chain some time later (e.g. in an asynchronous pipeline or air-gapped deployment), the freshness scores in the package items are those computed at assembly time. The reasoning chain should record the assembled_at timestamp and apply the freshness decay model (P147) relative to that timestamp to estimate the current freshness of each item.

[0016] Package Caching: Pre-assembled packages for common reasoning queries (e.g. standard domain evidence bundles) may be cached by the assembling node and offered to requesting reasoning chains without full re-assembly. Cached packages include an expires_at field computed from the minimum_freshness_score and the decay rate (P147) for the least fresh item; requests for cached packages after expires_at trigger re-assembly.

[0017] Package Validation: The receiving reasoning chain should validate an EvidencePackage by: (a) verifying package_signature; (b) confirming item_count matches the length of items; (c) confirming each deid in item_deid_list has a corresponding EvidencePackageItem; and (d) confirming each item’s content_canonical hashes to the value recorded in provenance_digest. Any validation failure produces a PackageIntegrityViolationRecord.

Claims-Exclusion Notice

This specification is published as open-source prior art. No patent claims are asserted by the author in respect of the mechanisms described. Any third party seeking to patent mechanisms substantially equivalent to those described herein is placed on notice of this prior art disclosure.

This specification is published as open-source prior art under the Apache License 2.0. Copyright 2026 Protocol Owner. Inventor: Protocol Architect.

Patent information · Licensing · All open specifications