Six Core Protocols
Built on Open Standards
Each protocol solves a specific challenge. Together, they create the foundation for universal AI interoperability.
ACP
REST API
Agent Communication Protocol
REST-based protocol for AI agent communication. Send messages, delegate tasks, and coordinate multi-agent workflows. Supports all data modalities.
Linux Foundation
Multimodal
Async-First
MCP
Context
Model Context Protocol
Universal connectivity for AI systems. Access the 6-dimension ontology, semantic search, and RAG pipelines. Native Claude Code integration.
Anthropic
RAG-Ready
Vector Search
A2A
Framework
Agent-to-Agent Protocol
Universal language for AI agents to collaborate. Framework-agnostic coordination across LangGraph, CrewAI, Semantic Kernel, and custom systems.
Google
Linux Foundation
Coordination
AP2
Payments
Agent Payments Protocol
Secure agent-led payments with cryptographic trust. Verifiable credentials, autonomous transactions, multi-platform bookings. Credit cards, crypto, bank transfers.
Google + 60 Orgs
Autonomous
Web3
X402
Micropayments
HTTP-Native Payments
Instant digital payments via HTTP 402. Zero fees, ~2 second settlement, blockchain-agnostic. Pay-per-API-call, pay-per-GB, micropayments as low as $0.001.
Coinbase
Zero Fees
Multi-Chain
AG-UI
Interface
Agent-Generated UI
Dynamic interfaces from structured JSON. Agents send component specs, frontend renders securely. Charts, tables, forms, actions—all type-safe and composable.
ONE Platform
Type-Safe
Real-Time
Better Together
The Power of Integration
Each protocol handles one concern. Together, they create infinite possibilities.
Example: Multi-Agent E-Commerce Pipeline
1
Discovery & Search
MCP
Agent accesses product catalog via semantic search ACP
Query multiple merchants in parallel 2
Coordination & Booking
A2A
Coordinate flight, hotel, and car rental agents AG-UI
Display booking options as interactive cards 3
Payment & Confirmation
AP2
Execute autonomous payment with mandates X402
Micropayments for API calls (~$0.001 each) Result: A single user request becomes a coordinated dance of specialized agents—discovering products, negotiating prices, booking across platforms, and handling payments—all while showing a beautiful, real-time UI. Six protocols. Infinite workflows.
The Ontology Advantage
One Data Model
Six Protocols. Zero Schema Changes.
The brilliant insight: all protocols map to the same 6-dimension ontology. Protocol-specific details live in metadata, creating a protocol-agnostic architecture.
The Universal Pattern
1
Same 6 Tables
groups
Multi-tenant isolation people
Authorization layer things
All entities connections
All relationships events
All actions knowledge
Labels & vectors 2
Protocol in Metadata
// Thing with ACP support
{
type: "intelligence_agent",
properties: {
protocols: {
acp: {
enabled: true,
endpoint: "/acp",
version: "1.0"
}
}
}
}3
Zero Schema Changes
Add new protocols without migrations
Existing code keeps working
Type-safe protocol usage
Universal querying across protocols
How Each Protocol Maps to the Ontology
ACP - Agent Messages
Communication tracked in events
// Event: ACP message sent
{
eventType: "communication_event",
metadata: {
protocol: "acp",
action: "message_sent",
messageId: "msg_abc",
to: "agent_456",
mimeType: "application/json"
}
}MCP - Context Access
Resources exposed via things
// Thing: MCP Server
{
type: "mcp_server",
properties: {
protocols: {
mcp: {
resources: [
"one://things",
"one://knowledge"
]
}
}
}
}A2A - Task Delegation
Connections track delegation
// Connection: Task delegation
{
relationshipType: "delegated_to",
metadata: {
protocol: "a2a",
taskId: "task_xyz",
taskType: "create_plan",
status: "in_progress"
}
}AP2 - Mandates
Intent stored as thing
// Thing: Intent Mandate
{
type: "intent_mandate",
properties: {
protocols: {
ap2: {
maxPrice: 1500,
autoExecute: true,
credentialHash: "sha256:..."
}
}
}
}X402 - Micropayments
Payment events with network
// Event: Payment verified
{
eventType: "payment_verified",
metadata: {
protocol: "x402",
network: "base",
amount: "0.01",
asset: "USDC"
}
}AG-UI - Components
UI messages as things
// Thing: UI Component
{
type: "message",
properties: {
protocols: {
agui: {
component: "chart",
data: { /* ... */ },
layout: { width: "full" }
}
}
}
}Complete Multi-Protocol Flow
Example: "Find and book a vacation under $3000"
MCP
Access Preferences Agent queries user budget and past trips via MCP resources
ACP
Query Travel Agents Send parallel messages to flight, hotel, and car rental agents
A2A
Coordinate Booking Multi-agent coordination across travel services
AG-UI
Show Options Display vacation packages as interactive cards
AP2
Create Mandate User approves $2700 payment with verifiable credential
X402
API Micropayments $0.01 payments for each booking API call
Result: Six protocols orchestrated through one ontology. Zero schema changes. Complete audit trail in events table.
Traditional Approach
// Custom tables per protocol
acp_messages
mcp_resources
a2a_tasks
ap2_mandates
x402_payments
agui_components
// Custom APIs per protocol
/api/acp/*
/api/mcp/*
/api/a2a/*
/api/ap2/*
/api/x402/*
/api/agui/*
// Result: 6x integration cost
// 6x maintenance burden
// Schema changes for every protocolONE Platform Approach
// Same 6 tables for ALL protocols
groups
people
things
connections
events
knowledge
// Universal API
/api/things
/api/connections
/api/events
// Result: Zero integration cost
// Protocol details in metadata
// Schema stable forever
// Future-proof architectureWhy Protocol-First Architecture?
Universal Interoperability
Connect to any AI framework, payment system, or communication platform. No vendor lock-in.
Type-Safe & Secure
All protocols mapped to the ontology. Type-safe validation, cryptographic trust, complete audit trail.
Zero Integration Cost
One ontology, six protocols. Every integration follows the same pattern. Add new protocols in hours, not months.
Ecosystem Amplification
Plug into existing MCP, ACP, A2A, AP2, and X402 ecosystems. Instant access to thousands of agents and services.
Ontology-First Design
Protocol details stored in metadata. Same 6-dimension ontology handles all protocols. Clean separation of concerns.
Future-Proof
New protocols emerge? Add them to metadata. Ontology stays stable. Your code doesn't break.