T1/T2 Protocol

T1/T2 Protocol — Heterogeneous Validation for MCP

中文文档 · MCP Registry entry (io.github.Fauxetine/t1-t2-protocol)

Reference implementation. This is a stdlib-only MCP reference server for structured reasoning discipline — not a production security product. Evaluate your own threat model before deploying in sensitive environments. Unlike official Python MCP servers, it does not use the mcp SDK; it speaks JSON-RPC over stdio directly.

T1/T2 is an MCP server that makes AI reasoning verifiable, auditable, and trustworthy — by decomposing ambiguous questions into structured tiers (T1), then validating answers through cross-model evaluation (T2), with a deterministic checksum layer that doesn't depend on any LLM.

Why?

When an LLM checks its own answer, it uses the same training data, the same reasoning preferences, and the same systematic biases. Self-reflection cannot catch its own blind spots.

T1/T2 introduces heterogeneous validation: the model that produces the answer and the model that evaluates it should be different. Their different training distributions cover each other's blind spots.

Tools

How tools return data: t1_protocol and t2_protocol return structured prompt templates for your MCP host's LLM to execute. Only checksum returns deterministic JSON (checksum_passed, errors).

Tool inputs (MCP schema)

t1_protocol

t2_protocol

checksum

Returns JSON: {"checksum_passed": bool, "errors": [...]}.

Quick Start

Requirements

• Python 3.10+
• An MCP client: Cursor, Claude Desktop, Windsurf, or any MCP-compatible host

Install

From PyPI (recommended):

pip install "t1-t2-protocol>=0.1.0"

From source (development):

git clone https://github.com/Fauxetine/t1-t2-protocol.git

cd t1-t2-protocol pip install -e ".[dev]" T1T2_DISABLE_COUNTERS=1 python -m pytest tests/ -v

Or run directly without installing:

python src/t1_t2_mcp_server.py   # Windows

python3 src/t1_t2_mcp_server.py # macOS / Linux

Configure

After pip install, use the console script in MCP config (recommended):

{

"mcpServers": { "t1-t2-protocol": { "type": "stdio", "command": "t1-t2-protocol" } } }

Cursor — .cursor/mcp.json (same as above).

Claude Desktop — claude_desktop_config.json:

{

"mcpServers": { "t1-t2-protocol": { "command": "t1-t2-protocol" } } }

From source (no pip install) — point at the script:

{

"mcpServers": { "t1-t2-protocol": { "type": "stdio", "command": "python", "args": ["C:/path/to/t1-t2-protocol/src/t1_t2_mcp_server.py"] } } }

On macOS/Linux use "command": "python3" instead of "python".

Verify it works

1. Restart or reload your MCP host after editing config.
2. Confirm three tools appear: t1_protocol, t2_protocol, checksum.
3. Call t1_protocol with {"question": "Should we adopt microservices?", "locale": "en"} — you should receive a structured T1 prompt template.
4. Call checksum with sample [L1 Facts] … --- text — you should receive JSON with checksum_passed.

Usage

T1: Structure a vague question

Call t1_protocol with your question. The host LLM receives a structured prompt template with four tiers:

Input:  {"question": "Should we migrate our monolith to microservices?"}

Output: Prompt template instructing the host to produce: [L1 Facts] Team size, codebase size, current stack [L2 Assumptions] Expected benefits that need verification [L3 Hypotheses] Testable claims about migration risk [L4 Unknown] Future growth trajectory [Core Question] The precise feasibility question

T2: Cross-validate a decision

Call t2_protocol with a decision or answer text. Returns an evaluation prompt for the host LLM:

Input:  {"answer": "Decision text for approach A..."}

Output: Prompt template requesting: Confidence: high | medium-high | medium | medium-low | low Adoption table with: ✅ Adopt — verified conclusions (L1) ⚠️ Reserved — needs more evidence (L2) ❌ N/A — blind spots to address

checksum: Validate output structure

Call checksum with structured text. It returns pass/fail based on deterministic rules:

Input: "[L1 Facts]\n1. ...\n[L2 Assumptions]\n1. ...\n---"

Output: {"checksum_passed": true, "errors": []}

Full pipeline

Vague question → T1 structured decomposition → Decision based on structure → checksum (optional) → T2 validation → Refined decision

For time-sensitive factual claims, search on the caller side before T2 — see Caller-side web verification (v2.6).

Configuration

Locale

Both t1_protocol and t2_protocol accept an optional locale parameter:

Example: {"question": "...", "locale": "zh"}

Weight hints

Both t1_protocol and t2_protocol accept an optional weight_hint parameter to bias evaluation criteria:

Recursion protection

T2 automatically detects recursion depth and terminates at depth >= 3, where marginal information gain drops below 5%.

Design Philosophy

See docs/philosophy.md for the full design rationale.

Core tenets:

1. Separate intelligence from trust — AI capability and AI safety should be guaranteed by different systems
2. Heterogeneous over self-referential — Cross-model validation is more reliable than self-reflection
3. Deterministic over probabilistic — What can be checked by code should not be left to model judgment

Examples

See examples/ for step-by-step walkthroughs:

• T1: Structure a vague question
• T2: Cross-validate a decision
• Full pipeline: T1 → decision → T2

Positioning

T1/T2 is a stdlib reference implementation for MCP Discussion #2574-style reasoning discipline: structure first (T1), cross-validate second (T2), checksum what code can verify. It is not a signed verdict API and not a security scanner.

Versioning

Two version numbers — do not conflate them:

Recommended install: pip install "t1-t2-protocol>=0.1.0". Erroneous PyPI releases 2.5.2–2.5.4 are yanked.

License

Apache License 2.0 — see LICENSE.

---

*Built for the MCP ecosystem. Part of a broader exploration into AI safety through deterministic architecture.*

---

Links

• Contributing
• MCP Registry — io.github.Fauxetine/t1-t2-protocol
• Security policy
• Changelog
• Design philosophy
• Caller-side web verification v2.6
• Agent / MCP host instructions