AGTS MCP Server

com.obligationsign.mcpPublished by mcp.obligationsign.comOfficial publisherv1.0.2Updated Oct 25, 2026

Sovereign MCP Gateway — 64 governed tools with Merkle transparency log. EU AI Act ready.

VerifiedStreamable HTTPWeb executableCloud & InfrastructureKnowledge & MemorySecurity & Monitoring

Overview

AI-generated overview

A remote, OAuth-protected governance gateway that routes an assistant's tool calls through a five-gate firewall and records them in a signed, Merkle-anchored, O

What you can do
Governance: submit actions for pre-execution gate evaluation, verify commitments with Merkle proofs, report outcomes, and manage policies and statistics. Identity and peer trust: register agent identities, scan skills, and run post-quantum peer authentication and credential exchange. Communications and storage: send encrypted mail, read inboxes, and upload, list, share, download or delete files. Memory: store, recall, search and consolidate hierarchical memory entries with TTL and garbage collection. Billing and orchestration: provision billing projects, set budget alerts, and spawn, chain and merge sub-agents. Infrastructure: manage VPN tunnels, DNS queries, health probes and alert checks.
When to use it
For teams that need an auditable, cryptographically verifiable record of what an AI agent was authorized to do and what it actually did, especially in regulated settings where EU AI Act, GDPR, SOC 2 or similar controls are cited. It suits agent workflows that need governed mail, encrypted file storage, agent identity, memory and sub-agent delegation behind one gateway.
Requirements
A remote streamable HTTP endpoint; no local package. An ObligationSign account and a Bearer token obtained by registering on the provider's platform, sent in the Authorization header. Network access to the provider's endpoint.
Before you install
The gateway requires a Bearer token in the Authorization header; treat it as a secret. Tools can send mail, upload, share and delete files, change governance policies, freeze or unfreeze spending, and launch sub-agents, so writes and spending changes are possible. Content and actions pass through the provider's hosted service and its transparency log, which is append-only and designed to be permanent.

Installation

In SourceWeft

  1. Open AGTS MCP Server in the dashboard and add it to a workspace.
  2. Connect the required credentials. They are stored privately and never shown on public pages.
  3. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/com.obligationsign.mcp%2Fagts-mcp/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config. The client completes OAuth sign-in on first connect.

{
  "mcpServers": {
    "agts": {
      "type": "http",
      "url": "https://mcp.obligationsign.com/mcp"
    }
  }
}

README

AGTS MCP Server

Sovereign MCP Gateway — Governed Tool Invocation for Autonomous Agents

Model Context Protocol server that turns tool calls into cryptographically authorized, verifiable actions. 115+ governed tools across 6 layers — hybrid Ed25519 + SLH-DSA signed and Merkle-anchored. Designed to support EU AI Act, GDPR, SOC 2, ISO 27001, DORA, NIS2, and FINRA compliance.

Server URL

https://mcp.obligationsign.com/mcp
TransportURLStatus
Streamable HTTP (primary)https://mcp.obligationsign.com/mcpActive
SSE (deprecated)https://mcp.obligationsign.com/mcp/sseDeprecated

Authentication

The gateway requires a Bearer token issued through the ObligationSign platform. All requests must include an Authorization header.

To obtain a token, register at obligationsign.com/start/.

Quick Start

Claude Desktop / Cursor / Windsurf

Add to your MCP configuration:

json
{  "mcpServers": {    "agts": {      "url": "https://mcp.obligationsign.com/mcp",      "headers": {        "Authorization": "Bearer YOUR_TOKEN"      }    }  }}

Programmatic (JSON-RPC over HTTP)

bash
curl -X POST https://mcp.obligationsign.com/mcp \  -H "Content-Type: application/json" \  -H "Authorization: Bearer YOUR_TOKEN" \  -d '{    "jsonrpc": "2.0",    "id": 1,    "method": "tools/list",    "params": {}  }'

What is AGTS?

AGTS (Autonomous Governance Transparency Standard) is a transparency-backed governance protocol that converts validated machine decisions into append-only cryptographic records, independently verified by a network of witnesses and monitors.

decision → record → immutable history → verifiable truth

Every tool call passes through a five-gate firewall (Statistical, Causal, Regression, Evidence, Human-Compatible Explanation) before execution. Admitted actions are Merkle-anchored into an append-only transparency log and signed with hybrid post-quantum cryptography.

Cryptography & Validator Quorum

Every governance envelope produced by this server is signed with a hybrid post-quantum signature: classical Ed25519 in parallel with SLH-DSA-SHAKE-128f. The signature is verifiable today with Ed25519-only tooling and remains forgery-resistant against future quantum adversaries via SLH-DSA. Sovereign Mail additionally uses ML-KEM-512 for encrypted key exchange, and peer-trust ceremonies use ML-DSA-44.

Admit decisions for governed tool calls require an independent 3-of-4 validator quorum with constraint regulator_count ≥ 1 and auditor_count ≥ 1. Validators are deployed as separate Cloudflare Workers (agts-validator-{a,b,c,d}) with distinct ECDSA P-256 keypairs; each validator independently re-evaluates the proof bundle and signs an AGTS_VOTE_V1 certificate. The quorum certificate is then anchored alongside the governance envelope in the Merkle transparency log, so any external party can reconstruct the four signed votes and verify that quorum was honestly met.

Tool Catalog (115+ Tools)

Layer 1 — Infrastructure

VPN & Network
ToolDescription
create_tunnelEstablish an attested VPN tunnel (WireGuard/IPSec/TLS)
tunnel_statusMonitor uptime, transfer bytes, and attestation status
disconnect_tunnelTerminate session and log the event
dns_querySecure DNS resolution through the Sovereign resolver
Monitor
ToolDescription
system_healthProbe all mesh workers for status and latency
check_alertsFetch the monitor alert timeline
subscribe_alertsWebhook subscription for real-time alerts
check_equivocationsFetch conflicting Signed Tree Head proofs
gossip_statusCurrent state of gossip protocol and monitor identity

Layer 2 — Identity & Communications

Sovereign Mail
ToolDescription
send_sovereign_mailSend encrypted (internal) or plaintext (external) messages
list_inboxList message metadata from an inbox
read_messageRetrieve full message content by ID
lookup_recipient_keysRetrieve public keys (ECDH P-384 / ML-KEM-512)
Sovereign Drive
ToolDescription
upload_fileClient-side encrypted upload with integrity anchoring
list_filesList file metadata, sizes, and sharing status
download_fileRetrieve ciphertext for client-side decryption
share_fileShare files using ECDH key wrapping
delete_fileRemove a file and create a death leaf in the log
OpenClaw (Agent Identity)
ToolDescription
register_clawCreate a cryptographic Claw Passport and identity keys
scan_skillScan agent skills through the five-gate firewall
claw_statusReturn trust score, governance history, and quota
export_passportSecure export of the identity envelope
govern_skill_execHigh-level gate for skill execution
report_skill_executionLink skill results to authorization
verify_skill_proofCryptographic verification of skill scans
Peer Trust (Post-Quantum)
ToolDescription
authenticate_peerHybrid PQC (ML-DSA-44) + Classical (ECDSA) auth ceremony
verify_agent_identityFingerprint and revocation check via key registry
exchange_credentialsSecure transport using hybrid ECDH + ML-KEM-512
peer_trust_networkList known peers and mutual trust status

Layer 3 — Governance

ToolDescription
submit_governancePre-execution gate evaluation (ADMIT/QUARANTINE/REFUSE)
verify_commitmentVerify commitment in transparency log with Merkle proofs
report_executionLog outcome of an authorized action
update_policyUpdate firewall parameters
list_policiesList active governance thresholds and history
governance_reportAggregated decision reporting
governance_statsPer-gate pass/fail statistics and HCE distribution
gate_analysisDetailed breakdown of a specific evaluation decision

Layer 4 — Memory

ToolDescription
memory_storeStore hierarchical key-value entries
memory_recallRetrieve specific entries by path
memory_listPrefix-based listing of memories
memory_searchSemantic similarity search using vector embeddings
cross_session_recallSemantic search across historical sessions
memory_contextMode-based contextual summary
consolidate_memoryCompare and compact redundant entries
memory_gcGarbage collection of stale entries
set_memory_ttlConfigure automatic expiration for entries
memory_deleteRemove specific memory paths

Layer 5 — Billing

ToolDescription
provision_resourceCreate a billing project for an agent
manage_spendingFreeze/unfreeze spending
check_project_billingDetailed usage and charge breakdown
verify_provisionCheck billing project linkage
set_budget_alertConfigure spending thresholds
check_budgetReal-time spend vs. cap tracking

Layer 6 — Orchestration

ToolDescription
spawn_sub_agentLaunch an isolated asynchronous sub-agent
sub_agent_statusPoll sub-agent execution status
sub_agent_resultRetrieve sub-agent results
chain_delegationRecursive delegation with budget decay and depth limits
create_templateDefine a reusable multi-step workflow
apply_templateInstantiate a template into a running task
list_sub_agentsList active sub-agents
list_templatesList available workflow templates
cancel_sub_agentTerminate a running sub-agent
merge_sub_resultsAggregate results from parallel sub-agents
delegation_treeReconstruct the full lineage of a delegated chain

REST API

In addition to MCP, the gateway exposes REST endpoints:

EndpointDescription
GET /api/v1/healthUpstream service health checks
GET /api/v1/auditAudit log queries
GET /api/v1/assetsAsset management
GET /verify?commitment={hash}Commitment verification with Merkle proof

Architecture

The MCP server is one access surface to the AGTS protocol. The full clearinghouse specification is published separately.

Agent ─── MCP Gateway ─── Five-Gate Firewall ─── Transparency Log               │                                        │               ├── Mail Worker (E2EE)                   ├── Merkle Tree               ├── Drive Worker (Encrypted Storage)     ├── Signed Tree Heads               ├── OpenClaw (Identity)                  └── Gossip Protocol               ├── Tunnel Worker (VPN)               ├── Monitor Worker (Health)               └── Protocol Worker (Governance)

How This Server Differs

Most MCP servers in the ecosystem (~83%) are thin API wrappers — a single connector exposed as one or two tools, running locally via stdio, with no authentication or validation. The production-tier servers from vendors like GitHub, Slack, and AWS (~2%) are well-built but architecturally simple: they translate tools/call into API requests for their own service.

This server operates at a different level. It is not a wrapper around an external API — it implements a full governance protocol where:

  • Every action must pass through five evaluation gates before execution is authorized
  • Admitted actions are cryptographically signed (hybrid Ed25519 + SLH-DSA) and Merkle-anchored in an append-only transparency log
  • Execution outcomes are traced back to their authorization, creating a closed governance loop
  • Independent monitors verify log consistency through a gossip protocol, detecting equivocation or tampering
  • Identity is handled through post-quantum cryptography (ML-DSA-44, ML-KEM-512) for forward security

The result is that every tool call produces independently verifiable cryptographic evidence of what was authorized, what was executed, and whether the outcome matched the authorization — the kind of audit trail required in regulated industries (financial services, healthcare, legal, critical infrastructure).

Regulatory Readiness

The gateway's architecture is designed to support compliance across multiple regulatory frameworks. The table below maps specific requirements to the AGTS features that address them.

EU AI Act
RequirementAGTS Implementation
Art. 9 — Risk managementFive-gate firewall evaluates every action before execution; QUARANTINE decisions enable human intervention
Art. 12 — Record-keepingAppend-only Merkle transparency log with signed governance envelopes; automatic recording of every authorization and execution event
Art. 13 — TransparencyEvery commitment is independently verifiable with cryptographic inclusion proofs; governance decisions are explainable via the HCE (Human-Compatible Explanation) gate
Art. 14 — Human oversightGate thresholds are configurable; QUARANTINE/REFUSE decisions halt execution; policy updates are themselves governed and logged
SOC 2
Trust PrincipleAGTS Implementation
SecurityHybrid Ed25519 + SLH-DSA signing; post-quantum key exchange (ML-KEM-512); Cloudflare Access authentication with email binding; per-tool rate limiting
AvailabilityMulti-worker mesh architecture with independent health monitoring; gossip protocol detects node failures; system_health probes all upstream services
Processing IntegrityFive-gate firewall validates every action before execution; execution outcomes are traced back to authorization; variance detection on deviated outcomes
ConfidentialityEnd-to-end encrypted mail (ECDH P-384 key wrapping); client-side encrypted drive storage; attested VPN tunnels for network isolation
PrivacyNo plaintext storage of message content; cryptographic identity via Claw Passport; key registry with revocation support
ISO 27001
Control AreaAGTS Implementation
A.8 — Asset managementEvery file, message, and identity key is tracked with cryptographic hashes; death leaves record asset deletion
A.9 — Access controlBearer token authentication; Cloudflare Access email binding; per-agent identity via Claw Passport with trust scoring
A.10 — CryptographyHybrid classical + post-quantum signing (Ed25519 + SLH-DSA); PQC key exchange (ML-KEM-512); ECDH P-384 for mail encryption
A.12 — Operations securityImmutable transparency log; independent monitor workers verify log consistency via gossip protocol; equivocation detection
A.16 — Incident managementAlert subscription system; equivocation checks detect conflicting Signed Tree Heads; governance variance records track deviations
A.18 — ComplianceAll governance decisions, policy changes, and execution outcomes are cryptographically anchored; audit trail is independently verifiable
DORA (Digital Operational Resilience Act)
RequirementAGTS Implementation
Art. 6 — ICT risk managementFive-gate firewall performs pre-execution risk evaluation; gate thresholds are configurable per policy; governance stats provide per-gate pass/fail analytics
Art. 9 — DetectionMonitor workers continuously probe service health; gossip protocol detects inconsistencies; alert subscriptions enable real-time incident notification
Art. 10 — Response and recoveryQUARANTINE decisions halt risky operations; manage_spending can freeze agent budgets; execution tracing links failures to their authorization
Art. 11 — TestingEvery governance decision is independently verifiable via Merkle inclusion proofs; verify_commitment enables third-party audit at any time
Art. 15 — Third-party riskSub-agent delegation enforces budget decay and depth limits; chain_delegation tracks recursive delegation lineage; delegation_tree reconstructs full provenance
GDPR
RequirementAGTS Implementation
Art. 5(1)(a) — Lawfulness, fairness, transparencyEvery agent action is pre-authorized through the five-gate firewall; governance decisions include HCE (Human-Compatible Explanation) for explainability
Art. 5(1)(e) — Storage limitationmemory_gc garbage collects stale entries; set_memory_ttl enforces automatic expiration; delete_file creates cryptographic death leaves proving deletion
Art. 5(1)(f) — Integrity and confidentialityEnd-to-end encrypted mail and drive storage; hybrid post-quantum cryptography; append-only transparency log ensures integrity
Art. 17 — Right to erasurememory_delete removes specific memory paths; delete_file with death leaf provides verifiable proof of deletion
Art. 25 — Data protection by designCryptographic identity via Claw Passport (no PII required); client-side encryption for stored files; key registry with revocation support
Art. 30 — Records of processing activitiesMerkle transparency log records every authorization, execution, and policy change with timestamps and cryptographic signatures
NIS2
RequirementAGTS Implementation
Art. 21 — Cybersecurity risk managementGovernance firewall, cryptographic signing, transparency log, and post-quantum key exchange form a defense-in-depth architecture
Art. 23 — Incident reportingAlert system with webhook subscriptions; equivocation detection; governance variance records provide forensic evidence chain
Art. 21(2)(d) — Supply chain securitySub-agent orchestration with budget controls and depth limits; delegation tree provides full provenance tracking across agent boundaries
FINRA
RequirementAGTS Implementation
Rule 3110 — SupervisionFive-gate firewall enforces pre-execution supervision of every agent action; QUARANTINE/REFUSE decisions prevent unauthorized transactions
Rule 3120 — Supervisory control systemGovernance stats and gate analysis provide supervisory analytics; policy thresholds are configurable and themselves governed
Rule 4511 — Books and recordsAppend-only Merkle transparency log with Ed25519 + SLH-DSA signed governance envelopes; every authorization and execution is permanently recorded
Rule 3310 — AML compliancesubmit_governance evaluates evidence including value, recipient, and intent before any financial action is authorized; variance detection flags deviations
Rule 2210 — Communicationssend_sovereign_mail with governance pre-authorization ensures all agent communications are reviewed and logged before transmission

The closest comparable in the market is not another MCP server — it is what a regulated enterprise would build internally to control what their AI agents can do in production.

Specification

The normative AGTS Clearinghouse specification is available at:

github.com/obligationsign/agts-clearinghouse

Links

License

This document is published for reference and integration purposes. The MCP server is operated by ObligationSign. See the AGTS Clearinghouse Specification for protocol terms.

Source: README.md at commit b690655

Tools

0
This server asks you to sign in, so SourceWeft could not read its tools without an account and has not indexed them. What a connected account sees can depend on that account and its permissions.

Version history

1
  1. v1.0.2LatestSep 16, 2026

Score

75% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts

    Declare a license in the repository or the registry entry.

Other Obligationsign integrations

AGTS MCP Server

Published by GitHub account ObligationSign

A remote governance gateway whose 115+ tools route agent actions through a five-gate firewall and record them in a signed, Merkle-anchored transparency log.

Streamable HTTPWeb executable
Cloud & InfrastructureNot indexed yetOct 24, 2026