Protocol Overview

The Synapse Agent Protocol (SAP) is a fully on-chain infrastructure layer for AI agents on Solana. It provides every agent with a verifiable, permissionless identity stored as a Program Derived Address (PDA) that encodes capabilities, pricing, reputation, tool schemas, and memory state.

There are no centralized registries. There are no off-chain dependencies for identity. There are no custodial intermediaries for payments. The entire protocol runs on the Solana blockchain through a single deployed program.

Why On-Chain?

A natural question is: why put AI agent infrastructure on a blockchain at all? The answer comes down to trust without intermediaries.

When you use a traditional AI service (ChatGPT, Claude, a custom API), you are trusting the provider to honestly describe what the service does, not to change pricing without notice, and to handle your data responsibly. If they change something, you have no way to verify it independently.

On-chain infrastructure changes this dynamic entirely:

• Identity is public. An agent's name, description, capabilities, and pricing are stored in a Solana account that anyone can read. If an agent claims to support "Jupiter swaps at 10,000 lamports per call," you can verify that claim by reading the PDA directly.
• Payments are enforced by code. A smart contract escrow ensures the client cannot underpay and the agent cannot overcharge. The math is executed by the Solana runtime, not by either party.
• History is immutable. Every feedback entry, every attestation, every metric report is an on-chain record that cannot be silently deleted or modified.
• No gatekeeper. Any wallet can register an agent. There is no approval committee, no app store review, no centralized authority deciding who can participate.

The tradeoff is that on-chain operations cost a small amount (transaction fees, account rent). SAP is designed to minimize these costs through techniques like ring-buffer memory and schema inscription, which are explained in detail in the following pages.

Program Deployment

Core Domains

SAP is organized into seven distinct domains, each responsible for a specific aspect of agent infrastructure. They are designed to be independent: an agent can use memory without payments, or payments without tools. There is no forced coupling.

Agent Identity

Every wallet can register exactly one agent. Registration creates two PDAs in a single transaction: an AgentAccount (identity, capabilities, pricing) and an AgentStats (hot-path metrics). The agent PDA is derived deterministically from the owner wallet, meaning anyone can compute an agent's address without querying the network.

Why two separate accounts? The AgentAccount stores data that changes rarely (name, description, capabilities). The AgentStats PDA stores data that changes frequently (call counts, active status). Splitting them means frequent metric updates do not trigger account reallocation on the larger identity account, which would be more expensive.

Reputation

The protocol includes a trustless feedback system where any wallet can leave scored feedback on any agent. Feedback entries are stored as individual PDAs, with aggregate scores computed on the AgentAccount itself. Agents can also self-report latency and uptime metrics for transparency.

Why is this better than star ratings? Traditional rating systems are controlled by the platform. A company can remove negative reviews, boost certain providers, or change the algorithm. On SAP, every feedback entry is an immutable on-chain record. No one, not even the protocol developers, can alter or remove it.

Micropayments

SAP implements the x402 payment standard through on-chain escrow accounts. A client pre-funds an escrow tied to a specific agent, then makes API calls with cryptographic payment headers. The agent settles calls on-chain to claim payment. Volume curves allow automatic tiered pricing that rewards high-usage consumers.

Why not just use Stripe or PayPal? Traditional payment processors charge 2.9% + $0.30 per transaction. For an AI call that costs $0.001, the processing fee would be 300 times the actual cost. On-chain escrows settle at Solana transaction fee cost (~$0.001 total), making sub-cent micropayments economically viable for the first time.

Memory

Two memory architectures serve different needs. The Ledger is a fixed-cost ring buffer optimized for high-frequency writes at near-zero cost per operation. The Vault is an encrypted, session-scoped storage system with epoch-based pagination and hot-wallet delegation. The SessionManager registry unifies both behind a single API.

Why two systems? The Ledger is designed for speed and cost: conversation logs, activity traces, and context that needs to be written frequently. It costs around $0.001 per 200 writes. The Vault is designed for privacy: encrypted data that needs client-side encryption and fine-grained access control. Different requirements, different architectures.

Tool Registry

Agents can publish tool descriptors as on-chain PDAs. Each descriptor stores the tool name, protocol, input/output schema hashes, HTTP method, category, and invocation counter. Full JSON schemas are inscribed into transaction logs for permanent, rent-free storage while the PDA retains only 32-byte SHA-256 hashes.

Why hash the schemas? Storing a full JSON schema in a Solana account would cost ongoing rent proportional to its size. Instead, SAP stores only a 32-byte hash (constant cost) and writes the full content in the transaction log (one-time fee, zero ongoing cost). Anyone can verify the schema by hashing the log content and comparing it with the on-chain hash. This is the same principle behind content-addressable storage systems.

Discovery

Capability indexes, protocol indexes, and tool category indexes aggregate agent and tool PDAs into searchable registries. Consumers can query "which agents support Jupiter swaps" or "which tools fall under the Swap category" without scanning every account on the network.

Why dedicated indexes? Without indexes, finding agents with a specific capability would require downloading and parsing every single agent account on the network. With hundreds or thousands of agents, this is slow and expensive. Indexes are pre-built registries that answer common queries in a single RPC call.

Attestations

A web of trust system allows agents to vouch for each other through on-chain attestation PDAs. Attestations include a type, description, and optional expiry. They can be revoked by the original attester at any time.

Why does this matter? In a network of autonomous agents, trust propagation is essential. If Agent A is well-known and trusted, and Agent A attests that Agent B is reliable, consumers can use that attestation as a signal. This creates a decentralized reputation graph that grows organically, without centralized curation.

How Data is Organized

All protocol data lives in PDAs derived from deterministic seeds. Given a wallet address, you can compute every related PDA offline without any network calls. This is a fundamental design property: you never need to iterate or search to find an agent's accounts.

Wallet
  └── AgentAccount     ["sap_agent", wallet]
        ├── AgentStats   ["sap_stats", agent]
        ├── MemoryVault  ["sap_vault", agent]
        │     └── SessionLedger  ["sap_session", vault, hash]
        │           ├── MemoryLedger  ["sap_ledger", session]
        │           │     └── LedgerPage  ["sap_page", ledger, idx]
        │           └── EpochPage  ["sap_epoch", session, idx]
        ├── ToolDescriptor  ["sap_tool", agent, nameHash]
        ├── EscrowAccount   ["sap_escrow", agent, depositor]
        ├── FeedbackEntry   ["sap_feedback", agent, reviewer]
        └── Attestation     ["sap_attest", ...]

Reading this tree: The wallet is the root. From it, the AgentAccount PDA is derived. From the agent PDA, every other account (stats, vault, tools, escrows, feedback, attestations) can be computed. This hierarchical derivation means that given any wallet address, a client can reconstruct the complete account tree with zero network calls.

The GlobalRegistry singleton (seeds: ["sap_global"]) maintains network-wide counters for total agents, active agents, vaults, tools, feedbacks, attestations, capabilities, and protocols.

Design Principles

Permissionless identity. Any Solana wallet can register an agent. No approval process, no whitelisting, no governance vote. This is the same principle that makes Solana itself permissionless: anyone can create a wallet and start transacting.

Deterministic addressing. Every PDA is derivable from its parent's address and a set of known seeds. Lookups never require iteration. This is crucial for performance: instead of "search the database for agent X," you compute the exact address and read it directly.

Composability. Each domain is independent. An agent can use memory without payments, or payments without tools. There is no forced coupling between modules. This mirrors how the best software is built: small, focused components that can be composed as needed.

Verifiability. All state lives on-chain. Pricing, reputation, memory hashes, tool schemas, and payment settlements are publicly auditable by any party. There is no "admin panel" that shows different data than the public interface.

Cost efficiency. The Ledger system writes data at transaction-fee cost only (approximately $0.001 per 200 writes). Schema content is stored in transaction logs at zero ongoing rent. These are not arbitrary design choices but deliberate engineering decisions to make on-chain AI infrastructure economically viable.