# CapiscIO

> CapiscIO is an AI Security Platform for Agentic Systems. When Legal asks "Who controls this AI agent?" — SecOps can answer: "We do. Here's the proof."

CapiscIO provides cryptographic identity, payload integrity, and trust enforcement for AI agents. Agent identity, verified. Payload integrity, guaranteed. Trust levels, enforced. Every request, cryptographically proven.

## The Problem We Solve

Your agents have no identity. Every call is trusted by default. That's the problem.

- **No Agent Identity**: API keys don't identify agents. When an LLM calls your tool, you have a token. You don't have proof.
- **No Payload Integrity**: Payloads get modified across hops, proxies, retries, and queues. Without cryptographic binding, that "verified" request could have been tampered with.
- **No Trust Levels**: Your dev agent and your production agent look identical to your tools. One is a self-signed test build. One has verified provenance. You treat them the same.

## Core Capabilities

- **Agent Identity**: Ed25519 signature verification proves which agent signed each request
- **Payload Integrity**: SHA-256 body hash binding detects any tampering
- **Freshness Protection**: 60-second window with strict iat/exp validation prevents replay attacks
- **Trust Levels**: Graduated trust (Levels 0-4) based on provenance and verification
- **Audit Trail**: Cryptographic evidence per request for compliance and forensics

## Products

### Agent Guard (A2A Protocol)
Runtime security middleware for agent-to-agent communication. Verifies caller identity, payload integrity, and trust levels before traffic reaches your handler.

- One decorator per endpoint. No protocol changes.
- Python SDK (`pip install capiscio-sdk`) or Go sidecar
- Sub-10ms verification overhead (benchmarked, varies by environment)
- [Product Page](https://capisc.io/products/guard)
- [Documentation](https://docs.capisc.io/quickstarts/secure/1-intro/)

### MCP Guard (Model Context Protocol)
Security decorator for MCP tool servers. Know which LLM or agent is calling before you expose write access.

- `@require_trust(level=2)` decorator on any tool
- Works with Claude, GPT, any MCP client
- Per-tool authorization and evidence logging (RFC-006)
- [Product Page](https://capisc.io/products/mcp-guard)

### CLI Tool
Command-line validator for A2A agent cards. Validates JWS signatures, tests live endpoints, enforces trust levels.

- Free and open source (Apache 2.0)
- `npm install -g capiscio` or `pip install capiscio`
- CI/CD integration with GitHub Action
- [Product Page](https://capisc.io/products/cli)
- [CLI Reference](https://docs.capisc.io/reference/cli/)

### Platform (Registry)
Centralized identity registry and governance layer for AI agents.

- DID Keys and did:web support
- Trust level visibility and decision logs
- Multi-tenant organization support
- [Product Page](https://capisc.io/products/platform)
- [Pricing](https://capisc.io/pricing)

## Security & OWASP Alignment

CapiscIO addresses the OWASP Top 10 for Agentic Applications 2026:

| OWASP Risk | Coverage |
|------------|----------|
| AG01: Agent Identity Spoofing | **Direct** - Ed25519 signature verification |
| AG02: Tool Misuse | Partial - Trust level gating |
| AG03: Excessive Agency | Partial - Trust thresholds |
| AG06: Communication Tampering | **Direct** - SHA-256 body hash |
| AG07: Replay Attacks | **Direct** - 60s freshness window |
| AG10: Audit Trail Gaps | **Direct** - Per-request evidence |

We document what we protect and what we don't. No vague claims.

- [Security Page](https://capisc.io/security) - Threat model, hard boundaries, OWASP mapping
- [AI Security Solutions](https://capisc.io/solutions/ai-security) - Use cases and integration patterns

## Quick Start

### Validate an Agent (CLI)
```bash
# Install
npm install -g capiscio

# Validate with signature verification
capiscio validate https://agent.example.com

# Full validation with live endpoint testing
capiscio validate https://agent.example.com --test-live --strict --json
```

### Secure Your Agent (Python SDK)
```python
from fastapi import FastAPI
from capiscio_sdk.simple_guard import SimpleGuard
from capiscio_sdk.integrations.fastapi import CapiscioMiddleware

app = FastAPI()

# Zero config: auto-discovers agent-card.json and key material
guard = SimpleGuard(dev_mode=True)
app.add_middleware(CapiscioMiddleware, guard=guard)

@app.post("/agent/message")
async def handle_message():
    # Only reached if identity, integrity, and freshness checks pass
    return {"status": "verified"}
```

### Protect MCP Tools
```python
from capiscio_mcp import require_trust

@require_trust(level=2)
async def delete_user(user_id: str):
    # Only agents with Trust Level 2+ can call this
    ...
```

## Key Concepts

- **Trust Badge**: JWS token (RFC 7515) serving as an agent's cryptographic identity. Contains `kid` (key ID), `iat`/`exp` (timestamps), `bh` (body hash).
- **SimpleGuard**: Zero-config security middleware. Verifies identity, integrity, and freshness on every request.
- **Trust Levels**: 0 (self-signed) to 4 (CA-signed with hardware attestation). Tools can require minimum levels.
- **Body Hash (bh)**: SHA-256 hash of request body bound to signature. Detects any payload modification.
- **Fail-Closed**: Missing or invalid badges return 401/403 immediately. No silent failures.

## Specifications (RFCs)

- [RFC-002](https://docs.capisc.io/rfcs/002-trust-badge-specification/): Trust Badge Specification (v1.3 Frozen)
- [RFC-003](https://docs.capisc.io/rfcs/003-key-ownership-proof/): Key Ownership Proof (PoP)
- [RFC-004](https://docs.capisc.io/rfcs/004-agent-card-schema/): Agent Card Schema Extensions
- [RFC-006](https://docs.capisc.io/rfcs/006-mcp-tool-authority/): MCP Tool Authority and Evidence
- [RFC-007](https://docs.capisc.io/rfcs/007-mcp-server-identity/): MCP Server Identity Discovery

## Documentation

- [Documentation Home](https://docs.capisc.io)
- [Quickstart: Validate](https://docs.capisc.io/quickstarts/validate/1-intro/) - Validate agents in 5 minutes
- [Quickstart: Secure](https://docs.capisc.io/quickstarts/secure/1-intro/) - Add security to your agent
- [Python SDK Reference](https://docs.capisc.io/reference/sdk-python/)
- [Trust Store Configuration](https://docs.capisc.io/recipes/security/trust-store/)

## Pricing

- **Free Forever**: CLI, Agent Guard SDK, MCP Guard decorator, 1 hosted identity
- **Developer ($79/mo)**: 10 identities, 30-day logs, domain verification
- **Team ($249/mo)**: 50 identities, custom trust policies, priority support
- **Enterprise**: Unlimited identities, self-hosted option, SLA

[Full Pricing](https://capisc.io/pricing)

## Resources

- [Blog](https://capisc.io/blog): Product updates and technical articles
- [GitHub](https://github.com/capiscio): Open source repositories
- [Roadmap](https://capisc.io/resources/roadmap): Product roadmap
- [Web Validator](https://capisc.io/validator): Validate agent cards online
- [Downloads](https://capisc.io/downloads): CLI binaries for all platforms
- [White Paper](https://cdn.capisc.io/white-papers/CapiscIO-White-Paper-rev2-0.pdf)

## About

CapiscIO creates the missing security layer for AI agents. When the auditor asks "which agents accessed production last quarter?" — you have cryptographic proof, not log correlation.

Founded by Beon de Nood. Building practical AI governance, not bureaucratic checkbox security.

- [About CapiscIO](https://capisc.io/about)
- [Enterprise Solutions](https://capisc.io/solutions/enterprise)

## Contact

- Website: https://capisc.io
- Documentation: https://docs.capisc.io
- GitHub: https://github.com/capiscio
- Email: hello@capisc.io
- Enterprise: partners@capisc.io