About TCP/AP
TCP/AP (Trusted Cognition Protocol / Agentic Protocol) is an open-source standard for deterministic interpretation and reproducible AI systems.
Agentic systems currently face a critical flaw: they lack true reproducibility. Even with deterministic settings (t = 0), identical inputs can yield different outputs. In some cases, that variability masquerades as creativity; for high-stakes workflows like payment processing or security triage, it is an operational risk. Unreproducible decisions cannot be audited or governed, which is why non-determinism is a critical challenge in scaling large language models (LLMs) in enterprise operations.
While technical factors like probabilistic inference contribute, our research shows the root cause is silent, unresolved ambiguity in how a model interprets its input. Non-determinism is not an inherent trait of language models but a byproduct of interpretive multiplicity. Deterministic interpretation is what makes a system reproducible and reliable, so solving non-determinism is a fundamental enabler for the next phase of enterprise AI adoption.
TCP/AP removes this barrier. By forcing the system to resolve interpretations before execution, it gives probabilistic systems deterministic, software-like behavior: the same input consistently produces the same, provable decision. Just as TCP/IP made networks reliable, TCP/AP turns unreliable agentic systems into production-grade infrastructure.
What TCP/AP solves
One discipline, two halves.
Substrate Engineering governs the input side. It constrains how a model interprets, so that the same input converges to byte-identical, SHA-256-verified output across different models, runs, and environments.
The Kernel governs the decision side. It verifies that output against a declared Agentic Protocol and signs the verdict.
The first makes outputs reproducible; the second makes decisions reproducible. Neither is sufficient alone: reproducible output that nothing checks is still ungoverned, and a checkpoint fed by drifting output is a checkpoint that fails inconsistently.
The boundary the Kernel keeps
The split is deliberate, and it is what makes the guarantee provable. The Kernel certifies that an artifact resolves to exactly one admissible decision under the declared protocol: structure and resolution. It does not certify that the artifact faithfully represents the user's intent, because it has no ground truth to check against; it sees only the artifact and the protocol. An artifact that is well-formed and resolves cleanly to a valid-but-wrong decision is still conformant. Fidelity is a separate concern, owned upstream.
| Concern | Who owns it | When |
|---|---|---|
| Fidelity: the artifact faithfully represents intent | Substrate Engineering + calibration | pre-deployment |
| Admissibility: the artifact resolves to one decision | the Kernel | runtime |
So the Kernel's guarantee is deliberately conditional: given a faithful artifact, the decision is admissible and unambiguous. That conditional is exactly what lets it be a keyless, deterministic, verifiable gate rather than an unfalsifiable "trust the model." It makes the one promise that can be kept with math, and hands fidelity to the layer that can measure it.
Research
Interpretation drift was formalised and tested before the protocol was written. Cross-model convergence is the research contribution that separates interpretive failure from computational failure. The TCP/AP protocol is built upon the empirical recognition that "interpretation drift" is an interpretive failure, not a computational one.
This protocol addresses the fundamental limitation where prompt engineering only biases selection without collapsing the interpretation space. By implementing this formalised constraint layer, we shift from managing instability through post-hoc validation to ensuring precision through pre-inference specification.
Key results
- Byte-Identical Convergence: Four frontier models achieve SHA-256 hash identity across 40 runs without iterative refinement or calibration.
- Substrate Engineering: By eliminating interpretive multiplicity at the source, we replace unstable retry-loops and voting cascades with single-pass determinism.
- Architectural Shift: Non-determinism is a property of task specification, not model behavior. Reliable AI is built by decoupling the interpretation layer from the computation layer.
Stewardship
TCP/AP is stewarded by TCPAP Global Infra AB (Stockholm), which holds the specification and the reference Kernel. OmnisensAI is the first implementer.
The specification is published so it can be implemented and verified independently. Conformance is a property of the artifact, not the vendor: any verdict is checkable by any party holding the conformance record.
Status
- Specification: v0.1 (Draft)
- Frozen: Agentic Protocol schema, Artifact envelope, conformance record format, verdict codes.
- Provisional: escalation hierarchy for 422, multi-party attestation.
- Change process: issues / RFC.
Frozen means an implementation written against it today will still conform after the next revision. Provisional means it may move; build on it with that in mind.
Conformance and Licence
The TCP/AP specification is open. Conformance is a property of the implementation's architecture, not of the vendor claiming it. The clauses below are each independently testable, and an implementation is conformant only when it satisfies all three groups.
Input · Substrate
- Interpretation is governed by a declared, portable specification external to the model, not by prompt-craft, routing logic, or application code.
- That specification collapses the admissible interpretation space to a singleton before inference (|I(D)| = 1). The condition is verified by convergence: independent models emit equivalent evaluable output, SHA-256-identical.
Decision · Kernel
- The Kernel is stateless and model-independent. The verdict is a pure function of the content-hashed (Artifact, Agentic Protocol) pair, not of which model produced the Artifact.
- It resolves to exactly one admissible decision, or an explicit typed failure drawn from the TCP/AP error taxonomy.
- Resolution is pre-execution: no state transition or side effect precedes the verdict.
- It emits a self-contained conformance record binding artifact, protocol, verdict, and execution context.
Separation
- Cognition and Action are architecturally separated. The Operator routes on the verdict alone and holds no interpretive logic of its own.
The Kernel specification and error taxonomy are open, so that any party can implement a validator and any party can verify a verdict. What TCPAP Global Infra AB offers commercially is schema derivation and managed hosting, not access to the standard.
Every paradigm shift became inevitable the moment humans learned to govern a new technology. The next will not be defined by intelligence alone, but by whether interpretation itself can be governed.
