Credatcredat
GitHubGitHub
Open Source SDK

The Trust Layer for AI Agents

Give your agents an identity. Delegate permissions. Verify trust. Stop agent fraud before it starts.

scopeOwnerDelegates permissionsAgentProves identityServiceVerifies trustDelegationTrust Chain
The Problem

AI Agents Are Everywhere. Trust Is Nowhere.

Agent Fraud

Any process can claim to be an agent. There's no standard way to verify it's who it says it is.

Agent-to-Agent Trust

When two agents need to collaborate, neither can prove its identity or capabilities to the other.

Delegation Verification

How does a service know an agent actually has permission from its owner? Today, it can't.

Scope Control

Agents need allowances — bounded permissions that limit what they can do. API keys don't cut it.

Developer Experience

Agent Trust in 5 Lines of Code

Create an agent identity, delegate permissions with scoped allowances, and verify trust — all from a single, composable SDK.

Get StartedGet Started
agent-trust.ts
import { createAgent, delegate, verifyPresentation } from "@credat/sdk"

// 1. Create an agent identity
const agent = await createAgent({
  domain: "agent.acme.com"
})

// 2. Delegate scoped permissions
const delegation = await delegate({
  agent: agent.did,
  owner: ownerDid,
  scopes: ["book:travel", "spend:500usd"]
})

// 3. Verify trust
const result = await verifyPresentation(presentation)
console.log(result.trusted) // true
Use Cases

What You Can Build

Travel Booking Agent

Your agent books flights and hotels on your behalf. Services verify it's authorized to spend up to your set limit — no API keys, no shared passwords.

Financial Agent with Spending Limits

Delegate a spending allowance to your agent. It can pay invoices, transfer funds, or manage subscriptions — all within the scope you defined.

Multi-Agent Workflows

Chain agents together where each one proves its identity and permissions to the next. Build complex pipelines where trust flows automatically.

Agent Platform Security

Run a marketplace where third-party agents interact with your APIs. Verify every agent's identity and scope before granting access.

Personal Assistant Agent

Your personal agent manages your calendar, emails, and tasks. It proves to every service that you authorized it — with exactly the right permissions.

How It Works
agent-trust.ts
1import { createAgent, delegate, createChallenge, presentCredentials, verifyPresentation } from "@credat/sdk"

3// 1. Create an agent identity
4const agent = await createAgent({
5 domain: "agent.acme.com"
6})

8// 2. Delegate scoped permissions
9const delegation = await delegate({
10 agent: agent.did,
11 owner: ownerDid,
12 scopes: ["book:travel", "spend:500usd"]
13})

15// 3. Service challenges the agent
16const challenge = createChallenge({ from: serviceDid })
17const presentation = await presentCredentials({
18 challenge, delegation, agent
19})

21// 4. Verify trust
22const result = await verifyPresentation(presentation, {
23 challenge, ownerPublicKey, agentPublicKey
24})
25console.log(result.trusted) // true
Step 1

Create an Agent

Give your agent a verifiable identity tied to your domain. One function call, no configuration.

Step 2

Delegate Permissions

Define exactly what the agent can do with scoped allowances. Book travel, spend $500, read emails — you decide.

Step 3

Challenge the Agent

When your agent arrives at a service, the service issues a challenge. The agent proves its identity and permissions.

Step 4

Verify Trust

The service verifies the agent's identity, its owner's delegation, and the scopes — all in one call.

Step 1

Create an Agent

Give your agent a verifiable identity tied to your domain. One function call, no configuration.

agent-trust.ts
1import { createAgent, delegate, createChallenge, presentCredentials, verifyPresentation } from "@credat/sdk"

3// 1. Create an agent identity
4const agent = await createAgent({
5 domain: "agent.acme.com"
6})

Step 2

Delegate Permissions

Define exactly what the agent can do with scoped allowances. Book travel, spend $500, read emails — you decide.

agent-trust.ts
8// 2. Delegate scoped permissions
9const delegation = await delegate({
10 agent: agent.did,
11 owner: ownerDid,
12 scopes: ["book:travel", "spend:500usd"]
13})

Step 3

Challenge the Agent

When your agent arrives at a service, the service issues a challenge. The agent proves its identity and permissions.

agent-trust.ts
15// 3. Service challenges the agent
16const challenge = createChallenge({ from: serviceDid })
17const presentation = await presentCredentials({
18 challenge, delegation, agent
19})

Step 4

Verify Trust

The service verifies the agent's identity, its owner's delegation, and the scopes — all in one call.

agent-trust.ts
21// 4. Verify trust
22const result = await verifyPresentation(presentation, {
23 challenge, ownerPublicKey, agentPublicKey
24})
25console.log(result.trusted) // true
Features

Everything You Need to Trust Agents

Agent Identity

Create portable, verifiable identities for AI agents. Each agent gets a unique identity tied to its owner's domain.

Create Identity
One function call
Resolve Identity
Domain-based lookup

Delegation

Scoped Permissions

Define exactly what an agent can do — book travel, spend up to $500, read emails — with typed scopes.

Delegation Chains

Agents can re-delegate subsets of their permissions to other agents. The chain is fully verifiable.

Instant Revocation

Revoke any agent's permissions at any time. Services see the change immediately.

Developer Tools

npm install @credat/sdk
Zero-config setup
100% TypeScript
Full type safety
< 50kb gzipped
Tree-shakeable
5 Lines

To Full Agent Trust

Create an agent, delegate permissions, and verify trust — the entire flow in 5 lines of TypeScript.

< 50kb

Gzipped Bundle

Tree-shakeable ESM architecture. Import only what you need — identity, delegation, or verification.

100%

Open Source

Apache-2.0 licensed. No vendor lock-in, no hidden fees. The only open-source, developer-first agent identity SDK.

Early Adopters

Built for Agent Developers

We needed a way to prove our agents were authorized. Credat gave us that in an afternoon. Dead simple API.

Sophie L.
Sophie L.
CTO, AI Startup

The delegation model is exactly what we needed. Scoped permissions for agents that just work. No overengineering.

Marcus W.
Marcus W.
Lead Engineer

We run a multi-agent platform. Credat solved our biggest problem: knowing which agent is actually authorized to do what.

Elena R.
Elena R.
Head of Platform

TypeScript-first, open source, and it handles the hard part — trust between agents — so we don't have to.

James C.
James C.
Senior Developer

We evaluated building our own agent auth system. Credat saved us months and is more secure than what we would have built.

Anna K.
Anna K.
VP Engineering

Finally someone is solving agent identity properly. Open source, developer-first, and built on real standards under the hood.

Pierre D.
Pierre D.
Founder
Open Source

Stop Agent Fraud. Start Shipping Trust.

Credat is the open-source trust layer for AI agents. Give your agents an identity, delegate permissions, and verify trust — in 5 lines of code.