The protocol stack for agent commerce

Identity. Custody. Guardrails. Trust. Four deterministic layers that make autonomous agents safe to deploy.

Read the SpecTry Operator — Free

Agents are transacting. Nothing is safe.

$670B

projected agent services market by 2030

Zero

identity infrastructure for autonomous agents

Prompt engineering

is not a security strategy

AI agents move money, sign agreements, and interact with other agents — with no verifiable identity, no secure key custody, no deterministic spending limits, and no auditable trust chain. That's not an agent economy. That's a liability vacuum.

Four layers. Each one deterministic.

1

Identity

CLP

Every agent gets a verifiable, cryptographic identity bound to its principal. You can't build anything else without knowing who you're dealing with.

Live — Open Source
2

Custody

VaultClaw

Keys, credentials, and sensitive assets held in secure enclaves with WASM-enforced access rules. The agent authenticates via its identity but never holds keys directly.

In Development
3

Guardrails

Deterministic State Machines

What can this agent do? Spend limits, approved counterparties, permitted actions — enforced by compiled WASM modules. Immutable at runtime. Impossible to jailbreak.

In Development
4

Trust

NamedSource

Verifiable trust ratings for agents, adapters, and WASM modules. Not reputation scores — cryptographic attestation chains.

Coming Soon

Open protocol. Deterministic settlement.

CLP is the wire protocol for agent commerce. Apache 2.0. Deterministic identity, authorization, and settlement — producing cryptographically verifiable proof bundles that anyone can independently verify.

35+ Conformance TestsGo · Python · TypeScript SDKsEd25519 Signatures
View on GitHub
example.ts
1import { ContractLane } from '@accordsai/sdk';
2
3const clp = new ContractLane({
4  operator: 'https://operator.accords.ai'
5});
6
7// Register agent identity
8const agent = await clp.registerAgent({
9  principal: 'org:acme-corp',
10  capabilities: ['transact', 'delegate']
11});
12
13// Create and settle a contract
14const contract = await clp.createContract({
15  parties: [agent.id, counterparty.id],
16  terms: { maxValue: 50000, currency: 'USD' }
17});
18
19const proof = await clp.settle(contract.id);
20// proof.id = sha256(canonical_json(proof))

Your agent transacts safely in 5 minutes.

Operator is the hosted CLP implementation. Free tier, no humans in the loop. Your agent gets verifiable identity and deterministic settlement through a single API.

Agent Identity

Cryptographic identity bound to your org

Deterministic Settlement

Verifiable proof bundles for every transaction

SDKs

Go, Python, TypeScript — agents understand in 5 minutes

Free Tier

Full features, generous limits, no credit card

Get Started — Free
“

You do not want AI making stateless decisions in sensitive areas. You need non-AI rulesets — deterministic state machines — governing what agents can do. The AI works within boundaries it cannot modify.

Everyone in AI safety is focused on making models harder to jailbreak. We're building systems where jailbreaking doesn't matter — because the AI never had the keys.

Built in the open. By design.

CLP is Apache 2.0 because protocols win through adoption. HTTP didn't win because one company controlled it. We're building the TCP/IP for agent commerce.

—

Stars

—

Forks

—

Contributors

View on GitHubJoin the community