agent-trust-protocol
Advanced tools
Agent Trust Protocol Core - Quantum-safe security protocol for AI agents with decentralized identity, verifiable credentials, and trust-based permissions
The world's first quantum-safe security protocol for AI agents — protecting your AI infrastructure from today's threats and tomorrow's quantum computers.
npm install atp-sdk
import { Agent } from 'atp-sdk';
const agent = await Agent.create('MyBot'); // Line 1: Create quantum-safe agent
await agent.send('did:atp:other', 'Hello!'); // Line 2: Send secure message
console.log(await agent.getTrustScore('did:atp:other')); // Line 3: Check trust
That's it! Your AI agent now has quantum-safe cryptography, decentralized identity, and trust scoring. Full quickstart →
For Decision Makers & Business Leaders
AI agents are transforming business operations, but they lack proper security infrastructure. Current cryptographic standards will be broken by quantum computers within 10-15 years, making all existing AI agent communications vulnerable.
ATP provides enterprise-grade security for AI agents with:
ATP is production-ready with Ed25519 cryptography, with quantum-safe options (ML-DSA) available for future-proofing. Architecture supports enterprise compliance requirements.
📞 Schedule Enterprise Demo | 📋 View Pilot Program
Build secure AI agents in 3 lines of code
npm install atp-sdk
Option 1: Quick Start (No Services Required) This works immediately - no setup needed:
import { Agent } from 'atp-sdk';
// Create quantum-safe agent (works offline!)
const agent = await Agent.create('my-ai-assistant');
console.log('Agent DID:', agent.getDID());
console.log('Quantum-safe:', agent.isQuantumSafe()); // true
Option 2: Full Integration (With ATP Services) For complete functionality with services running:
# Start ATP services (one command)
docker-compose up -d
# Or clone and start locally
git clone https://github.com/agent-trust-protocol/core.git
cd agent-trust-protocol
./start-services.sh
Then use the agent with full features:
import { Agent } from 'atp-sdk';
const agent = await Agent.create('my-ai-assistant');
await agent.initialize(); // Connects to ATP services
// Your agent now has:
// ✅ Decentralized identity (DID)
// ✅ Quantum-safe cryptography (hybrid Ed25519 + ML-DSA)
// ✅ Digital signatures for every action
// ✅ Trust scoring capability
console.log('Agent ID:', agent.did);
console.log('Ready for secure operations!');
const { Agent } = require('atp-sdk');
// Create an AI agent with cryptographic identity
const agent = new Agent('my-ai-assistant');
await agent.initialize();
// Your agent now has:
// ✅ Decentralized identity (DID)
// ✅ Quantum-safe cryptography
// ✅ Digital signatures for every action
// ✅ Trust scoring capability
console.log('Agent ID:', agent.did);
console.log('Ready for secure operations!');
const { Agent } = require('atp-sdk');
// Create two AI agents
const customerService = new Agent('customer-service-bot');
const paymentProcessor = new Agent('payment-processor');
// Initialize with quantum-safe security
await Promise.all([
customerService.initialize(),
paymentProcessor.initialize()
]);
// Establish trust relationship
await customerService.trust(paymentProcessor.did, {
level: 0.9, // High trust
permissions: ['process_payment', 'refund']
});
// Send cryptographically signed request
const response = await customerService.send(paymentProcessor.did, {
action: 'process_payment',
amount: 99.99,
currency: 'USD',
customer_id: 'cust_123'
});
// Every action is signed, verified, and auditable
console.log('Transaction verified:', response.verified);
console.log('Signature:', response.signature);
const { ATPSecurityWrapper } = require('atp-sdk');
const { OpenAI } = require('langchain/llms/openai');
// Wrap any LangChain agent with ATP security
const llm = new OpenAI({ temperature: 0 });
const secureAgent = new ATPSecurityWrapper(llm, {
agentName: 'langchain-assistant',
trustLevel: 'verified'
});
// Now all LLM calls are cryptographically signed
const response = await secureAgent.call("What's the weather?");
const { MCPServer } = require('atp-sdk/mcp');
// Create quantum-safe MCP server
const server = new MCPServer({
name: 'secure-mcp-server',
quantum_safe: true
});
// All MCP tools are now cryptographically protected
server.addTool('database_query', async (params) => {
// Tool implementation with automatic signature verification
});
const { atpMiddleware } = require('atp-sdk/middleware');
const express = require('express');
const app = express();
// Protect all API endpoints with ATP
app.use(atpMiddleware({
minTrustLevel: 0.7,
requireSignature: true
}));
app.post('/api/ai-action', (req, res) => {
// Only verified AI agents can access this endpoint
console.log('Verified agent:', req.agent.did);
res.json({ status: 'authorized' });
});
📖 Full Developer Docs | ⚡ Quick Start Guide | 💻 API Reference | 🧪 Examples | ❓ Troubleshooting
For IT Departments & Security Teams
| Deployment Type | Description | Best For | Setup Time |
|---|---|---|---|
| Cloud SaaS | Fully managed ATP service | Quick pilots, small teams | 5 minutes |
| Private Cloud | Dedicated ATP instance | Enterprise compliance | 1 day |
| On-Premise | Self-hosted in your datacenter | Maximum control | 2-3 days |
| Hybrid | Mix of cloud and on-premise | Gradual migration | 1-2 days |
# docker-compose.yml - Easy enterprise deployment
version: '3.8'
services:
atp-gateway:
image: atp/gateway:latest
environment:
- MODE=enterprise
- QUANTUM_SAFE=true
- AUDIT_LEVEL=full
ports:
- "443:443"
volumes:
- ./config:/config
- ./certs:/certs
| Plan | Monthly Cost | Agents | Support | SLA |
|---|---|---|---|---|
| Starter | $10,000 | 100 | Business hours | 99.9% |
| Professional | $50,000 | 1,000 | Priority 24/7 | 99.95% |
| Enterprise | Custom | Unlimited | Dedicated team | 99.99% |
📞 Contact Sales | 📋 Request Pilot | 📄 Security Status
| Aspect | No Security | Traditional Security | ATP (Quantum-Safe) |
|---|---|---|---|
| Agent Identity | ❌ None | ⚠️ Username/password | ✅ Cryptographic DID |
| Action Verification | ❌ None | ⚠️ API keys | ✅ Digital signatures |
| Quantum Resistant | ❌ No | ❌ No | ✅ Yes |
| Audit Trail | ❌ None | ⚠️ Basic logs | ✅ Cryptographic proof |
| Trust Management | ❌ None | ⚠️ Static rules | ✅ Dynamic scoring |
| Compliance Ready | ❌ No | ⚠️ Partial | ✅ Full |
Every AI agent gets a unique, cryptographically verifiable identity that can't be forged or stolen.
Hybrid Ed25519 + ML-DSA (Dilithium successor) enabled by default. All new agents automatically use quantum-safe cryptography for protection against both classical and quantum attacks.
Dynamic reputation system that tracks agent behavior and adjusts permissions in real-time.
Fine-grained access control with support for RBAC, ABAC, and custom policy languages.
Every action is logged with cryptographic proof, creating an unalterable record for compliance.
Instant signature verification ensures no unauthorized actions slip through.
Problem: Trading bots executing millions of transactions need verification
Solution: ATP ensures every trade is cryptographically signed and auditable
Result: Zero unauthorized trades, full regulatory compliance
Problem: AI assistants accessing patient records must be HIPAA compliant
Solution: ATP provides cryptographic access control and audit trails
Result: 100% HIPAA compliance with complete traceability
Problem: Classified AI systems require quantum-safe security
Solution: ATP's NIST-approved quantum-safe cryptography
Result: Future-proof security for sensitive operations
Problem: Multi-tenant AI platforms need isolated security domains
Solution: ATP's policy engine enables granular tenant isolation
Result: Secure multi-tenancy with zero cross-contamination
┌─────────────────────────────────────────────────────────────┐
│ Your AI Agents │
│ (LangChain, AutoGPT, Custom Bots, MCP Servers, etc.) │
└─────────────────┬───────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ ATP Security Layer │
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ DID │ │ Quantum │ │ Trust │ │ Policy │ │
│ │ Identity │──│ Safe │──│ Scoring │──│ Engine │ │
│ │ Service │ │ Crypto │ │ System │ │ │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
│ │
│ 🔒 Cryptographic Core │
└─────────────────┬───────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ Immutable Audit Trail (PostgreSQL) │
└─────────────────────────────────────────────────────────────┘
Agent A ATP Agent B
│ │ │
├──1. Request + DID──────> │
│ │ │
│ 2. Verify DID │
│ 3. Check Trust │
│ 4. Apply Policy │
│ │ │
│ <────5. Challenge │
│ │ │
├──6. Signed Response────> │
│ │ │
│ 7. Verify Signature │
│ 8. Log to Audit │
│ │ │
│ ├──9. Forward──────────> │
│ │ │
│ <──10. Signed Reply───── │
│ │ │
<──11. Verified Response─┤ │
Testing environment: AWS c5.2xlarge (8 vCPU, 16GB RAM)
| Operation | Throughput | Latency (p99) | CPU Usage |
|---|---|---|---|
| DID Creation | 20,000/sec | 45ms | 35% |
| Signature Generation | 50,000/sec | 20ms | 40% |
| Signature Verification | 60,000/sec | 15ms | 45% |
| Policy Evaluation | 120,000/sec | 8ms | 30% |
| Trust Score Update | 80,000/sec | 12ms | 25% |
Standard Ed25519: ████████████ 100% baseline
ATP Hybrid Mode: █████████████████ 144% (+44% overhead)
Future Quantum Attack: ████████████ 100% secure
Standard RSA-2048: ░░░░░░░░░░░░ 0% secure
Small price to pay for quantum-proof security
📋 Status: See Security Status for detailed implementation status.
Note: Formal certifications (SOC2 Type II, ISO 27001) are planned but not yet completed. The architecture is designed to meet these standards.
| Feature | Description | Standard | Status |
|---|---|---|---|
| Quantum-Safe Crypto | ML-DSA + Ed25519 hybrid (default) | NIST PQC Standard | ✅ Enabled by default in SDK v1.1+ |
| Classical Crypto | Ed25519 signatures (default) | RFC 8032 | ✅ Production-ready |
| Transport Security | TLS 1.3 support | RFC 8446 | ✅ Infrastructure-dependent |
| Identity | W3C Decentralized Identifiers | W3C DID v1.0 | ✅ Implemented |
| Credentials | Verifiable Credentials | W3C VC v1.1 | ✅ Implemented |
| Audit Logging | Cryptographic hash chain | NIST SP 800-92 | ✅ Implemented |
Found a security issue? Please email security@agenttrustprotocol.com
ATP uses ML-DSA (the standardized version of CRYSTALS-Dilithium), a lattice-based cryptographic algorithm from NIST's Post-Quantum Cryptography Standard. All new agents automatically use hybrid mode, combining ML-DSA with Ed25519 for backward compatibility, ensuring security today and future-proof protection against quantum computers. This provides protection against both classical attacks and future quantum computing threats.
API keys can be stolen, shared, or compromised. ATP uses cryptographic signatures where each agent has a unique private key that never leaves their control. Even if someone intercepts communications, they cannot forge signatures or impersonate agents.
ATP adds approximately 44% overhead compared to non-quantum-safe cryptography. In real terms, this means signature verification takes 15ms instead of 10ms. For most applications, this is negligible compared to network latency and LLM inference times.
Yes! ATP provides adapters for popular frameworks like LangChain, AutoGPT, and Model Context Protocol (MCP). You can also use our SDK to add ATP security to any custom implementation.
Yes, ATP is open source under the Apache 2.0 license. You can use it freely in commercial projects. We also offer enterprise support and managed cloud services for organizations that need additional assistance.
ATP supports gradual migration. You can run ATP alongside existing security systems, gradually moving agents over. Our enterprise team provides migration assistance for large deployments.
🧑💻 DevelopersStart building in 30 secondsnpm install atp-sdkView Quick Start → |
🏢 EnterpriseSchedule a demo with our teamSee ATP in action Contact Sales → |
🛡️ Agent Trust Protocol™
Protecting AI Agents from Tomorrow's Threats, Today
Website • Blog • Twitter • LinkedIn
Licensed under Apache 2.0.
FAQs
Agent Trust Protocol Core - Quantum-safe security protocol for AI agents with decentralized identity, verifiable credentials, and trust-based permissions
The npm package agent-trust-protocol receives a total of 2 weekly downloads. As such, agent-trust-protocol popularity was classified as not popular.
We found that agent-trust-protocol demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Multiple high-impact npm maintainers confirm they have been targeted in the same social engineering campaign that compromised Axios.
Security News
Axios compromise traced to social engineering, showing how attacks on maintainers can bypass controls and expose the broader software supply chain.
Security News
Node.js has paused its bug bounty program after funding ended, removing payouts for vulnerability reports but keeping its security process unchanged.
