PayPal leads $33 million funding round for Kite AI to build a promised land for agents
TechFlow Selected TechFlow Selected
PayPal leads $33 million funding round for Kite AI to build a promised land for agents
In a new world where agents can autonomously transfer funds and make decisions, Kite is building a full-stack trust infrastructure.
Navigating Web3 tides with focused insightsOriginal author: @0xPrismatic
Core Takeaways
-
Currently, the vast majority of AI agents remain trapped in "sandbox mode." Due to a lack of essential underlying infrastructure, they cannot scale transactions, payments, or collaboration. This is akin to having the most advanced self-driving car permanently stuck in a parking lot, unable to actually hit the road.
-
Kite is building a full technology stack to break this deadlock: a Layer 1 blockchain and developer platform purpose-built for agents, with trust, payments, and collaboration mechanisms built into its runtime. Its innovative "Agent Passport" system grants agents verifiable identities, clear spending limits, and operational boundaries. Smart contracts efficiently handle critical functions like escrow, service-level agreements (SLAs), and dispute resolution.
-
Since launching its testnet, Kite has successfully processed over 1.2 billion agent calls from more than 53 million users, scaling performance from 1 inference per second to over 450 inferences per second. The entire network runs on a "Proof of AI (PoAI)" consensus model that precisely incentivizes contributors—data providers, model builders, and service operators—based on actual task completion.
-
Kite's ultimate goal is to become the decentralized AWS of the "Agent Internet" era, enabling countless AI agents to seamlessly book trips, make purchases, and execute complex tasks across different platforms.
Imagine if every time you took an Uber, you had to personally instruct the driver which route to take, how much to charge, when to refuel, and manually approve every turn—that’s the reality AI agents face today. The issue isn’t insufficient model capability; it’s the missing infrastructure.
In the U.S. alone, analysts project the agent market will approach $69 billion by 2034, with billions of autonomous agents running. Despite rapidly declining inference costs, enterprises are still 3.4 times more likely to deploy agents in sandbox environments than in production.
In the U.S. alone, analysts project the agent market will approach $69 billion by 2034
There’s a deep reason behind this.
Today’s agents excel at tasks like workflow automation and data summarization. But when it comes to real financial transactions or multi-party collaboration, they stall. It’s as if we’ve built the most advanced self-driving car but decreed it can never leave the parking lot.
The missing piece is a trust infrastructure capable of supporting high autonomy. Agents need foundational primitives just like human society: verifiable identity, autonomous payment capability, and enforceable agreements. Without these, they’ll remain forever stuck in prototype mode.
Kite exists to fill this gap.
Kite’s story began in 2022 as ZettaBlock. The initial goal was clear: make Web3 data processing faster, cleaner, and more developer-friendly—positioning itself close to Snowflake or The Graph. By early 2024, ZettaBlock had successfully established itself as an “institutional-grade” Web3 indexing and analytics platform, earning support from top projects including EigenLayer, Sui, and Chainlink. Its software philosophy was distinct: SQL-first, strict schema design, and minimal unnecessary complexity. Team members had previously built large-scale systems at companies like Databricks, Uber, and Salesforce, and their technical depth was evident in the product.
Late in 2024, ZettaBlock rebranded to Kite, elevating its vision: evolving from a data infrastructure platform into a fully EVM-compatible Layer 1 public chain purpose-built for the AI economy.
This transformation was a natural progression.
This is a comprehensive deep-dive report, divided into three parts:
(I) Technical Deep Dive
(II) Assessment of Current Progress
(III) Analysis of Future Business Potential
You may skip around based on interest.
I. Technical Deep Dive
Building an agent isn’t hard. The real challenge lies in making it deliver tangible value.
To elevate agents into true economic participants, three core elements are required:
-
Identity & Delegation
Agents need a persistent, verifiable identity.
This goes beyond an API key or OAuth token—it’s a credential that can assert:
“Who created this agent, what level of permissions it has, and how much money it’s allowed to spend on specific tasks.”
Without this, every interaction carries hidden trust risks, requiring repeated manual approvals, and even a minor API change could collapse the entire workflow.
-
Autonomous Payments
Theoretically, agents can hold wallets, but in practice, they’re mostly stuck in fintech’s “purgatory”: each payment requires permission from platforms like Stripe, as if asking a parent for allowance (Stripe has made preliminary explorations into agent-driven payments). What agents truly need is a wallet-native payment rail—one that allows them to pay per API call, subscribe to data streams, and execute microtransactions—all without human intervention. Such infrastructure is nearly non-existent today.
-
Programmable Governance
Trust also depends on rules. What happens if an agent breaches contract terms or fails to meet service standards? Who arbitrates and enforces outcomes? In human society, we have courts and customer support. But agents can’t call customer service. They need programmable guardrails and enforceable agreements, where all rules are executed in code.
Nearly every agent developer has faced this dilemma. When you're excited to build a trading agent or on-chain research assistant, you quickly hit a wall:
-
How do you grant spending authority while maintaining security?
-
How do you enable autonomous interaction with other services?
-
How do you prove the agent actually completed the claimed work?
The current state forces developers to rely on makeshift wallet solutions and identity workflows, praying the system won’t crash. A scalable agent economy cannot be built on such fragile foundations. We urgently need new infrastructure that makes trust a native, programmable capability, freeing developers from reinventing the wheel.
A Transaction Layer Built for Agent AI
What Kite is building is exactly that: a transaction layer purpose-built for the Agent Internet.
At the heart of its tech stack is Kite AIR (Agent Identity Resolution), a programmable trust framework that empowers agents with the following capabilities:
-
Authentication: Obtain identity via a persistent, verifiable “Agent Passport.”
-
Transactions: Conduct native payments using stablecoins like USDC and PYUSD.
-
Execution: Enforce rules through programmable SLAs and policy modules.
Kite’s innovation lies in not patching existing financial infrastructure, but embedding trust directly into the protocol’s DNA. Each agent receives a cryptographically verified “passport” detailing its creator, permissions, spending rules, and usage constraints. Every interaction is settled on-chain, leaving a transparent, auditable trail, eliminating reliance on centralized intermediaries. Access to external services or APIs is strictly governed by smart contracts pre-encoded with pricing, permissions, and fallback plans.
This design turns independent agent operation from theory into reality.
More importantly, Kite lowers the barrier to crypto, making it accessible to mainstream developers—a prerequisite for Web3’s mass adoption. Developers don’t need to learn Solidity or manage private keys manually. The platform provides a full suite of SDKs, templates, and pre-built modules to easily register agents, configure rules, and deploy them.
Under the Hood: How Kite Delivers “Verifiable Trust” for Agents
Source: KiteAI Docs
First Pillar: Cryptographic Identity and Authorization
Most current AI agents are “stateless scripts,” unable to verify creators or define permission boundaries. Kite solves this with “Agent Passports”—cryptographically secured, verifiable credentials whose rules are mathematically enforced at the protocol layer.
Each “Agent Passport” precisely encodes:
-
Spending limits and budget caps
-
Authorized service providers and API whitelists
-
Time-based operational windows
-
Multi-signature approvals for high-value operations
This transforms agents into native economic participants. Users retain ultimate control while granting fine-grained, auditable permissions. For example, authorizing a travel agent with a $2,000 hotel booking limit means that cap is embedded in its cryptographic DNA—unbreakable under any circumstances, even accidents.
The result is clear: agents can only do what they’re authorized to do, no more, no less, with restrictions enforced by code.
This identity and authorization layer is key to enabling autonomy. When every agent has a persistent, verifiable identity with clearly defined permissions, service providers can confidently interact with them, payments execute automatically, and tasks flow seamlessly between agents—all governed by transparent, enforceable rules. Identity is the bottleneck preventing scalable autonomous collaboration, and “Agent Passports” offer a solution.
Second Pillar: Programmable Governance and Policy Enforcement
We can’t let AI agents run wild—they need rules. Some must be rigid, others flexible. Today’s AI lacks both, relying heavily on continuous human oversight.
Kite replaces “constant human supervision” with programmable governance. This rule engine deeply embeds safety guardrails into the agent’s core logic while allowing adaptive adjustments when needed. Intelligent constraints are built-in by design.
Kite’s governance system operates at two critical levels:
-
Context-Aware Controls
Kite’s architecture helps developers build intelligent monitoring systems that enforce operational boundaries. The system actively detects anomalous spending, verifies counterparty identities before transactions, and checks whether agent behavior aligns with authorized intent. If anomalies occur—for instance, a shopping agent attempting to buy unauthorized luxury goods—the system immediately halts execution.
-
Failsafe and Escalation Mechanisms
For extreme scenarios, Kite includes automated safety features. A “circuit breaker” can forcibly pause an agent if it behaves abnormally or exceeds operational thresholds. When an agent encounters unknown situations it cannot safely handle, decision-making rights revert to the human owner, accompanied by full audit logs and resolution suggestions.
Programmable governance transforms agents from “fragile demos” into trustworthy executors.
Third Pillar: Transparent Attribution and Audit Trails
Kite immutably records every API call, payment, inference, and policy trigger on-chain. This creates a fully trustworthy historical record of agent behavior, trusted by counterparties, users, and services alike.
Source: KiteAI Platform Demo
To protect privacy, Kite employs zero-knowledge auditing. This allows users and counterparties to verify compliance without exposing sensitive data. For example, a trading agent can prove it adhered to investment rules without disclosing specific portfolio details.
This deep transparency answers fundamental questions:
-
Did my agent act within my authorized scope?
-
If a task failed, can I trace the root cause?
More importantly, it creates compounding advantages. Over time, audit records drive system optimization. Agents learn from past behavior, service providers become more accountable due to permanent records, and users select agents based on “verifiable history” rather than marketing claims.
Transparency thus becomes a real competitive moat.
Built-In Safety Net: Dispute Resolution and Insurance
Accidents happen. Services fail, agents err. Kite builds safety mechanisms into the foundation, ensuring disputes resolve automatically and no one pays for undelivered services.
All transactions go through programmable escrow. Funds are locked until delivery conditions are met, then released. If a task fails, funds are automatically refunded. In case of disagreement over completion, Kite’s arbitration layer intervenes, using on-chain audit logs and predefined rules to render binding decisions enforced on-chain.
For more complex cases like fraud or partial fulfillment, Kite’s architecture supports integration with decentralized insurance modules. Several ecosystem protocols have shown strong interest. Claims can be automatically triggered by verifiable data, eliminating manual processes.
These safety mechanisms transform the agent economy from a fragile experiment into a robust system capable of handling real-world complexity. Agents can transact confidently, knowing failures and disputes have pre-defined resolutions.
Now, an industry fully operated by agents—ride-hailing, logistics, research, even financial trading—becomes tangible, with autonomous coordination and efficient execution, all without human oversight.
From Infrastructure to Seamless Integration: Simplifying Development
If Kite’s trust primitives are too complex to use, they’re worthless. Hence, one of Kite’s core principles is making developers barely notice the underlying infrastructure.
Kite offers developers the following conveniences:
-
SDK: Easily register agents, assign permissions, and connect services via Python and familiar APIs
-
Smart Contract Templates: Cover common scenarios like streaming payments, escrow, and SLA enforcement—developers focus on business logic, not rebuilding base contracts
-
Graphical Dashboard (provided by Kite modules and ecosystem developers): Configure agent policies, monitor status, and review audit logs via GUI—no blockchain coding required
-
Service Integration Kit: Helps traditional Web2 platforms verify agent identity and collect payments automatically
Kite aims to eliminate all unnecessary friction in the tech stack, letting developers focus entirely on agent design and logic, while identity, trust, and settlement are perfectly handled by the underlying infrastructure.
A Near-Future Vision: An Agent-Powered Uber Experience
As Kite’s infrastructure matures, a future of freely collaborating agents transitions from sci-fi to the next chapter of internet evolution.
Let’s revisit the earlier Uber example. A user instructs their personal agent: “Book me a ride from SoHo to JFK. Budget: $50. Tip $10 if we arrive early. Pay with USDC.”
-
The user’s personal agent instantly queries multiple verified ride-hailing agents (e.g., UberAgent, LyftAgent) for quotes
-
Each ride-hailing agent has a public reputation profile: SLA history, user ratings, uptime, and payment reliability
-
The personal agent selects UberAgent, escrows the $50 budget in a smart contract, and sets refund terms for late arrival
-
The vehicle arrives on time, SLA is met, and the smart contract automatically releases $50 plus a $10 tip to UberAgent
-
If issues arise (e.g., driver cancels), backup plans activate immediately: escrowed funds are refunded, UberAgent’s provider trust score drops, and the insurance pool (pre-funded by the user) covers “opportunity cost”
Driven by smart contracts, native wallet payments, and programmable agent governance, this entire process executes autonomously, transparently, and verifiably.
This is just one scenario.
Now imagine the same collaboration layer applied to Shopify shopping agents, portfolio management agents rebalancing via DEX agents, or healthcare agents retrieving cutting-edge medical papers via research agents.
Soul-Searching Question #1: Why Blockchain at All?
Even top teams struggle with this question.
The answer: because agents are about action, not requests. They execute transactions, pay bills, and call services in milliseconds—entirely without human input. No approval loops, no email chains, no “I need to escalate this” delays.
Traditional Web2 architectures simply can’t support this level of autonomy. API keys can be stolen, payment systems require manual KYC and approvals, and commercial disputes get stuck in endless customer service queues. When agents make machine-speed decisions, this outdated system collapses.
Human collaboration is already challenging; at agent scale, current models completely break down. Trust can no longer be an optional add-on—it must be the foundation. Agents need a new track where every action is provable, every transaction enforceable, and every decision traceable and accountable.
Among today’s technologies, blockchain is the only system built for this level of autonomous collaboration.
It grants agents five indispensable capabilities: enforceable agreements, continuous payments, portable identity, transparent public logs, and borderless execution. Each replaces fragile, inefficient human processes with deterministic code.
This isn’t decentralization for decentralization’s sake—it’s because autonomous software naturally needs a runtime independent of external approvals.
Soul-Searching Question #2: Why Build a Dedicated L1 for AI?
Okay, say we need blockchain—but why build a new one? Can’t we just use Ethereum, Base, or Solana?
Because no existing general-purpose chain is designed for AI agents’ core needs.
They were built for human activity: wallet logins, bulk payments, token swaps.
AI agents behave fundamentally differently, generating massive volumes of continuous, high-frequency, low-value transactions: micro-payments per API call, real-time status updates for streaming services, dynamic policy checks before every action. Even high-performance chains like Solana struggle with millions of concurrent agent micro-interactions. If a $0.01 API call costs $0.05 in network fees, the entire economic model collapses.
Kite’s sovereign chain solves this architecturally. Its state channel system handles the vast majority of agent interactions off-chain for efficiency, settling final security outcomes on-chain—balancing speed and trustlessness. This enables thousands of micro-transactions per second with finality. The main chain only intervenes during channel creation/closure or dispute resolution, greatly reducing load.
Source: KiteAI Docs
AI-Native “Base Primitives”
Kite replaces traditional consensus with Proof of Artificial Intelligence (PoAI)—a mechanism that tracks and rewards agent contributions based on measurable impact.
When an agent successfully completes a task, the generated value is precisely distributed among contributing data providers, model builders, infrastructure operators, and service nodes. High-quality contributors earn higher returns, creating incentive alignment by design.
In the Kite network, every agent operates via decentralized identifiers (DIDs) and verifiable credentials (VCs). Identity verification and access control happen on-chain, requiring no external validation layers.
Collaboration models between agents are also reshaped economically. Thousands of micro-transactions can be batched for settlement. Subscription models, pay-per-use billing, and programmable revenue sharing create clear, predictable cost structures. Value attribution becomes unprecedentedly precise and automated.
Together, these form an infrastructure layer treating agents as “software-first economic actors”. This is a protocol that truly understands AI.
(More details on tokenomics and incentive design will be disclosed by the team in the coming weeks.)
II. Kite’s Early Traction and Demand
Kite AI uses a modular system design. Each module is an independent execution environment focused on a specific domain, with its own rules and incentives, yet interoperable with the broader Kite network.
This design delivers three core advantages:
-
Permissionless Collaboration: Developers and data providers can freely create or join modules, free from centralized gatekeepers
-
Transparent Contribution: Every contribution—from data labeling and model fine-tuning to inference services—is clearly tracked and attributed on-chain
-
Decentralized Governance: Each module is steered by its community of stakeholders, ensuring long-term goals align with contributor incentives
For example, one module might manage medical imaging datasets, while another provides compute for physics simulations. They evolve independently but share Kite’s powerful infrastructure.
Codatta is the first full-stack data protocol fully integrated into Kite AI’s ecosystem as a module, bringing over 500 million cross-domain labeled data points across healthcare, robotics, and crypto.
Module 01: Codatta
As a Kite module, Codatta maintains autonomous operations while achieving seamless integration with other services. Agents can retrieve datasets, initiate labeling tasks, or evaluate model outputs via simple function calls. In Kite’s app store, Codatta’s services appear alongside other AI tools, making discovery and integration easy for developers.
The most exciting use case so far: leveraging annotated blood smear datasets to power AI models for early blood cancer detection. These agents are saving lives in the real world, not just trading tokens.
Kite’s blockchain is deeply optimized for AI-scale computation, ensuring smooth operation even during peak data labeling and retrieval—critical for Codatta’s real-time workflows. Royalty mechanisms are embedded in the protocol: whenever an agent uses a dataset, the smart contract automatically records and distributes earnings to data contributors.
Codatta is the first strong proof of Kite’s open AI economy vision—but just the beginning. Together, Codatta and Kite will enter more verticals, introduce additional functional modules, and jointly build a composable, incentive-aligned data layer for autonomous AI.
Kite Testnet Progress
Product-market fit (PMF) isn’t achieved through “points” or leaderboards. It happens when real users and developers choose to stay and keep using your product—even without material incentives.
Kite’s core Layer 1 launched its testnet in early 2025. Despite the full agent toolchain still rolling out incrementally, community enthusiasm remains strong.
Testnet v1: Aero
Phase one, Aero, targeted general users with a no-code interface to interact with AI agents developed by the Kite team. Lightweight incentives were used.
During Aero, Kite released several internal demo agents, including ecosystem guide The Professor, fraud detection agent Sherlock, and market-tracking Crypto Buddy. Users interacted via a simple chat interface—each command triggered real on-chain inference, attribution, and reward distribution.
Source: KiteAI Aero Testnet
This preliminarily validated Kite’s agent economic loop as genuinely viable:
-
Over 1.2 billion agent calls processed
-
Over 53 million cumulative users, with daily peaks exceeding 100,000 new users
-
Over 30 million on-chain transactions, with steady weekly growth
-
Daily peak interactions exceeding 20 million, over 200,000 daily active users, and over 100,000 users experiencing AI for the first time
The vast majority of transactions stemmed from agents executing tasks, generating inferences, and recording attributions—fully aligned with testnet objectives.
Source: Dune
Testnet v2: Ozone
In July 2025, phase two, Ozone, launched with major upgrades: universal accounts, social login, account abstraction, staking, and the first agents from ecosystem partners.
More importantly, participation now extends beyond Kite’s official team.
For example, AIVeronica from Animoca Brands (dubbed “the world’s first and largest AI Game Master”) went live on Kite’s testnet in early form, along with several “personality dialogue” agents based on immersive NPC prototypes (e.g., Zane, Vyn).
Agents from more partners like Bitte and BitMind are expected to join in later stages, further solidifying Kite’s positioning as a cross-domain, multi-developer platform.
Ozone’s early metrics are impressive:
-
Over 509 million agent calls processed within weeks
-
13.4 million new unique users
-
Daily interactions consistently in the tens of millions
-
Millions of NFT badges minted, reflecting high early user engagement
Source: Dune
Testnet v3
Testnet v3 is in planning, expected to launch by end of August, introducing multisig wallets, fiat on/off ramps, cross-chain bridges, token swaps, staking, and airdrop infrastructure—laying the groundwork for the mainnet launch in Q4.
While public testing progresses, Kite is also refining its core tech stack for developers and enterprise partners (currently invite-only). The Kite agent marketplace helps teams easily publish and monetize agents; Kite Passport solves identity, permissions, and programmable payments; Kite SDK integrates everything, enabling seamless agent service embedding into applications.
Next steps include stablecoin payments, cross-chain settlements, e-commerce plugins, agent reputation scoring, and “Know Your Agent (KYA)” certification. The feature list is long, but each addition strengthens Kite’s position as the preferred infrastructure for AI collaboration.
Since the Aero testnet launch, the team has made significant technical progress:
-
Token generation time reduced from over 15 seconds to 1.3 seconds
-
Inference throughput increased from 1 per second to over 450 per second
-
Attribution stability and reward calculation accuracy significantly improved
This rapid iteration—solving bottlenecks, optimizing logic, improving UX—demonstrates the team’s determination and capability to achieve production-grade scalability before mainnet.
III. Kite’s Business Outlook
Where will future demand come from?
Testnet activity shows users are curious about blockchain-native AI agents. But curiosity fades. Sustainable demand must stem from strong economic gravity.
Three Core Value Propositions
Kite’s competitive edge lies in unlocking new economic opportunities impossible under traditional tech—specifically, commercialization, composability, and liquidity of AI assets.
-
Monetizable Open AI Market: In current AI architectures, value is often captured by top-layer platforms acting as “toll booths,” taking most profits. Kite’s attribution engine precisely tracks and rewards true value creators. For example, a medical research institute whose dataset improves a healthcare agent’s diagnostic accuracy earns automatic revenue each time it’s used. This pay-per-use model—versus traditional licensing—makes open contribution economically viable for the first time.
-
Stronger AI Module Ecosystem: Developers can assemble agents like LEGO, combining independent modules from different providers, each with clear pricing and verifiable performance. A financial advisor agent might integrate Company A’s fraud detection, Company B’s macroeconomic signal module, and Company C’s risk analysis. Each module earns revenue proportional to its contribution—better performance, higher income—creating a virtuous cycle that incentivizes innovation and quality.
-
Vibrant DeFi Economy: Owning its Layer 1 enables Kite to deeply embed DeFi primitives. High-quality AI services themselves can be tokenized, staked, and traded, with their revenue streams becoming investable assets. Capital flows more efficiently toward truly valuable innovations.
Ecosystem Flywheel: From “Single Agent” to “Real AI Economy”
Kite’s strength is how these value propositions reinforce each other, creating powerful network effects.
Agents → Drive Demand for Services
Every agent relies on resources: data, models, APIs, real-world connections. In Kite’s system, these become monetizable modules:
-
Weather APIs can charge agents per call
-
Data providers can license by query volume
-
Trading signal bots can offer pay-per-use subscriptions
Agents settle with service providers in real time, backed by verifiable SLAs. This opens a new commercial path for all service providers: revenue no longer depends on ads, but on direct, programmable compensation—triggered by agent usage, verified by smart contracts, settled in stablecoins.
Services → Incentivize More Participants
As more services join Kite, economic returns grow:
-
Shopify merchants gain new orders from shopping agents
-
Data providers earn passive income from diverse AI assistants
-
Niche but efficient models get called and paid by thousands of autonomous apps
This creates sustainable revenue models, attracting more high-quality service providers and fueling ecosystem growth.
Infrastructure → Empowers Stronger Agents
As the service ecosystem grows richer and easier to access, building agents becomes more valuable and feasible. Developers no longer write custom integrations for every API—they can confidently use vetted services with clear pricing and terms. Agents easily chain multiple services together to complete complex tasks, eventually evolving into full-fledged applications.
A powerful growth flywheel emerges: better services → stronger agents → more usage → more revenue → more high-quality services.
This is the essential path from single-agent utility to a multi-agent collaborative economy.
It will make Kite the coordination layer of the next-generation internet—a global, permissionless collaboration network where AI agents continuously create value.
Team and Funding
Co-founder & CEO Chi Zhang holds a PhD in AI and Statistics from UC Berkeley, specializing in interpretable machine learning. This expertise shapes Kite’s core architecture: transparent, verifiable attribution for autonomous systems. Her career blends rigor and practicality—applying AI to high-stakes domains like cancer diagnostics at Gilead, and leading product roles at dotData (AutoML) and Databricks, gaining deep experience in large-scale data pipelines. This rare combination of advanced AI research and real-world product execution is exactly what’s needed to build something as ambitious and technically intricate as Kite.
Co-founder & CTO Scott Shi is a top-tier technical architect who led AI infrastructure development at some of the world’s most data-intensive tech giants. He headed engineering for Salesforce Einstein, creating and patenting an orchestration system for AI workflows across business units. At Uber, he built the company’s security analytics platform from scratch, processing billions of records to generate regulatory-compliant metrics. Later, he co-founded RisingWave, a high-performance streaming data company, further honing his expertise in large-scale real-time data processing.
Other team members bring equally strong backgrounds, drawing talent from Alibaba, Uber, eBay, Salesforce, McKinsey, PayPal, and NEAR, with deep expertise in Web2 scale, AI productization, enterprise compliance, and Web3 infrastructure. Collectively, this is a well-balanced, top-tier team in the AI x Crypto space.
Since inception, Kite AI has attracted backing from leading AI and strategic investors, including PayPal Ventures, General Catalyst, 8VC, Vertex Ventures, Samsung Next, Alumni Ventures, HashKey Capital, Hashed, Animoca Brands, SBI US Gateway Fund, LayerZero, Avalanche Foundation, and Dispersion Capital.
Funding will accelerate infrastructure deployment, support R&D for new developer APIs like Kite AIR, and expand its service integration network.
Our Thoughts
#1: Real-World Use Cases Need Real-World Partners
For Kite to become the transaction layer for real-world agents, AI agents and crypto infrastructure alone aren’t enough. It must embrace real-world services. I mean services people actually use daily: Shopify merchants, fintech APIs, food delivery platforms, SaaS tools, streaming content, and travel booking engines. If agents can’t book rides or shop from real suppliers, their value plummets—and Kite risks becoming an isolated “crypto playground.”
Thus, in many ways, Kite is not just a tech platform but a powerful business development engine. Its success hinges on:
-
Convincing mainstream Web2 service providers to deploy service contracts or register agents on Kite
-
Providing extremely simple dashboards, plugins, and SDKs so non-crypto businesses can integrate easily
-
Encapsulating complex processes—wallets, KYC, stablecoins—behind familiar APIs
-
Delivering enterprise-grade billing, risk control, and SLA solutions
To fulfill its potential, Kite must become the simplest, most efficient gateway for traditional businesses entering the “agent economy.” One deep integration with Shopify, DoorDash, or PayPal could generate more momentum and user growth than any technical milestone.
Kite faces a historic opportunity: to bridge AI agents and the existing internet. That demands thinking like a “partner company,” not just a “protocol.”
#2: Parallels and Divergences with Bittensor
In a recent report by Coinbase Ventures, Kite and Bittensor are grouped under the “decentralized intelligence and collaboration” category.
Source: Coinbase Ventures
Both projects are making bold architectural bets: building crypto-native networks where AI service providers and consumers (agents) collaborate on-chain and earn incentives. Bittensor pioneered this paradigm with its subnet model; Kite aims to extend it into broader agent-driven real economies. Both share similar goals: open participation, transparent incentives, and on-chain enforceable accountability.
Of course, Kite’s implementation path differs.
relies on Yuma consensus, distributing TAO token rewards based on nodes evaluating each other’s model outputs. Essentially, it’s a peer-review-based reputation game. Kite, by contrast, uses Proof of AI, where value attribution is tied directly to task execution outcomes. Agents perform verifiable work, and the value they create is distributed across all contributing nodes—data, models, infrastructure.
Bittensor’s success proves that a well-designed incentive flywheel, once activated, can unleash tremendous energy: over 100 subnets, more than $60 million in monthly token incentives, and a large, active contributor community. Kite hopes to ignite similar momentum, but rooted in real agent transactions—not just AI inference.
Bittensor’s early trajectory offers valuable lessons: where incentives worked, where consensus became a bottleneck, and how economic models ultimately shaped network behavior. Kite has the chance to optimize and forge its own path.
The next chapter of the internet will be written by software that acts autonomously and creates value through work.
#3: Developer Experience Will Determine Ecosystem Success
Most AI engineers don’t know Solidity. They use Python, call REST APIs, and deploy models to hosted endpoints. For Kite to attract top agent developers, it must make complex crypto infrastructure fade into the background.
The Kite team understands this clearly. Their developer toolkit emphasizes SDKs, templates, and automation. Whether registering an agent, configuring an SLA, or integrating payments, everything can be done via simple CLI commands or ready-made SDKs.
For mass adoption, crypto must become optional:
-
Agent developers shouldn’t need to understand tokenomics or governance
-
Publishing an agent should be as easy as uploading a model to HuggingFace
-
Monetization should be plug-and-play
Stripe succeeded by perfectly abstracting complex payment clearing networks—developers collect payments without understanding the internals. Kite must do the same for agents. The real explosion will happen when developers realize Kite is the easiest way to publish, manage, and monetize agents—regardless of blockchain knowledge.
Conclusion
Today’s AI agents are like “self-driving cars stuck in parking lots.” They can think, but when it comes to collaborating with the real world, they’re paralyzed.
Kite is changing that. The rails it’s laying will transform agents from passive tools into true economic participants—with identity, incentives, and collaboration capabilities.
The project is still early, the vision immense. But the direction is unequivocally right.
The next-generation internet will be driven by agents. Kite is almost ready.
Join TechFlow official community to stay tuned
Telegram:https://t.me/TechFlowDaily
X (Twitter):https://x.com/TechFlowPost
X (Twitter) EN:https://x.com/BlockFlow_News
@cot_research
