Protocol specification

Working vocabulary and status.

This register describes the working vocabulary and explains the scope of each term.

Seven fields make a Knowledge Object addressable.

Level 0 Candidate tests the smallest useful Wrapper contract. It makes a representation identifiable, situated, source-bound, attributable and rights-aware without implying that legal, classification, custody or federation assessments are complete.

{
  "@context": "https://intw.example/schema/core",
  "id": "intw:ko:7F3A",
  "type": "Appeal",
  "about": ["urn:case:MAL-2023-1842"],
  "source": {
    "canonical": "https://example.se/diarium/...",
    "retrieved_at": "2026-08-28T09:42:00Z",
    "content_hash": "sha256:74c9…a21e"
  },
  "provenance": { "created_by": "urn:org:source" },
  "rights": { "status": "unresolved" },
  "status": { "lifecycle": "registered", "validation": "unreviewed" }
}

One Agora. Many situated views.

The Agora is one shared logical and relational knowledge space. It is not a central repository, universal graph or common view. Knowledge remains distributed across independently governed nodes, while each person, organisation, system or agent encounters a projection resolved for its identity, purpose, mandate, rights and context.

distributed objects + relations
             ↓
identity + purpose + mandate + time
             ↓
object + field + representation + relation policy
             ↓
permitted Agora projection
             ↓
Current Knowledge State for this participant

Thirteen extensible metadata domains.

The general model covers the context required by stewards, reusers, coordinators and technical developers. Domain profiles may add requirements but must not weaken the core.

A governed composition is also a Knowledge Object.

A Knowledger gives a related body of Knowledge Objects its own addressable purpose, membership, governance and version lifecycle. It does not copy, absorb or own its members. Each member keeps its independent identity, provenance, authority, rights and history.

CharacterizationAssertion {
  characterizes: KnowledgerRef
  character: resemblance | evidence | contradiction |
    risk | shared_learning | ExtensionTerm
  assertedBy: AgentRef
  context: ContextRef
  purpose: Purpose
  evidence: EvidenceRef[]
  confidence?: ConfidenceRecord
  validation: ValidationState
  visibility: PolicyRef
}

{
  "id": "intw:knowledger:municipality-a:case-8421",
  "type": "knowledger",
  "profiles": ["#CoreProfile", "#KnowledgerProfile@0.1"],
  "version": 4,
  "purpose": ["assessment", "audit"],
  "current_state_basis": {
    "as_of": "2026-08-31T12:00:00Z",
    "resolution_policy": "intw:policy:municipality-a:v3",
    "participating_sources": ["intw:node:municipality-a"],
    "unavailable_or_excluded_inputs": []
  },
  "members": [{
    "ref": "intw:ko:decision:8421",
    "role": "decision",
    "resolution": "pinned@2",
    "asserted_by": "@case-owner"
  }],
  "ledger_ref": "intw:ledger:case-8421"
}

State is multidimensional.

An object can simultaneously be published, validated, restricted and connected through a proposed relation. The protocol keeps these dimensions separate so one status cannot silently imply another.

The source remains inspectable.

Wrapper creates a preservation envelope around the source observation. It adds context without claiming ownership of source truth.

The Knowledge Object is not its payload.

A Knowledge Object carries durable identity, meaning, provenance, governance and relationships. A Representation describes one file, record, media item, API resource or derived embodiment. Payload bytes may remain in the authoritative source system or an independent repository.

Representation {
  id: RepresentationId
  represents: KnowledgeObjectRef
  location: EmbeddedPayload | SourceRef | RetrievalEndpoint
  mediaType: string
  contentHash: string
  availability: available | missing | stale | withdrawn |
    unreachable | expired
  transformation?: ProvenanceRecord
  custodian: AgentRef
  rights: RightsPolicy
}

Connections are typed evidence.

Every relation may carry target, confidence, evidence, verified_by, valid_from and its own lifecycle state. Identity mappings remain reversible and contestable through SAME_AS, POSSIBLY_SAME_AS, DIFFERENT_FROM, LOCAL_EQUIVALENT_OF, SPECIALISATION_OF, MERGED_INTO and SPLIT_FROM.

GET /v1/knowledge-objects/{id}
GET /v1/knowledge-objects/{id}/versions
GET /v1/knowledge-objects/{id}/relations
GET /v1/knowledgers/{id}/versions/{version}
POST /v1/knowledgers/{id}/resolve
GET /v1/schemas/knowledge-object/{version}

Events: created · observed · classified · validated · used · disputed · corrected · reused · merged · split · superseded · archived
Errors: 400 schema · 403 policy · 409 version · 422 semantics

A challenged relation remains visible without remaining unqualified.

Assertions and Intertweens have their own reviewable lifecycle. Contestation never silently rewrites source objects, and withdrawal does not erase the provenance of earlier use.

ContestationEvent {
  assertion: KnowledgeObjectRef
  contestedBy: AgentRef
  grounds: Claim
  evidence: EvidenceRef[]
  scope: field | assertion | object | derivation
  createdAt: Timestamp
  reviewBy?: Timestamp
}

ImpactNotice {
  sourceVersion: KnowledgeObjectRef
  affectedObjects: KnowledgeObjectRef[]
  action: review_required | suspended | superseded
}

Relational Trace

The local register describes current knowledge. Its current graph can change; Relational Trace records the attributable events through which it changed. Corrections, contestations and supersessions append new linked events. An event is a claim made in a context, not automatic evidence of truth.

RelationalTraceEvent {
  id · event_type · subject_refs · actor · mandate · purpose
  timestamp · sequence · previous_event · input_refs · output_refs
  policy_decision · validation_status · originating_node · trace_scope
  event_hash · signature
}

Sequence is local to a node and trace scope. Actor participation may be masked, anonymous or unknown; the node signs its record without requiring public identification of the contributor. Authority is evaluated separately. An existing event log does not automatically satisfy the proposed integrity requirements.

Evidence beyond one node

Originating nodes sign hash-linked events and checkpoints. Authorised witnesses retain commitments and issue explicitly scoped attestations. Comparing independently retained commitments can reveal altered or conflicting committed histories without creating a central repository or requiring agreement on every interpretation.

IntegrityCheckpoint {
  node · trace_scope · sequence_from · sequence_to · merkle_root
  previous_checkpoint · created_at · signing_key · signature
  witness_attestations
}
CrossNodeAttestation {
  witness · checkpoint_hash · claim · created_at · signature
}

Inclusion proves membership in a committed tree. Consistency establishes extension of an earlier commitment. Neither proves that every real action was recorded or that a search result is complete. Detection needs comparisons and available witnesses; witness independence, compromise thresholds, quorum and freshness must be specified by each federation profile.

Retaining a checkpoint, verifying its signature and verifying sequence consistency are different witness claims. A signing key must be trusted through a separate policy. Rotation, revocation, compromise timing, conflicting histories and recovery require explicit procedures.

Detection is not recovery

Checkpoints cannot reconstruct missing events. Authorised retained records or replicas are required to rebuild a view, after verifying them against retained commitments. Missing evidence means incomplete verification. Preserve conflicts and quarantine the affected view rather than silently choosing a history.

Proofs have privacy and retention rules

Stable references, predictable hashes, timestamps and relationships may reveal an actor. Masking a signed record changes its bytes; a disclosed projection needs its own evidence. Append-only does not require perpetual readability: retention and erasure policies must explain which records and verification capabilities remain.

POST /v1/federation/checkpoints
GET  /v1/federation/checkpoints/{node}/{sequence}
POST /v1/federation/attestations
POST /v1/federation/verify
GET  /v1/federation/consistency-proof
POST /v1/federation/integrity-notices

Proposed interfaces only; no endpoints are implemented here. Authentication, authorisation, replay handling, algorithm versions and error semantics remain to be specified.

Threat model, schemas and experiment boundaries ↗ · Run the local tampering experiment ↗

Level 0 remains unchanged. Separate experimental schemas are structural contracts, not proof of secure implementation. The local demo checks selected cryptographic properties using two simulated nodes in one runtime; it is not a deployed federation.

Technical reference: RFC 9162, Merkle proofs and split-view limitations; this is not a claim of Certificate Transparency conformance.

One object. Four explicit projections.

Availability is not the same as visibility. Private, local, federated and open describe scopes within one Agora, not four different spaces. A projection is calculated from classification, identity, role, purpose, policy and current context. The protocol intends to express these rules through a versioned ODRL application profile rather than a standalone policy language.

Federate projections, not assumptions.

A protocol node may discover and exchange knowledge with other nodes while retaining control over its sources, infrastructure, policies and legal responsibilities. Nodes do not automatically replicate complete Knowledge Objects or accept another node's interpretation as truth.

POST /v1/federation/projection-requests
GET  /v1/federation/capabilities
POST /v1/federation/exchange-receipts
POST /v1/federation/lifecycle-notices
POST /v1/federation/learning-returns

request:  @requester + !purpose + #profile + [scope]
decision: {allow | mask | deny} + [obligations]
result:   [permitted_projection] + [resolution_evidence]
receipt:  [signed] + [ledger_ref] + [expires_at]

Protocol work must additionally define permitted backfill, version downgrade behaviour, withdrawal and revocation propagation, and how cached projections retain their continuing obligations.

Actorship, access, action and learning are separate.

An entity may be an actant because it changes what happens in a context. That analytical role grants no system permission. An agent is the narrower operational role that receives an identity, purpose and bounded mandate.

AI-generated fields must be visibly labelled, separated from source facts, traceable to model and input, and governed by their own validation status.

A staged path from addressable object to federation.

Level 0 remains a candidate profile until validated against real objects and fixtures. A valid JSON document is not automatically a safe, lawful or meaningful Knowledge Object.

intw validate object.json --profile wrapper-level-0-candidate
schema             pass
source_bound       pass
rights_present     pass
status_present     pass
candidate_valid    true

Architecture must expose the questions it cannot answer alone.

This appendix is a review framework, not legal advice or a compliance claim. Each pilot must record its applicable law, responsible organisation, assessment owner and decision.

Published intent and tested capability are kept distinct.

The framework is broader than the current software demonstration. Conformance claims apply only to the profile and test suite explicitly named by an implementation.

First. Then. Thereafter.

Temporal governance and governed attribution

Proposed architecture. These requirements are not implemented or validated and do not change the core schema, Wrapper validator or existing conformance levels. They support collective learning, reuse and traceable responsibility under local sovereignty.

Wrapper → Mapper → Tracker remains the launchpad. Cultivator is a future component for learning proposals and voluntary, locally governed reciprocity.

A time trigger initiates review, not unconditional deletion. Restriction, archiving, verified anonymization and authorised deletion require authority, policy version and decision evidence. Expired mandates must stop new actions; historical accountability evidence needs justified retention. Logs, backups, indexes and embeddings also need lifecycle controls.

The registry should expose only explicitly permitted metadata. Relationships, timestamps and roles can jointly identify people. Pseudonymization is not anonymization. Federated policy changes need signed notices, replay protection, acknowledgements and explicit refused or unreachable exceptions. A receipt alone does not prove all copies were deleted.

Contribution history, public attribution and entitlements must be governed separately. Withholding identity transfers no rights to a commons pool. Future reciprocity requires voluntary agreements, reviewed rules and dispute procedures. Reuse frequency alone proves neither causation nor fair compensation.

The next proof point is a two-node demonstration testing identity separation, expired mandates, changed visibility, preserved claims and propagation failures. Legal review and independent assessment of re-identification risk remain outstanding.

A proposed neutral stewardship model.

Status fields make missing assessment visible; they do not perform the assessment. Classification, confidentiality review, lawful basis, GDPR compliance and protective-security assessment remain with the responsible organisation.

From intertweens to reusable skills

An intertween can seed a reusable method represented as a separate Knowledge Object. Its instructions, prerequisites, evidence, conditions and versions remain linked to its origins. The original intertween is preserved, and several skills may develop from it.

The learning-and-skills proposal connects intentions, interpretations, experiments, evaluations, adoption and outcomes. It covers learning around a model and learning through adaptation where records are available. Evaluation, authorisation and demonstrated capability are separate. The proposal does not change Level 0 or establish runtime enforcement.