If you ask what Web3 is currently lacking, most people would say it's lacking applications and users. However, very few realize that what we actually lack is an underlying payment system that allows AI Agents to operate smoothly. This is not a false demand, but a real market worth $4.4 trillion waiting for infrastructure maturity.
The KITE project first caught my attention because of a sentence in their white paper "From Human-Centric to Agent-Native". This transition from being human-centered to being agent-native sounds very abstract, but when you dive into their technical architecture, you'll find it's a very concrete engineering problem.
First, let’s discuss the basic identity system. People on the blockchain use an EOA account, where the private key controls everything. This logic is simple and direct, but it is insufficient for AI agents, as a single user may run dozens of agents, each performing different tasks. If they all use the same private key, permission management becomes a disaster, as an issue with one agent could empty the entire wallet.
KITE's solution is a three-layer identity architecture. The user layer uses EOA as the root account, the agent layer derives sub-identities from BIP-32, and the session layer uses temporary keys. The most ingenious aspect of this design is that it guarantees unified management while achieving permission isolation. You can set a daily limit of $100 for a shopping agent, grant only read permissions to a data analysis agent, and restrict a trading agent to operate only on specific DEXs. Each agent can make autonomous decisions within its permission scope, and requests outside that range are automatically rejected.
This layered authorization is not something KITE came up with on a whim, but rather a mature standard based on BIP-32, a Bitcoin Improvement Proposal. It utilizes the derivation logic of HD wallets to generate agent identities. The benefit is strong compatibility; existing wallet infrastructure can support it with minor modifications without starting from scratch.
After access control, the next issue is payment speed. Traditional blockchains face a fatal flaw in payment throughput. Ethereum's mainnet can only handle 15 TPS, while Solana's theoretical value is 60,000 but often drops to several thousand in practice. This speed might be sufficient for humans, as you may only process a few dozen card transactions a day. However, AI agents are different; a smart assistant may simultaneously be booking flights, buying coffee, and paying subscription fees, needing to process multiple micropayments in a second.
KITE's solution is the state channel. This technology is not new; the Lightning Network has been using it for a long time. However, KITE has made specific optimizations. They categorize state channels into three types: unidirectional for continuous payment scenarios, bidirectional for mutual settlements between agents, and programmable for complex conditional payments. All channel openings and closings occur on-chain, while thousands of transactions in between happen off-chain, achieving millisecond-level latency of less than 100ms.
The 100ms delay is a critical metric because even the most advanced LLM models have response times of only 200-300ms. If payment delays exceed the model's inference time, user experience breaks down. KITE has managed to keep payment times under 100ms, meaning that in most scenarios, payment confirmation is faster than the model's response, and users are completely unaware of the blockchain running in the background.
The state channel solves the speed issue, but what about the cost issue? Transferring funds on Ethereum can easily cost several dollars in gas fees. AI agents need to handle micropayments, which may only be a few cents, making gas fees more expensive than the principal. KITE's approach is to optimize gas fees to nearly zero at the L1 level. They claim that the cost per transaction is less than $0.000001, a price that can be ignored.
Achieving such low costs relies on two technologies: one is a specialized payment channel design that offloads a lot of computation off-chain, while only recording the final results on-chain; the other is using stablecoins as the native gas token. Traditional chains use ETH or their own tokens to pay for gas, which has significant price volatility, while KITE directly uses USDC and pyUSD, making costs predictable.
Speaking of stablecoins, there is an important strategic choice here: why does KITE not create its own stablecoin but instead use USDC and pyUSD? On the surface, it seems to be because of backing from PayPal Ventures, making the direct use of pyUSD convenient. However, the deeper reason is that KITE does not want to struggle in the regulatory-sensitive area of stablecoins. What they want to do is build payment tracks, not issue tokens; this positioning is very clear.
Moreover, using mature stablecoins has the added benefit of existing liquidity. USDC has a circulating supply of hundreds of billions of dollars, and pyUSD is supported by the PayPal ecosystem. Agents holding these tokens can directly use them in various DeFi protocols without worrying about insufficient depth or high slippage. If KITE were to create its own stablecoin, the liquidity issues of starting from scratch would take one or two years to resolve.
The most hardcore part of the technical architecture is the PoAI consensus mechanism, or Proof of Attributed Intelligence. This name sounds impressive, but fundamentally, it is a system for validating the contributions of AI agents. Traditional PoS validates how many tokens you have staked, PoW validates how much computational power you have contributed, and PoAI validates how much valuable work your agent has accomplished.
To verify this, KITE has designed a Service Level Agreement (SLA) contract. Each agent must commit to an SLA on-chain before providing services, for instance, guaranteeing 99.9% uptime and committing to a latency of less than 100ms. If these standards are not met, automatic penalties are enforced; if met, rewards are provided. These data points are verified through oracles and zero-knowledge proofs to prevent fraud.
This mechanism addresses a core issue: how to quantify the credit of agents. In human society, we have credit systems and scoring mechanisms, but AI agents are a new species where traditional credit systems are not applicable. PoAI essentially builds a new credit ledger for agents, where every service quality and contract performance is recorded on-chain, forming a verifiable credit profile.
Even more impressively, KITE has also implemented formal verification. They included several mathematical theorems in their white paper to prove that under certain conditions, the system can guarantee safety. For example, the Bounded Loss Theorem shows through mathematical proof that a user's maximum loss has an upper limit. This is not just a claim but is derived through mathematical logic.
Formal verification is not widely used in the blockchain field because it is too difficult; it requires abstracting the system into a mathematical model and then proving safety properties using formal languages. The KITE team being able to accomplish this indicates their strong technical foundation. This rigor is particularly important for payment systems, as financial matters cannot be taken lightly.
In terms of security, KITE has also designed a multi-layer revocation mechanism. If an agent's behavior is found to be abnormal, revocation messages can be quickly disseminated through a P2P network, blacklisting identities through a certificate system, and reducing stakes through economic penalties known as slashing. This three-layer protection ensures that even malicious agents can be quickly isolated.
Recently, they also partnered with Brevis to introduce zero-knowledge proof technology for verifying SLA and Passport identities. The benefit of zero-knowledge proofs is that they can prove a claim is true without exposing specific data. For instance, an agent can prove it has completed 1,000 transactions without revealing the details of each transaction, which is crucial for privacy protection.
KITE's tech stack also includes support for various AI protocols, such as Google's A2A (Agent-to-Agent), Anthropic's MCP (Model Context Protocol), and OAuth 2.1. These are all standard protocols for AI agent communication. KITE has integrated them, meaning that no matter what framework your agent is developed on, it can connect to KITE's payment network.
This open and compatible strategy is very clever because the AI agent field is still rapidly evolving, and no one can determine what the future standards will be. Rather than betting on a single protocol, it is better to support all mainstream protocols and allow developers to choose freely. This way, the ecosystem can take off.
Architecturally, KITE is a four-layer stack. The bottom layer is Base L1, responsible for payment settlements. The second layer is Platform, which provides identity authentication APIs. The third layer is Programmable Trust, which includes Kite Passport and SLA. The top layer is Ecosystem, which consists of the agent marketplace and various applications. This layered design allows each layer to be optimized independently without interfering with one another.
Kite Passport is worth mentioning separately. It is a cryptographic agent ID, an encrypted agent identity card. Each agent has a passport that records the agent's identity information, service history, and credit score, and it supports selective disclosure. You can prove that your credit score is above a certain threshold without disclosing all transaction records.
This design draws on the ideas of decentralized identity (DID) and verifiable credentials (VC), but it has been specifically optimized for AI agents. For instance, a reputation inheritance mechanism has been added: if an agent is upgraded, the new version can inherit the reputation of the old version without starting from scratch.
At the smart contract level, KITE uses an EVM-compatible solution. This choice has its pros and cons. The benefits include the ability to directly reuse Ethereum ecosystem tools and developers, allowing Solidity-written contracts to be seamlessly migrated. The downside is that the EVM has performance bottlenecks. However, KITE has pushed TPS to the million range through lower-level optimizations, basically offsetting the EVM's disadvantages.
Their AA account abstract wallet uses the ERC-4337 standard, which is an account abstraction solution promoted by the Ethereum community. The benefit is that it can be implemented without a hard fork, and many wallets already support it. KITE has added session key rules on this basis, allowing for complex permission logic to be set via contracts. For example, the addSessionKeyRule function can specify that a particular session key can only call specific functions or transfer a limited amount.
The escrow contract uses ERC-3009, which supports gasless operations, meaning that users do not need to hold ETH or KITE tokens to initiate transactions. The gas fees are covered by a third party, which is particularly useful for AI agents, as they may have just been created and have nothing in their wallets. If they need to recharge before they can use them, the experience would be very poor.
KITE's documentation also mentions a SPACE framework, which summarizes the five core characteristics of AI payment chains: Stablecoin-native, Programmable constraints, Agent-first auth, Compliance audits, and Micropayments viable. These five terms compose SPACE, aligning perfectly with their vision of exploring new spaces in the AI agent economy.
It is worth noting that compliance is an aspect that many Web3 projects avoid, but KITE proactively lists it as a core feature. This attitude is very pragmatic because building payment infrastructure, especially when involving AI agents in autonomous transactions, will inevitably face regulatory issues. Rather than waiting for passive responses, it is better to actively design compliant modules.
From the testnet data, KITE's performance has essentially reached its design goals. As of early November, there have been over 500 million on-chain transactions, averaging 670,000 transactions per day, with over 74 million unique addresses. This level of activity is already quite impressive for a testnet phase, especially as it is still under conditions where functionality is not fully open. Once the mainnet goes live in Q1 and connects to more ecosystem projects, the data is expected to increase significantly.
In terms of ecosystem integration, KITE has already connected with projects like Shopify, Pieverse, and LayerZero. Shopify is a key partner because it is one of the largest e-commerce SaaS platforms in the world, with millions of merchants opening stores on it. If KITE can enable AI agents to directly place orders and make payments on Shopify, this use case becomes very concrete and no longer a pipe dream.
On the technical roadmap, KITE has many plans for 2026. In Q1, they aim to push the AI Agent Subnet expansion and connect to specialized agent platforms like Bitte Protocol. In Q2, they will integrate decentralized storage, with Filecoin and Walrus planned. Throughout the year, they will also complete the comprehensive upgrade of the PoAI consensus. If these can be implemented on time, KITE's tech stack will truly be complete.
To be honest, from a technical perspective, KITE faces significant challenges. The million TPS figure can be achieved in a lab environment, but under real network conditions, various unpredictable factors may affect performance, especially the user experience of state channels when opening and closing them. How to ensure ordinary users remain unaware of these processes, the PoAI validation mechanism, and how to prevent score manipulation are all challenges that need to be validated in practice.
From the perspective of code contribution, KITE's GitHub repository is reasonably active, and the documentation is relatively complete. Solidity basics, contract patterns, reentrancy guards, and access control are all present, indicating that the team is doing solid work and not just giving presentations.
KITE's depth of technical thinking exceeds that of most AI + Crypto projects. They do not merely stitch AI and blockchain together; they genuinely understand what kind of infrastructure is needed for the AI agent economy and design from the ground up. This approach has the potential to create genuinely useful products rather than just another hype concept.
