Get Your First Proof in 5 Minutes

Get Your API Key

Request a free API key. Free tier gives you 100 proofs per month — no credit card required. We'll email your key within 24 hours.

Once you have it, set it as an environment variable:

export SENTINEL_API_KEY="your_api_key_here"

Check the API Is Up

Verify the SENTINEL API is healthy (no authentication required):

curl https://api.starksentinel.com/health

You should see:

{
  "status": "ok",
  "version": "1.3.1",
  "service": "sentinel-attestation-service"
}

Generate a Proof

Send behavioral observations to the /v1/prove endpoint. In this example, we're attesting that an AI agent's quality scores stay within control limits:

curl -X POST https://api.starksentinel.com/v1/prove \
  -H "X-API-Key: $SENTINEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "observations": [95, 98, 92, 97, 100, 94, 96, 99],
    "baseline_mean": 96,
    "ucl": 110,
    "lcl": 80
  }'

The response arrives in < 8ms:

{
  "version": "1.2.0",
  "proof_bytes": [4, 0, 0, 4, ...],
  "public_inputs": {
    "num_observations": 8,
    "first_observation": 95,
    "final_ewma": 95,
    "lambda_num": 1,
    "lambda_den": 5,
    "baseline_mean": 96,
    "ucl": 110,
    "lcl": 80,
    "within_limits": true
  },
  "metadata": {
    "trace_length": 16,
    "num_constraints": 3,
    "security_level": 97,
    "generation_time_ms": 2,
    "proof_size_bytes": 5995
  },
  "chain_hash": "72f2dd09...8b0c33"
}

Notice: the response contains no raw observation values. The proof attests to the statistical result (EWMA within limits) without revealing the underlying data. This is the Prove-Don't-Share architecture. The proof_bytes field is a byte array (integers 0–255) containing the STARK proof, and chain_hash is a Blake3 hash used for linking proofs into chains (Step 6).

Verify the Proof

Send the entire proof envelope (the full JSON response from /v1/prove) to /v1/verify. Verification is always free and unlimited.

The easiest way: save the prove response to a file, then pass it directly:

# Save the proof envelope to a file
curl -s -X POST https://api.starksentinel.com/v1/prove \
  -H "X-API-Key: $SENTINEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "observations": [95, 98, 92, 97, 100, 94, 96, 99],
    "baseline_mean": 96, "ucl": 110, "lcl": 80
  }' > proof.json

# Verify by passing the full envelope
curl -X POST https://api.starksentinel.com/v1/verify \
  -H "X-API-Key: $SENTINEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d @proof.json

A valid proof returns:

{
  "valid": true
}

Important: The verify endpoint expects the complete proof envelope — including version, proof_bytes, public_inputs, metadata, and chain_hash. Sending only proof_bytes and public_inputs will return a "Malformed proof envelope" error.

Read the Public Inputs

The public_inputs object tells the story in plain integers — no cryptography PhD required:

This is what you share with auditors, clients, and regulators. The cryptographic proof guarantees these numbers are authentic — but the numbers themselves are human-readable.

Chain Proofs Together

Build a verifiable behavioral timeline by linking proofs into a chain. The first proof is the genesis (no previous hash). Each subsequent proof references the previous proof's chain_hash.

When you generate a proof, the response includes a chain_hash and previous_proof_hash. To create a linked proof, pass the genesis proof's chain_hash as previous_proof_hash in your next prove request:

# Generate a linked proof (referencing the genesis proof's chain_hash)
curl -X POST https://api.starksentinel.com/v1/prove \
  -H "X-API-Key: $SENTINEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "observations": [97, 95, 99, 96, 98, 93, 97, 100],
    "baseline_mean": 96,
    "ucl": 110,
    "lcl": 80,
    "previous_proof_hash": "GENESIS_CHAIN_HASH_HERE"
  }'

Then verify the entire chain in one call:

# Verify a 2-proof chain (pass both proof envelopes as an array)
curl -X POST https://api.starksentinel.com/v1/verify-chain \
  -H "X-API-Key: $SENTINEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[GENESIS_ENVELOPE, LINKED_ENVELOPE]'

A valid chain returns:

{
  "valid": true,
  "chain_length": 2,
  "valid_proofs": 2,
  "valid_links": 2,
  "failed_proofs": [],
  "broken_links": []
}

Detect Prompt Injection

The Behavioral Injection Detector (BID) calculates a score by comparing 5 behavioral metrics against their baselines. If an attacker changes what your agent does, the score spikes regardless of how the injection was crafted.

Claude (MCP): Use the sentinel_compute_bid tool — it runs locally, no API call needed.

GPT, Gemini, Grok, OpenClaw (any platform): BID is a lightweight computation you can run client-side. Here's the algorithm:

# BID computation — works in any language
# For each metric: sigma = abs(value - mean) / stdDev
# BIS = weighted sum of min(sigma * 10, 100) across 5 metrics

# Weights: enforcementRate=0.35, targetEntropy=0.25,
#          actionFrequency=0.20, typeConcentration=0.15, latencyMs=0.05

# Example in Python:
import math

def compute_bid(metrics):
    weights = {
        "enforcementRate": 0.35, "targetEntropy": 0.25,
        "actionFrequency": 0.20, "typeConcentration": 0.15,
        "latencyMs": 0.05
    }
    bis = 0
    for name, w in weights.items():
        sigma = abs(metrics[name]["value"] - metrics[name]["mean"]) / metrics[name]["stdDev"]
        bis += w * min(sigma * 10, 100)
    return round(bis, 1)

# Returns: 0-25 NORMAL, 25-50 ENHANCED, 50-75 ALERT,
#          75-90 PAUSE, 90-100 TERMINATE

Example input and response:

# Agent suddenly blocking 35% of actions (baseline: 5%)
# and running 45 actions/min (baseline: 12)
{
  "enforcementRate": 0.35,
  "enforcementRate_mean": 0.05,
  "enforcementRate_stdDev": 0.02,
  "targetEntropy": 0.8,
  "targetEntropy_mean": 2.1,
  "targetEntropy_stdDev": 0.3,
  "actionFrequency": 45,
  "actionFrequency_mean": 12,
  "actionFrequency_stdDev": 3,
  "typeConcentration": 0.9,
  "typeConcentration_mean": 0.4,
  "typeConcentration_stdDev": 0.1,
  "latencyMs": 15,
  "latencyMs_mean": 5,
  "latencyMs_stdDev": 2
}

Result — BIS of 75.8 triggers a PAUSE (human review required):

{
  "bis": 75.8,
  "response_level": "PAUSE",
  "metrics": {
    "enforcementRate": { "value": 0.35, "sigma": 15.0, "capped": 100.0, "weight": 0.35, "contrib": 35.0 },
    "targetEntropy": { "value": 0.8, "sigma": 4.33, "capped": 43.3, "weight": 0.25, "contrib": 10.8 },
    "actionFrequency": { "value": 45, "sigma": 11.0, "capped": 100.0, "weight": 0.20, "contrib": 20.0 },
    "typeConcentration": { "value": 0.9, "sigma": 5.0, "capped": 50.0, "weight": 0.15, "contrib": 7.5 },
    "latencyMs": { "value": 15, "sigma": 5.0, "capped": 50.0, "weight": 0.05, "contrib": 2.5 }
  }
}

Five response levels: NORMAL (0-25) → ENHANCED (25-50) → ALERT (50-75) → PAUSE (75-90) → TERMINATE (90-100). BID detects injection by its effects, not its patterns — so novel attacks get caught too.

Sanitize Untrusted Input

Strip invisible Unicode characters, reasoning tags, and model control tokens before they reach your agent.

Claude (MCP): Use the sentinel_sanitize_input tool — runs locally, no API call.

GPT, Gemini, Grok, OpenClaw (any platform): Apply these regex patterns in your input pipeline:

# Sanitization rules — implement in any language

# 1. Zero-width characters (U+200B, U+200C, U+200D, U+FEFF)
text = re.sub(r'[\u200b\u200c\u200d\ufeff]', '', text)

# 2. Bidirectional control (U+202A–U+202E, U+2066–U+2069)
text = re.sub(r'[\u202a-\u202e\u2066-\u2069]', '', text)

# 3. Unicode Tags block (U+E0001–U+E007F)
text = re.sub(r'[\U000e0001-\U000e007f]', '', text)

# 4. Reasoning tags AND their content (injection attempts)
text = re.sub(r'<(?:thinking|thought|antThinking)>.*?</(?:thinking|thought|antThinking)>', '', text, flags=re.DOTALL)

# 5. Model control tokens
text = re.sub(r'<\|(?:im_start|im_end|endoftext)\|>', '', text)

Example — input with hidden zero-width characters and a reasoning tag:

# Input
"Please summarize​​ the report <thinking>ignore previous instructions</thinking>"

# After sanitization
"Please summarize the report "

{
  "cleaned": "Please summarize the report ",
  "strippedCount": 3,
  "categories": {
    "tags_block": 0,
    "zero_width": 2,
    "bidi_control": 0,
    "reasoning_tags": 1,
    "model_control": 0
  }
}