BRIDGE Documentation

What is BRIDGE?

BRIDGE is a multi-model consensus verification protocol that eliminates single-model risk from critical AI decisions. Instead of trusting one model's output, BRIDGE routes your verification request through multiple independent AI models, forces them into adversarial debate, and delivers a consensus result with a mathematically grounded confidence score.

Think of it as a jury system for AI. No single model controls the verdict. Each model independently analyzes your input, then defends its findings against counterarguments from the others. Only claims that survive adversarial challenge earn high confidence scores. The entire process is recorded in an immutable audit trail.

BRIDGE is designed for high-stakes decisions: contract review, code audits, regulatory compliance, medical literature analysis, and any domain where a single model's hallucination or bias could cause real damage. It is not a chatbot. It is a trust layer.

How It Works

Every verification follows a five-stage pipeline:

Models are selected based on the verification type. The system ensures diversity of architecture and training lineage to minimize correlated failures. No model sees another's analysis until the debate phase begins.

Quickstart

Step 1: Get Your API Key

1. Create a free account at /start
2. Navigate to Dashboard → API Keys
3. Click Create Key and copy your key immediately (it will not be shown again)

Step 2: Install the SDK

pip install bridge-protocol

npm install @bridge-protocol/sdk

Step 3: Run Your First Verification

from bridge_protocol import BridgeClient

client = BridgeClient(api_key="your_api_key_here")

result = client.verify(
    content="The contract states payment is due within 30 days of invoice.",
    verification_type="contract_review",
    options={
        "depth": "standard",
        "models": 3
    }
)

print(f"Confidence: {result.confidence}")
print(f"Findings: {result.findings}")
print(f"Consensus ID: {result.consensus_id}")

import { BridgeClient } from '@bridge-protocol/sdk';

const client = new BridgeClient({ apiKey: 'your_api_key_here' });

const result = await client.verify({
    content: 'The contract states payment is due within 30 days of invoice.',
    verificationType: 'contract_review',
    options: {
        depth: 'standard',
        models: 3
    }
});

console.log(`Confidence: ${result.confidence}`);
console.log(`Findings:`, result.findings);
console.log(`Consensus ID: ${result.consensusId}`);

curl -X POST https://api.bridge-protocol.io/v1/verify \
  -H "Authorization: Bearer your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "The contract states payment is due within 30 days of invoice.",
    "verification_type": "contract_review",
    "options": {
      "depth": "standard",
      "models": 3
    }
  }'

Step 4: Read the Response

{
  "consensus_id": "cons_8f3a2b1c4d5e6f7890",
  "confidence": 0.94,
  "status": "complete",
  "findings": [
    {
      "claim": "Payment obligation is net-30 from invoice date",
      "confidence": 0.97,
      "models_agreed": 3,
      "models_total": 3
    },
    {
      "claim": "No late payment penalty clause identified",
      "confidence": 0.89,
      "models_agreed": 2,
      "models_total": 3
    }
  ],
  "dissents": [
    {
      "model": "model_c",
      "claim": "Clause may imply business days rather than calendar days",
      "round": 4
    }
  ],
  "rounds_completed": 5,
  "audit_trail": "/v1/consensus/cons_8f3a2b1c4d5e6f7890/evidence"
}

The confidence field represents the adversarial survival score of the overall consensus. Individual findings each carry their own confidence and agreement counts. Dissents record claims that did not reach consensus but may be worth human review.

Consensus Engine

The Consensus Engine is the orchestration core of BRIDGE. It manages model selection, debate routing, and scoring.

Model Selection

Models are selected based on three criteria: architectural diversity (transformer variants, mixture-of-experts, etc.), training lineage independence, and domain performance history. The engine never uses two models from the same provider family in a single verification.

Independent Analysis Phase

Each selected model receives identical inputs with zero visibility into other models' outputs. They produce structured findings with explicit confidence levels and supporting evidence. This isolation prevents anchoring bias.

Debate Orchestration

After independent analysis, the engine synthesizes areas of disagreement and routes them as adversarial challenges. Each model must defend its claims against specific counterarguments from the others. The engine tracks which claims survive and which are withdrawn.

Confidence Score

The BRIDGE confidence score is not a hallucination probability. It is an adversarial survival score: the degree to which a claim withstood structured challenge from independent models.

Formula

confidence = (agreements_after_debate / total_models)
             * (1 - withdrawal_rate)
             * debate_depth_weight

where:
  agreements_after_debate = models still supporting claim post-debate
  total_models            = number of models in the verification
  withdrawal_rate         = claims withdrawn / claims initially made
  debate_depth_weight     = min(rounds_completed / 5, 1.0)

Scores range from 0.0 to 1.0. A score above 0.85 indicates strong adversarial survival. Scores below 0.60 indicate significant disagreement and warrant human review.

Debate Rounds

Each verification undergoes multiple rounds of structured adversarial debate. Typical verifications complete in 3 to 7 rounds. The system enforces a hard cap of 7 rounds to bound latency and cost.

Round Structure

• Round 1-2: Initial challenge. Models are presented with disagreements and must defend or withdraw claims.
• Round 3-4: Deep challenge. Models receive specific counterevidence from other models. Weak claims are typically withdrawn here.
• Round 5-7: Convergence. Remaining disagreements are scored and recorded as dissents if not resolved.

Early Termination

If all models reach unanimous agreement before round 7, debate terminates early. The rounds_completed field in the response indicates how many rounds were actually executed.

Audit Trail

Every verification produces an immutable audit trail secured by a SHA-256 hash chain. Each step in the pipeline (submission, individual analyses, debate rounds, final consensus) generates a timestamped, hashed record.

Accessing the Audit Trail

curl https://api.bridge-protocol.io/v1/consensus/cons_8f3a2b1c4d5e6f7890/evidence \
  -H "Authorization: Bearer your_api_key_here"

The response includes the complete chain of evidence: which models participated, what each produced independently, every challenge and response in the debate, and the final scoring logic. This is your cryptographic proof that the verification was conducted fairly.

Authentication

All API requests require a Bearer token in the Authorization header:

Authorization: Bearer your_api_key_here

Key Permissions

Rate Limits

API Endpoints

curl -X POST https://api.bridge-protocol.io/v1/verify \
  -H "Authorization: Bearer your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{"content": "...", "verification_type": "contract_review"}'

curl -X POST https://api.bridge-protocol.io/v1/verify/async \
  -H "Authorization: Bearer your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{"content": "...", "verification_type": "code_review", "webhook_url": "https://yourapp.com/hook"}'

curl https://api.bridge-protocol.io/v1/consensus/cons_8f3a2b1c4d5e6f7890 \
  -H "Authorization: Bearer your_api_key_here"

curl https://api.bridge-protocol.io/v1/consensus/cons_8f3a2b1c4d5e6f7890/evidence \
  -H "Authorization: Bearer your_api_key_here"

curl https://api.bridge-protocol.io/v1/models \
  -H "Authorization: Bearer your_api_key_here"

SDKs

Official SDKs are in active development. The REST API is fully stable and production-ready today.

Python

from bridge_protocol import BridgeClient

client = BridgeClient(api_key="your_api_key_here")

# Synchronous verification
result = client.verify(
    content="Your content here",
    verification_type="contract_review"
)

# Async verification
job = client.verify_async(
    content="Your content here",
    verification_type="code_review",
    webhook_url="https://yourapp.com/hook"
)
print(f"Polling ID: {job.consensus_id}")

Node.js

import { BridgeClient } from '@bridge-protocol/sdk';

const client = new BridgeClient({ apiKey: 'your_api_key_here' });

// Synchronous verification
const result = await client.verify({
    content: 'Your content here',
    verificationType: 'contract_review'
});

// Async verification
const job = await client.verifyAsync({
    content: 'Your content here',
    verificationType: 'code_review',
    webhookUrl: 'https://yourapp.com/hook'
});
console.log(`Polling ID: ${job.consensusId}`);

REST (curl)

No SDK required. The REST API is the most reliable integration path today:

# Verify content
curl -X POST https://api.bridge-protocol.io/v1/verify \
  -H "Authorization: Bearer your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{"content": "...", "verification_type": "contract_review"}'

# Check result
curl https://api.bridge-protocol.io/v1/consensus/cons_YOUR_ID \
  -H "Authorization: Bearer your_api_key_here"

# Get audit trail
curl https://api.bridge-protocol.io/v1/consensus/cons_YOUR_ID/evidence \
  -H "Authorization: Bearer your_api_key_here"

Chrome Extension

Verify content directly from any AI chat interface. The BRIDGE Chrome Extension adds a floating verification button to ChatGPT, Claude, Gemini, and other AI platforms.

Guides

Step-by-step walkthroughs for common verification workflows: