Knowledge Architecture Beyond the Single Consumer

Each unit must be intelligible to a reasoner encountering it without prior context or compensating heuristics. DITA assumes a human reader who can infer relationships from document structure. Simon's (1962) architecture of complexity provides the theoretical foundation: complex systems that are decomposable into nearly independent subsystems are easier to understand, design, and evolve than systems with dense interdependencies. The extension requires that knowledge artifacts mirror this property: each unit should be a nearly independent subsystem of the knowledge architecture, with explicit interfaces to other units rather than implicit dependencies. When the consumer may be an agent with no structural memory, or a regulatory automation system processing units in isolation, each unit must carry its own scope boundary and relationship pointers. This failure appeared across domains: platform documentation was modular but modules assumed knowledge from other modules, making isolated consumption unreliable; API reference pages assumed familiarity with authentication flows documented elsewhere; disclosure sections assumed context from other sections of the same filing.

Can a reasoner with no prior exposure to this system extract a single unit and form a correct belief about its scope and implications?

Self-description must include authority, currency, and verification pointers alongside structural metadata. Schema.org describes what an entity is. The extension requires describing when that description was valid, who asserts it, and how the assertion can be checked. This requirement emerged from disclosure standard design, where the critical decision was binding disclosure to a specific system release rather than to a project name. A Schema.org annotation that describes a platform without specifying which version is temporally unbound and potentially misleading to any consumer. The same pattern appeared in API documentation (version-agnostic endpoint descriptions) and agent capability schemas (tool descriptions without currency signals).

Can a reasoner determine what this artifact is, when it was valid, who asserts it, and how to verify the assertion?

Every claim must be paired with the method by which any consumer can independently verify it. Existing verification systems are domain-specific: cryptographic proofs for system state, audit logs for financial systems, citations for academic claims. The extension requires verification surfaces that are consumable by heterogeneous reasoners. Popper's (1963) falsificationist epistemology provides the theoretical foundation: claims that cannot be subjected to potential refutation carry no epistemic weight, regardless of how precisely they are stated. Meyer's (1992) design by contract operationalizes this for software systems: every interface specifies preconditions, postconditions, and invariants that can be checked mechanically. Lamport's (2002) TLA+ extends the principle to temporal properties, demonstrating that system behaviors over time can be formally specified and verified. Systems routinely publish claims (scalable, reliable, secure, decentralized) without publishing the evidence that would allow any external reasoner to check. Disclosure standards address this through machine-readable manifests alongside human-readable guides. The principle generalizes: every knowledge artifact that makes a claim should expose the evidence that supports it in a form any consumer can process.

Can a reasoner verify this claim through a method that works for their specific capabilities (human inspection, automated checking, agent verification)?

Knowledge artifacts must be bound to a specific system state, with explicit signals for currency and staleness that are machine-parseable. Standard versioning practices (changelogs, 'last updated' timestamps) serve human consumers who understand version semantics. Agents, regulatory automation, and verification systems need structured temporal metadata: effective date, expiry signal, version identifier, and a pointer to the current version. This requirement emerged from disclosure standard design, where release-bound conformance was the foundational decision, and from infrastructure analysis, where documentation consistently described a previous system state with no signal of the divergence. API documentation exhibits the same pattern: endpoint behavior changes across versions while the documentation reflects a previous state.

Does this artifact specify the exact system state it describes, in a format that any consumer can parse, with an explicit currency signal?

Modality independence must extend to the verification surface. It is well established that content should be separable from presentation (write once, render for web, PDF, mobile). The extension is that evidence and verification methods must also be renderable across modalities. A human analyst verifies a system's reliability claim by inspecting distribution charts. An agent verifies the same claim by parsing a structured data feed. A regulatory system verifies it by checking against a compliance threshold. The underlying evidence is the same; the verification rendering differs. This was absent from nearly every documentation system we examined: evidence was coupled to its original presentation modality.

Can this knowledge and its verification surface be faithfully rendered for a consumer the original author did not anticipate?

Each resolution level must be complete and correct at its own depth, verifiable independently of deeper levels. Sweller's (1988) cognitive load theory explains why progressive disclosure works when done correctly: it manages intrinsic load by presenting complexity in stages, allowing the reasoner to construct mental models incrementally rather than processing the entire information space at once. The extension requires that summaries are true, meaning a reasoner forming beliefs from the summary level forms correct beliefs, even if less detailed. We observed the opposite across multiple domains: executive summaries described aspirations while detailed technical documentation described constraints; API overview pages described ideal usage while reference pages documented limitations; platform marketing described capabilities while changelogs documented regressions. Pinch and Bijker's (1984) interpretive flexibility identifies the structural cause: different organizational functions (marketing, engineering, legal) produce different resolution levels with different interpretive commitments, and without a mechanism to enforce consistency across levels, each level reflects the interpretive framework of its authors rather than a coherent picture of the system. An agent, a regulatory triage system, or a human scanning at summary level would form incorrect beliefs. The degradation was systematic.

Can a reasoner form a correct belief at the summary level, one that is less detailed but still true?

Composed knowledge must preserve provenance, authority, and temporal binding from each source. Standard API composition preserves data integrity. The extension requires preserving knowledge integrity: when an agent composes capabilities from multiple platforms, or an analyst synthesizes disclosures from multiple systems, or a governance body aggregates compliance evidence, the composite must carry the provenance, authority, and currency metadata of each component. Composition failures were observed across domains: comparative assessments lost temporal binding and evidence quality when aggregated; agent workflows that combined outputs from multiple tools lost provenance tracking; regulatory reviews that synthesized multiple filings lost the currency signals of individual submissions.

Can artifacts from independent sources be combined while preserving each source's provenance, authority, and currency?

Knowledge systems must degrade gracefully when producers have incentives to obscure, and must surface the absence of expected evidence as a signal rather than a gap. Existing adversarial systems protect data integrity. The extension protects knowledge integrity: the system should make it visible when expected disclosures are missing, when verification surfaces are absent, and when claims lack evidence. Williamson's (1985) analysis of opportunism under bounded rationality provides the economic foundation: when information asymmetry exists and enforcement is costly, rational actors have incentives to misrepresent or withhold. Zuboff's (2019) surveillance capitalism analysis documents a systemic version: platforms that extract behavioral data while rendering their own extraction mechanisms opaque. Noble's (2018) work on algorithmic discrimination demonstrates that opacity in classification systems perpetuates structural harm. In adversarial environments, narrative substitution (replacing structural description with marketing), context privatization (restricting material facts to private channels), and verification absence (publishing claims without evidence) are common strategies used to resist external analysis. Disclosure standards address this by making disclosure categories explicit: a missing category is a visible signal, visible to any consumer.

Does this system surface missing evidence as an explicit signal rather than a silent gap?

Machine-readable schemas declaring operations, constraints, authentication requirements, rate limits, cost, and output guarantees. Implements semantic self-description and structural decomposability for agent consumption. Motivated by the observation that agents encountering tool descriptions designed for human developers consistently misinterpret constraint boundaries, because the descriptions rely on contextual understanding the agent lacks.

How an agent determines whether a capability meets its workflow requirements under current constraints. Implements progressive disclosure and composability at the capability selection layer. Directly addresses Observation 3 (discovery without constraint metadata): current discovery protocols surface capability existence without the comparison metadata needed for informed selection.

The runtime agreement between agent and platform. Implements temporal binding and verification surface for execution-time knowledge. Motivated by the observation that missing error taxonomies are the most common cause of agent workflow failures: the distinction between 'retry safely' and 'abort immediately' is invisible, producing either cascading retries or premature abandonment.

How an agent confirms that an operation succeeded. Implements verification surface and adversarial resilience at the execution result layer. Motivated by the same pattern observed across domains: claims without verification surfaces propagate through downstream reasoning unchecked. In agent workflows, unverified results compound through multi-step chains.

The percentage of a system's knowledge artifacts that carry full self-describing metadata: scope, authority, currency, relationships, and verification surface. Partial coverage creates asymmetric reasoning: some knowledge is reliable, some is degraded, with no signal to distinguish them.

The ratio of context spent on knowledge the reasoner actually uses versus total context spent on knowledge acquisition. Higher ratios suggest more efficient disclosure structures, though the optimal ratio varies by task complexity, reasoner architecture, and domain specificity. This metric can be measured automatically for agent workflows (token counts are observable) and approximated for human workflows (reading time vs. task-relevant reading time).

The percentage of actions (by any consumer) that produce the outcome the system intended, as determined by the knowledge artifact. Low fidelity indicates the knowledge layer is misleading: the consumer forms beliefs about what will happen, and the results diverge. This is the most direct measure of whether the knowledge architecture produces reliable beliefs, and the most straightforward to validate empirically.

The percentage of claims in the knowledge system that can be independently verified. Claims without evidence are assertions that consumers must accept on trust. In adversarial environments, unverifiable claims are the primary vector for exploiting any reasoner's decision-making.

The percentage of knowledge artifacts that accurately describe the current version of the system. Temporal incoherence means the knowledge describes a system state that may no longer exist. Documentation describing previous system architectures with no signal of the divergence was the single most common failure mode observed across our analysis work.

A system that publishes its interfaces, dependencies, governance structure, and operational parameters in structured form has already produced a declaration layer. Disclosure surfaces map directly to capability declarations when the consumer is an agent evaluating integration, and to compliance evidence when the consumer is a regulatory body. This was the original observation that motivated the design principles: the same structured facts, organized by the same principles, serve both audiences from a single source.

Disclosure standards bind disclosure to a specific release. DNCE binds execution terms to a specific version. API versioning strategies bind documentation to a specific endpoint configuration. The temporal binding principle requires this of all knowledge artifacts. The convergence is direct: independent design processes in different domains arrived at the same requirement from different consumer classes. This independent convergence strengthens the case that temporal binding is a property of reliable knowledge, regardless of consumer.

Disclosure standards require machine-readable manifests alongside human-readable guides. DNCE requires machine-readable verification of execution results. OpenAPI requires machine-readable endpoint specifications alongside human-readable documentation. All refuse to accept prose as proof. The convergence suggests that regulatory disclosure, agent-facing knowledge architecture, and API documentation are expressions of the same requirement: structured, verifiable evidence about what a system is and what it does, consumable by any reasoner that needs to form beliefs about it.

When any reasoner's ability to operate a system depends on the knowledge layer's accuracy, the knowledge layer inherits the reliability, versioning, and correctness requirements of the execution layer. A capability schema that returns incorrect metadata is functionally equivalent to an API that returns incorrect data.

The core competency shifts from clarity of exposition to correctness of specification. The quality metric shifts from readability scores to schema fidelity: the rate at which consumers form correct beliefs about system behavior from knowledge artifacts.

Building separate knowledge systems for developers, agents, regulators, and internal tools is economically unsustainable and produces inconsistency. The design principles require a single structured source from which consumer-specific renderings are derived.

Disclosure standards target human analysts and regulators. DNCE targets agents. OpenAPI targets developers. As all converge on the same structural requirements, the standard that serves all audiences from the same principles is positioned to define the next generation of knowledge infrastructure.