Kite is a building the foundational infrastructure for trust in the agentic web  

Alan Du | PayPal Ventures | September 2, 2025 

2025 has been the year of agentic commerce… or at least the year of talking about it. Jokes aside, there has been a flurry of activity around enabling a new breed of digital citizens known as AI agents. In the last several months, Anthropic, Coinbase, Google, Mastercard, OpenAI, Perplexity, Visa, and of course, PayPal, have all made major announcements about enabling AI to make purchases online — it appears that all the important companies in the world are going “all in” on agentic commerce, and agents have begun taking over. 

A broad consensus seems to be building around the inevitability of autonomous agents emerging as a transformative force across industries, thanks to rapid advances in large language models. ChatGPT and Claude have quickly become new gateways to the Web — ChatGPT reached massive annual query volumes within two years of launch, the same scale took Google much longer to achieve. The cost of running AI models has also dropped by orders of magnitude since 2022 and continues to fall, making scaled deployment economically feasible. 

So when can I unleash my personal shopping agents to scour the Web for the best deal on limited-edition Labubu dolls or let my personal finance agents manage my monthly budget, pay my bills, and rebalance my stock portfolio? The reality might be somewhat underwhelming — the current volume of agentic transactions is limited, clunky, and largely experimental. 

Most autonomous agents today are deployed via centralized systems which, while convenient and familiar, were designed and optimized for human-centric activities. This forces agents to operate through human-oriented (and sometimes brittle) mechanisms for authentication, authorization, and transactions, leading to inefficiencies and risks. 

The M×N problem 

Within the current infrastructure, agents lack native identities of their own. Integrating M agents across N services becomes a messy M×N spiderweb of OAuth handshakes, client IDs, API keys, and delegated credentials. Agents often emulate human users — effectively “borrowing” identities — and use long-lived OAuth tokens and API keys across multiple services. This approach breaks down when we inevitably need agents to run multi-hop workflows autonomously, requiring fine-grained permissions, attribution, and credential portability across different ecosystems. 

What deserves more emphasis here: 

·                  Give agents a passport, not a hall pass. The fix is first-class agent identity: cryptographic credentials and verifiable IDs issued to agents themselves, not borrowed from users. Each agent should be able to prove who it is and what it’s allowed to do without smuggling your OAuth tokens around. 
 

·                  We’ve seen this movie before. The early web only scaled once we got a common trust fabric (DNS + SSL/TLS). Agentic commerce needs an analogous fabric for agents: stable naming, authenticated channels, and policy-aware credentials baked into the stack. That collapses the M×N maze into a sane, composable layer. 

Scaling trust 

Models can hallucinate or behave erratically, and unchecked mistakes or malicious behaviors can be costly. In a future where agents are prevalent throughout commerce — not only at Fortune 500s but also among SMBs and solopreneurs — trust can become fragile and scarce. When a Client Agent in London purchases data from Server Agent X in California, licenses a custom model from Server Agent Y in Stockholm, and runs inferences on Server Agent Z’s GPU cloud in Taipei, the Client Agent must trust the Server Agents’ claims about authenticity, quality, and reliability. Now imagine that repeated automatically over billions of microtransactions across a universe of known and unknown agents — without a “FICO score.” Yikes. 

Push this further: 

·                  Don’t just trust who — trust what. It’s not enough to verify identity or payment. We need mechanisms to verify agent outputs and actions: cryptographic audit trails, attestations, re-execution/spot-checkers, and policy engines that can block unsafe actions pre-execution. 
 

·                  New safety nets. This opens room for agent insurance (covering misbehavior with auditable logs) and standardized certifications for different classes of agents. A proper trust stack lets markets price agent risk and hold them accountable. 

Off the rails 

Suppose you managed to get past the trust gap and now your agent needs to pay service providers — existing payment rails present another challenge. Current payments still lean on systems like ACH and card networks that are over half a century old, adding latency and taking a cut on each transaction. Micropayments — pennies or fractions of a penny — can be common in agentic interactions. Waiting two days for settlement while paying a 3% fee on a $0.10 API call is not acceptable for AI use cases. While virtual cards and credential tokenization can provide a near-term viable workaround in some cases, both have limits in a truly agentic future where multiple agents negotiate and transact simultaneously at machine speed. 

Don’t miss the upside: 

·                  Micropayments as rocket fuel, not roadblocks. With the right rails, granular, automated payments unlock new business models: pay-per-API-request, pay-per-second of compute time, pay-per-byte of data, and machine-to-machine data markets. 
 

·                  From bottleneck to bazaar. Think precision commerce: services metered at fine granularity and paid on the fly. Providers monetize “too-small-to-bill” services; users pay only for what they actually consume. The catch: you need rails that settle millions of tiny transactions cheaply and instantly. 

For agents to deliver, the stack must be rethought 

Several projects have begun exploring blockchain-based solutions to coordinate AI models and agents, leveraging blockchains and token incentives to create AI networks. In theory, existing blockchain infrastructures offer clear advantages over traditional payment rails — immutable logs, cryptographic proofs, and reproducible smart-contract logic. Blockchain-based payments also remove intermediaries and enable cross-border micropayments. 

However, most current blockchains suffer from two major weaknesses: 

Lack of a dedicated trust layer for AI output 

While smart contracts can enforce rules and verify certain on-chain actions, existing solutions don’t fully extend cryptographic attestation to AI outputs and off-chain interactions. In many blockchain/AI projects, users still have to trust that an agent is behaving as claimed because the chain records token transfers or simple proofs — not the content or context of AI decisions. Some networks rank model responses to determine rewards, but rankings can be subjective and vulnerable to gaming. Robust trust in agents requires end-to-end verification: secure identities and payments, plus monitored, auditable activities and outputs. 

Latency and fees 

Public blockchains process transactions in discrete blocks with finite intervals, and finality often requires multiple confirmations. This is problematic for AI-native interactions, which are continuous streams of actions and microtransactions. An agent may need to send dozens of small payments per second — not a great match for the block-by-block cadence of typical L1 chains. For low-value transactions, gas fees can be prohibitively high since fees are charged per transaction and are largely fixed. As activity grows, network congestion can cause gas fees to spike. (Yes, some L2s and alt-L1s are faster and cheaper, but sustaining billions of micro-events with strong finality and policy controls is still very hard – especially given most are not optimized for AI use cases.) 

This is why we got really excited about Kite AI 

Kite introduced a network that is a purpose-built L1 blockchain designed to support autonomous agents with both programmable trust and AI-compatible performance. Kite combines trustless computation, self-custody, composability, real-time throughput, streaming payments, and integration with AI workflows. The result is a platform where AI agents can truly act on behalf of users — even handling real money and interacting with real-world services — with guarantees of safety, efficiency, and auditability. 

Not your grandfather’s blockchain: an agent-native approach 

Kite isn’t a general-purpose chain chasing whatever is trendy; it’s built for the agentic era. That means agent-native primitives are first-class citizens: 

·                  Agent identity & credentials. Each agent gets a unique, verifiable on-chain ID — effectively a passport — encoding permissions, provenance, and transaction history. 
 

·                  Programmable trust & auditability. Every significant action (service calls, state changes, payments) can be checked against on-chain policies before execution and immutably logged after, enabling traceability, accountability, and clean post-mortems. If an agent misbehaves, there’s an enforceable paper trail. 
 

·                  Attribution & fairness. Consensus rules can reward good behavior and attribute contributions (e.g., who provided data, who did the compute) to reduce freeloading and gaming. 

AI-compatible performance 

Kite’s architecture is built for speed and scale. A cornerstone is a state-channel mechanism that enables streaming micropayments and agent-to-agent communication off-chain with instant finality. Agents that transact frequently open secure channels (conceptually akin to payment channels) so tiny payments or data exchanges occur peer-to-peer in real time without waiting for block confirmations. Billions of micro-events can be processed off-chain and summarized on-chain, dramatically improving throughput and cost. Kite can therefore support the streaming microtransactions agents require — paying per API call, per unit of compute time, per byte of data. 

Why PayPal Ventures is onboard 

We’ve watched a few tectonic shifts in commerce — the rise of e-commerce, mobile, and real-time payments — and agentic commerce has that same “big bang” energy. We invested in Kite AI because the pattern is familiar: a new network paradigm needs new infrastructure. As a company that’s spent decades helping money move safely between people and businesses, we see clearly that agents need their own economic layer — identity, payments, and verification in a single, composable stack. Kite is building the picks and shovels for that future, solving the hard trust and coordination problems so agentic commerce can scale safely. 

Agents will become as ubiquitous and impactful as the Web itself. Realizing this future requires a re-architecture of the foundational digital infrastructure to be compatible with these non-human actors. Kite AI is pioneering solutions to this very problem, and we at PayPal Ventures are beyond thrilled to be part of the journey. 

If this feels like the mid-1990s all over again, that’s because it probably is. Back then, multiple ecosystems and standards competed until the world coalesced around a small set of core protocols (TCP/IP, HTTP, SSL). We’re in the dial-up phase of agentic commerce: noisy, chaotic, and incredibly promising. The right identity, trust, and payment primitives will be the “dial tone” of the agentic internet. Let’s just hope what comes next loads faster than your old 56k modem.