Skip to main content
Glama
GLOBAL-AI-GOVERNANCE

Global AI Governance MCP server

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

check_inventory

Policy-as-code governance checks on an AI system inventory CSV. Returns findings by severity

global-ai-governance-toolkit run_pipeline (pinned cf906ef)

build_decision_pack

Prepares the digest-listed Decision Pack, verifies its integrity, and returns the manifest, the reference-only handoff, and optional Markdown documents

toolkit run_pipeline + verify_output_directory

validate_passport

Verifies an Agent Trust Passport: schema, semantics, Ed25519 signature, key trust, validity window, and signed revocation

agentic-ai-governance tools/validate_artifact.py (pinned 2124aea)

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_disposition

  • issued_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.md

Protocol: 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

GAG_MCP_ALLOWED_HOSTS

Comma-separated Host allow-list (DNS-rebinding protection). Set this on any public host.

GAG_MCP_CORS_ORIGINS

Comma-separated origins for browser-based clients (e.g., MCP Inspector). Off by default

GAG_MCP_BEARER_TOKEN

Optional static bearer token for private pilots. This is not OAuth; see "Auth" below

GAG_TOOLKIT_PATH, GAG_AGENTIC_PATH

Use other checkouts instead of vendor/

HOST, PORT

Bind address (defaults 127.0.0.1:8000)

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_TOKEN works with the API connectors (authorization / authorization_token fields).

  • 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 (cloudflared tunnel --url http://localhost:8000)

Free, no account

Demos only. Random temporary URL; xAI's own cookbook uses this pattern

Render free web service (deploy/Dockerfile)

$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 (deploy/Dockerfile)

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 envelope

  • src/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 verification

  • scripts/fetch_upstreams.sh: pinned upstream clones

  • manifest.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_passport with 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 main is 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 tools
build_decision_packPrepare a Decision Pack for human reviewA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
use_sampleNoRun the toolkit's synthetic sample inventory instead of caller CSV.
inventory_csvNoAI 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_timeNoOptional fixed UTC time (ISO 8601, e.g. 2026-10-16T00:00:00Z) for byte-reproducible output.
include_documentsNoAlso return the Markdown documents for the decision-maker (each capped at 20,000 chars).

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A3.9/5.0
Behavior4/5

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.

Conciseness4/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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 gapsA
Read-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).

ParametersJSON Schema
NameRequiredDescriptionDefault
use_sampleNoRun the toolkit's synthetic sample inventory instead of caller CSV.
inventory_csvNoAI 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_timeNoOptional fixed UTC time (ISO 8601, e.g. 2026-10-16T00:00:00Z) for byte-reproducible output.

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A3.7/5.0
Behavior4/5

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.

Conciseness4/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines3/5

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 PassportA
Read-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).

ParametersJSON Schema
NameRequiredDescriptionDefault
at_timeNoEvaluation time, UTC ISO 8601. Defaults to the example's fixed time or now.
exampleNoSynthetic demo passport (test-only keys). Omit to verify caller-supplied JSON.
passport_jsonNoAgent Trust Passport as a JSON string.
trusted_key_jsonNoTrusted Ed25519 verification key as a JSON string (required with passport_json).
revocation_list_jsonNoSigned revocation list as a JSON string (optional).

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4.3/5.0
Behavior4/5

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.

Conciseness4/5

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.

Completeness4/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

  1. 3 tool updatesv0.1.0
    • First observedbuild_decision_pack
    • First observedcheck_inventory
    • First observedvalidate_passport

TDQS

A4.1/5.0

Scored across 3 tools

Disambiguation5/5

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.

Naming Consistency5/5

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.

Tool Count4/5

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.

Completeness4/5

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

ActivityMaintained
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    C
    maintenance
    Enables 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
  • A
    license
    Not graded
    quality
    B
    maintenance
    Enables assistants to inspect tamper-evident AI agent action journals through read-only verification, event querying, and policy-rule explanation.
    113 PyPI
    1
    Apache 2.0
  • A
    license
    B
    quality
    C
    maintenance
    Enables 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.
    7
    MIT
  • A
    license
    Not graded
    quality
    A
    maintenance
    Enables 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