Kite 백서

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

Build Agent Passport About Company Community Events Job Blog Whitepaper Whitepaper(Korean) MiCAR Whitepaper Podcast Media BrandKit From Human-Centric to Agent-Native: Building Trustless Payment Infrastructure for Agentic AI Kite AI Team Link: Project Page | X Account TL;DR: Kite enables AI agents to autonomously transact at scale with cryptographic safety and native x402 compatibility—solving the infrastructure crisis imprisoning the agent economy today. While autonomous AI agents demonstrate production–grade multi–step reasoning capabilities today, they remain constrained by the human-centric infrastructure . Organizations face an impossible dilemma: grant agents financial authority and risk unbounded losses, or require manual authorization and eliminate autonomy. This infrastructure mismatch—not capability limitations—constitutes the primary bottleneck preventing realization of the projected $4.4 trillion agent economy. This paper introduces Kite, the first comprehensive infrastructure system architected from first principles to treat AI agents as first-class economic actors . We address three fundamental failures of existing systems: credential management complexity , payment infrastructure barriers , and unverifiable trust . Our solution, the SPACE framework, along with integratiblity with x402 protocol , provides: (1) Stablecoin-native payments with sub–cent fees and instant finality; (2) Programmable constraints cryptographically enforced through smart contracts; (3) Agent-first authentication via hierarchical identity with mathematical delegation; (4) Compliance-ready immutable audit trails ; and (5) Economically viable micropayments enabling pay–per–request pricing at global scale. Kite’s technical contributions include: (1) A three-layer identity architecture separating user (root authority), agent (delegated authority), and session (ephemeral authority) identities through BIP–32 hierarchical derivation; (2) Programmable governance spanning services through unified smart contract accounts where compositional rules enforce global constraints at the protocol level; (3) Agent-native payment rails using state channels that achieve sub–100ms latency at approximately $0.000001 per transaction. We provide a formal security analysis of our design. Our multilayer revocation mechanism combines immediate peer–to–peer propagation, cryptographic certificate verification, and economic slashing to ensure that compromised agents get terminated instantly. Furthermore, Kite achieves native compatibility with the x402 standard alongside Google’s A2A, Anthropic’s MCP, OAuth 2.1, and the Agent Payment Protocol, positioning it as a universal execution layer rather than an isolated protocol . This level of interoperability enables seamless integration with existing ecosystems without bespoke adapters while delivering agent–native capabilities. In summary, Kite provides the missing infrastructure layer that transforms autonomous agents from sophisticated chatbots into trustworthy economic actors—enabling the agent economy through mathematically guaranteed safety, not assumed trust, with x402 protocol for AI commerce at scale. 1. Entering the Agentic Future 1.1 The Promise and Prison of Autonomous AI Artificial intelligence has reached an inflection point. GPT models process billions of daily requests, demonstrating remarkable accuracy on complex reasoning tasks. Claude orchestrates sophisticated multi–step workflows across thousands of function calls. Language models now reliably execute complex multi–step plans—the capability is proven and production–ready. This technological maturity marks a fundamental shift from human-mediated interactions to agent-native autonomy. Today’s autonomous agents analyze markets in milliseconds, optimize supply chains across continents, and execute investment strategies with precision that surpasses human capabilities. They coordinate distributed systems, manage portfolios worth billions, and make nuanced decisions at speeds and scales that would overwhelm entire teams of human operators. McKinsey projects these agents will generate $4.4 trillion in annual value by 2030, a conservative estimate given the exponential pace of adoption. Yet a striking paradox emerges: the very infrastructure that should enable these agents instead imprisons them. Autonomous agents remain severely constrained by infrastructure designed exclusively for human users. An AI agent that analyzes global markets in microseconds must wait days for cross–border payment settlement. Agents trusted with critical business decisions cannot cryptographically prove they’re operating within defined constraints. Users face the same impossible choice at the operational level: grant unconditional trust to agent monetary operations and risk everything, or manually authorize each transaction and destroy the very autonomy that makes agents valuable. This isn’t a capability problem. Infrastructure, not intelligence, has become the bottleneck. Three converging forces make an infrastructure revolution not just inevitable but urgent: First, model readiness : Language models now reliably execute complex multi–step plans with production–grade consistency. The capability question is settled. Second, enterprise demand : Companies face an impossible choice between granting agents real authority while risking catastrophic losses, or constraining them to advisory roles and forfeiting competitive advantage. The status quo is untenable. Third, regulatory reality : Frameworks like the EU AI Act demand algorithmic accountability, requiring cryptographic proof of agent behavior. Compliance is no longer optional. The models are ready. The businesses are desperate. The regulators are watching. With Kite, the infrastructure revolution begins. 1.2 Why Existing Human-Centric Infrastructure Fails Autonomous Agents 1.2.1 Authentication vs Authorization: Twin Failures for Agent Systems Contemporary digital services operate under a fundamental assumption: the entity requesting access is human. This assumption permeates every layer of security infrastructure, from username–password combinations to biometric verification systems. For AI agents, this creates distinct but interrelated failures in both authentication (verifying identity) and authorization (granting permissions). Table 1 : Human vs Agent Infrastructure Comparison Dimension Human Infrastructure Agent Reality Credential Management Username/password, SSO M×N API keys, no unified management Identity Verification Biometrics, 2FA, device fingerprinting No cryptographic binding to principal Authorization (OAuth) One–time consent, session–based Continuous operations, no runtime controls The Credential Management Crisis Consider the operational reality of enterprise AI deployment. A single organization deploying 50 agents across 20 services must manage 1,000 unique credential relationships. Each relationship requires separate provisioning, rotation schedules, access policies, and audit trails. The complexity scales exponentially: M agents across N services generate M×N credential relationships, each with distinct security requirements and failure modes. This nightmare is already visible in today’s Claude MCP integrations, where even a few deployments require managing dozens of API keys. This proliferation creates cascading vulnerabilities. Long–lived API keys–service accounts, the current standard for agent authentication–possess dangerously broad permissions because narrowly–scoped credentials would require complex bidirectional configuration between every agent–service pair. When compromised, these keys grant attackers persistent access with permissions originally intended for humans or even administrators. The security model degrades to “security through obscurity,” hoping credentials remain undiscovered rather than enforcing cryptographic constraints. Identity Verification Impossibility The absence of cryptographic agent–to–principal binding creates a fundamental identity crisis. No service can definitively verify that “Alice’s trading agent” genuinely belongs to Alice rather than a malicious actor claiming that relationship. Current authentication mechanisms cannot reliably distinguish between legitimate agents operating within defined parameters, compromised agents impersonating legitimate agents, or multiple agents falsely claiming the same principal. This identity ambiguity forces services into binary trust decisions: grant full access based on credentials alone, or deny agent access entirely. Neither option enables the nuanced, constraint–based authorization that autonomous operations require. OAuth’s Blindness to Autonomous Behavior Traditional authorization frameworks like OAuth assume predictable, human–supervised API calls rather than autonomous agents executing thousands of non–deterministic operations per minute. While OAuth technically supports fine–grained scopes, the deeper problem is that these systems make authorization decisions once and then go blind. After an AI agent receives an OAuth token, the system cannot answer critical runtime questions such as whether the agent’s behavior has suddenly changed in ways that suggest compromise, whether a given action will trigger a cascade of expensive operations across integrated services, or whether the cumulative cost of the agent’s operations has exceeded reasonable bounds. Current authorization models fail because they’re: • Rigidly evaluated – Permissions checked once at auth time, never reconsidered against changing context or costs • Economically blind – No native tracking of resource consumption or spending velocity • Compositionally explosive – Agents authorizing sub–agents create unpredictable permission chains impossible to audit The result: each integrated service becomes a potential bankruptcy vector. A compromised agent with “payment processing” scope could execute thousands of micro–transactions below fraud thresholds. Even an agent with read–only access could perform costly DoS attacks by repeatedly querying expensive endpoints. We need authorization systems that understand agent behavior, enforce economic boundaries, and make continuous trust decisions based on runtime context. 1.2.2 The Payment Infrastructure Mismatch Traditional payment systems embody assumptions about transaction patterns that are antithetical to agent behavior. Where humans generate occasional, substantial transactions, agents produce continuous streams of micropayments. This fundamental mismatch creates economic and operational barriers that prevent agents from augmenting business and individual money movement workflows. Economic Impossibility of Agent Transactions The unit economics of traditional payments make agent operations financially prohibitive. Credit card processing incurs fixed costs ($0.30) plus percentage fees (2.9%), making small payments economically absurd. A penny transaction can cost over thirty cents to process—more than the actual payment itself. While local real–time payment systems like UPI, M–Pesa, and Alipay offer lower costs for human transactions, they too are fundamentally designed for person–to–person or person–to–merchant flows, not the high–frequency, API–driven micropayments that agents require. Agent operations naturally create many tiny transactions: an agent making thousands of API calls would rack up massive payment fees to transfer minimal actual value. This economic impossibility forces suboptimal workarounds that cripple agent effectiveness. Prepayment in large chunks locks up capital and creates reconciliation nightmares. Operation batching introduces dangerous latency in time–sensitive decisions. Delayed settlement leaves agents waiting for confirmation while opportunities vanish. Each compromise moves further from the real–time, pay–per–use model that agents require. The global nature of AI agents collides with the regional reality of payments. International transfers cost $15–50 regardless of amount and impose multi–day delays. An agent coordinating suppliers across three continents faces payment friction that would paralyze any human operation, yet this is precisely the scale at which modern agents must operate. Absence of Programmable Money Traditional payments execute simple atomic transfers: move X from A to B. Agents require programmable money with complex conditional logic that current systems cannot express: • Streaming payments : Continuous flows that adjust dynamically based on resource consumption • Conditional releases : Funds released only upon cryptographic proof of completion • Automatic splits : Proportional distribution calculated from real–time contribution metrics • Escrow with triggers : Holdings released when oracle conditions verify • Recursive payments : Transactions that programmatically spawn child transactions Current systems require extensive external infrastructure to approximate these patterns, each layer introducing complexity, latency, and cascading points of failure. What should be simple programmable logic becomes a fragile tower of webhooks, databases, and reconciliation scripts. 1.2.3 The Trust and Programmability Void The most fundamental limitation lies in the absence of verifiable, programmable trust. Current systems offer only binary trust models: complete access or complete denial. This void prevents agents from operating autonomously while remaining provably constrained within user–defined boundaries. Unverifiable Constraint Enforcement When users delegate authority to agents, they have no way to verify that the agents are actually respecting the constraints set for them. For instance, an investment agent might claim to enforce a 5% daily loss limit but could easily violate this rule without the user realizing until it is too late. Although agents function as black boxes by nature, current systems provide no cryptographic proof that the constraints were properly configured, that violations never occurred, or that the agent’s reported actions faithfully reflect what actually happened. Users discover breaches only after catastrophic damage—portfolios liquidated, accounts drained, data destroyed—with no verifiable record of what the agent actually did or when safeguards failed. Programmable Governance Impossibility Today, governance of agent behavior is fragmented across individual platforms, leaving users with no way to define or enforce unified policies. What’s needed is programmable governance —rules that apply holistically across all services an agent touches. Instead of scattered per–platform controls, users should be able to encode global constraints like “total spend across all agents under $1,000/day” or “any transaction above $100 requires user approval regardless of service. ” Without such programmable, unified governance, agents can exploit gaps, distributing actions across platforms to bypass limits. With programmable governance, however, every transaction is checked against user–defined policies, ensuring agents operate within provable, system–wide guardrails. Accountability and Recourse Vacuum When agents misbehave, determining responsibility turns into manual forensic investigation rather than cryptographic verification. Without immutable audit trails, it becomes impossible to prove what actions the agent actually executed, whether those actions violated defined constraints, which component failed—be it model hallucination, platform error, or integration bug—or what the user originally authorized versus what ultimately occurred. While no system can guarantee an agent perfectly executes user intent (an impossibility given the non–deterministic nature of AI), the lack of cryptographic traceability means we cannot even establish what happened. Without this foundational accountability layer—the ability to prove which agent did what, when, and under whose authority—resolution depends on lawyers instead of code. Users are left without automated kill switches to halt rogue agents, lack visibility into the chain of operations, and have no programmatic path to understanding failures, turning the promise of autonomous agents into a liability nightmare. 1.3 Stablecoin: The Native Currency for the Agentic Internet Fig. 1: Stablecoins as the Native Currency for the Agentic Internet The solution begins with a radical reconceptualization of money itself. Digital versions of paper currency, while eliminating physical constraints, fail to address the fundamental economic and latency barriers facing agents. Agents require native currency that is machine–verifiable, programmable, and economical enough to meter each request, not monthly statements designed for human review, but streaming micropayments settled in real–time. Traditional payment systems fail spectacularly in the agent context. A single credit card transaction traverses a complicated multi–party network: issuers, payment networks, tokenization services, acquirers, and banks. Each node adds latency, fees, and failure modes. All these result in high fixed fees, days–long settlement, and chargeback windows extending 120 days. These economics make agent–scale per–message pricing and automated machine–to–machine (M2M) micropayments impossible. Blockchain–based stablecoins transform this equation entirely. A cryptographically signed stablecoin transfer from wallet to wallet achieves what traditional systems cannot: • Transaction fees below one cent, enabling true pay–per–request economics • Instant finality with zero chargeback risk • Native programmability for conditional and streaming payments • Global interoperability without cross–border friction For these reasons, stablecoins aren’t just an optimization. They provide programmable value transfer that operates at machine speed with machine precision, proving to be the fundamental primitive that makes the agentic economy possible. 1.4 The Incomplete Revolution: Why Existing Payments-First Blockchain Isn’t Enough Recent developments in blockchain architecture have addressed a critical insight: payments and general computation require fundamentally different optimizations. While Ethereum pioneered programmable money, its design optimizes for maximum expressiveness rather than payment efficiency. This creates a paradox where the most sophisticated smart contract platform struggles with simple payment operations due to high costs, unpredictable fees, and congested block space during peak demand. Tempo, introduced by Paradigm, represents a pivotal shift in blockchain design philosophy, a "payments–first" architecture that prioritizes transaction efficiency over computational generality. This approach acknowledges that 90% of blockchain activity involves simple value transfers, not complex smart contracts. By optimizing for this reality, payments–first chains achieve dramatic improvements in cost, speed, and predictability. Tempo’s architecture delivers three critical optimizations: • Predictable stablecoin fees : Eliminates gas token volatility by charging fees directly in stablecoins • Opt-in privacy : Transactions remain private by default, with cryptographic proofs enabling compliance when required • Dedicated payment lanes : Isolated blockspace for transfers, preventing congestion from other activities Yet even Tempo’s payments–first design lacks the agent–native infrastructure required for autonomous operations: • No wallet hierarchy : Without separate tiers for agents and principals, security boundaries blur dangerously • Missing programmable guardrails : Agents will hallucinate and make errors—only cryptographic spending rules can prevent catastrophic losses • Absent agent transaction types : No native support for embedding API requests within payments • Zero protocol compatibility : Lacks integration with essential agent standards like A2A, M
프로젝트로 돌아가기