Global AI Governance MCP server
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Global AI Governance MCP serverrun a governance inventory check on my AI systems CSV and summarize findings"
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.
gag-mcp: Global AI Governance MCP server (non-authorizing)
Status: v0.1.0. Built and tested locally on the Grok Bot box, Oct 16, 2026. Not published, not deployed, not pushed to GitHub.
gag-mcp lets any MCP-capable assistant (Claude, ChatGPT, Grok, and others) call the real Global AI Governance reference tooling:
Tool | What it does | Upstream code it runs |
| Policy-as-code governance checks on an AI system inventory CSV. Returns findings by severity |
|
| Prepares the digest-listed Decision Pack, verifies its integrity, and returns the manifest, the reference-only handoff, and optional Markdown documents | toolkit |
| Verifies an Agent Trust Passport: schema, semantics, Ed25519 signature, key trust, validity window, and signed revocation |
|
Authority boundary, enforced in code and tests. Every result carries authority_effect: "NONE", the review_boundary text, and human_decision_state: "PENDING_HUMAN_DECISION". Upstream fields that an assistant could paraphrase as an authorization are relabeled, with their values left verbatim:
operating_disposition→reference_policy_dispositionissued_assessment_result→assessment_result_recorded_in_artifact
The test suite fails if any output contains an authorization-like key, a non-NONE authority effect, conditionally_authorized, or a PERMITTED value outside the relabeled field. All three tools are annotated readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, and each has a title. Both the OpenAI and Anthropic directories require these annotations.
Not affiliated with or endorsed by xAI, OpenAI, or Anthropic. Compatible with MCP-based agents.
Install and run (local)
cd gag-mcp
python3 -m venv .venv && . .venv/bin/activate
pip install -e ".[dev]"
./scripts/fetch_upstreams.sh # read-only clones of the two public repos, pinned
gag-mcp # stdio
gag-mcp --http --port 8000 # Streamable HTTP at http://127.0.0.1:8000/mcp ; GET /health
pytest # 16 tests
python scripts/smoke_test.py --transcript docs/verification-transcript.mdProtocol: the official Python SDK mcp==2.3.0, which speaks MCP 2026-07-28 (the current spec revision). The smoke test also confirms that handshake-era clients (initialize with 2025-06-18 / 2025-11-25) work over HTTP. HTTP mode is stateless with JSON responses, which suits serverless hosts.
Environment variables (HTTP mode):
Var | Purpose |
| Comma-separated Host allow-list (DNS-rebinding protection). Set this on any public host. |
| Comma-separated origins for browser-based clients (e.g., MCP Inspector). Off by default |
| Optional static bearer token for private pilots. This is not OAuth; see "Auth" below |
| Use other checkouts instead of |
| Bind address (defaults |
Related MCP server: io.github.aileron-sh/aileron
Client configuration (copy-paste)
Replace /ABS/PATH/gag-mcp and https://YOUR-HOST with your own values. Remote platforms (ChatGPT, the Claude API and claude.ai, the OpenAI, Anthropic, and xAI APIs, grok.com) cannot reach stdio or localhost. They need a public HTTPS URL (see "Hosting").
Claude Desktop (local, stdio)
claude_desktop_config.json (Settings → Developer → Edit Config):
{
"mcpServers": {
"gag": {
"command": "/ABS/PATH/gag-mcp/.venv/bin/gag-mcp",
"env": {
"GAG_TOOLKIT_PATH": "/ABS/PATH/gag-mcp/vendor/global-ai-governance-toolkit",
"GAG_AGENTIC_PATH": "/ABS/PATH/gag-mcp/vendor/agentic-ai-governance"
}
}
}
}One-click desktop extension: manifest.json (MCPB manifest_version 0.4) passes mcpb validate. Packing a .mcpb still needs platform-specific dependency bundling (cryptography has native wheels). Consider switching to the uv server type. Not yet tested in Claude Desktop.
Claude.ai / Claude Desktop / mobile (remote custom connector)
Settings → Connectors → Add custom connector → URL https://YOUR-HOST/mcp. No auth is needed for this public, no-user-data server. Which plans can add custom connectors: unverified; check the Claude Help Center.
Anthropic Messages API (MCP connector)
curl https://api.anthropic.com/v1/messages \
-H "content-type: application/json" -H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" -H "anthropic-beta: mcp-client-2026-09-15" \
-d '{
"model": "CLAUDE_MODEL_ID", "max_tokens": 1500,
"messages": [{"role": "user", "content": "Use gag to check the sample AI inventory and summarize the critical findings."}],
"mcp_servers": [{"type": "url", "name": "gag", "url": "https://YOUR-HOST/mcp"}],
"tools": [{"type": "mcp_toolset", "mcp_server_name": "gag"}]
}'(mcp-client-2025-11-20 is the previous header. Add "authorization_token" to the server entry if you enable a bearer token.)
OpenAI Responses API (remote MCP tool)
curl https://api.openai.com/v1/responses \
-H "content-type: application/json" -H "authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "OPENAI_MODEL_ID",
"input": "Use gag to verify the signed-revoked example passport and explain the result.",
"tools": [{
"type": "mcp", "server_label": "gag", "server_url": "https://YOUR-HOST/mcp",
"allowed_tools": ["check_inventory", "build_decision_pack", "validate_passport"],
"require_approval": "never"
}]
}'(Add "authorization": "TOKEN" if a bearer token is enabled. For a server that is never exposed publicly, OpenAI documents a Secure MCP Tunnel (tunnel_id). That path is untested here.)
ChatGPT (developer mode / custom app)
Enable developer mode (workspace admin on Business/Enterprise/Edu; Pro users get read/fetch MCP only, per OpenAI Help). Then create an app or connector with MCP server URL https://YOUR-HOST/mcp and authentication "None". All three tools are read-only. Exact menu labels change often, so they are unverified. Public listing goes through the OpenAI plugin submission portal.
xAI Grok API (remote MCP tool)
curl https://api.x.ai/v1/responses \
-H "content-type: application/json" -H "authorization: Bearer $XAI_API_KEY" \
-d '{
"model": "GROK_MODEL_ID",
"input": "Use gag to run check_inventory on the sample and list critical findings.",
"tools": [{
"type": "mcp", "server_label": "gag", "server_url": "https://YOUR-HOST/mcp",
"server_description": "Non-authorizing AI governance checks (authority_effect NONE)",
"allowed_tools": ["check_inventory", "build_decision_pack", "validate_passport"]
}]
}'xAI supports only Streamable HTTP or SSE; require_approval is not supported. In the xAI Python SDK, use mcp(server_url=..., server_label="gag", allowed_tool_names=[...]).
Grok (grok.com consumer connectors)
grok.com/connectors → New Connector → Custom → enter https://YOUR-HOST/mcp. The server must be reachable on the public internet.
Auth
Local stdio: no auth. The MCP spec says stdio servers take credentials from the environment.
Public demo endpoint: no auth is acceptable. The tools are read-only, process only caller-supplied data, and store nothing. Anthropic's directory allows no-auth for servers without user-specific data.
Private pilots:
GAG_MCP_BEARER_TOKENworks with the API connectors (authorization/authorization_tokenfields).OAuth 2.1: only needed if a hosted version ever holds per-user data. The MCP spec then requires Protected Resource Metadata (RFC 9728) plus an authorization server. Not implemented.
Hosting (needed for every remote platform; nothing has been deployed)
Option | Cost (per provider docs, Oct 2026) | Fit |
Cloudflare Quick Tunnel ( | Free, no account | Demos only. Random temporary URL; xAI's own cookbook uses this pattern |
Render free web service ( | $0; 512 MB; spins down after 15 min idle (about 1 min cold start) | Cheapest always-addressable URL; cold starts may time out some clients (unverified) |
Google Cloud Run ( | Free tier of 2M requests/month; billing account required | Recommended for directory submission. Scales to zero, HTTPS, custom domain |
Directory submissions also need a stable HTTPS domain the owner controls (ideally on a GAG domain), a published privacy policy and terms (drafts in docs/), a support contact, and, for OpenAI, domain verification at /.well-known/openai-apps-challenge.
Privacy note: a hosted endpoint changes the toolkit's "LOCAL · NO UPLOAD" promise for that mode. Label it clearly, and keep stdio as the private default.
Files
src/gag_mcp/core.py: transport-independent logic plus the authority envelopesrc/gag_mcp/server.py: MCP server (stdio and Streamable HTTP,/health, CORS, optional bearer)tests/: 16 tests (core behavior, determinism, fail-closed input, non-authorizing invariants, in-process, stdio, and HTTP transports, bearer enforcement)scripts/smoke_test.py,docs/verification-transcript.md: real-client verificationscripts/fetch_upstreams.sh: pinned upstream clonesmanifest.json: MCPB desktop-extension manifest (validated, not packed)deploy/Dockerfile: container for a remote host (not built)docs/PRIVACY-DRAFT.md,docs/TERMS-DRAFT.md: drafts for owner review
Known limits
Tool calls are synchronous and use process-global stdout redirection, so they are fine for low traffic. Add a worker pool before heavy use.
validate_passportwith caller-supplied JSON can't run full evidence-bundle binding checks, because no bundle is accepted over MCP yet. The output says this.The agentic validator is an experimental alpha, and toolkit
mainis ahead of tag v2.3.0. Pin to tags before publishing.
Support and contact
Questions, integrations, and pilot requests: GitHub Discussions. Security issues: see the Global AI Governance security policy.
License
Apache-2.0. See LICENSE. The pinned upstream repositories fetched by scripts/fetch_upstreams.sh keep their own licenses (toolkit: MIT; agentic: Apache-2.0). gag-mcp is compatible with MCP-based agents. It is not affiliated with or endorsed by any model provider.
Available Tools
3 toolsbuild_decision_packPrepare a Decision Pack for human reviewARead-onlyIdempotent
Run the toolkit pipeline and return the Decision Pack manifest (files + SHA-256 digests), the integrity-check result, and the reference-only handoff. include_documents=true also returns the Markdown documents for the decision-maker. The pack prepares a decision; it is not the decision.
| Name | Required | Description | Default |
|---|---|---|---|
| use_sample | No | Run the toolkit's synthetic sample inventory instead of caller CSV. | |
| inventory_csv | No | AI system inventory as CSV text with a header row (toolkit template columns: system_id, system_name, owner, ... evidence_complete). Max 1 MB. Omit when use_sample is true. | |
| evaluation_time | No | Optional fixed UTC time (ISO 8601, e.g. 2026-10-16T00:00:00Z) for byte-reproducible output. | |
| include_documents | No | Also return the Markdown documents for the decision-maker (each capped at 20,000 chars). |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds genuinely useful behavioral context: what the tool returns (manifest with SHA-256 digests, integrity-check result, reference-only handoff), that include_documents expands the payload, and that document output is capped. It does not contradict the annotations; idempotence is even reinforced by this framing, though not stated outright.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, front-loaded with the core action, and the distinguishing scope clause is placed at the end for emphasis. Tight and purposeful, though the document-inclusion detail slightly duplicates the schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be enumerated, yet the description helpfully summarizes the manifest + integrity-check + handoff shape. All 4 params are covered by the schema. The main gap is the absence of routing guidance against siblings, which a complete definition of this pipeline entry point should include.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all four parameters, including the 1 MB CSV cap and the ISO 8601 format expectation. The description adds only the include_documents behavior, which is already in the schema's property description, so it adds no meaning beyond structured fields. Baseline 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and a distinctive resource ('Run the toolkit pipeline and return the Decision Pack manifest'), and the closing line 'The pack prepares a decision; it is not the decision' establishes a purpose scope that clearly separates it from validate_passport and check_inventory.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage ('prepare a decision for human review') but never states when to use this tool versus check_inventory or validate_passport, nor any prerequisites such as first validating the inventory CSV.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
check_inventoryCheck AI inventory for governance gapsARead-onlyIdempotent
Run the Global AI Governance toolkit's policy-as-code checks on an AI system inventory CSV (toolkit template columns) and return findings by severity. Set use_sample=true to run the synthetic sample. Output is non-authorizing (authority_effect NONE).
| Name | Required | Description | Default |
|---|---|---|---|
| use_sample | No | Run the toolkit's synthetic sample inventory instead of caller CSV. | |
| inventory_csv | No | AI system inventory as CSV text with a header row (toolkit template columns: system_id, system_name, owner, ... evidence_complete). Max 1 MB. Omit when use_sample is true. | |
| evaluation_time | No | Optional fixed UTC time (ISO 8601, e.g. 2026-10-16T00:00:00Z) for byte-reproducible output. |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds genuinely new behavioral context beyond that: output is non-authorizing with authority_effect NONE, results are bucketed by severity, and a sample path exists. It stops short of describing pagination or how findings are structured.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two compact sentences, with the core action front-loaded before the sample-mode hint and the non-authorization caveat. Nothing is padding, though the parenthetical 'toolkit template columns' is somewhat redundant with the schema and the sentence is dense enough to be slightly hard to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need no prose explanation, and the description still covers the two input modes, the expected CSV shape, and the non-authorizing nature of the result. What remains missing is only minor: no explicit routing guidance against sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all three parameters, including the CSV column list, the 1 MB limit, and the ISO 8601 evaluation_time format. The description restates use_sample and the CSV template columns without adding syntax or format detail beyond the schema, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description gives a specific verb+resource: run policy-as-code checks from the Global AI Governance toolkit against an AI system inventory CSV, returning findings by severity. That is concrete and unambiguous. It does not, however, contrast itself with the siblings build_decision_pack or validate_passport, so an agent gets no explicit differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the described scenario (governance gap checking on an inventory) and the description notes 'Set use_sample=true to run the synthetic sample', which tells the agent one operating mode. There is no explicit when-to-use/when-not guidance relative to validate_passport or build_decision_pack, and no stated prerequisites for the CSV.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
validate_passportVerify an Agent Trust PassportARead-onlyIdempotent
Verify an Agent Trust Passport (agentic-ai-governance reference validator): schema, semantics, Ed25519 signature, key trust, validity window, and signed revocation. Use example='signed-unrevoked' or 'signed-revoked' for synthetic demos, or pass passport_json and trusted_key_json (and optionally revocation_list_json) as JSON strings. Verification is not authorization (authority_effect NONE).
| Name | Required | Description | Default |
|---|---|---|---|
| at_time | No | Evaluation time, UTC ISO 8601. Defaults to the example's fixed time or now. | |
| example | No | Synthetic demo passport (test-only keys). Omit to verify caller-supplied JSON. | |
| passport_json | No | Agent Trust Passport as a JSON string. | |
| trusted_key_json | No | Trusted Ed25519 verification key as a JSON string (required with passport_json). | |
| revocation_list_json | No | Signed revocation list as a JSON string (optional). |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds genuinely useful context beyond that: the demo keys are test-only synthetic keys, and critically that 'Verification is not authorization (authority_effect NONE)', which prevents an agent from misusing the result.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Purpose and scope are front-loaded in the first clause, followed by mode guidance and the authorization caveat. It is a dense single block but every sentence carries information; a list-style breakdown would read more cleanly, hence not a 5.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need no explanation, and annotations cover the safety profile. The description covers purpose, modes, required parameter combinations, and the important non-authorization caveat. It does not describe failure/error behavior, which leaves a minor gap for a verification tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds value by explaining the parameter relationships in prose: which parameters pair together (passport_json with trusted_key_json), that revocation_list_json is optional, and that passing example bypasses caller-supplied JSON. That is more than the raw schema conveys.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (verify) and resource (Agent Trust Passport) and enumerates precisely what is checked: schema, semantics, Ed25519 signature, key trust, validity window, and signed revocation. This distinguishes it clearly from the unrelated siblings check_inventory and build_decision_pack.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives two clear invocation modes and the condition that selects each: use example='signed-unrevoked'/'signed-revoked' for synthetic demos, or pass passport_json (with trusted_key_json, optionally revocation_list_json) for real input. It does not state when NOT to use it or compare against siblings, but the sibling set is unrelated, so a 4 is appropriate.
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.
3 tool updates
v0.1.0- First observed
build_decision_pack - First observed
check_inventory - First observed
validate_passport
TDQS
Scored across 3 tools
Each tool targets a distinct artifact and action: checking an AI inventory CSV, building a Decision Pack, and verifying an Agent Trust Passport. There is no meaningful overlap in purpose or inputs, so an agent can select correctly without hesitation.
All three names follow a clean snake_case verb_noun pattern (check_inventory, build_decision_pack, validate_passport). The convention is applied uniformly with no style drift.
Three tools is on the lean side for a server with a broad 'Global AI Governance' name, but each tool represents a substantial, self-contained workflow. It is slightly under-scoped rather than padded, which is acceptable.
The surface covers the core verification/assessment workflows (inventory policy checks, decision packaging, passport validation) with clear non-authorizing semantics. It lacks any authoring or lifecycle operations (e.g., generating inventories or issuing passports), but those may fall outside the server's reference-toolkit scope.
Maintenance
Related MCP Connectors
Read-only Remote MCP for externally grounded AI agent trust receipts.
Find governed AI capabilities and verify signed receipts. Read-only, no account.
Read-only MCP tools for AI agent discovery, structured resources, and NIULAI information.
Read-only checks for proposed orders against evidence and policy; no trading or payment authority.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables AI clients to perform safe, read-only IT diagnostics and retrieve local runbooks, asset records, and knowledge articles through MCP, with allowlisted network checks and audit logging.MIT
- AlicenseNot gradedqualityBmaintenanceEnables assistants to inspect tamper-evident AI agent action journals through read-only verification, event querying, and policy-rule explanation.113 PyPI1Apache 2.0
- AlicenseBqualityCmaintenanceEnables MCP-compatible agents to perform read-only incident investigations by querying logs, building timelines, searching runbooks, validating evidence, and creating ticket drafts only with explicit approval.7MIT
- AlicenseNot gradedqualityAmaintenanceEnables free, read-only checks of AI agents and MCP servers for conformance, published changes, delivery evidence, and verifiable receipts without requiring an account or API key, using public or non-personal data only.MIT