Correctover-CCS v3.0.0

Agent Runtime Verification Protocol — 同步拦截，结构级 Fail-Closed 保证

---

What is CCS?

CCS (Correctover Conformance Standard) is the Agent Runtime Verification Protocol — a protocol-level validation framework that provides structural fail-closed guarantee for LLM agent systems.

Unlike observer-pattern hooks that fail-open when the governance layer crashes, CCS ensures that if verification fails, the action is NEVER executed. This eliminates CWE-636 (failure to use fail-safe defaults) at the protocol level.

Core Properties

• Structural Fail-Closed: Governance failure → action blocked (never executed)
• Synchronous Interception: Validation happens BEFORE the tool call, not after
• Sub-100μs Overhead: P50=14.5μs, P99=99μs (Python) / P50=75μs (TypeScript)
• 87 Self-Healing Rules: Automatic recovery from 19,251 known failure paths
• Multi-Framework: CrewAI, LangChain, AutoGen, Ibex, Patronus

The Problem CCS Solves

Single-fault self-healing achieves 97.4% success, but compound fault chains degrade to ~72%, exposing 19,251 failure paths (38.5% of test space) that remain uncovered by existing frameworks. CCS formalizes runtime conformance as Required(τ) ⊆ Supported(τ) — a simple, empirically-grounded criterion that works in production.

---

Quick Start

Python

pip install correctover-ccs

from ccs import govern

# Wrap any function with CCS governance
@govern(policy="default")
def search_web(query: str) -> str:
    return fetch_api(query)

search_web("test")  # ✅ Governed — validated before execution

TypeScript

npm install @correctover/ccs

import { govern } from "@correctover/ccs";

const governedSearch = govern(searchWeb, { policy: "default" });
governedSearch("test"); // ✅ Fail-closed guaranteed

4-Line Integration

from ccs import ConformantCrewAgent

agent = ConformantCrewAgent(my_crewai_agent)
result = agent.execute_task("Your task")
print(result.conformant)  # True / False

---

Architecture

┌─────────────────────────────────────────────────┐
│                   Agent Layer                    │
│   CrewAI / LangChain / AutoGen / Ibex / Patronus │
├─────────────────────────────────────────────────┤
│              CCS Runtime (v3.0.0)               │
│  ┌──────────┬──────────┬──────────┬──────────┐  │
│  │ Structure│  Schema  │  Latency │   Cost   │  │
│  │ Verifier │ Validator│  Monitor │  Monitor │  │
│  ├──────────┼──────────┼──────────┼──────────┤  │
│  │ Identity │ Integrity│  Policy  │ Failover │  │
│  │ Tracker  │  Checker │  Engine  │  Engine  │  │
│  ──────────┴──────────┴────────────────────┘  │
├─────────────────────────────────────────────────┤
│                 Tool / Action                    │
│  (Blocked if ANY dimension fails → Fail-Closed) │
└─────────────────────────────────────────────────┘

---

6-Dimension Verification

Dimension	Verifies	Failure Mode
Structure	Action has valid structure (agent_id, action_type, required fields)	Malformed action rejected
Schema	Output matches expected schema	Invalid output rejected
Latency	Response time within bounds	Timeout → Fail-Closed
Cost	Token usage within limits	Budget exceeded → blocked
Identity	Action is traceable (unique ID)	Untraceable → rejected
Integrity	Output is complete (non-empty, valid hash)	Corrupted → rejected

---

API Reference

Core

Interface	Description
govern(fn, options?)	Wrap function with CCS governance
getRuntime(config?)	Get global CCS runtime singleton
ConformantCrewAgent(agent)	CrewAI integration wrapper
ConformantLangChainAgent(agent)	LangChain integration wrapper
ConformantAutoGenAgent(agent)	AutoGen integration wrapper

Runtime

Method	Returns	Description
evaluate(toolName, toolInput, policy?)	{result, latencyUs}	Evaluate governance
registerPolicy(name, policy)	void	Register custom policy
getStats()	RuntimeStats	Performance statistics
getHealth()	HealthStatus	System health check

Custom Policy

from ccs import CCSPolicy, GovernanceResult

class BlockDeletePolicy(CCSPolicy):
    def evaluate(self, tool_name: str, tool_input: dict) -> GovernanceResult:
        if "delete" in tool_name or "rm" in tool_name:
            return GovernanceResult.DENY
        return GovernanceResult.ALLOW

---

Performance

Benchmarked on 50,000 production-derived decision traces, 13 LLM providers:

Metric	Python	TypeScript
P50 Latency	14.5μs	75μs
P95 Latency	45μs	120μs
P99 Latency	99μs	150μs
Throughput	68,965 ops/s	13,333 ops/s
Memory Overhead	<1MB	<2MB
L3 Failover (end-to-end)	949ms	N/A

Test environment: CANON P50, Python 3.12 / Node.js v22

---

Self-Healing

CCS includes 87 self-healing rules covering 19,251 known failure paths:

Category	Rules	Recovery Rate
Provider Failover	12	99.2%
Timeout Recovery	15	98.7%
Token Budget	10	97.1%
Schema Repair	18	94.3%
Context Drift	14	91.8%
Dependency Health	18	96.5%

---

Framework Adapters

Framework	Package	Status
CrewAI	correctover-crewai	✅ v3.0.0
LangChain	correctover-ccs	✅ v3.0.0
AutoGen	correctover-ccs	✅ v3.0.0
Ibex	correctover-ibex	✅ v3.0.0
Patronus	correctover-patronus	✅ v3.0.0
VS Code	correctover extension	✅ v3.0.0

---

Deployment

Local

pip install correctover-ccs

Docker

FROM python:3.12-slim
RUN pip install correctover-ccs
COPY . /app
CMD ["python", "app.py"]

Kubernetes

apiVersion: apps/v1
kind: Deployment
metadata:
  name: correctover-ccs
spec:
  template:
    spec:
      containers:
      - name: ccs
        image: correctover/ccs:3.0.0
        env:
        - name: CCS_POLICY
          value: "default"

---

Standards & Research

• Protocol: CCS v3.0 Specification
• Paper: DOI: 10.5281/zenodo.21271910
• Benchmark Dataset: 34,669 real conformance traces across 9+ providers

---

License

CC BY 4.0 — © 2026 Correctover. All rights reserved.

Contact

• Website: correctover.com
• Email: wangguigui@correctover.com
• GitHub: github.com/Correctover

---

Correctover — Failover ≠ Correctover™