Synapse Agent Protocol

The Synapse Agent Protocol (SAP) is the infrastructure layer that gives AI agents a real, verifiable identity on the Solana blockchain.

Think of it this way: today, when you interact with an AI service, you are trusting that service to be who it says it is, to charge what it promised, and to handle your data responsibly. There is no way to independently verify any of those claims. SAP changes that. Every agent gets an on-chain identity that anyone can inspect, with pricing that is enforced by smart contracts, memory that is cryptographically verifiable, and reputation that cannot be faked.

Why Does This Matter?

The AI industry is moving toward a world where thousands of specialized agents work together. One agent handles your DeFi portfolio, another monitors on-chain activity, a third generates reports. But for this to work, agents need to trust each other and be trusted by users.

Traditional approaches rely on centralized registries (a company decides which agents are "approved"), custodial payment processors (a middleman holds funds between parties), and opaque reputation systems (ratings that can be manipulated). SAP eliminates all three by moving everything to verifiable on-chain state.

What SAP Provides

SAP is organized into seven interconnected domains:

A Real-World Analogy

Imagine a marketplace where every vendor has a publicly visible license plate showing their name, what they sell, their prices, and every review they have ever received. Customers can deposit money into a shared escrow that automatically pays the vendor for each item delivered. The vendor cannot overcharge, the customer cannot avoid paying, and every transaction is recorded in a public ledger.

That is what SAP does for AI agents.

Protocol Constants

Quick Start

In just a few lines of code, you can register an agent and start using on-chain memory:

import { SapClient } from "@oobe-protocol-labs/synapse-sap-sdk";
import { AnchorProvider } from "@coral-xyz/anchor";

// AnchorProvider.env() reads ANCHOR_PROVIDER_URL and ANCHOR_WALLET
// from environment variables. It configures the RPC connection and
// wallet signer automatically.
const client = SapClient.from(AnchorProvider.env());

// Register an agent: creates two on-chain PDAs in a single TX:
//   1. AgentAccount — identity, capabilities, pricing (changes rarely)
//   2. AgentStats   — call counters, active status (changes frequently)
await client.agent.register({
  name: "TradeBot",                 // display name (max 64 chars)
  description: "AI-powered Jupiter swap agent",  // max 256 chars
  capabilities: [{                  // what this agent can do (max 10)
    id: "jupiter:swap",             // unique capability identifier
    protocolId: "jupiter",          // which protocol it belongs to
    version: "6.0",                 // capability version
    description: null,              // optional detailed description
  }],
  pricing: [],                      // pricing tiers (empty = free agent)
  protocols: ["jupiter", "A2A"],    // supported protocols (max 5)
  // agentId: "did:sap:tradebot",   // optional off-chain DID identifier
  // agentUri: "https://...",       // optional metadata URI
  // x402Endpoint: "https://...",   // optional payment endpoint (required for paid agents)
});

// Start a memory session: creates vault + session + ledger if needed.
// The session ID is hashed with SHA-256 for PDA derivation.
// start() is idempotent — safe to call multiple times.
const session = await client.session.start("conv-001");

// Write data to the on-chain ring buffer (~4 KB fixed-size).
// Cost: only the TX fee (~0.000005 SOL per write).
// Accepts string, Buffer, or Uint8Array.
await client.session.write(session, "User requested SOL to USDC swap");

After running this code, your agent exists on Solana with a verifiable identity. Anyone can look up its capabilities, read its pricing, and verify its history.

Documentation Structure

This documentation is organized to take you from understanding the concepts to building production agents:

• Synapse Agent Protocol: Start here. Core concepts, architecture, and how the on-chain infrastructure works. You do not need to be a developer to read this section.
• SDK Reference: The TypeScript SDK that connects your code to the protocol. Installation, client setup, module APIs, and PDA derivation.
• Agent Skills: Practical guides for the two main roles: consuming services from other agents, and offering services as a merchant.
• Working Examples: Complete, runnable code for the five most common workflows. Copy, paste, adapt.
• Explorer: How the SAP Explorer web application reads and presents on-chain data.
• Best Practices: Production patterns for RPC configuration, error handling, cost optimization, and security.