Use atp-sdk the recommended package for application development.
See VERSIONING.md for full policy.

Try It Now

Follow the GitHub docs and examples below to get started with ATP, or use the hosted website and dashboard when available.

• Create quantum-safe agents
• See trust scoring in action
• Test quantum-safe signatures
• Run OpenClaw multi-agent workflows
• Explore the policy engine
• Verify blockchain audit trails

Quick Start (60 Seconds)

New Developers: Start with Scaffolding

Interactive CLI (ESM-first, Node 18+):

npx create-atp-agent my-agent

This creates a project folder with:

• "type": "module" and atp-sdk in package.json
• TypeScript or JavaScript starter (agent.ts or agent.mjs) with top-level await
• .atp.json with your chosen security profile
• After install, the CLI opens the embedded onboarding UI at http://127.0.0.1:3456 (next free port if busy). Use --no-dashboard to skip, or --dashboard-only for the UI without scaffolding.

Then:

cd my-agent
npm install   # skipped if you chose install during prompts
npm start

For the full web onboarding wizard (production ATP site), use agenttrustprotocol.com and /onboard/agent when logged into the app.

Experienced Developers: Add to Existing Project

If you already have a project, just install the SDK:

npm install atp-sdk

Then use it:

import { Agent } from 'atp-sdk';
const agent = await Agent.quickstart('MyBot');

Zero Install (Nothing on your machine? No problem.)

Mac / Linux:

curl -fsSL https://agenttrustprotocol.com/install.sh | bash

Windows (PowerShell as Admin):

irm https://agenttrustprotocol.com/install.ps1 | iex

What Makes ATP Different?

Examples

Basic Agent Communication

import { Agent } from 'atp-sdk';

// Create two agents
const alice = await Agent.create('Alice');
const bob = await Agent.create('Bob');

// Send cryptographically signed message
await alice.send(bob.getDID(), 'Hello from Alice!');

// Check trust score
const trustScore = await alice.getTrustScore(bob.getDID());
console.log(`Trust level: ${trustScore}`); // 0.0 to 1.0

Zero-Knowledge Authentication

⚠️ Experimental. The trust-level / range “proofs” use a hash-based commitment (H(value‖blinding)), not a true Pedersen commitment, and the verifier checks proof structure rather than an arithmetic range relation — so it does not yet cryptographically prevent a prover from claiming a threshold it doesn’t meet. A vetted EC/Ristretto + bulletproofs implementation is planned. Today’s sound mechanisms are challenge-response authentication, selective disclosure, and Merkle membership.

// Alice challenges Bob to prove trust level
const challenge = await alice.requestAuth(bob.getDID(), [
  { type: 'trust_level', params: { minTrustLevel: 0.7 } }
]);

// Bob generates a trust-level proof (experimental — see note above)
const response = await bob.respondToChallenge(challenge);

// Alice verifies the response (structural check today; soundness is roadmap)
const result = await alice.verifyAuthResponse(response);
console.log('Verified:', result.verified); // true

Integration with Popular Frameworks

OpenClaw (Multi-Agent Systems):

import { registerClawWithAtp, wrapSkillWithAtp } from '@atpdevelopment/openclaw-atp';
import { ATPClient } from 'atp-sdk';

// Initialize with a security profile
const atp = new ATPClient({ baseUrl: 'https://api.atp.dev', profileId: 'openclaw-sandbox' });

// Register agent
const { did, trustScore } = await registerClawWithAtp(atp, {
  name: 'trader-agent',
  capabilities: ['trading', 'analysis'],
  trustLevel: 'high'
});

// Secure tools with profile-based action gating
const secureTrade = wrapSkillWithAtp(tradeTool, atp, { actionType: 'network' });
const secureShell = wrapSkillWithAtp(shellTool, atp, { actionType: 'shell' });

LangChain:

import { ATPSecurityWrapper } from 'atp-sdk/langchain';
const secureChain = new ATPSecurityWrapper(langchainAgent, {
  agentName: 'langchain-bot'
});

MCP (Model Context Protocol):

import { MCPServer } from 'atp-sdk/mcp';
const server = new MCPServer({
  name: 'secure-mcp-server',
  quantum_safe: true
});

Security Profiles

ATP includes built-in security profiles that control what agents can and cannot do:

import { ATPClient, BUILTIN_PROFILES } from 'atp-sdk';

// Select a profile at initialization
const client = new ATPClient({ baseUrl: 'https://api.atp.dev', profileId: 'safe-default' });

// Or set/change at runtime
client.setProfile('enterprise-locked');

// Evaluate whether an action is allowed
const decision = client.evaluateActionWithProfile({
  actionType: 'shell',        // shell | filesystem | network | credentials | messaging
  state: 'executing',         // planning | executing | communicating | completed
});
console.log(decision); // "allow" | "deny" | "require_approval"

Onboarding

Register agents via the embedded dashboard, CLI, or web wizard:

# Scaffold a new ESM-first agent project (interactive CLI).
# After scaffolding, the CLI starts a local onboarding UI at http://127.0.0.1:3456 by default.
npx create-atp-agent my-agent

# Embedded onboarding UI only (no new project folder)
npx create-atp-agent --dashboard-only

# Interactive CLI onboarding (for existing agents)
npx atp-onboard-agent

# Or visit the web wizard on your ATP site, for example:
# /onboard/agent

create-atp-agent ships a small static wizard plus a mock POST /api/agents/onboard on the same port (for local demos). The full Next.js wizard at /onboard/agent is separate and can be wired to real ATP services in production.

Architecture

ATP is designed to layer under any agent protocol — the same did:atp identity and trust score apply whether an agent speaks MCP, A2A, Swarm, or ADK:

Your AI Agents (LangChain, OpenClaw, AutoGPT, MCP, Swarm, ADK, A2A)
         │
         ▼
    ┌──────────────────────────────────────┐
    │        ATP Security Layer            │
    │  ┌──────────┐ ┌──────────┐ ┌────────┐ │
    │  │ Quantum  │ │   DID    │ │ Trust   │ │
    │  │  Safe    │ │ Identity │ │ Scoring │ │
    │  │  Crypto  │ │ Service  │ │ System  │ │
    │  └──────────┘ └──────────┘ └────────┘ │
    └──────────────────────────────────────┘
                    │
            ┌───────▼───────┐
            │   ATP SDK     │
            │ (3 lines to   │
            │   secure)     │
            └───────────────┘

Specifications & Conformance

ATP is being standardized as a set of open specifications under a dedicated W3C Community Group. The drafts live in docs/specs/ as ReSpec documents — start from the specifications landing page, or open any spec’s index.html in a browser to read the rendered specification. See docs/COMMUNITY-RELEASE.md for how these are published to the w3c-cg/atp Community Group repository.