Kite 백서

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

agent, that agent belongs to a user, and that user authorized the current operation. No central authority needed, no API calls required, just mathematical proof. Verifiable Credentials (VCs) : Cryptographic attestations that prove specific capabilities or authorizations. A VC might certify that an agent passed compliance training, holds a trading license, or maintains a reputation above a threshold. These aren’t self–declared claims but cryptographically signed attestations from trusted authorities (e.g., educational email verification). VCs enable finegrained access control where services can require specific proofs before granting access. An exchange might require KYC verification, a data provider might require payment history, a compute cluster might require reputation scores. The beauty lies in composability: agents accumulate credentials over time, building portable proof of capabilities. Proof of AI : Every agent action creates an immutable, tamper–evident log anchored to the blockchain. These aren’t just logs but cryptographic proof chains of what occurred. They establish complete lineage from user authorization through agent decision to final outcome. When disputes arise, proof chains provide indisputable evidence. When regulators investigate, they see complete transparency. When users audit their agents, they verify every action. Traditional systems rely on logs that can be altered or deleted. Proof chains provide mathematical certainty about historical events. 3.2.3 Wallets Structure The agent economy demands sophisticated wallet structures that enable programmable control without sacrificing security. EOA Wallet (Externally Owned Account) : The traditional blockchain wallet controlled by a private key. In Kite’s architecture, users maintain master EOA wallets that serve as the root of authority. These wallets live in secure enclaves, hardware security modules, or user devices, never exposed to agents or services. The EOA signs the initial authorizations that delegate specific powers to agent operations, creating the foundation of the trust chain. While simple in concept, EOAs become powerful when combined with smart contract delegation. AA Wallet (Smart Contract Account) : The revolutionary advance that makes agent payments possible. Account Abstraction wallets aren’t just addresses but programmable accounts with built–in logic. AA enables developers to write smart contract code that governs spending, bundles transaction execution, and allows third parties to pay gas fees. Unlike traditional account models, Kite’s AA implementation enables multiple agents to operate from a single treasury with cryptographically isolated permissions. In Kite’s model, the user owns a single on–chain AA account holding shared funds in stablecoins. Multiple agents operate this account via session keys, but only within their authorized limits. One treasury, multiple operators, perfect isolation. Embedded Wallets : Self–custodial wallets integrated directly into applications, abstracting complexity while maintaining sovereignty. Users don’t manage seed phrases or private keys, yet they maintain complete control over funds. Embedded wallets enable one–click agent authorization, automatic session management, and transparent fund flows. They make blockchain invisible to users who think in their local currency, not tokens, while preserving the cryptographic guarantees that make agent operations safe. 3.2.4 Payment Architecture Kite’s payment system consists of two coordinated components: (i) the on–chain Agent Payment Protocol, which enforces programmable flows and policy limits; and (ii) the On/Off–Ramp API, which mediates fiat and stablecoin ingress/egress. Users pre–fund agent wallets, agents spend under explicit authorization, and merchants settle in their preferred currency. The components are detailed below. Agent Payment Protocol : A comprehensive system that enables payment flows impossible with traditional infrastructure. This protocol supports micropayments down to fractions of cents, streaming payments that flow continuously based on usage, pay–per–inference models where every API call carries value, and conditional payments that release based on performance. The Agent Payment Protocol enables instant, global, programmable value transfer at machine speed. On/Off-Ramp API : The bridge between traditional finance and the agent economy. Through integration with global providers like Coinbase, PayPal, users fund agent wallets with local payment methods, stablecoins, and bank accounts while merchants withdraw earnings to bank accounts, leveraging Kite’s identity and trust infrastructure. The ramp handles compliance, fraud prevention, and currency conversion invisibly. Users never need to understand blockchain; they just see their local currency in and out. This abstraction layer makes agent payments accessible to billions who will never own crypto but need agent services. 3.2.5 Governance and Safety Mechanisms Autonomous agents require sophisticated governance that ensures safety without sacrificing capability. SLA (Service-Level Agreement) Contracts : Smart contracts that transform vague service promises into mathematically enforced guarantees. Unlike traditional SLAs that rely on legal enforcement, these contracts automatically execute penalties and rewards. An SLA might specify 99.9% uptime with automatic pro–rata refunds for downtime, response times under 100ms with tiered pricing based on performance, or data accuracy requirements with slashing for errors. These programmable agreements create trust through code rather than courts. Programmable Trust/Intent-Based Authorization : Users express their intentions through mathematical constraints that compile to blockchain enforcement. Instead of hoping agents respect policies, the system ensures they cannot violate them. Intents can specify spending caps that cannot be exceeded even if the agent tries, temporal windows outside which operations automatically fail, whitelisted merchants or blacklisted categories enforced at protocol level, and complex conditional logic like "if volatility exceeds 20%, reduce limits by half." These intents automatically expire, preventing forgotten authorizations from becoming vulnerabilities. The user’s intent becomes immutable law. Session Keys/Ephemeral Keys : Temporary cryptographic keys that implement zero–trust session management. Generated for each agent task, these keys are completely random, never derived from permanent keys, ensuring perfect forward secrecy. A session key might authorize "transfer maximum $10 to providers A, B, or C for data feeds between 2:00 PM and 2:05 PM today." The key executes its authorized operation then becomes cryptographically void forever. Even total session compromise affects only one operation for minutes with bounded value. This architecture prevents the cascading failures that plague traditional API key systems where one breach means total compromise. Reputation System : Trust scores that accumulate based on verifiable behavior rather than self–reported ratings. Every successful payment increases reputation. Every failed delivery decreases it. Every policy violation triggers penalties. But unlike traditional ratings that can be gamed, Kite’s reputation derives from cryptographic proofs of actual behavior. High reputation agents access better rates, higher limits, and premium services. Low reputation agents face restrictions and additional verification. Reputation becomes portable across services, solving the cold–start problem where new relationships begin from zero trust. An agent with proven history on one platform can present verifiable credentials to new services, bootstrapping trust through cryptographic proof rather than promises. 3.3 Detailed Design 3.3.1 The Three Layer Identity Imperative Human payment systems recognize only two entities: the payer and the payee. This binary model suffices when humans initiate every transaction, evaluate every risk, and maintain control over every key. Agent systems shatter this assumption. They require a third layer that enables delegation without the catastrophic vulnerability of key sharing. User Identity (Root Authority) The user maintains ultimate control as the cryptographic root of trust. Their private keys live in secure enclaves, hardware security modules, or protected device storage, never exposed to agents, services, or even the Kite platform itself. Users can instantly revoke all delegated permissions with a single transaction, set global constraints that cascade through all agents, and monitor every operation through immutable proof chains. This isn’t theoretical control through terms of service; it’s mathematical control through cryptographic enforcement. Agent Identity (Delegated Authority) Each AI agent receives its own deterministic address mathematically derived from the user’s wallet using BIP–32 hierarchical key derivation. When you create a ChatGPT agent for portfolio management, it gets address 0x891h42Kk9634C0532925a3b844Bc9e7595f0eB8C, provably linked to your wallet yet cryptographically isolated. This address serves as the agent’s on chain identity, enabling it to authorize sessions for spending operations. The mathematical derivation creates powerful properties. Anyone can verify the agent belongs to you through cryptographic proof, yet the agent cannot reverse the derivation to access your private key. The agent maintains its own reputation score, coordinates with other agents autonomously, and operates within user defined boundaries that the blockchain enforces absolutely. Even total agent compromise remains bounded by smart contract constraints. Session Identity (Ephemeral Authority) For each task execution, the system generates a completely random session key with address 0x333n88Pq5544D0643036b4c955Cc8f8706g1dD9E. These keys are never derived from wallet or agent keys, ensuring perfect forward secrecy. They’re single–use authorization tokens that execute specific actions without exposing permanent credentials. The session key generation happens entirely locally, without server communication or private key transmission. Once generated, a DID session registers in the agent network, self–containing the proof of authority, chain of trust, and validity period. The session validates through its time window then becomes permanently invalid. Even quantum computers cannot resurrect expired sessions. This three tier model provides defense in depth that payments first chains lack. Compromising a session affects only one transaction. Compromising an agent is limited by user imposed constraints. Only user key compromise enables unbounded loss, and secure enclave protection makes this nearly impossible. Identity Resolution Through Standards Kite extends ENS standards to claim agent ownership with human readable identifiers: • User ID: did:kite:alice.eth • Agent ID: did:kite:alice.eth/chatgpt/portfolio–manager–v1 Public resolvers enable instant verification: • GetAgent(AgentID) → AgentID, AgentDomain, AgentAddress • ResolveAgentByDomain(AgentDomain) → AgentID, AgentDomain, AgentAddress • ResolveAgentByAddress(AgentAddress) → AgentID, AgentDomain, AgentAddress • GetAgentBySession(SessionID) → AgentID, AgentDomain, AgentAddress, SessionInfo Any service can verify the complete authority chain without contacting Kite or the user, enabling permissionless interoperability. 3.3.2 Programmable Governance and Money Smart contracts revolutionized programmable money, but agents require programmable governance that spans services, evolves over time, and responds to changing conditions. These aren’t simple spending limits; they’re sophisticated control systems that make agent autonomy safe. Compositional Rules Across Services Constraints combine through boolean logic to create sophisticated policies. "Total spending across all platforms less than $1000/day AND no single transaction greater than $100 AND only verified providers." These rules compile to smart contract code that evaluates atomically. Agents cannot circumvent limits by splitting transactions or distributing operations across services. The blockchain becomes the ultimate arbiter, enforcing rules with mathematical certainty. Temporal Evolution of Trust Static limits ignore the reality that relationships build over time. Kite implements progressive trust: "Start with $10/day limit, increase by $10 weekly up to $100/day after trust is established." The blockchain automatically adjusts limits based on time and behavior. No manual intervention, no forgotten updates, just programmatic trust evolution that reflects actual agent performance. Conditional Response to External Signals Markets change, threats emerge, opportunities appear. Agent constraints must adapt: "If volatility is greater than 20%, reduce trading limit by 50%." Oracle networks feed real time signals into smart contracts, triggering automatic adjustments. When markets panic, agents automatically become more conservative. When security breaches occur, new authorizations freeze. The system responds to threats faster than humans can react. Hierarchical Cascade Through Organizations Enterprise deployments require nested governance: "ChatGPT agent limit $10,000/month, Cursor limit $2,000/month, other agents limit $500/month." Constraints cascade through delegation levels, with child limits automatically bounded by parent limits. A department cannot exceed its division’s budget. An agent cannot exceed its tier’s allocation. Organizational policies propagate cryptographically. The Unified Account Model Kite designs a unified smart contract account model that elegantly balances simplicity with control. The user (EOA 0xUser) owns a single on–chain account holding shared funds in USDC or pyUSD. Multiple verified agents—Claude, ChatGPT, Cursor—each operate this account via their own session keys (0xSession01 through 03), but only through sessions that enforce rules and quotas. When an agent executes a task, spending comes from the shared pool within its session allowance, and the account pays merchants programmatically. Result: one treasury, per session risk isolation, and fine grained, auditable control across all the user’s agents. No fund fragmentation, no complex reconciliation, just elegant unified management. Fig. 4: The Unified Account Model Spending Rules versus Policy The system distinguishes between on chain rules and off chain policies based on their evaluation requirements: Dimension Spending Rules Policy Scope Asset or stablecoin related, leveraging programmable money Full control and flexibility for complex logic Evaluation Entirely on chain through smart contracts, ensuring transparency Securely off chain in user’s local or Kite’s TEE Interoperability Integrates with any on chain account, fully decentralized Platform specific but can integrate third party systems Use Cases Spending limits, rolling windows Session TTL, categories, recipient lists Session Key Implementation with Smart Contracts The AA wallet smart contract implements session keys through a plugin architecture: addSessionKeyRule ( address sessionKeyAddress, // The newly generated session key bytes32 agentId, // Agent performing the actions bytes4 functionSelector, // Allowed function (e.g . , pay()) uint256 valueLimit // Maximum transaction value ) The user signs authorization transactions with their EOA wallet, representing cryptographic intent. The transaction packages as a UserOperation and sends to a bundler for on chain execution. Sessions expire automatically when validUntil timestamps pass, or users can actively revoke by calling removeSessionKeyPermission(). Programmable Escrow Contracts Kite extends beyond direct payments by introducing programmable escrow mechanisms that embed smart contracts between agents and merchants. In this framework, buyers issue cryptographically signed payment intents, authorizing funds into escrow accounts with defined expiry conditions. These escrows can be partially or fully released based on verified outcomes, supporting the complete lifecycle of commercial interactions including authorization, capture, charge, void, reclaim, and refund. The design remains noncustodial and permissionless, ensuring that users retain full control over assets throughout the process. The protocol supports the inclusion of additional operators such as third–party entities that can relay transactions or cover gas costs while remaining cryptographically constrained by the payer’s signed hash. Leveraging standards such as ERC 3009, Kite enables signature based gasless preapprovals that further streamline execution and user experience. As the escrow layer is implemented as code, it can be extended with programmable business logic including dynamic revenue sharing, token swaps, conditional privacy modules, or integration with other smart contracts. Each transaction thereby becomes an auditable, reversible, and composable financial primitive, aligning with Kite’s goal of transforming payments into transparent, verifiable, and programmable economic interactions. 3.3.3 Compatible with Agent Protocols Modern agents don’t operate in isolation. They integrate with Google’s A2A protocol, Anthropic’s MCP, and enterprise OAuth systems. Payment infrastructure must provide native bridges to these ecosystems, not awkward adapters. Protocol Translation Seamless mapping between agent communication standards enables universal interoperability. A Kite agent speaks A2A to Google agents, MCP to Claude, OAuth to enterprise services—all through the same identity and payment rails. This isn’t middleware translation; it’s native multilingual capability. Identity Federation Unified authentication eliminates the M ×N credential problem. Users authenticate once with existing providers; agents inherit permissions across all connected services. No duplicate credentials, no synchronization nightmares, just elegant identity flow. Compliance Frameworks Built in support for regulatory requirements across jurisdictions ensures global operability. GDPR in Europe, CCPA in California, data residency requirements in China—all handled automatically through configurable compliance modules. The integration happens through extended protocol definitions: // AgentDID definition message AgentDID { string did = 1; // Unique identifier for the agent string user_wallet = 2; // User's wallet address who controls this agent repeated VerificationMethod verification_methods = 3; AgentProvider provider = 4; int64 created = 5; int64 updated = 6; } message VerificationMethod { string id = 1; // Verification = key identifier string type = 2; // Always 'EcdsaSecp256k1VerificationKey2019' string controller = 3; // DID that controls this key string public_key_hex = 4; // Agent's public key for verification } Combined with the A2A protocol: // AgentCard conveys key information: Key information uses a bold message AgentCard { // New DID we proposed. AgentDID id = 19; // The service provider of the agent, like ChatGPT AgentProvider provider = 4; // description of agents // JSON Web Signatures computed for this AgentCard. repeated AgentCardSignature signatures = 17; } // AgentCardSignature represents a JWS signature of an AgentCard . // This follows the JSON format of an RFC 7515 JSON Web Signature (JWS) message AgentCardSignature { // The protected JWS header for the signature. This is always a // base64url-encoded JSON object. Required . string protected = 1 [(google.api.field_behavior) = REQUIRED]; // The computed signature , base64url-encoded. Required . string signature = 2 [(google.api.field_behavior) = REQUIRED]; // The unprotected JWS header values. google.protobuf.Struct header = 3; } This architecture ensures Kite agents participate as first class citizens in e
프로젝트로 돌아가기