Three components. One infrastructure.
Each component works independently or as part of an integrated stack.
ActProof Diagnostics
Measure
Structural metrics engine that wraps any AI pipeline or autonomous system. Measures Control Cost, detects hidden compensation between modules, and triggers alerts before structural collapse. Zero retraining. Below 5% overhead.
- ✓ Control Cost (CC) — steering effort ratio
- ✓ Latent Tension (T) — hidden stress gradient
- ✓ Module Compensation Index (MCI)
- ✓ Flashover detection — collapse prevention
ActProof OS
Operate
Event-sourced enterprise operating layer for workforce management, process monitoring, and operational risk analysis. Every operation is an immutable event with deterministic rebuild guarantee and cryptographic state verification.
- ✓ Event Sourcing + CQRS architecture
- ✓ HMAC-signed QR attendance tracking
- ✓ Bradford Factor risk scoring
- ✓ Deterministic state verification (Stage 1F)
AioP Protocol
Verify
Deterministic contract execution protocol for AI agent-to-agent commerce. Versioned immutable contracts, session pinning, JSON Schema validation, and HMAC-SHA256 signed execution proofs. Every transaction is independently verifiable.
- ✓ Contract → Session → Execute → Proof
- ✓ Canonical JSON + HMAC-SHA256 signatures
- ✓ Idempotent — replay returns identical proof
- ✓ Agent-native — no UI required
Where ActProof fits in your stack
ActProof deploys as a non-invasive layer between your systems and your observability stack.
Your System (LLM, API, ERP)
Events and telemetry flow from your existing infrastructure. No code changes required — ActProof reads event streams, API logs, or SSE feeds.
ActProof Layer
Structural metrics engine calculates CC, T, MCI, and Φ in real-time. Classifies system regime (STEERABLE → CRITICAL). Generates verifiable execution proofs via AioP.
Dashboard & Alerts
Real-time regime classification, flashover warnings, and MCI heatmaps. REST API and SSE streams for integration with your existing monitoring stack (Grafana, Datadog, custom).
Beyond prompting
Today's AI systems have no native, enforceable separation between evidence representation and narrative production. ActProof provides that missing layer — today as an external framework, tomorrow as built-in architecture.
Prompt Layer
System prompts with epistemic classification (A / B / C), confidence levels, and source attribution. Like a "drive carefully" sticker on a car.
- ✓ Epistemic level classification
- ✓ Source attribution policy
- ✓ Confidence calibration
Orchestration Layer
JSON Schema validation, guardrails, and external verifier modules. Evidence gating before response generation. An external ABS system.
- ✓ Evidence gating pipeline
- ✓ Schema-enforced guardrails
- ✓ Narrative entropy approximation
Native Architecture
Three separated modules: knowledge backend with provenance, evidence layer measuring narrative entropy, and a constrained generator. ABS built into the braking system.
- → Backend Engine (provenance graph)
- → Evidence Layer (entropy + gating)
- → Constrained Generator
ActProof is an externally enforced epistemic substitute architecture for systems that do not yet natively implement the separation: trace → justification → narrative.
Real-time flashover detection
Not just post-hoc evaluation. ActProof detects the moment when a system transitions from grounded inference to smooth speculation — while the output tone doesn't signal the shift. The question isn't "are there sources?" but "does the system have the right to state this, in this force, in this tone?"
The epistemic vocabulary
Without this vocabulary, you cannot build a system that truly separates what is grounded from what is merely generated.
Chain-of-Thought Checkpoint
A long reasoning chain monitored by lightweight structural metrics at every step. When tension crosses a threshold — automatic circuit breaker.
LangChain / LangGraph Pipeline
Multi-step reasoning chain: retrieval → analysis → synthesis → generation. Standard orchestration — no model internals needed.
ActProof Wrapper
After every N steps: lightweight CC/T measurement from external telemetry. No access to model weights. Pure orchestration-layer instrumentation.
Circuit Breaker
CC exceeds threshold → automatic task split or verification step. Prevents hallucination accumulation before output.
Live Protocol Demo — AioP Core
Deterministic contract execution for AI agents with verifiable proof. Click "Run the demo" to execute a real protocol flow against a live server.
This is a public demo contract — no personal data is used.
/contracts/{id}
Fetch Contract
Signed, immutable, versioned.
/sessions
Pin Session
Locks contract hash. No mid-transaction changes.
/execute
Execute Action
Schema + rules validated server-side.
/proofs/{id}
Verify Proof
Signed receipt — independently verifiable.
This hash uniquely identifies the contract version.
Session pins the contract hash to prevent mid-transaction changes.
Server validated schema + rules. Execution accepted.
Proof is a signed receipt — independently verifiable.
The multi-agent verification gap
When Agent A delegates to Agent B, who verifies B didn't hallucinate? Today's answer — "a second LLM checks the first" — is expensive and epistemically circular (who checks the checker?).
AioP provides an architecturally clean alternative: deterministic proof.json for every agent execution. Not another LLM opinion — a cryptographic receipt. As multi-agent frameworks grow (CrewAI, AutoGen, LangGraph), none of them has a native execution verification layer. This is the gap AioP fills.
When the game was already lost — though no one saw it
A structural analysis of a Go game that shows how hidden tension works in any system.
What happened?
In 2016, a computer program played against one of the world's best Go players. At one point it made a move that surprised everyone. Commentators called it brilliant. But was it really "genius"? Or was it the moment when the system crossed a tension threshold?
Why was it surprising?
The move seemed illogical. Professional players said no human would play it. Probability estimates gave it less than 1 in 10,000 chance. Yet after that move, the entire game shifted. The opponent — a world champion — never recovered. Evaluations flipped. The game entered a completely different state.
Visible stability stays flat while hidden tension grows — until the breakthrough point.
What was happening beneath the surface?
Imagine the game as a spring. Every move tightens it slightly. For a long time everything looks stable. The position seems balanced. Both players appear to have options. But the tension builds. Until at some point — the spring snaps to a new state.
In ActProof's language, we would call this a rise in control cost and latent tension. The system was spending more and more effort on internal regulation — while still appearing stable externally.
The moment of no return
After that move, the opponent had to play increasingly defensively. Every subsequent move required more effort to maintain balance. The position still looked "alive" — but its stability was already an illusion. The cost of holding it together exceeded what the system could sustain.
This is an example of what ActProof calls "flashover" — the moment when hidden tension exceeds the system's ability to stabilize. The collapse appears sudden, but structurally it was building for a long time.
What this says about systems
The same mechanism operates in AI systems, companies, and teams. For a long time everything looks fine. But the cost of maintaining stability grows. Until at some point the change becomes sudden and irreversible.
ActProof was built to detect this — before the moment arrives.
Two markets. One infrastructure.
ActProof addresses two rapidly growing needs: mandatory structural verification for autonomous AI systems, and predictive operational resilience for human-machine processes.
AI Safety
A mandatory verification layer for agents operating in the real world — finance, healthcare, legal, critical infrastructure. Not optional monitoring — structural proof that the system behaves as contracted.
Operational Resilience
Predicting not only IT failures, but operational risks in processes managed by humans and machines together. Detecting the moment when the system still looks correct on the frontend, but the cost of maintaining that appearance is already growing in the backend.
Example: AI System with CCC
A realistic deployment scenario showing how CCC prevents structural collapse in an LLM pipeline.
LLM with safety layer
Standard LLM pipeline deployed with content safety module. System appears stable in output metrics.
Alignment tax rises
Safety module increasingly overrides model output. edit_ratio climbs. CC_turn rises each conversation turn. Invisible to standard monitoring.
MCI detects compensation
CCC's MCI heatmap shows DG→SCE compensation pattern. One module is silently covering for another. T gradient rises.
CC_global accumulates
Accumulator Φ grows. THS (Temporal Horizon Scanner) detects escalation trend. System classified as RIGID.
Flashover prevented
Before Φ exceeds Φ_critical, Control Knobs adjust pipeline parameters. Regime shifts from RIGID to STEERABLE. Collapse avoided.
Integration & Deployment
Designed to fit existing infrastructure. No retraining, no vendor lock-in.
REST API and SDK available for integration. Full specification provided during technical onboarding.
Built for decision-makers
- Architecture diagrams with formal component boundaries
- API layer with telemetry input and dashboard output
- Defined deployment model (Docker, systemd, Caddy)
- Overhead below 5% — measured, not estimated
- 300+ integration tests with deterministic rebuild verification
- New category: structural diagnostics layer
- Cross-domain applicability: AI safety + enterprise + monitoring
- Proprietary metrics (CC, T, MCI) — difficult to replicate
- Formal mathematical model (UDM) as intellectual foundation
- Production-deployed, not conceptual
- SDK interface for custom integrations
- REST endpoints for diagnostics and telemetry
- Control Knobs API for runtime parameter adjustment
- Event-driven compatibility (SSE, webhooks)
- Middleware integration — zero model modification
Want to see
ActProof in action?
Get in touch — we'll schedule a demo and walk you through the architecture.