Skip to content

CapiscIO

The Authority Layer for AI Agents

Like Let's Encrypt revolutionized HTTPS, CapiscIO brings verifiable identity and trust to the agent economy. Give your agent a DID, earn trust badges, be discovered.

Get Your Agent's Identity Quick Start

The Three Pillars

  • Decentralized Identity

    Every agent gets a DID (Decentralized Identifier) — a globally unique, cryptographically verifiable identity that travels with your agent.

    did:web:registry.capisc.io:agents:my-weather-bot
    • W3C standard — interoperable everywhere
    • Cryptographic proof — unforgeable
    • Portable — move providers, keep identity

    Learn about DIDs

  • Trust Badges

    Earn trust levels 0-4 based on identity verification depth. Like SSL certificates for agents.

    Level Verification
    0 Self-signed
    1 Email verified
    2 Domain validated
    3 Organization validated
    4 Extended validation

    Get a Trust Badge

  • Registry API

    REST API for managing agents, issuing badges, and resolving DIDs.

    • Agent CRUD operations
    • Badge issuance and verification
    • DID resolution
    • Public status endpoints

    Registry API

Quick Start

# 1. Install CLI
npm install -g capiscio       # or: pip install capiscio

# 2. Initialize your agent
capiscio init

# 3. Validate your agent card
capiscio validate

✅ Validation passed!

Compliance: 95/100 (A+)
Trust: 78/100 (Good)

Agent card is valid and ready to use.

Full Getting Started Guide Download Samples

Why CapiscIO?

The Problem

AI agents are proliferating. But there's no standard way to:

  • Verify identity — Is this really the agent it claims to be?
  • Establish trust — Can I trust this agent with my data?
  • Validate compliance — Does this agent card meet standards?

API keys prove you paid. OAuth tokens expire. Self-descriptions can be forged.

The Solution

CapiscIO provides the trust infrastructure for the agent economy:

Component What It Solves
DID Identity Permanent, verifiable, portable agent identity
Trust Badges Tiered verification like SSL certificates
Validation Engine Multi-dimensional agent card scoring
SDK/CLI Frictionless integration for developers

Result: Agents can prove who they are, establish trust, and find each other.

Developer-First Design

We obsess over developer experience. Every feature works in three commands or less.

capiscio key gen
# ✅ did:key:z6Mk... generated

capiscio validate agent-card.json
# ✅ Validation passed: 95/100 (A+)

capiscio badge issue --self-sign
# ✅ Badge issued with did:key identity

from capiscio_sdk import SimpleGuard

guard = SimpleGuard(dev_mode=True)  # That's it!

@app.post("/task")
@guard.protect
async def handle(request):
    # Requests are verified automatically
    pass

Trust Hierarchy

Level 0
Self-Signed
Level 1
Registered
Level 2
Domain Validated
Level 3
Org Validated
Level 4
Extended

Higher levels = more verification = more trust. Choose what's right for your use case:

Use Case Recommended Level
Development & testing 0 (self-signed)
Personal projects 1 (registered)
Production APIs 2 (domain validated)
Enterprise integrations 3 (org validated)
Financial, healthcare 4 (extended validation)

Learn about Trust Levels

What You Can Build

  • Secure Agent Networks

    Build multi-agent systems where agents verify each other's identity before communicating.

  • Trusted API Gateways

    Enforce trust level requirements at your API boundary. Only Level 2+ agents can access production endpoints.

  • Agent Marketplaces

    Create directories of verified agents. Users trust your curation because trust is cryptographically proven.

  • Enterprise Integrations

    Meet compliance requirements with org-validated identities and audit trails.

Built on Standards

CapiscIO implements and extends open standards:

Standard How We Use It
A2A Protocol Agent communication format
W3C DIDs Decentralized identifiers
JWS (RFC 7515) Request signing
Ed25519 Cryptographic keys

We're not inventing new cryptography — we're applying proven standards to the agent economy.

CapiscIO RFCs

Our core specifications are published as RFCs (Request for Comments):

RFC Title What It Defines
RFC-001 Agent Governance Control Plane (AGCP) Authority delegation and transitive trust model
RFC-002 Trust Badge Specification Cryptographic identity credentials (JWS format)
RFC-003 Key Ownership Proof Protocol Challenge-response key binding for IAL-1 badges

Browse All RFCs

Documentation

  • Getting Started

    Step-by-step guides for common tasks.

    Getting Started

  • Concepts

    Understand how CapiscIO works under the hood.

    Concepts

  • How-To Guides

    Task-oriented recipes for specific problems.

    How-To Guides

  • Reference

    Complete API documentation.

    Reference

Open Source Components

CapiscIO core tools are open source under the Apache 2.0 license.

  • capiscio-core

    The Go CLI and core validation engine.

    GitHub

  • capiscio-sdk

    Python SDK for runtime security.

    GitHub

  • capiscio-server

    Commercial registry and Badge CA server.

    Contact Sales

  • capiscio-docs

    This documentation site.

    GitHub

Get Started Now

Generate Your DID Sign a Badge Validate Agent Cards

Questions? Open an issue or join the discussion.