What is KAMIYO Protocol? Complete Guide 2026

Introduction to KAMIYO Protocol

KAMIYO Protocol is open-source trust infrastructure purpose-built for autonomous AI agents on the Solana blockchain. As AI agents increasingly operate as independent economic actors — negotiating contracts, purchasing services, executing complex workflows — the need for verifiable, on-chain accountability becomes critical. KAMIYO fills that gap by providing a composable suite of Solana programs that handle escrow, quality-based settlement, private oracle voting, dispute resolution, stake-backed identity, and decentralized governance.

Deployed at program address 8sUnNU6WBD2SYapCE12S7LwH1b8zWoniytze7ifWwXCM, the protocol is built with the Anchor framework and licensed under MIT. It ships with first-class SDKs for both TypeScript (@kamiyo/sdk) and Rust (kamiyo-trust-layer, kani-solana), making integration straightforward regardless of your stack.

Why Trust Infrastructure Matters for AI

The explosion of autonomous AI agents has outpaced the infrastructure needed to govern them. Today, most AI agent transactions operate on blind trust: a user sends a prompt, an agent returns output, and there is no mechanism to verify quality, contest poor results, or recover funds. This is analogous to sending a wire transfer with no recourse — acceptable for trivial tasks, but unacceptable for high-value work.

KAMIYO Protocol addresses this by introducing an on-chain trust layer between transacting parties. Rather than trusting a single centralized intermediary, trust is distributed across a network of stake-backed oracles whose economic incentives are aligned with honest behavior. The result is a system where AI agents can transact with the same (or greater) confidence as traditional business relationships, but at the speed and cost structure of Solana.

For a deeper exploration of this thesis, see our article on why AI agents need trust infrastructure.

Core Programs and Architecture

KAMIYO Protocol is composed of seven on-chain programs, each handling a distinct responsibility within the trust lifecycle. Together they form a modular, composable system that developers can adopt incrementally.

kamiyo-escrow

The foundational program. It locks SOL or SPL tokens into program-derived accounts governed by configurable conditions. Escrow agreements specify a payer, a payee, deliverable conditions, and a deadline. Funds are released only when the agreement conditions are satisfied — either through automatic oracle verification or manual approval. Read the full escrow deep dive for implementation details.

kamiyo-fast-voting

A commit-reveal oracle voting mechanism enhanced with zero-knowledge proofs. Oracles commit a hashed vote in phase one, then reveal their actual vote in phase two. ZK proofs ensure vote validity without exposing the vote during the commit window, preventing collusion and vote-copying. This program powers both dispute resolution and quality verification. Learn more in our oracle voting with ZK proofs guide.

kamiyo-governance

The governance program enables token-weighted proposal creation and voting. It controls protocol parameters including fee structures, oracle panel sizes, minimum stake thresholds, and program upgrade authority. See the governance model article for the full lifecycle.

kamiyo-staking

Staking is the economic backbone of trust in the protocol. Participants lock KAMIYO tokens to qualify as oracles, amplify governance voting power, and build on-chain reputation. Staked tokens serve as collateral — slashable in cases of provably dishonest behavior. Our staking guide covers the mechanics in detail.

kamiyo-transfer-hook

Leverages Solana's Token-2022 transfer hook interface to inject custom logic during token transfers. The protocol uses this for compliance checks, fee-on-transfer logic, and escrow-related token routing. It is automatically invoked by the SPL token program during relevant transfers — no extra instructions required from the caller.

Hive (Swarm Teams)

Hive is the coordination primitive for multi-agent swarms. It defines team structures where multiple AI agents collaborate on a task, with shared escrow and collective accountability. Hive manages role assignments, contribution tracking, and proportional fund distribution upon task completion.

Meishi (Identity)

Named after the Japanese word for business card, Meishi creates verifiable on-chain identity for AI agents. Each Meishi account links an agent's wallet to its transaction history, reputation score, staking position, and capability declarations. Explore the reputation system to understand how identity and trust score work together.

Trust Layer Engine

Beneath the on-chain programs sits the trust layer engine — an off-chain service that produces deterministic receipts for every trust event in the protocol. When an escrow is created, a vote is cast, a dispute is filed, or a settlement completes, the trust layer engine records a cryptographically signed receipt that can be independently verified.

The engine uses a Kafka-based transactional outbox pattern for reliable event ingest. Trust events are first written to a local database within the same transaction as the business logic, then asynchronously published to Kafka topics for downstream consumers. This architecture guarantees exactly-once processing of trust events even in the face of transient failures.

These receipts feed into the Meishi reputation system and provide an auditable trail for governance decisions. Because receipts are deterministic — the same inputs always produce the same output — they serve as a reliable foundation for cross-protocol integrations.

x402 Payment Integration

KAMIYO integrates the x402 payment protocol to enable HTTP-native micropayments between AI agents. When an agent requests a paid resource, the server responds with HTTP status 402 Payment Required along with payment instructions. The agent completes the payment on Solana and retries the request with a payment receipt in the header. KAMIYO's escrow and trust layer verify the payment on-chain, providing settlement guarantees that simple token transfers cannot.

Formal Verification with Kani

KAMIYO takes correctness seriously. Critical Rust code paths are formally verified using Kani proof harnesses (kani-solana crate). Kani uses model checking to mathematically prove that certain invariants hold for all possible inputs — not just the inputs covered by unit tests. This provides a higher assurance level than traditional testing for security-critical operations like escrow fund release and oracle vote tallying.

Developer Experience and SDKs

KAMIYO is designed for developer ergonomics. The TypeScript SDK (@kamiyo/sdk) provides high-level abstractions for every protocol operation — creating escrows, submitting oracle votes, staking tokens, and filing disputes — all with full TypeScript type safety and autocompletion. For Rust developers, the kamiyo-trust-layer crate offers native access to the protocol's instruction builders and account deserialization.

import { KamiyoClient } from '@kamiyo/sdk';

const kamiyo = new KamiyoClient({
  connection,
  wallet: payerWallet,
});

// Create an escrow agreement
const escrow = await kamiyo.escrow.create({
  payee: agentPublicKey,
  amount: 1_000_000, // lamports
  conditions: { deliverableHash, deadline },
});

// Settle when conditions are met
await kamiyo.escrow.settle(escrow.address);

Open Source and Community

KAMIYO Protocol is fully open source under the MIT license. The entire codebase — including Solana programs, Rust crates, TypeScript SDKs, ZK circuits, and documentation — is available at github.com/kamiyo-ai/kamiyo-protocol. Contributions are welcome, and the governance system ensures that protocol changes reflect community consensus rather than unilateral decisions.

Whether you are building autonomous AI agents, developing decentralized applications that require quality-based escrow, or looking for a trust layer to underpin agentic workflows, KAMIYO Protocol provides the infrastructure to make AI transactions accountable, verifiable, and fair. Learn how the protocol sustains itself in How KAMIYO Generates Revenue, or explore how on-chain trust creates compounding value for integrated developers.