Architecture
Protocolware architecture is a minimal system that makes AI work predictable. It is built from Canon, Reality, Path, Gate, and Proof, and it only changes through Reduction.
The problem
- Most AI workflows are implicit, making failures hard to diagnose.
- If the system's state cannot be named, it cannot be governed.
- Lack of Proof makes audits depend on memory and chat logs.
- Systems drift when rules are not explicit and enforced.
- Teams cannot point to a single source of truth when decisions are challenged.
- Changes are debated in meetings instead of verified in artifacts.
The shift
- Not agent execution, but controlled reduction of artifacts into a new, explicit Reality.
How it works
Think of the core diagram as a pipeline:
Canon + Reality + Path → Reduction → new Reality + Proof.
Canon sets boundaries.
Reality is the current state.
Path defines the permitted transitions.
A Gate sits in the Path and returns PASS or FAIL.
“Stop is valid” is a first-class outcome when the Gate rejects a step.
Artifacts are truth. Every output is persisted, and every decision is tied to a Gate. Proof records exactly what was admitted or rejected. This is what turns AI work into production-grade operations rather than ad hoc experimentation.
The architecture is model-agnostic and tool-agnostic. It does not depend on any specific vendor’s workflow; it depends on explicit artifacts and Gates that can be reviewed, tested, and improved over time.
The practical effect is that a CTO can ask four questions and get deterministic answers:
- What was allowed? (Canon)
- What exists now? (Reality)
- What transition was permitted? (Path)
- What did the Gate decide? (Proof)
This architecture is intentionally small. Fewer primitives mean fewer places to hide risk, and clearer boundaries for every decision.
The mechanism is intentionally strict. It trades spontaneity for clarity so the system can be reviewed, improved, and trusted over time. Every change remains accountable to explicit artifacts and Gates rather than memory or preference, which keeps governance stable as teams and vendors change.
Artifact Families
Protocolware is built around a small set of artifact families.
Each family has a single responsibility and a clear boundary.
Together, they define what is allowed, what exists, and what can change.
Canon (LAW artifacts)
Canon artifacts define what is allowed in the system.
They are the highest authority:
- read-only
- not produced by agents
- referenced by every Gate
If a behavior is not permitted by Canon, it cannot exist in the system.
Typical Canon artifacts include:
- doctrine and invariants
- non-negotiable rules
- safety and governance constraints
Canon does not describe what should happen.
It defines what may never be violated.
Reality (STATE artifacts)
Reality artifacts define what exists now.
They represent the current state of the system:
- exactly one active version
- replaced, not mutated
- no hidden or implicit state
If something is not written into Reality, the system treats it as non-existent.
Reality answers a single question:
“What is true right now?”
PATH (Transition artifacts)
PATH artifacts define permitted transitions.
They do not express intention, goals, or plans.
They describe the space of allowed movement from one Reality to the next.
- declarative
- side-effect free
- evaluated by Gates, not executed directly
A PATH does not say what should happen.
It says what is allowed to happen.
Gate (Admissibility artifacts)
Gate artifacts decide whether a transition may occur.
A Gate:
- evaluates Canon, Reality, and PATH
- returns PASS or FAIL
- runs before any Reduction
A FAIL is not an error.
It is a correct and expected outcome.
“Stop is valid” is a first-class result of the system.
Proof (Evidence artifacts)
Proof artifacts record what actually happened.
They are the only admissible evidence that a step:
- was evaluated
- passed or failed a Gate
- resulted in a new Reality
Proof artifacts are:
- append-only
- immutable
- referentially linked to inputs
If there is no Proof, the system assumes the step did not happen.
Why families matter
Each artifact family answers exactly one question:
- Canon → What is allowed?
- Reality → What exists now?
- Path → What transitions are permitted?
- Gate → Was the transition admitted?
- Proof → What is the recorded outcome?
By separating these concerns, Protocolware prevents:
- hidden authority
- implicit state
- unverifiable decisions
- silent drift
The result is a system that prefers clarity over cleverness —
and governance over improvisation.
Why it matters
- Ensures every change has a visible cause and a recorded decision.
- Separates authority (Canon) from current state (Reality).
- Makes failures safe, because “stop is valid” prevents silent drift and uncontrolled behavior.
- Enables audits without relying on memory or informal explanations.
- Supports CTO-level governance without slowing delivery.
- Creates a stable architecture that can scale across teams and vendors.
- Improves incident response by preserving a precise decision trail.