GATE — Live Agent Authority Verification
This MCP server exposes GATE authority verification and status tools for delegated-agent authorization checks.
Verify at effect time whether an AI agent/actor currently has a valid delegated authority path from a principal for an optional action context, returning ALLOW, DENY, or UNKNOWN; UNKNOWN must not permit the protected action.
Pass
principal,actor, optionalactiondetails, requestedconsistency(boundedorstrict), andmaxStalenessMs; Free Developer Preview supports bounded only.Inspect configured verifier mode and operational status for setup checks and troubleshooting; status is not an authorization decision.
Use a configured live GATE endpoint with credentials for network verification, or simulated demo mode; demo mode is not production authority.
Remember that verification alone does not enforce authorization—the trusted execution boundary must enforce the returned decision.
GATE — Authority Verification Network
Stage 17 Developer Preview · Live public adoption
Does a live delegation path from this principal to this actor still exist right now?
GATE is the live authority-state resolver for delegated agents across trust domains.
It resolves whether a currently valid authority path still exists at effect time using live authority state from external trust domains. GATE does not mint a proprietary delegation token, replace OAuth, replace your policy engine, or require MCP.
GATE Stage 17 — current Developer Preview
Current operational boundary: one Canadian primary database, no production regional replicas, and no independent third-party issuer propagation SLA.
maxStalenessMsmeasures primary snapshot age only. The Developer Preview is not enterprise GA.
GATE public product website — launch, Free plans, and supported developer paths.
Independent Free MCP trial — no repository clone — published MCP dev.9, signed grant/revoke, one disposable local effect, and a feedback checklist.
Signed revocation quickstart — actual GATE Network DENY → ALLOW → DENY with a self-controlled ES256 test issuer.
Start with the hosted sandbox — synthetic graph for learning GATE revocation semantics.
Create a real Free GATE Network project — live gate-network with a real API key and managed quota.
Stage 17 has validated real Free onboarding, independent CAEP/SSF revocation interoperability, external problem validation, and Free-to-paid entitlement continuity. GATE remains a Developer Preview: independent adoption and enterprise-scale operation are the next validation targets.
Related MCP server: MCPGate
Where GATE fits
Identity / credentials / policy / issuer systems
|
| authority state + trust signals
v
+-------------------+
| GATE |
| live authority |
| state resolver |
+-------------------+
|
gate.verify()
|
v
trusted effect boundaryGATE complements identity, credential, policy and gateway systems. MCP is one integration surface, not GATE's definition.
The differentiator is not multi-hop alone. It is the combination of live upstream revocation, alternate-path preservation, federated issuer state, freshness semantics and protocol-neutral effect-time resolution.
Read: docs/POSITIONING.md, docs/INTEGRATION-MODEL.md, docs/RELEASE-BOUNDARY.md.
Public Developer Quickstart
GATE exposes two separate onboarding paths.
Sandbox
Use the hosted sandbox to learn GATE semantics on a synthetic authority graph:
https://gate-phi-eosin.vercel.app/quickstart.html
Temporary key: 7 days. Quota: 500 verifications/project/day.
Live Free Network
Canonical endpoint:
https://ufqtoyakmrddqytrkcje.supabase.co/functions/v1/gate-network
Current Free Developer Preview: 50,000 verifications/month, 1 authority issuer, bounded consistency. Strict consistency is not included.
Use GateClient from @gate-avn/sdk. See docs/QUICKSTART.md for the complete live-network flow.
Repository development demo
Requirements: Node.js 20+.
npm install
npm test
npm run demoThe demo calls the public SDK shape:
import { GateClient } from './packages/sdk/dist/index.js';
const gate = new GateClient({ endpoint: process.env.GATE_URL });
const result = await gate.verify({
principal: 'user:jerome',
actor: 'agent:C@company-c',
action: {
protocol: 'mcp',
name: 'delete_customer_data',
resource: 'customer:3456'
},
consistency: 'bounded',
maxStalenessMs: 200
});
if (result.decision !== 'ALLOW') throw new Error(result.reason);What GATE verifies
GATE answers a deliberately narrow question: whether the actor still has at least one live delegation path from the principal, according to sufficiently fresh external authority state.
The public contract separates authority state from application policy. A credential can remain syntactically valid while GATE returns INVALID or UNKNOWN because the authority behind it is no longer live or cannot be established with the requested freshness.
It can return:
VALID / ALLOW— at least one live authority path exists.INVALID / DENY— the known paths are revoked/invalid.UNKNOWN / DENY— freshness or availability is insufficient for the requested consistency contract.
What GATE does not do
GATE is not your business-policy PDP. The action object is carried for integration/audit context in this preview; policy such as "may this principal delete customer 3456?" belongs in AuthZEN, Cedar, OPA, Permit, Cerbos, OpenFGA, or your existing authorization system.
GATE is also not trying to replace OAuth, MCP, A2A, OpenID Federation, Security Event Tokens, Shared Signals, an IdP, or an API/AI gateway. The intended role is to sit underneath/alongside them as a live authority-state resolver.
The Developer Preview does not claim a portable cryptographically signed authority proof. It returns a live resolution result; a signed GATE receipt is a possible future layer, not a current release promise.
Why a network service?
A local verifier can validate signatures, expiry, scopes and token chains. It cannot independently know every external issuer's current revocation state, trust changes, alternate delegation paths, or freshness across domains. GATE's hypothesis is that the defensible value is the shared, low-latency state network — not a secret verification algorithm.
Consistency contracts
bounded: live verification from the canonical primary on v7, with a bounded primary-read snapshot age; regional replicas are not yet deployed.strict: canonical primary-read verification available only to eligible plans; not synchronous confirmation of external issuer systems.
Repository map
packages/sdk/ public developer-facing client
examples/ minimal SDK demonstration
services/ experimental control plane / edge / trust services
src/ PoC verification primitives
mcp/ MCP enforcement harness
test/ SDK + distributed consistency tests
docs/ architecture, integration contract, due diligenceInstall
SDK
npm install @gate-avn/sdk@0.1.0-dev.4Repository Stage 16 baseline: 0.1.0-dev.4
Published SDK version used by the trial: 0.1.0-dev.4.
MCP server
npm install @gate-avn/mcp@0.1.0-dev.9Repository Stage 16 baseline: 0.1.0-dev.8
Published npm @dev: 0.1.0-dev.9; @latest remains 0.1.0-dev.2 (public registry checked 2026-11-02). Pin the trial version explicitly.
The current repository CLI descriptions differ from the published dev.9 archive after PR #24. The trial installs from npm and does not substitute workspace code. Glama indexing and npm publication are separate: discovery is not proof of an independent successful integration.
Official MCP Registry:
io.github.Projetxana/gate-authority-networkStatus
GATE is publicly available as a Developer Preview on npm and in the Official MCP Registry.
The SDK and MCP server are currently installable from the public npm registry. The MCP server is also discoverable through the Official MCP Registry.
The HTTP, x402, AuthZEN, A2A, AP2 and SSF adapters exist in the Stage 16 repository baseline but are not yet published as public npm packages.
This remains experimental Developer Preview software and is not production-ready.
Read next: docs/STAGE17D-EXTERNAL-VALIDATION.md, docs/STAGE17E-FREE-PAID-CONTINUITY.md, docs/DUE-DILIGENCE-2026-10-02.md and docs/PUBLIC-VALIDATION-PLAN.md.
License
Apache-2.0. This repository is intended to make the verification logic easy to inspect and challenge; the long-term product hypothesis is the shared live authority network, not proprietary verifier code.
Available Tools
2 toolsgate_statusGATE statusARead-onlyIdempotent
Inspect the configured GATE verifier mode and operational status. Use this tool for setup checks and troubleshooting, not to authorize an action. In demo mode, it reports the local simulated authority graph. In network mode, it requests the configured endpoint health information. A healthy response does not prove that an actor has permission to act. Use gate_verify at the trusted effect boundary for authority decisions. If the status request fails, do not assume access is allowed.
Inputs: no named parameters.
gate_verifyVerify live delegated authorityARead-onlyIdempotent
Verify whether an AI agent currently has a valid delegated authority path from a principal for a requested action. Call immediately before a protected operation, using trusted principal, actor and action context. The verifier evaluates current authority evidence, including upstream revocation and alternative delegation paths, subject to the configured consistency and freshness guarantees. Inspect the returned decision: ALLOW, DENY or UNKNOWN authority. UNKNOWN must not permit the protected action. A standalone verification response does not enforce authorization: the trusted execution boundary must enforce the decision. Live network verification requires a configured GATE endpoint and appropriate credentials. Demo mode is simulated and not production authority.
Inputs: actor (required), principal (required), action, consistency, +1 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 2 tools
gate_verify (authority decision at effect boundary) and gate_status (configuration/health inspection) are explicitly delineated, and both descriptions cross-reference each other to prevent misuse. An agent can unambiguously choose between making an authorization decision and checking setup/health.
Both tools use a uniform snake_case verb/noun pattern with a consistent 'gate_' prefix (gate_verify, gate_status). The convention is predictable and scales if more gate operations are added.
Two tools is thin even for a narrowly scoped verification service; the surface is tightly focused but offers no affordances beyond a single decision call and a status probe. It sits at the borderline of minimal but arguably sufficient.
The core lifecycle — check readiness, then verify authority at the effect boundary — is covered, including the critical UNKNOWN/deny semantics. Minor gaps remain: no way to inspect delegation chains, revocation evidence, or batch/bulk verification results directly.
Maintenance
Related MCP Connectors
Zero-secret MCP gateway for AI agents: risk-scored, audited calls with human-in-the-loop approval.
An MCP gateway for teams deploying AI tools at scale to employee-facing and headless agents.
1MCP gateway: one connection for your AI apps, with tool policies, PII redaction and audit logs.
Zero-setup MCP gateway securely connecting AI to your tools with authentication and workflows
Related MCP Servers
- AlicenseBqualityCmaintenanceSecurity gateway that wraps any MCP server with per-tool policies, approval gates, and optional Ed25519-signed decision receipts. Shadow mode logs every tool call without blocking; enforce mode applies block, rate-limit, and minimum-tier rules. Receipts are independently verifiable offline with no accounts needed.511MIT
- AlicenseNot gradedqualityDmaintenanceMCPGate aggregates multiple MCP servers into a single unified endpoint, enabling centralized tool management with granular filtering, automatic namespacing, and observability. Features a real-time web dashboard and optional PostgreSQL-backed audit trails for monitoring and controlling AI tool access across local and remote deployments.Apache 2.0
- AlicenseNot gradedqualityDmaintenanceMCP Server for AI agent identity and authorization. Create, verify, and manage agent identities with trust scores and scoped authorization tokens.31 PyPIMIT
- AlicenseNot gradedqualityDmaintenanceAn MCP server that enforces runtime governance on AI agent actions — file access, command execution, delegation chains, and permission escalation.MIT