Identify the Agent
Each participant uses a DID-backed identity so peers can bind messages to an agent-level cryptographic identity.
Open source protocol for secure AI agent communication. One gateway, unlimited agents, unlimited locations — large-scale deployment with zero licensing costs.
Reduce connection overhead in distributed agent systems with QUIC transport and persistent sessions designed for low-latency communication.
One gateway, unlimited agents, unlimited locations — zero licensing costs. AXCP Core is Apache 2.0. Deploy across 5 offices or 50 countries with message-layer identity and signing. The Commercial Pack adds governed operations, Signed Agent Manifest controls, and regulated evidence features for specialized deployments.
Connect any agent, in any language, over any stack. AXCP abstracts away transport details so Rust micro-services, Python ML pipelines, Go edge agents — even legacy MCP, A2A, and ACP systems — can exchange context through a single, strongly-typed envelope. Build heterogeneous swarms without rewriting code.
Security built into every message. TLS 1.3 transport, Ed25519 signatures, DID-based identity, and replay protection — all in Core. Need governed operations or regulated evidence? Contact us for the Commercial Pack.
Modern transport protocol with built-in TLS 1.3 encryption, multiplexed sessions, and improved behavior over traditional TCP for agent-to-agent communication.
Commercial state synchronization for distributed agent workflows.
Optional privacy controls for telemetry and aggregate analytics while preserving application payloads.
Dynamically negotiate security profiles between agents based on capabilities and requirements. Profile negotiation is built into the handshake protocol.
Trusted runtime readiness for high-assurance production deployments.
Production observability for monitoring runtime health, policy posture, and operational behavior.
Three tiers designed for different assurance requirements — from open source Core deployments to governed commercial operations.
Basic logging (optional)
Development, CI/CD pipelines, single-org deployments, edge agents, startups
Tamper-evident audit evidence
Multi-tenant SaaS, public cloud, IIoT gateways, B2B platforms
Tamper-evident audit evidence
Finance, healthcare, government, cross-border AI operations
AI agents are becoming part of our daily lives. They need a secure way to talk to each other. Here's why AXCP Core is the answer.
AI agents from different companies can't securely communicate with each other. It's like having phones that only work within the same carrier — but worse, because there's no standard for security.
AXCP gives every AI agent a verified identity and signs every message cryptographically. Think of it as "HTTPS for AI agents" with message-level verification.
Claude, GPT, Gemini, and any other AI can work together securely on the same task.
Cryptographic signatures prove authenticity. You don't need to trust — you can verify.
QUIC transport is designed for low-latency behavior while keeping security checks explicit.
Apache 2.0 licensed. Use it, modify it, build on it. No proprietary runtime requirement.
AXCP Core isn't a "demo tier." It's a production-ready protocol that can power your entire organization.
LONDON NEW YORK TOKYO SYDNEY
┌───────┐ ┌───────┐ ┌───────┐ ┌───────┐
│Agent 1│ │Agent 4│ │Agent 7│ │Agent10│
│Agent 2│ │Agent 5│ │Agent 8│ │Agent11│
│Agent 3│ │Agent 6│ │Agent 9│ │Agent12│
└───┬───┘ └───┬───┘ └───┬───┘ └───┬───┘
│ │ │ │
└───────────────┴────────┬───────┴────────────────┘
│
▼
┌─────────────────────────┐
│ AXCP GATEWAY │
│ Frankfurt (HQ) │
│ gateway.company.com │
└─────────────────────────┘
✓ All 12 agents communicate securely
✓ Ed25519 signatures on every message
✓ Zero licensing costs
Connect agents from any location worldwide. If they can reach your gateway, they can communicate securely.
Organize by team, department, or authorization level. Each agent only knows the DIDs it needs to communicate with.
Apache 2.0 licensed. Deploy 10 agents or 10,000 — the cost is the same: free.
A manufacturing company with factories in 5 countries deploys AXCP Core on their central server. Each factory runs AI agents for quality control, inventory management, and logistics. All agents communicate through the single gateway — coordinating production across continents with cryptographic security.
AI agents are moving from isolated tool calls into distributed workflows where identity, message integrity, and replay protection matter at the protocol layer. Transport security alone does not prove which agent sent which message after the fact.
AXCP Core is designed as a complementary security layer for agent ecosystems: signed envelopes, DID-based identity, replay protection, and typed transport for verifiable agent-to-agent communication. MCP defines what agents can do; AXCP helps verify who is communicating, what was sent, and whether it was replayed.
AXCP Core keeps the secure communication flow explicit and verifiable without requiring a commercial control plane.
Each participant uses a DID-backed identity so peers can bind messages to an agent-level cryptographic identity.
The message envelope is signed before transport, making sender identity and message integrity verifiable beyond the TLS session.
The gateway validates signatures, timestamps, nonces, and profile expectations before forwarding valid traffic.
Previously seen or stale messages are rejected so captured envelopes cannot simply be reused later.
This is the public AXCP Core security baseline. Commercial tiers add governed admission, Signed Agent Manifest, operational visibility, and regulated evidence workflows without changing the Core license.
AXCP Core gives you the Apache 2.0 secure baseline. The Commercial Pack adds licensed control-plane capabilities for governed operations and regulated deployments.
Not sure which tier you need? We're happy to help.
Build against the public Apache 2.0 Core implementation with SDK surfaces for Go, Python, and TypeScript. Rust remains available in the repository as an experimental telemetry adapter.
Canonical Core implementation for DID authentication, Ed25519 signing, replay validation, profile negotiation, and typed AXCP envelopes.
go get github.com/tradephantomllc/axcp-spec/sdk/go@latest
Core Python SDK for AI and ML agents: identity generation, deterministic protobuf envelopes, Secure Baseline signing, verification, timestamps, replay, and QUIC transport.
git clone https://github.com/tradephantomllc/axcp-spec.git python3 -m pip install -e axcp-spec/sdk/python
Typed Core SDK for Node applications with Secure Baseline parity, deterministic envelopes, signing and verification, replay checks, stream framing, and a TLS adapter.
git clone https://github.com/tradephantomllc/axcp-spec.git cd axcp-spec/sdk/typescript && npm install && npm test
Python and TypeScript SDKs are available from the public repository today. Package-registry publication will follow the SDK release checklist; the commands above use the source tree until those packages are published.
Direct answers for developers and technical evaluators.
AXCP (Adaptive eXchange Context Protocol) is a secure communication protocol designed for autonomous AI agents. It provides DID-based identity, Ed25519 cryptographic signatures, replay protection, and QUIC transport with TLS 1.3.
Yes. AXCP Core is free and open source under the Apache 2.0 license. Advanced and Enterprise tiers add commercial capabilities for governed and regulated deployments.
AXCP Core provides public SDKs for Go, Python, and TypeScript. Rust remains available as an experimental telemetry adapter.
AXCP is complementary to MCP and A2A. MCP and A2A help describe tools, resources, discovery, and coordination. AXCP focuses on secure agent-to-agent communication with DID-based identity, signed envelopes, replay protection, and typed transport.
AXCP is a new project with a vision to build a passionate community of security experts, developers, and privacy advocates. We're just getting started and would love for you to help shape the future of secure, efficient data exchange protocols.
We're in the early stages and building our community from the ground up.
Your contributions can make a real impact on the project's direction.
AXCP Core is fully open source under the Apache License 2.0. Use, modify, and distribute freely for any purpose — including commercial applications.
Three Tiers: