Govern

What is Govern?

Checkpoint Govern enables you to deploy and manage KYA-OS ("Know Your Agent — Operating System"; see the glossary) servers for comprehensive AI agent governance. While Detect identifies agents and Enforce blocks or redirects them, Govern provides a framework for authorizing agents: letting verified AI agents interact with your resources under controlled conditions.

Govern implements a zero-trust model: every AI agent request must carry a cryptographic proof of identity and authorization before accessing protected resources.

How It Works

AI Agent → KYA-OS Proof → Your Server → Checkpoint Verification → Protected Resource
                                              ↓
                                    Dashboard (audit trail)

1. An AI agent obtains a delegation (authorization grant) through an OAuth flow
2. The agent creates a cryptographic proof for each request, referencing the delegation
3. Your server uses @kya-os/bouncer-middleware to verify the proof with Checkpoint
4. If valid, the request proceeds with verified agent identity attached
5. All activity is logged to the Checkpoint dashboard for audit

Key Concepts

Agent DIDs

Every AI agent is identified by a DID (Decentralized Identifier), such as did:key:z6Mk.... This provides a stable, verifiable identity for agents across sessions and services.

Delegations

A delegation is an authorization grant from a user or service to an AI agent. It specifies what the agent can do (scopes), for how long, and under what constraints. Think of delegations as OAuth tokens for AI agents.

Learn more about delegations

Proofs

A proof is a cryptographic assertion attached to each request. It contains the agent's DID, the target audience, a nonce, and a reference to the delegation that authorizes the request.

Learn more about proof verification

Scopes

Scopes define fine-grained permissions. For example, files:read allows reading files while payment:create allows initiating payments. Each delegation grants specific scopes, and each protected endpoint can require specific scopes.

Verifiable Credentials

Checkpoint issues and verifies verifiable credentials that attest to agent identity and permissions. These are signed by Checkpoint's infrastructure and can be independently verified.

Deployment Options

Checkpoint supports three ways to run a KYA-OS server:

Deploy a KYA-OS Server →

Migrating an Existing MCP Server

Already have a standard MCP server? Add KYA-OS identity and authorization without rewriting your server.

Migration Guide →

Authentication Methods

When an agent requests access, the user must authenticate. Checkpoint supports multiple methods:

Compare authentication methods →

Prerequisites

• A Checkpoint account with a project
• Your project's API key and Project ID: see Credentials for where to find them
• A Node.js/Express server (or equivalent) to add the middleware to

Quick Start

1. Install the middleware

npm install @kya-os/bouncer-middleware

2. Protect an endpoint

import express from 'express';
import { createBouncerMiddleware } from '@kya-os/bouncer-middleware';

const app = express();
app.use(express.json());

app.post(
  '/api/files',
  createBouncerMiddleware({
    apiKey: process.env.CHECKPOINT_API_KEY!,
    projectId: process.env.CHECKPOINT_PROJECT_ID!,
    requiredScopes: ['files:write'],
  }),
  (req, res) => {
    // Access verified agent info
    const { agentDid, scopes } = req.bouncer;
    res.json({ message: 'File created', agent: agentDid });
  }
);

3. Configure tools in the dashboard

Navigate to Policy → Auth (/dashboard/{orgId}/{projectId}/policy/auth) to define which tools require delegations and what scopes they need: create an auth method (OAuth or credentials when the user has to sign in, or consent-only when they just have to approve), plus the scopes it grants, then assign it as the owner of each tool it should protect. Auth methods are reusable, so one can own many tools.

Features

Govern vs Enforce

Dashboard

Manage Govern features from the Checkpoint dashboard:

• Delegations: View and revoke active delegations
• Proofs: Monitor verification activity and audit agent access
• Policy → Auth: Configure auth methods and providers, customize the consent screens agents see, and assign per-tool protection
• Gateway → Connections: Let users link upstream OAuth accounts (e.g. GitHub) so gateway tool calls carry their credentials (a separate concept from delegations); see GitHub Connections
• Control Access (legacy surface): Tool discovery/removal and a few consent extras remain at /dashboard/{orgId}/{projectId}/control-access until the new Access surface lands. See Control Access

Related Projects

Checkpoint Govern is part of a larger KYA-OS ecosystem. These external projects provide additional context and tooling:

Next Steps

• Deploy a KYA-OS Server: Dashboard Deploy, Molti managed hosting, or self-host
• Molti: Managed hosting with no repo or Cloudflare account required
• Migrate from MCP to KYA-OS: Add identity to an existing server
• Authentication Methods: Choose how users authorize agents
• Managing Delegations: Create and verify authorization grants
• Proof Verification: Implement server-side proof checking
• OAuth Integration: Standard OAuth flows for agents
• GitHub Connections: Let users link GitHub for gateway tool calls
• Tool Protection: Per-tool access control
• Consent Flows: User consent for agent actions