Kite 백서

bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 7쪽 중 2쪽

CP, AP2, and OAuth 2.1 Without these agent–specific layers, organizations cannot confidently delegate payment authority. The vision of transforming every agent interaction into a compliant, auditable micropayment remains unrealized. Tempo solves the payment problem but not the agent problem. The promise of autonomous agents remains unfulfilled, and thus the agentic infrastructure revolution is still incomplete. 1.5 The SPACE Framework: End-to-End Infrastructure Reimagined for Agents This paper introduces Kite, the first infrastructure system designed from first principles for the agentic economy. We present the SPACE framework as the complete solution: • S tablecoin–native: Every transaction settles in stablecoins with predictable sub–cent fees • P rogrammable constraints: Spending rules enforced cryptographically, not through trust • A gent–first authentication: Hierarchical wallets with cryptographic principal binding • C ompliance–ready: Immutable audit trails with privacy–preserving selective disclosure • E conomically viable micropayments: True pay–per–request economics at global scale Our Core Innovations The core innovations of Kite include: Three-Layer Identity Architecture We introduce the first hierarchical identity model that separates user (root authority), agent (delegated authority), and session (ephemeral authority) identities. Each agent receives its own deterministic address derived from the user’s wallet using BIP–32, while session keys are completely random and expire after use. Sessions are authorized by their parent agent through cryptographic signatures, creating a clear delegation chain from user to agent to session. This defense–in–depth architecture ensures graduated security: compromising a session affects only one delegation; compromising an agent remains bounded by user–imposed constraints; and user keys secured in local enclaves inaccessible to any external third parties, which are thus highly unlikely to be compromised, represent the only point of potential unbounded loss. While funds remain compartmentalized for security, reputation flows globally across the system. Every transaction and interaction contributes to a unified reputation score, establishing trust that spans users, agents, and services throughout the Kite platform. Programmable Governance Beyond Smart Contracts While smart contracts enable programmable money, agents require compositional rules that span multiple services. Kite implements a unified smart contract account model where users own a single on–chain account holding shared funds. Multiple verified agents operate through session keys with cryptographically enforced spending rules: "Expense agent limit $5,000/month for reimbursements, Scheduling agent limit $500/month for bookings, Grocery agent limit $2,000/month with velocity controls, Investment agent limit $1,000/week with volatility triggers." Rules can be temporal (e.g., increase limits over time), conditional (e.g., reduce limits if volatility spikes), and hierarchical (cascade through delegation levels). These aren’t policies, but programmatically enforced boundaries. Agent-Native Payment Rails with State Channels Beyond stablecoins and payments–first blockchains, the real revolution goes deeper. Kite creates agent–first transaction types. Beyond simple transfers, Kite implements programmable micropayment channels optimized for agent patterns. Instead of the traditional over–complicated multi–party card rails of authenticate, request, pay, wait, and verify, payments are instantly settled during agent interaction within the same channel. Two on–chain transactions (open and close) enable thousands of off–chain signed updates, achieving sub–hundred–millisecond latency at $1 per million requests. This architectural inversion, treating per–request and streaming micropayments as first–class behaviors with instant finality, unlocks agent–native economics which were previously impossible. In the following chapters, we will detail how Kite’s architecture, protocols, and implementations solve each infrastructure failure, transforming the promise of the agentic economy into operational reality. The agentic future isn’t waiting for better models. It’s waiting for infrastructure that treats agents as first-class economic actors. With Kite, the wait ends. 2. Kite AI Design Principles 2.1 Tailored Design for the Future of Agentic AI The evolution from human infrastructure to agent infrastructure requires fundamental architectural reimagination. Every existing blockchain, from Bitcoin to Ethereum to modern payments chains like Tempo, embeds a critical assumption: transactions are initiated by humans who can manage private keys, evaluate risks in real time, and intervene when necessary. This assumption shapes everything from authentication to settlement timing. Kite breaks this assumption entirely. Built from first principles to treat AI agents as first–class citizens in the digital economy, each agent maintains its own cryptographic identity, authentication mechanisms, wallet hierarchy, and governance policies. This creates a system where agents authenticate, transact, and coordinate natively without human workarounds. The implications cascade through every layer. Manual key management becomes hierarchical key derivation. Transaction evaluation becomes programmable constraint enforcement. Social reputation becomes cryptographic verification. These inversions of design assumptions transform not just how agents operate, but what becomes possible when infrastructure aligns with agent capabilities rather than fighting them. Consider the difference in practice. A human evaluates a $1,000 transaction by reading the amount, recognizing the recipient, and clicking confirm. An agent executing the same transaction must prove its authorization cryptographically, demonstrate the transaction falls within programmed boundaries, generate an immutable audit trail, and settle instantly to continue its workflow. The human process takes seconds of attention. The agent process takes milliseconds of computation. Yet current infrastructure forces agents through the human process, destroying their advantages. 2.2 Chain of Trust with Cryptographic Proof Every action in the Kite system creates a cryptographically verifiable audit trail, establishing an immutable chain of custody from user to agent to service to outcome. This transforms agent operations from black–box mysteries into transparent, provable sequences where every decision can be verified and every constraint can be enforced mathematically. The chain of trust operates through three critical principles: No Direct Key Access : The revolution starts with a simple insight: agents should never touch private keys directly. Instead, each operation receives a one–time, task–scoped session key with surgical precision permissions. An agent authorized to purchase data feeds receives a key valid only for specific providers, exact amounts, and narrow time windows. When the task completes or the window expires, the key becomes cryptographically useless. Even total compromise affects only that single operation. Fine-Grained Task Authorization : Permissions are scoped at the task level, not the agent level. Both users and agents can create these scoped authorizations—users delegate to agents, and agents can further sub–delegate to specialized sub–agents or tasks. This granular authorization extends beyond simple spending limits. Permissions scope down to individual API endpoints, specific data types, and conditional triggers. An agent authorized to "purchase data feeds" receives a session key valid only for strictly enforced specific data providers, amounts, and time windows. This granularity makes broad compromises mathematically impossible. Reputation Without Identity Leakage : The relationship between users and agents creates a fascinating paradox: shared reputation with independent identity. Each user and corresponding agent accumulates their own track record of successful operations, building trust through performance. For each user–agent binding, the reputation of the duo is inherited as a combination of the user’s reputation and the agent’s reputation, and the operation outcome affects both the reputation of the user and the agent, where the cryptographic binding to the controlling user ensures accountability flows upward. Services know that behind every agent stands a real user with real stakes, even when that user’s identity remains private. Users can selectively disclose ownership when beneficial, but privacy remains the default. This architecture enables something unprecedented: complete transparency without sacrificing privacy. Regulators can verify that agents operated within legal boundaries. Services can confirm payment authorization. Users can audit every action their agents took. Yet sensitive business logic, trading strategies, and personal information remain encrypted. The system proves compliance without revealing secrets. 2.3 Sovereignty through Separation Kite rigorously separates decentralized asset management from developer services, creating an architecture where security and usability reinforce rather than compromise each other. Decentralized Asset Model : The decentralized asset model ensures complete user sovereignty. All funds remain in self–custodial wallets controlled by smart contracts that even Kite cannot access. Users maintain exclusive control over their digital wealth while agents operate within mathematically enforced boundaries. Users maintain independent access to their funds through standard blockchain interfaces, regardless of Kite’s availability. This isn’t a promise or a policy. It’s a cryptographic guarantee. Kite Platform Services : Meanwhile, the Kite platform provides the abstraction layer that makes agent operations practical. APIs handle complex cryptographic operations, protocol translations, and cross–chain interactions. Developers work with familiar patterns while the platform manages key derivation, session management, and constraint compilation. The platform never touches assets directly. It simply provides the tools to make asset operations seamless. This separation solves a fundamental tension in blockchain systems. Pure decentralization often means terrible user experience. Pure centralization means unacceptable risk of single point failure and user assets compromise. Kite achieves both security and usability by separating concerns architecturally. Assets remain decentralized and sovereign. Services remain centralized and optimized. Users get the best of both worlds without compromise. The implications extend beyond technical architecture. Regulators can audit the platform without accessing user funds. Developers can build sophisticated applications without managing private keys. Users can delegate complex operations without surrendering control. Each stakeholder operates in their domain of expertise while the system maintains security guarantees across all layers. 2.4 Native Compatibility: Zero Friction to Integrate With Existing Standards Rather than creating another isolated protocol that fragments the ecosystem further, Kite embraces existing standards as first principles. This isn’t grudging compatibility or minimal compliance. It’s architectural integration that makes Kite agents native citizens of multiple protocols simultaneously. x402 standard defines a common, agent–first payment flow and message schema so any compliant service can accept payments from any compliant agent without bespoke adapters. In Kite, x402 serves as the interoperability layer between agents and services: agents convey payment intents; services verify authorization and terms; settlement details travel in a standard, machine–actionable envelope. The Agent Payment Protocol (AP2) then specializes this flow for stablecoin settlement on Kite, preserving broad compatibility while providing a practical default path today. Google’s A2A protocol enables direct agent coordination across platforms. Kite agents speak A2A fluently, coordinating with agents from any ecosystem using established communication patterns. When a Kite agent needs to coordinate with a Google agent to complete a complex workflow, they communicate directly without translation layers or compatibility bridges. Google’s Agent Payment Protocol is a neutral, open protocol that defines how agent payments should be expressed, it is like ERC20. Kite plays the Ethereum role: the execution + settlement layer for those AP2 intents. A Kite agent takes an AP2–compliant mandate and enforces it on–chain with programmable spend rules, gasless/bundled ops, and stablecoin–native settlement. Anthropic’s MCP ensures model interoperability across the entire LLM ecosystem. Claude, GPT, and emerging models interact through the same protocol layer, making model choice a business decision rather than a technical constraint. A Kite agent can leverage Claude for reasoning, GPT for generation, and specialized models for domain tasks, all within a single workflow. OAuth 2.1 compatibility means compatibility with human–centric services and existing login/payment flows, thus existing services don’t need to rebuild their authentication systems. A service supporting OAuth today can accept Kite agents tomorrow with minimal changes. This backward compatibility creates a gradual migration path for developers where they can adopt Kite AI infrastructure without abandoning the broader internet and enterprise ecosystems. Together with x402 standard compatibility, agent–native payment flows are connected with today’s service ecosystems without demanding bespoke adapters or rewrites. These standards embrace transforming adoption dynamics. Developers don’t choose between Kite and their existing stack. They add Kite to enhance what already works. Services don’t rebuild for agents. They extend existing APIs with agent awareness. The future arrives through evolution, not revolution. 3. Architecture 3.1 Overview Kite’s architecture represents a purposeful departure from traditional blockchain design. Instead of building another general purpose chain that happens to support payments, every architectural decision optimizes for one goal: enabling autonomous agents to operate with mathematical safety guarantees. The architecture stacks purpose–built layers from blockchain to applications, each solving specific challenges in the agent autonomy puzzle: Fig. 2: Overview of Kite’s Purpose–built Layered Architecture Base Layer : An EVM–compatible L1 optimized for stablecoin payments, state channels, and settlement. Unlike general–purpose chains, every optimization targets agent transaction patterns. Platform Layer : Abstracts blockchain complexity through agent–ready APIs for identity, authorization, payments, and SLA enforcement. Developers interact with familiar patterns while the platform handles cryptographic proofs and on–chain settlement. Programmable Trust Layer : Introduces novel primitives including Kite Passport (cryptographic agent IDs), Agent SLAs (smart contract interaction templates), and compatibility bridges to A2A, MCP, and OAuth 2.1. This layer ensures agents can interact with both Web3 and traditional services seamlessly. Ecosystem Layer : Two interconnected marketplaces—an Application Marketplace for AI services and an Agents Ecosystem connected through standard protocols. Services register once and become discoverable by millions of agents. Together, these layers let agents transact with predictable fees, enforce SLAs, and accumulate reputation across accounts and interactions. Kite architecture achieves transformative results: dramatic reduction in payment costs through state channels, significant latency improvement via dedicated agentic payment lanes, and complete elimination of credential management overhead through cryptographic identity. More critically, true agent autonomy is realized with programmable guarantee of constraint compliance. 3.2 Terminology and Core Concepts Understanding Kite requires grasping the fundamental building blocks that enable autonomous agent operations. These aren’t merely technical definitions but the architectural choices that transform AI agents from sophisticated chatbots into economic actors. Fig. 3: Illustration of Kite AI Core Entities and Workflow 3.2.1 Core Entities The Kite ecosystem operates through four fundamental entity types, each playing a critical role in the agent economy. User : The human principal who owns and controls a fleet of AI agents. More than account holders, users represent the bridge between traditional legal frameworks and autonomous systems. They delegate specific capabilities to agents while maintaining ultimate authority, manage master wallets that serve as the root of cryptographic trust, and set global policies that cascade through all their agents. Users remain the legally responsible entities, ensuring that agent autonomy never means absence of accountability. Agent :A personal AI assistant or autonomous program acting on behalf of a user. These are sophisticated entities that execute complex tasks, interact with multiple services simultaneously, and handle money within cryptographically enforced boundaries. Each agent maintains its own wallet, accumulates its own reputation, and operates under its own governance policies. Yet they remain mathematically bound to their controlling user through BIP–32 derivation, creating provable ownership without key exposure. Service : Any external offering that agents interact with to accomplish tasks. Services span from data APIs providing real–time market feeds to GPU providers offering inference compute, from SaaS applications exposing business logic to other agents offering specialized capabilities. Services can integrate through multiple protocols: MCP for model interactions, A2A for agent coordination, or traditional OAuth for legacy compatibility. Each service maintains sovereignty over its access policies while participating in the global agent marketplace. Merchant/Provider : The businesses, developers, or infrastructure operators who make services discoverable and consumable by millions of agents. Providers don’t just list APIs; they define SLAs with automatic penalties, establish reputation through verifiable performance, and participate in programmable commerce where every interaction becomes a micropayment. The merchant role transforms B2B services from manual integration nightmares into plug–and–play agent resources. 3.2.2 Identity and Trust Infrastructure Identity in the agent economy transcends usernames and passwords. It requires cryptographic proof, verifiable delegation, and portable reputation. Kite Passport : The cryptographic identity card that makes agent operations possible. Unlike traditional credentials that merely authenticate, the passport creates a complete trust chain from user to agent to action. It binds to existing identities like Gmail or Twitter through cryptographic proofs, enabling users to leverage their existing digital presence. The passport contains not just identity but capabilities: what an agent can do, how much it can spend, which services it can access. Most critically, it enables selective disclosure. An agent can prove it belongs to a verified human without revealing which human, preserving privacy while maintaining accountability. Decentralized Identifier (DID) : A globally unique, cryptographically verifiable identifier that establishes immutable binding between agents and users. DIDs aren’t random strings but structured identifiers that encode relationships. A user might have did:kite:alice.eth while her trading agent has did:kite:alice.eth/chatgpt/portfolio–manager–v1. This hierarchy makes authority chains instantly verifiable. Any service can cryptographically confirm that a session belongs to an
프로젝트로 돌아가기