Which integrations are available for this server?

Routes queries to local Ollama instances for AI model inference with automatic failover, enabling private and self-hosted operation.

How do I use Sovereign MCP?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Sovereign MCP Compute route: 'explain quantum computing'" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

Sovereign MCP

by SNAPKITTYWEST

Overview Schema Related Servers Score Discussions

JavaScript

Hybrid

Sovereign MCP

AI Infrastructure You Can Verify.

Every decision. Signed. Recorded. Provable.

         Your Request
              │
       Sovereign Router
              │
       ┌──────┼──────┐
       │      │      │
   Bedrock  Groq  Ollama
       │      │      │
       └──────┼──────┘
              │
        ERE Verification
        (deterministic gate)
              │
         Ed25519 Sign
              │
         WORM Receipt
         (append-only)
              │
          Response

What It Does

Your AI provider can change pricing tomorrow, shut down your model, read every prompt, or refuse your workload. You have no recourse.

Sovereign MCP fixes this:

Provider independent — Swap from Claude to Llama to Ollama with zero code changes. If one goes down, the next catches it automatically.
Deterministically verified — Every output passes 5 verification gates before it ships. No stubs. No placeholders. No "TODO: implement."
Cryptographically signed — Ed25519 signature on every response. Prove what the AI said, when, and to whom.
Append-only audit trail — WORM-style receipts. Tamper-evident. Permanent. If it happened, you can prove it.
Self-hosted — Runs on your hardware, your network, your rules. No cloud dependency required.

Related MCP server: Predicate

Quick Start

# stdio mode (Claude Code / VSCode)
node sovereign-mcp.mjs

# HTTP mode (BobIDE / Android / any client)
node sovereign-mcp.mjs --http

Configure providers in .env.local:

AWS_ACCESS_KEY_ID=your-key
AWS_SECRET_ACCESS_KEY=your-secret
AWS_REGION=us-east-1
BEDROCK_MODEL_ID=us.anthropic.claude-haiku-4-5-20251001-v1:0
GROQ_API_KEY=your-groq-key
OLLAMA_URL=http://localhost:11434

Any provider you don't configure is skipped. The router uses what's available.

Tools

Tool	What it does
`compute_route`	Route queries through the best available provider with automatic failover
`ere_verify`	Deterministic 5-pass verification — catches stubs, placeholders, secrets, broken code
`magma_seal`	WORM-seal any content with verification hash + Ed25519 signature
`agent_dispatch`	Route tasks to specialized agents or registered proxy services
`magma_exec`	Execute composable instruction pipelines with `§VERB:AGENT:ACTION{payload}` syntax
`proxy_register`	Register external services as callable tools
`proxy_list`	List registered proxy integrations
`governor_pubkey`	Export Ed25519 public key for external signature verification

Verification Gates (ERE)

Every output is checked by 5 deterministic passes before it leaves the system:

Pass	What it catches
P1	Empty or trivial responses
P2	"Not implemented" stubs, TODO placeholders
P3	Crypto operations in wrong language boundary
P4	Hardcoded secrets, unauthorized AI dependencies
P5	Structural integrity (unbalanced delimiters)

If any pass fails, the output is BLOCKED. Not logged and forwarded — blocked. The gate is fail-closed.

Instruction Language (Magma)

Composable instructions with pipeline support:

§COMPUTE:FORGE:BUILD{query:"build a WORM handler in Rust"}

Pipeline — chain operations:

§QUERY:ORACLE:SEARCH{q:"find auth patterns"} >> §SEAL:SENTINEL:ANCHOR{data:_prev}

Verbs: COMPUTE (paid model) · QUERY (fast/free) · SEAL (sign + log) · DISPATCH (route to agent) · NULLIFY (void an action)

Every instruction is audit-logged with timestamp, executor, and signature.

Agent Routing

Define specialized agents with system prompts. Route tasks to the right expert:

const AGENT_PROMPTS = {
  forge:    "Production-grade builder. TypeScript, Rust, Haskell. Never stubs.",
  oracle:   "Knowledge graph. Citations. Never hallucinate sources.",
  sentinel: "Zero-trust security. Hard verdicts: APPROVED or BLOCKED.",
  vault:    "Treasury. Basis points, yield curves, capital efficiency.",
}

Add your own. Remove ours. The architecture doesn't care what agents you define — it cares that their output is verified and signed.

Provider Cascade

1. Bedrock (sovereign, paid, AWS credentials)
      │ fails?
      ▼
2. Groq (fast, free tier)
      │ fails?
      ▼
3. Ollama (local, bare metal, zero cost)
      │ fails?
      ▼
   Hard error — no silent degradation

No unverified fallback. No quiet failure. If all providers are down, you know immediately.

Integration

Claude Code / VSCode

Add to your .mcp.json:

{
  "mcpServers": {
    "sovereign": {
      "command": "node",
      "args": ["path/to/sovereign-mcp.mjs"]
    }
  }
}

HTTP Client (any language)

curl -X POST http://localhost:7071 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"compute_route","arguments":{"agent":"forge","query":"build a REST API"}}}'

Verify Signatures Externally

import { verify } from 'crypto'

const pubkey = await fetch('http://localhost:7071', {
  method: 'POST',
  body: JSON.stringify({jsonrpc:'2.0',id:1,method:'tools/call',params:{name:'governor_pubkey',arguments:{}}})
}).then(r => r.json())

// Use pubkey to verify any response signature

Architecture

sovereign-mcp/
├── sovereign-mcp.mjs     Server (stdio + HTTP)
├── .env.example           Provider configuration template
├── LICENSE                [Your license here]
└── README.md

Single file. No build step. No dependencies beyond @aws-sdk/client-bedrock-runtime (optional — only if you use Bedrock).

Who This Is For

Teams that need to prove what their AI said and when
Enterprises that can't send data to a third party
Developers building multi-model systems that don't break when one provider goes down
Anyone who thinks AI infrastructure should be auditable, not just "hopefully correct"

The Question

If your AI made a decision that cost you $10M, could you prove exactly what it said, when, and why?

If not, you don't have AI infrastructure. You have a hope and a prayer.

AI Infrastructure You Can Verify.

License

Functional Source License 1.1 — Ahmad Ali Parr / Bel Esprit D'Accord Trust

Change Date: 2030-07-24 · Change License: Apache 2.0

Use it. Build on it. Don't compete with it for 4 years.

SnapKitty Collective · 2026

Available Tools

7 tools

agent_dispatchA

Dispatch a task to a registered proxy tool or sovereign agent. Runs ERE gate before forwarding.

ParametersJSON Schema

Name	Required	Description	Default
`target`	Yes	Proxy name (from proxy_list) or agent key
`payload`	Yes	Task or query payload

TDQS

A3.5/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Given no annotations, the description must fully disclose behavior. It mentions the ERE gate but does not describe what happens on gate failure, required permissions, side effects, or return behavior. The tool could be destructive or have rate limits, but this is not addressed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two concise sentences, front-loaded with purpose and key operational detail (ERE gate). No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema and no annotations, the description misses critical information like return format, error handling, and the ERE gate's behavior. It is adequate but has clear gaps for a tool that dispatches tasks.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema descriptions for both parameters exist (100% coverage), so the description does not need to add much. The tool description does not add additional meaning beyond what the schema provides, meeting the baseline of 3.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it dispatches a task to a registered proxy tool or sovereign agent, using a specific verb and resource. It mentions the ERE gate, adding operational context, and distinguishes from sibling tools by focusing on dispatching rather than verification or registration.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for sending tasks to proxies or agents, but does not provide explicit guidance on when to use this tool versus alternatives like compute_route or ere_verify. No when-not-to-use or alternative tool mentions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

compute_routeC

Route a query to the best available compute provider (Bedrock → Groq → Ollama). Returns result wrapped in Magma envelope.

ParametersJSON Schema

Name	Required	Description
`agent`	Yes	Agent key: ahmad, forge, oracle, sentinel, vault, enki, nexus, edaulc
`query`	Yes	The question or task to send to the agent
`max_tokens`	No	Max tokens for response (default 1024)

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry the full behavioral burden. It discloses the routing order and return envelope, but omits critical details: error handling (e.g., if all providers fail), authentication requirements, rate limits, or whether the operation is idempotent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is brief (two sentences) with no redundancy. It front-loads the key action and order. One minor improvement would be structuring return format separately, but overall it is efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's role as a router with 3 parameters, no output schema, and a sibling tool (agent_dispatch) that may overlap, the description lacks completeness. It does not explain 'best available', what the Magma envelope is, or how the tool handles unavailability. Error scenarios and return value structure are absent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with clear descriptions for all parameters. However, the description adds little value beyond the schema: it mentions 'query' and 'best available compute provider', but the agent parameter values (e.g., ahmad, forge) are not mapped to providers (Bedrock, Groq, Ollama), creating a semantic gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool routes a query to a compute provider with a specified fallback order (Bedrock → Groq → Ollama), and it specifies the return format (Magma envelope). This distinguishes it from siblings like ere_verify or proxy_register, which have different purposes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no explicit guidance on when to use this tool versus alternatives (e.g., agent_dispatch). It does not mention prerequisites, when-not-to-use, or trade-offs, leaving the agent to infer usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

ere_verifyB

Run ERE 5-pass verification on a content string. Returns pass/fail per pod and METATRON certification.

ParametersJSON Schema

Name	Required	Description	Default
`content`	Yes	Content to verify
`filepath`	No	Filepath hint for language detection (e.g. "foo.ts")

TDQS

B3.2/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It does not disclose behavioral traits like side effects, required permissions, rate limits, or whether it's a read-only operation. The phrase '5-pass verification' implies a process but no details about implications.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is very concise: two sentences, front-loaded with the action and then the result. No superfluous words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema, but the description lists return values. However, key context is missing: what is '5-pass verification', 'pods', and 'METATRON certification'? For a complex tool, this is insufficient for an agent to fully understand the tool's behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so both parameters are described in the schema. The description adds no additional meaning beyond the schema; it mentions the overall process but not parameter specifics. Baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('Run ERE 5-pass verification'), the resource ('content string'), and the outcome ('Returns pass/fail per pod and METATRON certification'). It is specific and distinguishes from siblings like 'compute_route' or 'magma_seal'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is given on when to use this tool versus alternatives (e.g., other siblings) or when not to use it. The description lacks any contextual usage notes.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

governor_pubkeyA

Return the governor public key (base64 Ed25519 SPKI DER). Use this to verify Magma envelope signatures externally.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, but description discloses return format and usage context. For a simple read-only key retrieval, it is sufficiently transparent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences with no filler: first states return value, second states usage. Efficient and front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema, but description fully explains what is returned (base64 key). No complex behavior, so description is complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters, so baseline 4 per guidelines. Description adds no parameter info as none exist.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states it returns the governor public key in base64 Ed25519 SPKI DER format and its purpose (verifying Magma envelope signatures). Distinguishes from siblings like ere_verify which likely does verification but doesn't return a key.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly says 'Use this to verify Magma envelope signatures externally.' Provides clear context for when to use, though no explicit when-not-to-use or alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

magma_execA

Execute a Magma instruction string. Parses §VERB:AGENT:ACTION{payload}, routes to the correct executor (COMPUTE→Bedrock, QUERY→Groq, SEAL→WORM, DISPATCH→proxy), signs result with governor Ed25519 key, and returns Magma envelope. Supports pipeline syntax with >>.

ParametersJSON Schema

Name	Required	Description	Default
`verify_sig`	No	Optional: base64 Ed25519 sig to verify against instruction before executing
`instruction`	Yes	Magma instruction: §VERB:AGENT:ACTION{payload} or pipeline with >>

TDQS

A3.9/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full transparency burden. It discloses signing with Ed25519 key, routing details, pipeline syntax, and envelope return. However, it omits safety warnings about potential destructive actions, auth requirements, or error behavior. Adequate but not comprehensive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Four sentences, front-loaded with the main action, no redundant or filler text. Each sentence adds distinct value: parsing, routing, signing, pipeline support.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema and no annotations, the description covers execution flow, routing, signing, and output format (Magma envelope). It lacks prerequisites (e.g., governor key setup) and error handling details. Mostly complete for the complexity level.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema has 100% coverage with basic descriptions. The description adds significant context: explains Magma instruction format (§VERB:AGENT:ACTION{payload}), pipeline syntax (>>), and routing logic based on verb. This goes well beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool executes Magma instructions, explains the parsing of §VERB:AGENT:ACTION{payload}, routing to different executors (COMPUTE→Bedrock, etc.), signing with governor key, and returning a Magma envelope. It distinguishes from siblings like compute_route and magma_seal by covering the full execution lifecycle.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use magma_exec vs sibling tools like compute_route, ere_verify, or proxy_register. The description implies it's for full instruction execution but does not state alternatives or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

magma_sealB

Wrap any content in a Magma envelope with ERE verification and WORM hash.

ParametersJSON Schema

Name	Required	Description	Default
`agent`	Yes	Agent that produced the content
`content`	Yes	Content to seal

TDQS

B3.2/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must carry full burden. It discloses that ERE verification and WORM hashing occur, implying a write operation. However, it omits side effects, permissions, and return behavior, which are important for safe usage.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no filler. It is front-loaded with the core action. However, it could benefit from slightly more detail, but remains efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the simplicity (2 params, no output schema), the description provides an adequate overview. However, for an AI agent to use it vs siblings, more context on when to seal vs compute or verify would improve completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so baseline is 3. The description adds minimal extra meaning: it explains that content is wrapped, but does not elaborate on agent semantics or provide usage tips beyond schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (wrap content in a Magma envelope) and mentions specific processes (ERE verification, WORM hash). It uses a specific verb and resource, distinguishing from siblings like ere_verify which might only verify.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool vs alternatives like ere_verify or magma_exec. The description does not provide context for selection, leaving the agent to infer from the name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

proxy_registerB

ParametersJSON Schema

Name	Required	Description
`url`	Yes	Base URL of the proxy service
`name`	Yes	Unique name for this proxy
`secret`	No	Optional bot secret for internal proxies
`description`	No	What this proxy does

TDQS

B3.4/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided. Description only states registration action, omitting behavioral details like idempotency, overwrite behavior, auth requirements, or failure modes. Insufficient for a registration tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, front-loaded verb, no wasted words. Efficient and to the point.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema, no annotations, 4 params. Lacks context on return value, error handling, uniqueness guarantees, or how agent_dispatch uses the proxy. Incomplete for a complex registration tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with decent field descriptions. Description adds minimal extra meaning ('Register...at a URL'). Falls at baseline 3 given complete schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states action (register), resource (named proxy tool), and mechanism (at a URL). It also ties to sibling agent_dispatch, distinguishing purpose.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Implies usage via 'callable via agent_dispatch,' but no explicit when-to-use or alternatives among siblings. Lacks exclusions or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

7 tool updatesv2.0.0Jul 25, 2026
- First observedagent_dispatch
- First observedcompute_route
- First observedere_verify
- First observedgovernor_pubkey
- First observedmagma_exec
- First observedmagma_seal
- First observedproxy_register

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.6/5.0

Disambiguation4/5

Tools have mostly clear boundaries, but `agent_dispatch` and `compute_route` could be confused for routing tasks, and `magma_exec` is a meta-tool that overlaps with several others. Still, descriptions are detailed enough to differentiate.

Naming Consistency4/5

Names follow a consistent `<system>_<action>` pattern (e.g., `ere_verify`, `proxy_register`) except `compute_route` which reverses the order. Otherwise well-structured.

Tool Count5/5

7 tools cover the core functionality without bloat. Each tool serves a distinct purpose and the set feels well-scoped for a sovereign computation system.

Completeness4/5

Covers primary operations (routing, verification, sealing, dispatch, execution, key retrieval). Missing explicit tools for verifying signatures or listing proxies, but the existing set handles core workflows.

Maintenance

ActivityMaintained

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

mcp-agentcore A
com.geiant
AI governance MCP server for EU AI Act compliance and jurisdiction verification
Legal & Compliance AI & Machine Learning Government Data
32
anotherai
dev.anotherai
MCP server for building and testing AI agents with multi-model experimentation and insights.
Agent Orchestration Autonomous Agents Testing & QA Tools
2
secureflows-mcp A
io.github.michal-lefler
MCP server for secureFlows: token-free URL builders and integration-linting tools for AI agents.
Code Analysis Developer Tools Security
181
mcp A
com.everstake
MCP server connecting AI agents to non-custodial staking data across 130+ networks.
Blockchain Cryptocurrency
1111

Related MCP Servers

mcp-witness
Security Legal & Compliance
edwiniac
A
license
Not graded
quality
D
maintenance
Cryptographic proof of every AI decision. An immutable, verifiable audit trail MCP server.
Updated 2 months ago (2026-07-03 02:24 UTC)
1
MIT
Predicate
Knowledge & Memory AI & Machine Learning RAG Systems
NordicAgents
A
license
Not graded
quality
D
maintenance
An MCP server that provides a self-improving knowledge graph with per-triple provenance and deterministic reasoning, enabling auditable, reproducible, and contradiction-aware answers for AI agents.
Updated a month ago (2026-07-29 08:56 UTC)
61,643
MIT
agent-gate
Autonomous Agents Agent Orchestration
Jott2121
A
license
B
quality
B
maintenance
An MCP server that enforces fail-closed deterministic checks, independent refute-first review, and tamper-evident hash-chained receipts for AI agent outputs before claiming completion.
Updated 18 days ago (2026-08-19 12:07 UTC)
4
3
MIT
QuantaOptima
Security AI & Machine Learning
jdhart81
A
license
Not graded
quality
C
maintenance
MCP server that provides cryptographic audit trails for AI agent actions, making every action tamper-evident via HMAC-SHA256 signed hash chains.
Updated 6 months ago (2026-03-05 00:59 UTC)
Apache 2.0

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/SNAPKITTYWEST/sovereign-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server