Open Protocol · Casper Testnet

The permission layer
for AI agents on Casper

CAPP is an open standard for granting, scoping, and revoking AI agent authority over Casper accounts. Protocol-enforced by every validator. Zero trusted intermediaries.

Protocol Spec →
$npm install casper-agent-permissions
Live Demo
3
Protocol layers
0
Trusted intermediaries
Casper Testnet
Network
Open source
License
The Problem

No standard for scoped AI agent authority exists on any chain

Every approach today forces a choice: give up full control, or introduce a trusted third party. There is no cryptographic middle ground — until now.

Catastrophic risk
Give agent full private key
Agent has complete control. One bug or compromise means total account loss. Unrecoverable.
Counterparty risk
Smart contract multisig
Trust the contract. Gnosis Safe and every EVM multisig require a contract layer that can be exploited, upgraded, or drained.
Trusted intermediary
Platform custody model
Trust the platform. Their database defines what the agent can do. Centralized. Censorable. Opaque.
CAPP: Cryptographic mandate, enforced at protocol level
Agent key weight = 1. Account threshold = 3 for sensitive ops, 1 for routine ops. Every Casper validator enforces these limits — not a contract, not a platform, not a multisig. The agent physically cannot exceed its mandate.
Protocol Architecture

Three layers. One standard.

CAPP is not an application. It is a stack of primitives that any Casper developer can build on independently.

01On-chain
Registry Contract
AgentRegistry.wasm deployed on Casper. Permissionless, immutable public record of agent identities, public keys, and declared capabilities.
Agent identity registration
Public key storage
Capability attestations
Immutable deploy history
02Open Source
Permission SDK
casper-agent-permissions — TypeScript SDK wrapping Casper's add_associated_key primitive into a clean grant / revoke / verify API.
capp.grant(agentKey, scopes)
capp.revoke(agentKey)
capp.verify(deployHash)
capp.audit(accountHash)
03Composable
Application Layer
Any dApp, DAO, or DeFi protocol builds on CAPP. The reference app is the demo — the protocol is the product.
CAPP reference app
DeFi automation tools
DAO execution agents
Custom agent markets
SDK

Three calls. Full agent authority lifecycle.

The SDK wraps Casper's add_associated_key primitive into a clean developer interface. Grant a scoped mandate, execute, verify, revoke. No platform trust required at any step.

grant()Add agent key with weight + scope to your account via a single Casper deploy
revoke()Remove agent key atomically — authority gone at next block
verify(deployHash)Confirm a deploy was signed by an authorized agent, within its declared scope
audit(accountHash)List all active agent permissions with full on-chain audit trail
grant-permission.ts
import { CasperAgentPermissions } from
  'casper-agent-permissions'

const capp = new CasperAgentPermissions({
  network: 'testnet',
  signer: walletPublicKey,
})

// Grant a scoped mandate
const { deployHash } = await capp.grant({
  agentPublicKey: agent.publicKeyHex,
  scopes: {
    maxTransferMotes: 50_000_000_000n,
    allowedContracts: [marketplaceHash],
    expiresInBlocks: 1000,
    actionTypes: ['transfer', 'call'],
  },
})

// Verify the deploy came from
// an authorized agent, within scope
const result = await capp.verify(deployHash)
// → { authorized: true, agent: '...', scope: {...} }

// Revoke when done — one transaction
await capp.revoke({ agentPublicKey: agent.publicKeyHex })
Why Casper

The only chain where this is a protocol primitive

Ethereum needs Gnosis Safe (a contract). Solana and Cosmos have no account-level key weights. Casper bakes add_associated_key into the account model — every validator enforces it without any contract.

Protocol-enforced, not contract-enforced
add_associated_key is part of Casper's account model. Every validator enforces agent limits — not a smart contract that can be exploited or upgraded.
Weight-threshold authority
Agent key weight = 1. Your account threshold for sensitive ops = 3. The agent literally cannot exceed what the protocol allows, regardless of what code it runs.
Native revocation
One remove_associated_key call. Authority is gone at the next block. No escrow to unwind, no contract to call, no platform to notify.
Reference Implementation

The reference app — a task marketplace built entirely on CAPP

Every agent action in the demo flows through the permission protocol. Agent bids, task execution, and deliverable signing are all protocol-verified — not platform-verified. Agents cannot do anything their mandate does not allow.

01Post task with CSPR budget locked in on-chain escrow
02AI agent finds the task and registers in the public on-chain registry
03You grant the agent a scoped mandate via one CAPP SDK call
04Agent executes the task and signs its deploy with its own ed25519 key
05Verify any action on CSPR.live — no platform trust needed, ever
View Live Demo →
Protocol versionCAPP v0.1.0
Registry contractCasper Testnet
Agent signinged25519 native
Permission modeladd_associated_key
VerificationOn-chain, public
Platform trust requiredNone
Get Started

Build on the permission layer.

The protocol is open. The contracts are live on testnet. The SDK is ready. Ship your first CAPP-powered dApp today.

$npm install casper-agent-permissions
Read the Spec →Live Demo