Hydra-MCP — Cryptographic Memory Protocol IETF-TRACK

AI Agent Memory · Tamper-Evident Timestamps · Long-Horizon Amnesia Zero · OpenTTT MCP Server

Tamper-evident timestamps sealed into AI agent memory — 100% state recovery (100/100 measured) after context compaction.

100%

Long-Horizon Amnesia Zero recovery rate (100/100 after server restart)

1,000

causal chain verified (chain_broken=False)

2,056

req/s pot_generate (500VU, p99 671ms, error 0%)

2,589

req/s pot_query (1000VU, p99 372ms)

zero

embedding cost — O(1) exact recall, no vector ops

2 min

npx retrofit — no server changes required

What It Is

AI agents forget their work on every context compaction. Letta, LangGraph, Mem0 lean on vector embeddings — fuzzy recall, no guarantee of deterministic state recovery after a restart.

Hydra-MCP (OpenTTT) works at a different layer. It seals every event with a TTTPS temporal proof (PoT), links them in a causal chain, and looks them up in O(1) by SHA-3 hash. After a restart, the entire chain rebuilds from the Redis DAG — cryptographically verified.

Key Differentiators

  · OpenTTT MCP Server — instant launch from Claude / GPT / Cursor via npx @helm-protocol/ttt-mcp@0.3.0
· 8 MCP Tools — pot_generate · pot_query · pot_checkpoint · pot_verify · pot_status · pot_graph · pot_chain · pot_evict
· Long-Horizon Amnesia Zero — 1,000 causal chains verified, 100% recovery rate after server restart
· SHA-3-based O(1) exact recall — zero embedding cost. No vector DB. No fuzzy search.
· IETF-track I-D (draft-03) — based on TTTPS (draft-helmprotocol-tttps-03). Purpose-built for Byzantine-fault-tolerant AI audit.
· Offline operation — automatic fallback to local-clock without a Roughtime server
· Persistent signing_key — event recovery unaffected by server restart; pub_key remains unchanged

MCP Tools (8)

Claude Code, GPT-4o, Cursor — works instantly with any MCP-compatible client.

Tool	Description	Latency
`pot_generate`	Seal a new event with a TTTPS temporal proof	p50 35ms / p99 671ms (500VU k6, GCP CPU)
`pot_query`	O(1) event lookup via SHA-3 exact hash	p50 31ms / p99 372ms (1000VU k6, GCP CPU)
`pot_checkpoint`	Seal the current chain state as a checkpoint (240 epochs)	<50ms (target, GCP CPU)
`pot_verify`	Verify event integrity — tamper detection	<10ms (target, GCP CPU)
`pot_status`	Query current chain state, epoch, and connected event count	<5ms (target, GCP CPU)
`pot_graph`	Query causal chain DAG (reverse index O(1))	<20ms (target, GCP CPU)
`pot_chain`	Link event IDs into a causal chain	<15ms (target, GCP CPU)
`pot_evict`	Safely remove stale events (evictedEventIds tracked)	<10ms (target, GCP CPU)

Long-Horizon Amnesia Zero — Verification Results

Measured on: GCP CPU · Redis DAG rebuild · recovery verified after server restart (in-memory reset).

100/100

Event recovery rate after server restart

1,000

Consecutive causal chain verifications (chain_broken=False)

2⁻²⁵⁶

SHA-3 hash collision probability — exact lookup basis

Checkpoints added (240×N epochs)

Test Scenario	Result	Condition
Event recovery after server restart	100/100 PASS	Redis AOF + DAG rebuild (including in-memory reset)
1,000 consecutive causal chain continuity	chain_broken=False	pot_generate × 1,000 sequential, then pot_graph verification
Recovery after context compaction	100% deterministic	SHA-3 exact hash → Redis DAG re-query
pot_generate high load (500VU)	2,056 req/s · error 0%	max 6.55s, p99 671ms
pot_query high load (1000VU)	2,589 req/s · error 0%	p99 372ms, max 578ms

AI Agent Memory — Competitor Comparison

Benchmark: deterministic state recovery after context compaction.

Tool	Context Compaction Survival	Embedding Cost	Recall Method	2-min Install	Cryptographic Verification	IETF I-D	Offline Operation
Letta / Mem0	✗	per op	fuzzy	✗	✗	✗	✗
LangGraph / LangMem	Partial*	per op	semantic	✗	✗	✗	✗
RAG / vector DB	✗	per query	fuzzy	✗	✗	✗	✗
OpenTTT / ttt-mcp	✓	zero	O(1) exact	✓	✓	✓	✓

If fuzzy semantic recall is needed, use OpenTTT alongside a vector DB. For deterministic state recovery with Byzantine-fault-tolerant audit chain, OpenTTT is the purpose-built IETF-track implementation (draft-03).

Architecture

  · Temporal Proof (PoT) — Seal event timestamps via Roughtime multi-source (k≥3) or automatic local-clock fallback
· SHA-3 causal chain — Each event's hash is linked as the parent of the next event. O(1) exact lookup.
· Redis DAG persistence — AOF mode enables full chain rebuild after server restart
· Rollup checkpoint — Automatic checkpoint every 240 epochs. Compresses stale events.
· MCP interface — Model Context Protocol standard. Works with any AI client.
· mode:local — Fully offline operation without network. No Roughtime server required.

Installation — 2 Minutes

No server installation required. Run instantly with a single npx command.

# Run directly via npm / npx
npx @helm-protocol/ttt-mcp@0.3.0

# In Claude Code
claude mcp add ttt -- npx -y @helm-protocol/ttt-mcp@0.3.0

# Or via Claude Desktop settings.json
{
  "mcpServers": {
    "ttt-mcp": {
      "command": "npx",
      "args": ["@helm-protocol/ttt-mcp"]
    }
  }
}

After installation, use immediately in Claude/GPT:

# Generate an event
pot_generate({ "content": "architecture decision: QUIC transport confirmed", "context": "session-001" })

# O(1) exact lookup
pot_query({ "event_id": "sha3-abc123..." })

# Seal a session checkpoint
pot_checkpoint({ "label": "v0.3.0-release" })

One-Click Test — Live REST API

Test instantly via REST API — no server installation required. REST-available endpoints below.

# 1. Seal a new event (POST /pot/generate)
curl -X POST https://api.kenosian.com/mcp/pot_generate \
  -H "Content-Type: application/json" \
  -d '{"content":"test event","context":"demo"}'

Expected response (pot_generate):

{
  "event_id":   "sha3-7f4a2b...",
  "timestamp":  "2026-05-31T00:00:00.000Z",
  "proof":      "roughtime:...",
  "chain_head": "sha3-prev...",
  "epoch":      240
}

# 2. O(1) exact lookup (GET /pot/query)
curl "https://api.kenosian.com/mcp/pot_query?event_id=sha3-7f4a2b..."

# 3. Chain state and statistics (GET /pot/stats)
curl "https://api.kenosian.com/mcp/pot_stats"

# 4. Trigger chain rollup / checkpoint alias (POST /pot/rollup)
curl -X POST https://api.kenosian.com/mcp/pot_rollup \
  -H "Content-Type: application/json" \
  -d '{}'

Note: pot_checkpoint is MCP-channel only (Claude / GPT / Cursor via ttt-mcp). It is not available as a direct REST endpoint — use pot_rollup for equivalent functionality via REST.

Pricing

Tier	Price	Quota	Action
Free (OSS)	$0	100 events/day · self-hosted	→ GitHub
Dev	$29/mo	5M events/mo · hosted · 1K req/s
Pro	$99/mo	20M events/mo · priority · SLA
Team	$299/mo	100M events/month (fair-use) · tamper-evident audit export · EU AI Act Art.12 · overage $0.01/1K
Enterprise	Contact	Custom SLA · SSO · on-prem · MiFIR Art.22c audit chain	→ Contact

Free tier: 100 events/day via hosted API — no credit card. Overage (Team): $0.01 per 1K calls beyond 20M/month.

→ npm package → TTTPS Protocol → Early Access Inquiry

Long-Horizon Amnesia Zero: 1,000 causal chains verified + 100% recovery after server restart.

Letta, LangGraph, Mem0 — all forget after context compaction. OpenTTT persists the SHA-3 causal chain in Redis, so compaction becomes sleep. On wake, the chain is restored intact. Cryptographically.

→ github.com/helm-protocol/openttt · IETF draft-helmprotocol-tttps-03

Trust Mark

TTTPS

Verifiable
WHEN

proposed

“TTTPS-certified” — a trust mark for agent memory (proposed)

Each memory operation an agent performs can carry a verifiable, tamper-rejecting record of when it happened and in what order — timing-integrity evidence that an agent’s recorded actions cannot be silently backdated or reordered. If TTTPS is adopted as the standard, an agent-memory deployment could carry the “TTTPS-certified” mark.

Proposed mark for explanation only. Any “certified” status is conditional (“could / if adopted”) and would operate under the Kenosian root of trust — not a present-day certification program.