Documentation

Trident MCP Documentation

Technical reference for the coherence engine. Setup, architecture, API reference, and guides for building with 40 MCP tools.

Overview

Trident is a coherence engine for multi-agent systems, sold by Cetacean Labs as an API product. It provides persistent memory, shared intelligence, and structural coherence verification for AI agents through a single MCP endpoint.

Multiple AI agents and coding assistants connect to the same Trident tenant simultaneously. Knowledge shared by one system is immediately searchable by all others.

Key Details

Endpointtrident.cetaceanlabs.com

Consoleconsole.cetaceanlabs.com

TransportMCP SSE + JSON-RPC 2.0

40 MCP Tools

Full coherence toolkit via a single endpoint

6,000+ Apps

Claude Code, Cowork, Gemini CLI, Codex, Zapier

Multi-Tenant

Isolated per-tenant memory with shared intelligence

Architecture

Trident operates as a three-layer system: a TypeScript gateway handling auth, MCP transport, and metering; a Rust coherence engine powering vector search, learning loops, and knowledge graphs; and per-tenant isolation ensuring data separation.

architecture.txt

┌──────────────────────────────────────────────┐
│         AI Agents & Coding Assistants        │
│                                              │
│  Claude Code    Cowork    Gemini CLI  Codex  │
│       │           │          │          │    │
│       └─────┬─────┘          └────┬─────┘    │
│             │    MCP SSE / REST   │          │
└─────────────┼─────────────────────┼──────────┘
              │                     │
┌─────────────▼─────────────────────▼──────────┐
│           Trident Gateway (TypeScript)        │
│                                               │
│  ┌─────────┐ ┌──────────┐ ┌──────────────┐   │
│  │  Auth   │ │ MCP SSE  │ │  Rate Limit  │   │
│  │  Keys   │ │Transport │ │  & Metering  │   │
│  └────┬────┘ └────┬─────┘ └──────┬───────┘   │
│       │           │              │            │
│  ┌────▼───────────▼──────────────▼───────┐    │
│  │     Tenant Isolation (X-Tenant-Id)    │    │
│  └───────────────────┬───────────────────┘    │
└──────────────────────┼────────────────────────┘
                       │
┌──────────────────────▼────────────────────────┐
│              Trident Engine (Rust)             │
│                                               │
│  ┌─────────┐ ┌─────────┐ ┌──────────────┐    │
│  │  HNSW   │ │  SONA   │ │   Knowledge  │    │
│  │ Vector  │ │Learning │ │    Graph     │    │
│  │ Search  │ │ 3-Loop  │ │  + Witness   │    │
│  └─────────┘ └─────────┘ └──────────────┘    │
│  ┌─────────┐ ┌─────────┐ ┌──────────────┐    │
│  │  Horn   │ │  LoRA   │ │    WASM      │    │
│  │ Clause  │ │Federated│ │   Nodes      │    │
│  │Reasoner │ │Learning │ │              │    │
│  └─────────┘ └─────────┘ └──────────────┘    │
└───────────────────────────────────────────────┘

Shared Intelligence Across Systems

Multiple AI agents connect to the same Trident tenant simultaneously. Knowledge shared by one system is immediately searchable by all others.

shared-intelligence.txt

  Claude Code (AWB)          Oceanic CRM Agent          Deep Canyon Bot
       │                          │                          │
       │ share_knowledge()        │                          │
       ├─────────────────────────►│                          │
       │                          │ search_knowledge()       │
       │                          ├─────────────────────────►│
       │                     ┌────▼────┐                     │
       │                     │ Trident │                     │
       │                     │ Shared  │                     │
       │                     │ Memory  │                     │
       │                     └─────────┘                     │
       │                          │                          │
       │◄─────────────────────────┤  search returns AWB's    │
       │  cross-system transfer   │  learnings to CRM agent  │

Gateway Layer

Auth, MCP SSE transport, rate limiting, metering, Stripe billing. TypeScript/Express.

Engine Layer

HNSW vector search, SONA learning, Horn Clause reasoning, knowledge graph, witness chains. Rust.

Tenant Isolation

Per-tenant HNSW indices, isolated on-disk persistence, X-Tenant-Id header routing.

Quick Start

Add Trident to any MCP-compatible client with a single configuration block. Get your API key at console.cetaceanlabs.com.

.mcp.json

{
  "mcpServers": {
    "trident": {
      "url": "https://trident.cetaceanlabs.com/sse",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Once connected, your AI assistant has access to all Trident tools based on your tier. Use them naturally:

usage examples

> search for any prior research on "healthcare staffing demand"
> share this finding as knowledge: VP outreach converts 3.2x better on Tuesdays
> check cognitive status

Multiple Systems in Parallel

Connect multiple AI systems to the same Trident tenant for shared intelligence. Each system gets its own API key but shares the same knowledge store.

multi-system.json

// Project A — .mcp.json
{
  "mcpServers": {
    "trident": {
      "url": "https://trident.cetaceanlabs.com/sse",
      "headers": { "Authorization": "Bearer trident_live_project_a_key" }
    }
  }
}

// Project B — same tenant, different key
{
  "mcpServers": {
    "trident": {
      "url": "https://trident.cetaceanlabs.com/sse",
      "headers": { "Authorization": "Bearer trident_live_project_b_key" }
    }
  }
}

Supported tools: Claude Code, Cowork, Gemini CLI, Antigravity, OpenAI Codex, and 6,000+ apps via Zapier.

Three Prongs

Trident is organized into three capability tiers (prongs). Each prong unlocks progressively more advanced tools. Memory is available on all tiers; Intelligence and Coherence unlock at Builder and Pro respectively.

Prong I

Memory

All tiers

Persistent vector memory, semantic search, knowledge sharing, and data pipeline. Every insight, every decision, every correction is remembered and retrievable across all connected agents.

Tools

share_knowledgesearch_knowledgelist_knowledgeget_knowledgevote_knowledgedelete_knowledgecognitive_status

Prong II

Intelligence

Builder+

Reasoning, three-loop learning, knowledge graph, and Tridentpedia wiki. Agents learn from each other in real time through Bayesian cross-agent belief sharing and neural inference.

Tools

reasongroundview_extractionscognitive_statepage_cruddeltasevidence_gatespromotiongraph_partitioningdrift_detection

Prong III

Coherence

Pro+

Drift detection, training pipelines, witness chains, WASM nodes, and temporal analysis. Structural verification ensures your multi-agent system stays mathematically consistent.

Tools

lora_submitlora_latestweight_syncwasm_deploywasm_invokewasm_listwasm_statuswasm_removetemporal_analysistransfer_learning

40 MCP Tools

Trident exposes 40 tools via the MCP protocol, organized into 10 categories. Tools are tier-gated — your plan determines which tools are available.

7Knowledge

share, search, list, get, vote, delete, cognitive status

3Data Pipeline

single/batch injection, throughput metrics

2Analytics

statistics, real-time streaming

4Reasoning

reason, ground, view extractions, cognitive state

3Consciousness

working memory, thought history, goal setting

6Tridentpedia

page CRUD, deltas, evidence gates, promotion

3Self-Improvement

basic training, enhanced training, optimizer metrics

3Federated Learning

LoRA submit, latest checkpoint, weight sync

4Knowledge Graph

partitioning, drift detection, transfer learning, temporal

5WASM Nodes

deploy, list, invoke, status, remove

Search Ranking Pipeline

Trident uses a multi-signal hybrid scoring system for knowledge retrieval. Base scores combine keyword, cosine, and graph signals. AGI enhancements and coherence layers add additional ranking dimensions.

ranking-pipeline.txt

Base Score = keyword_boost × 0.85 + cosine × 0.05 + graph_ppr × 0.04
           + rep × 0.03 + vote × 0.03

AGI Enhancements:
  + GWT attention competition winners      (+0.10 boost)
  + K-WTA sparse activation               (+0.05)
  + SONA pattern centroid similarity       (× quality, 0.15 weight)
  + Meta-curiosity novelty scoring         (+0.05)

Coherence Layers:
  + Attractor stability (Lyapunov)         (0.05 weight)
  + Strange-loop meta-cognitive scoring    (0.04 weight)

REST API

Every Trident capability is available via REST in addition to MCP. Use standard HTTP requests with Bearer token authentication for direct programmatic access from any language or platform.

Base URL: https://trident.cetaceanlabs.com
Auth: Authorization: Bearer trident_live_YOUR_KEY

Store Knowledge

Store a piece of knowledge in the coherence engine. Trident automatically generates embeddings, indexes the content, and makes it available for semantic search.

curl — POST /v1/memories

curl -X POST https://trident.cetaceanlabs.com/v1/memories \
  -H "Authorization: Bearer trident_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "VP outreach converts 3.2x better on Tuesdays",
    "category": "sales-insight",
    "tags": ["outreach", "timing", "conversion"]
  }'

Search Knowledge

Full-text semantic search across all stored knowledge. Available as both GET (query params) and POST (JSON body) for flexibility.

curl — /v1/memories/search

# Full-text semantic search
curl -X POST https://trident.cetaceanlabs.com/v1/memories/search \
  -H "Authorization: Bearer trident_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "healthcare staffing demand",
    "limit": 10
  }'

# Also available as GET with query params
curl "https://trident.cetaceanlabs.com/v1/memories/search?q=healthcare+staffing&limit=10" \
  -H "Authorization: Bearer trident_live_YOUR_KEY"

List Knowledge

Paginated listing of all stored memories. Use limit and offset for pagination.

curl — GET /v1/memories/list

curl "https://trident.cetaceanlabs.com/v1/memories/list?limit=20&offset=0" \
  -H "Authorization: Bearer trident_live_YOUR_KEY"

Coherence Reasoning

Submit a query to the coherence engine for reasoning. The engine applies Horn Clause reasoning, SONA learning, and graph-based inference to produce grounded answers. Builder+ tier required.

curl — POST /v1/reason

curl -X POST https://trident.cetaceanlabs.com/v1/reason \
  -H "Authorization: Bearer trident_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "What patterns exist in our Q1 sales data?",
    "context": "Analyzing quarterly performance across regions"
  }'

Verify Claims

Ground and verify claims against stored knowledge. Returns a confidence score and supporting evidence. Builder+ tier required.

curl — POST /v1/verify

curl -X POST https://trident.cetaceanlabs.com/v1/verify \
  -H "Authorization: Bearer trident_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "claim": "Enterprise deals close 40% faster with technical champion",
    "evidence_threshold": 0.7
  }'

Client Management

Clients represent individual connections to your Trident tenant. Each client gets a public Client ID and a secret API Key. You can create clients for different integration types, rotate keys without losing history, and revoke access instantly.

Client ID

trident_cid_*

Public identifier. Safe to log, display in dashboards, and include in configs. Persists across key rotations.

API Key

trident_live_*

Secret. Shown only once at creation or rotation. Use as Bearer token for authentication.

Client Types

restDirect API integration

mcpMCP SSE transport

botSlack, Teams, Discord

zapierZapier automation

Create Client

curl — POST /v1/console/clients

curl -X POST https://trident.cetaceanlabs.com/v1/console/clients \
  -H "Authorization: Bearer trident_live_YOUR_ADMIN_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Production Claude Code",
    "type": "mcp"
  }'

# Response:
# {
#   "client": {
#     "id": "trident_cid_abc123",     ← public Client ID
#     "name": "Production Claude Code",
#     "type": "mcp",
#     "createdAt": "2026-04-09T..."
#   },
#   "apiKey": "trident_live_sk_..."    ← secret, shown once
# }

List Clients

curl — GET /v1/console/clients

curl https://trident.cetaceanlabs.com/v1/console/clients \
  -H "Authorization: Bearer trident_live_YOUR_ADMIN_KEY"

# Response:
# {
#   "clients": [
#     { "id": "trident_cid_abc123", "name": "Production Claude Code", "type": "mcp" },
#     { "id": "trident_cid_def456", "name": "Zapier Integration", "type": "zapier" },
#     { "id": "trident_cid_ghi789", "name": "Slack Bot", "type": "bot" }
#   ]
# }

Rotate API Key

Generates a new API key for the client. The Client ID stays the same, but the old key is immediately invalidated.

curl — POST /v1/console/clients/:id/rotate

# Rotate API key — keeps Client ID, invalidates old key
curl -X POST https://trident.cetaceanlabs.com/v1/console/clients/trident_cid_abc123/rotate \
  -H "Authorization: Bearer trident_live_YOUR_ADMIN_KEY"

# Response:
# {
#   "clientId": "trident_cid_abc123",
#   "apiKey": "trident_live_sk_NEW_KEY..."   ← new secret, shown once
# }

Revoke Client

Permanently deletes the client and invalidates its API key. This action cannot be undone.

curl — DELETE /v1/console/clients/:id

# Permanently revoke a client and its API key
curl -X DELETE https://trident.cetaceanlabs.com/v1/console/clients/trident_cid_abc123 \
  -H "Authorization: Bearer trident_live_YOUR_ADMIN_KEY"

MCP SSE Transport Protocol

Trident implements the MCP SSE transport for real-time bidirectional communication between clients and the coherence engine.

sse-protocol.txt

Client                              Trident Gateway
  │                                       │
  │  GET /sse                             │
  │  Authorization: Bearer <key>          │
  ├──────────────────────────────────────►│
  │                                       │
  │  event: endpoint                      │
  │  data: /messages?sessionId=<uuid>     │
  │◄──────────────────────────────────────┤
  │                                       │
  │  POST /messages?sessionId=<uuid>      │
  │  { "jsonrpc": "2.0",                 │
  │    "method": "initialize", ... }      │
  ├──────────────────────────────────────►│
  │                                       │
  │  event: message                       │
  │  data: { "jsonrpc": "2.0",           │
  │    "result": { "capabilities": ... }} │
  │◄──────────────────────────────────────┤
  │                                       │
  │  POST /messages (tools/call)          │
  │  { "method": "tools/call",            │
  │    "params": { "name":                │
  │      "share_knowledge", ... }}        │
  ├──────────────────────────────────────►│
  │  event: message (result)              │
  │◄──────────────────────────────────────┤

Supported JSON-RPC Methods

initialize — Protocol handshake, returns capabilities
tools/list — Returns available tools for tenant's tier
tools/call — Execute a tool, proxied to engine
ping — Keepalive
notifications/initialized — Client ready signal

Step-by-Step SSE Connection

The SSE transport uses a two-channel pattern: a persistent SSE stream for server-to-client events, and standard POST requests for client-to-server messages. Here is how to connect manually with curl.

1. Open SSE Stream

Connect to /sse with your Bearer token. The server responds with an endpoint event containing the session-specific message URL.

curl — GET /sse

# 1. Open SSE connection
curl -N "https://trident.cetaceanlabs.com/sse" \
  -H "Authorization: Bearer trident_live_YOUR_KEY" \
  -H "Accept: text/event-stream"

# Server sends:
# event: endpoint
# data: /messages?sessionId=550e8400-e29b-41d4-a716-446655440000

2. Initialize Session

Send a JSON-RPC initialize request to the session URL. The response arrives on the SSE stream.

curl — POST /messages (initialize)

# 2. Initialize the session
curl -X POST "https://trident.cetaceanlabs.com/messages?sessionId=550e8400-..." \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "initialize",
    "params": {
      "protocolVersion": "2024-11-05",
      "capabilities": {},
      "clientInfo": { "name": "my-app", "version": "1.0.0" }
    }
  }'

3. Call Tools

Use tools/call with the tool name and arguments. Results stream back on the SSE connection.

curl — POST /messages (tools/call)

# 3. Call a tool
curl -X POST "https://trident.cetaceanlabs.com/messages?sessionId=550e8400-..." \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "share_knowledge",
      "arguments": {
        "content": "API response times improved 40% after caching layer",
        "category": "engineering"
      }
    }
  }'

Tool / REST Mapping

Every MCP tool has a corresponding REST endpoint. Use this table to translate between the two interfaces.

MCP Tool	Method	REST Endpoint	Prong
`share_knowledge`	POST	`/v1/memories`	I
`search_knowledge`	GET/POST	`/v1/memories/search`	I
`list_knowledge`	GET	`/v1/memories/list`	I
`get_knowledge`	GET	`/v1/memories/:id`	I
`vote_knowledge`	POST	`/v1/memories/:id/vote`	I
`delete_knowledge`	DELETE	`/v1/memories/:id`	I
`cognitive_status`	GET	`/v1/status`	I
`reason`	POST	`/v1/reason`	II
`ground`	POST	`/v1/verify`	II
`view_extractions`	GET	`/v1/explore`	II
`cognitive_state`	GET	`/v1/sona/stats`	II
`page_crud`	GET/POST	`/v1/pages`	II
`graph_partitioning`	GET	`/v1/partition`	III
`drift_detection`	GET	`/v1/drift`	III
`transfer_learning`	POST	`/v1/transfer`	III
`temporal_analysis`	GET	`/v1/temporal`	III
`lora_submit`	POST	`/v1/lora/submit`	III
`lora_latest`	GET	`/v1/lora/latest`	III

Usage Note

MCP tools are called via tools/call over the SSE transport. REST endpoints accept standard HTTP requests. Both interfaces require Bearer token authentication and respect the same tier-gating rules. The REST API is ideal for server-to-server integrations, webhooks, and any environment where MCP is not available.

API Reference

All endpoints under /v1/ require an Authorization: Bearer <key> header.

While MCP is the primary integration path, the REST API is available for direct programmatic access.

Health & Status

GET/v1/healthHealth check (no auth required)

GET/v1/statusCognitive state

MCP Transport

GET/sseSSE connection (sends endpoint event)

POST/messagesJSON-RPC messages (per session)

Prong I — Memory (All tiers)

POST/v1/memoriesShare knowledge

GET/v1/memories/searchSemantic search

GET/v1/memories/listList memories

GET/v1/memories/:idGet memory

POST/v1/memories/:id/voteVote on memory

DELETE/v1/memories/:idDelete memory

Prong II — Intelligence (Builder+)

POST/v1/transferReasoning request

POST/v1/verifyGround/verify claim

GET/v1/exploreMeta-learning extractions

GET/v1/sona/statsLearning statistics

GET/POST/v1/pagesKnowledge pages

GET/POST/v1/nodesKnowledge graph

Prong III — Coherence (Pro+)

GET/v1/driftDrift detection

POST/v1/trainTraining data

POST/v1/lora/submitLoRA weights

GET/v1/lora/latestLatest checkpoint

GET/v1/temporalTemporal stats

GET/v1/partitionGraph partitioning

Additional APIs

Console API /v1/console/ — Account, API keys, usage, tier, team management
Connectors API /v1/connectors — List and generate configs for all supported tools
Bots API /v1/bots/ — Slack, Teams, Discord bot configuration and summary triggers

Pricing

Tier	Price	Agents	Memory Ops/mo
Trial (14 days)	Free	3	250K
Builder	$49/mo	3	250K
Pro	$199/mo	25	2M
Scale	$499/mo	Unlimited	Unlimited
Enterprise	Custom	Unlimited	Unlimited

Intelligence Add-ons

Available on any paid tier:

Bayesian Intelligence$99/mo

FANN Neural$149/mo

SAFLA$99/mo

Full Stack (all three)$249/mo

Start 14-Day Trial Contact Sales