Imagine needing to tell your Uber driver exactly where to go, how much to charge, when to stop for gas, and manually approving every turn they make. That’s what today’s AI agents feel like.

The models are capable. The infrastructure is not…yet…there.

In the U.S. alone, analysts expect the agent market to reach nearly $69B by 2034, with billions of agents operating autonomously. Inference costs are collapsing. Yet organizations are still 3.4x more likely to keep agents in sandbox environments, not in real deployment.

There’s a reason for this.

Agents today can automate workflows and summarize data. But when it’s time to transact, like spend money or coordinate on tasks, they stall.

It’s like building self-driving cars that can’t leave the dealership parking lot.

The missing piece is a trust infrastructure that supports autonomy. Agents need the same primitives humans rely on: verifiable identity, autonomous payments, and enforceable agreements. Otherwise, they will never scale beyond prototypes.

That’s the gap Kite is solving.

Kite didn’t emerge from nowhere. It started as ZettaBlock in 2022 with a focused goal: make Web3 data fast, clean, and developer-friendly. The product leaned closer to Snowflake or The Graph.

By early 2024, ZettaBlock had positioned itself as “institutional-grade” Web3 indexing and analytics. It had growing traction, powering infrastructure for teams like EigenLayer, Sui, Chainlink, and others.

It was opinionated software: SQL-first, schema-strict, and allergic to unnecessary complexity. You could feel the influence of a team that had built real systems at Databricks, Uber, and Salesforce.

Later that year, ZettaBlock became Kite. What started as data infra became something much more ambitious: a purpose-built, EVM-compatible Layer-1 for the AI economy.

It was the next logical step.

Okay, this one’s a really detailed report, so we’ve split it into three parts: (I) a technical deep dive into what Kite is, (II) a look at current traction, and (III) a business analysis of where it’s headed. Skip around as you like.

Building agents is easy. Letting them do anything substantial? That’s the hard part. To promote them to full economic actors, they need three things:

Agents need a persistent, verifiable identity. Not just an API key or OAuth token, but something that says:

“This agent was created by this user, has this level of authority, and is allowed to spend this much to complete these tasks.”

Without this, every agent interaction becomes a trust risk. Every interaction needs human-in-the-loop approval and can easily break when the API changes.

Yes, technically, agents can hold wallets. But most of them are stuck in Fintech purgatory: asking Stripe for permission like it’s their dad (Stripe has toyed with agent-driven payments)

What agents need are wallet-native payment rails. Paying per API call, subscribing to data streams, executing microtransactions without human approval. That infrastructure barely exists today.

Trust is also about rules. What happens if an agent breaks the contract? What if a service doesn’t deliver? Who enforces the terms?

In human systems, we rely on courts or customer support to resolve problems. Agents can’t call customer support. They need programmable guardrails and enforceable agreements. Rules enforced in code.

Most agent builders feel this friction. You start with an ambitious idea like building a trading agent or an on-chain research assistant and quickly hit the wall:

Today, everyone is duct-taping wallets and patching together identity flows, hoping they don’t break.

That’s not how the agent economy scales.

We need a foundational infrastructure that makes trust native and programmable, so agent builders don’t have to reinvent it every time.

Kite is building exactly that: a transaction layer purpose-built for the agentic internet.

At the core of the stack is Kite AIR (Agent Identity Resolution), a programmable trust framework that enables agents to:

Rather than bolting trust on top of existing financial infrastructure, Kite makes it part of the protocol itself.

Each agent is issued a cryptographically verifiable passport containing its creator, delegated authority, spending rules, and usage constraints. Every interaction it performs is settled on-chain, with transparent audit trails and no reliance on centralized intermediaries. Access to external services or APIs is governed by smart contracts that encode pricing, permissions, and fallback behaviors.

This setup allows agents to function independently not just in theory, but in practice.

Importantly, Kite is designed to be usable by developers who aren’t crypto-native. That’s the only way web3 can go mainstream.

So agent builders don’t need to write Solidity or manage private keys manually. The platform provides SDKs, templates, and prebuilt modules to register agents, configure rules, and deploy them into production.

Most AI agents today are stateless scripts. There’s no way to verify their creator and scope their permissions.

Kite fixes this with Agent Passports: cryptographically verifiable credentials. They’re mathematically enforced at the protocol level.

Every Agent Passport encodes:

This turns agents into native economic actors. Users maintain ultimate control while granting agents precise, auditable permissions. If you authorize a travel agent to spend $2,000 on hotels, that ceiling is baked into the agent’s cryptographic DNA. It cannot be exceeded. Not even by accident.

The result is simple but powerful: agents can only do exactly what they’re authorized to do. Nothing more, nothing less. The limitations are enforced by code.

This identity and delegation layer is what makes autonomy viable. When every agent has a persistent, verifiable identity with scoped authority, services can interact with them confidently. Payments can execute without human approval. Tasks can flow agent-to-agent, governed by transparent, enforceable constraints.

Identity is the bottleneck that breaks autonomous coordination at scale. Agent Passports is one way to fix it.

We can’t just let AI agents wing it. They need structure. Some rules are rigid, others adjust to the moment. Most AI today lacks both. Instead, it leans on constant human supervision.

Kite replaces that with programmable governance. It’s a rule engine that hardwires guardrails into the agent’s core and gives it the judgment to adapt as needed. Smart limits, built in.

Kite’s governance system enforces rules at two critical levels:

Context-Aware Controls

Kite’s architecture enables developers building on top of the network to easily implement monitoring systems that intelligently enforce boundaries. It detects out-of-pattern spending, verifies counterparties before transactions, and validates whether an agent’s actions align with its authorized intent. If anomalies arise, like a shopping agent trying to purchase luxury items, it halts the action immediately.

Failsafes & Escalations

In edge cases, Kite applies automated safety mechanisms. Circuit breakers pause agents that behave erratically or exceed operational thresholds. When an agent faces a situation it cannot resolve safely, the system escalates the decision to the human owner, providing a full audit trail and actionable recommendations.

Programmable governance is what turns agents from brittle demos into reliable operators. 

Kite logs every API call, payment, inference, and policy trigger immutably. This creates a verifiable history of agent behavior that can be trusted by counterparties, users, and services alike.

To protect privacy, Kite uses Zero-Knowledge Audits that allow users and counterparties to verify compliance without exposing sensitive data. For instance, a financial agent can prove it adhered to investment rules without revealing portfolio details.

This level of transparency answers the questions that matter:

Did my agent do exactly what I authorized?

If it failed, can I understand why?

More importantly, it creates a compounding advantage. Over time, these audit trails enable continuous improvement. Agents learn from past actions. Service providers stay accountable. Users choose agents based on verifiable histories, not marketing claims.

Transparency → real competitive advantage. Love it.

Things break. Services fail. Agents misbehave. Kite builds safety into the rails, so disputes resolve themselves and no one pays for work that never happened.

Every transaction flows through programmable escrow. Payments are locked until delivery conditions are met. If a task fails, funds are refunded automatically. If agents disagree on whether a task was completed, Kite’s arbitration layer checks the audit trail, applies the rules, and enforces the outcome on-chain.

For edge cases, like fraud or partial failures, Kite’s architecture supports decentralized insurance modules, built by ecosystem protocols already showing interest in the space. Claims are triggered automatically based on verifiable data. No human intervention required.

These safety mechanisms transform the agent economy from a fragile demo into a system capable of handling real-world scale. Agents can transact with confidence because failures and disputes resolve themselves.

Now we can start imagining industries (ride-hailing, logistics, research, even trading) run entirely by agents, coordinating and enforcing agreements without human oversight.

All of Kite’s trust primitives are useless if they’re hard to implement. So Kite’s focus is on making them invisible to builders.

Here’s what developers get:

The goal is to reduce friction across the stack so builders can focus on agent design and logic, while the underlying infrastructure handles identity, trust, and settlement. 

As Kite’s infrastructure matures, the full vision of agent-to-agent coordination starts to look less like science fiction and more like the logical next phase of the internet.

Let’s go back to our Uber analogy from the beginning. A user instructs their personal agent:

“Book me a ride from SoHo to JFK Airport. Budget: $50. Tip $10 if it’s early. Pay in USDC.”

All of this runs autonomously and verifiably, powered by smart contracts, wallet-native payments, and programmable agent governance.

But this is just one domain.

Now imagine the same coordination layer applied to shopping agents on Shopify. Portfolio management agents rebalancing assets through DEX agents, or healthcare agents accessing the latest studies via medical research agents.

In each case, agents coordinate, negotiate, and resolve disputes with minimal friction. And Kite provides the invisible rails that make it all possible.

The question that trips up even the best teams.

Because agents don’t ask. They act. They strike deals, pay bills, trigger services. All in milliseconds, all without a human in the loop. No oversight, no email threads, no “Oops, let me escalate that.”

Web2 infrastructure wasn’t built for this kind of autonomy. API keys get stolen. Payment systems require human KYC and manual approvals. Disputes get kicked to customer support queues that take days to resolve. None of that holds up when agents are making decisions at machine speed.

Coordination was already hard. At agent scale, it breaks completely. Trust can’t be a nice-to-have. It has to be the substrate.

Agents need rails where every action is provable, every transaction enforceable, and every decision accountable. Blockchain is the only system designed for autonomous coordination at this level.

In practice, it gives agents five essential powers: enforceable agreements, continuous payments, portable identity, transparent logs, and borderless execution. Each one replaces a brittle, human-mediated step with deterministic code.

This isn’t just “decentralization” as a principle. It’s about software that acts on its own, and needs rails that don’t rely on approval.

Okay, so we need blockchain. But why start from scratch? Why not just use Ethereum/Base or Solana?

Because none of them were designed for AI agents.

General-purpose blockchains assume human-driven activity: wallet logins, batched payments, token swaps.

AI agents operate differently. They generate continuous, high-frequency, low-value transactions: micropayments per API call, real-time state updates for streaming services, and dynamic policy checks for each agent action

Even Solana would choke on millions of agents streaming micro-interactions at scale. A $0.01 API call doesn’t make sense if the network charges $0.05 to process it. The economics break.

Kite’s sovereign chain fixes that at the architecture level.

Its state channel system moves agent interactions off-chain while keeping settlement trustless. Thousands of microtransactions can clear per second, with finality baked in. The main chain is only involved when it matters, like during channel creation, closure, and dispute resolution.

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 completes a task, value flows to the data providers, model builders, infrastructure operators, and service nodes that made it possible. High-quality actors earn more than low-value participants. Incentives are aligned by design.

Every agent on Kite operates with Decentralized Identifiers (DIDs) and Verifiable Credentials. Identity and permissioning are enforced on-chain, with no need for external authentication layers.

Agent-to-agent coordination gets restructured at the economic level. Thousands of microtransactions collapse into batch settlements. Subscription tiers, usage pricing, and programmable fee splits create clean, predictable cost models. Attribution rewards are precise and automated.

The result is an infrastructure layer that understands agents as software-first economic actors. A protocol that speaks AI natively.

Tokenomics and incentive design will be detailed by the team in the coming weeks.

Kite AI runs on a modular system. Each module is a self-contained execution environment dedicated to a specific domain. Modules operate independently, with their own rules and incentives, yet remain interoperable with the broader Kite network.

This design creates three key advantages.

First, collaboration is permissionless. Developers and data providers can launch or join modules without centralized gatekeeping.

Second, contribution is transparent. Every action, from data labeling, model fine-tuning, and inference, can be traced on-chain and tied to the contributor.

Third, governance is decentralized. Each module has its own stakeholder community that steers its roadmap, aligning long-term outcomes with contributor incentives.

In practice, this means one module might manage a medical image dataset, while another handles compute for physics simulations. Each plugs into Kite’s infrastructure but evolves on its own path.

Codatta is the first full-stack data protocol integrated as a module within the Kite AI ecosystem. It brings over 500 million labeled data points across domains like healthcare, robotics, and crypto.

As a module, Codatta operates autonomously while remaining interoperable with other services on Kite.

Agents can pull datasets, trigger labeling tasks, or evaluate outputs with simple function calls. Codatta’s services sit alongside other AI tools in Kite’s app store, making them easy to discover and integrate.

My favourite use case from this partnership: annotated blood film datasets powering AI models for early blood cancer detection. These are agents actually saving lives in the real world, not just flipping tokens.

Kite’s blockchain is optimized for AI-scale operations. That means no slowdowns even during high-volume annotation and retrieval, crucial for Codatta’s real-time workflows.

Royalties are baked in. Every time an agent uses a dataset, smart contracts log the action and distribute revenue directly to contributors.

Codatta is the first real proof of Kite’s open AI economy. The roadmap is bigger than one module. Codatta and Kite will keep expanding into new verticals, bringing on more modules and building out a composable, incentive-aligned data layer for autonomous AI.

You don’t get to product–market fit from “points”. Or leaderboard grinding. You get it when real users and developers show up, and stick around without being bribed to care.

Kite’s core Layer-1 has been live on testnet since early 2025. The full agent tooling is still rolling out, but that hasn’t slowed down interest.

The first launch, called Aero, offered a no-code interface for interacting with AI agents built by the Kite team. It was designed for retail users and ran with light incentives.

During Aero, Kite shipped a few demonstration agents built in-house.

The Professor was a guide to the ecosystem. Sherlock was a fraud detection agent. Crypto Buddy tracked market trends across major tokens. They lived in a simple chatbot interface. Each prompt triggered real inference, real attribution, and real rewards on-chain.

That was the first proof Kite’s agent loop actually worked.

Most transactions come from AI agents executing tasks, generating inferences, and logging attribution events. This is exactly the behavior the testnet was built to test.

In July 2025, Kite launched the second phase. Ozone came with major upgrades: universal accounts, social logins, account abstraction, staking, and the first wave of ecosystem-partner agents.

Importantly, the ecosystem expanded beyond Kite-built agents.

For example, AIVeronica from Animoca Brands, pitched as the world’s first and largest AI Game Master, is on Kite’s testnet in an early form. There are also several chatbot-style personalities inspired by immersive NPC archetypes such as Zane (bold, charming, and protective) and Vyn (dark, poetic, and fiercely loyal). 

More agents from partners like Bitte and BitMind are expected to join in upcoming phases, underscoring the platform’s role as a multi–developer, multi–domain environment.

Early results from Ozone:

Testnet v3 is already on deck. Set to go live by the end of August, it will bring in multisig wallets, fiat on-ramps, bridges, token swaps, staking mechanics, and airdrop infrastructure. That’s all ahead of the mainnet launch in Q4.

While the public testnets expand, Kite is also building out its core stack for developers and enterprise partners (access is currently limited).

The Kite Agent App Store helps teams publish and monetize agents directly into the ecosystem. Kite Passport handles identity, permissions, and programmable payments. The Kite SDK wraps it all together, letting builders integrate agent services into their own apps.

What’s next? Stablecoin payments. Cross-chain settlement. E-commerce plugins. Agent reputation scores. “Know Your Agent” verification. The feature list is long, and every addition is meant to make Kite the default infrastructure for AI coordination.

Since the start of the Aero testnet:

This level of rapid iteration, like fixing bottlenecks, refining attribution logic, and improving user experience, speaks to a team that is serious about reaching production-grade scalability before mainnet.

Yes, some of the usage came from airdrop farmers. That’s the cost of incentivized testing. But even with noise in the system, Kite has proven it can handle real workloads, under real stress

Early testnet activity shows people are ready to use blockchain-native AI agents. But curiosity wears off. Sustainable demand requires economic gravity.

Kite's demand will emerge from creating new economic opportunities that weren't previously possible…

ie. Monetization, composability, and liquidity for AI assets. Capabilities that traditional platforms can’t offer.

Monetizable Open AI Marketplace: In today’s AI stacks, value concentrates at the top. Platforms act as toll booths, extracting most of the upside. Kite’s attribution engine tracks which models, datasets, or services drive performance, and pays contributors automatically.

A medical research institution, for example, can earn revenue every time its dataset improves diagnostic outcomes across thousands of healthcare agents. Payments flow per use, not per license. It’s continuous, usage-based compensation that finally makes open contribution economically viable.

Better AI Module Ecosystem: Developers can assemble agents using independently built modules, each with clear pricing and performance metrics. A financial advisory agent can bring in fraud detection from one provider, economic signals from another, risk analytics from a third.

Each component earns based on usage. The better the performance, the higher the payout. This creates a natural feedback loop that rewards quality and encourages open experimentation.

Vibrant DeFi Economy: Because Kite operates its own Layer-1, it can embed DeFi-native primitives directly into the system. Useful AI services can be tokenized, staked, and traded. Revenue streams become assets. Capital flows to what works.

What makes Kite powerful is how that utility compounds.

Agents → Demand for Services

Every agent needs resources: data, models, APIs, and real world services. With Kite, these dependencies become monetizable modules:

Agents pay for these services in real time, with verifiable SLAs. This gives any service provider a native path to monetize in an agentic world, not through advertising revenue, but through direct, programmable compensation triggered by agent usage, verified by smart contracts, and settled in stablecoins.

Services → Incentives to Participate

As more services become agent-accessible, it becomes profitable to plug into the network:

This creates sustainable revenue streams that incentivize high-quality service provision and continuous ecosystem growth.

Infrastructure → More Agents

As services become richer and easier to access, the value of building agents skyrockets. Developers no longer need to manually hardcode API integrations. They can rely on verified services with clear payment and SLA terms. Agents can chain services together, coordinate tasks, and evolve into full-blown applications.

This creates the feedback loop: 

More services → more powerful agents → more usage → more revenue → more services.

This is how we get from single-agent utility to multi-agent economies.

And this is what turns Kite into the coordination fabric for a new kind of internet, one where AI agents create value through permissionless collaboration at a global scale.

Co-founder & CEO Chi Zhang holds a Ph.D. in AI and Statistics from UC Berkeley, where she focused on explainable machine learning. A technical through-line that now shows up in Kite’s core architecture: transparent, verifiable attribution for autonomous systems.

Her career spans both high-stakes applied AI (cancer diagnostics at Gilead) and product leadership roles at dotData (AutoML) and Databricks, where she helped scale tools for managing massive data pipelines. That combination of deep AI research and real-world product execution is rare and exactly what’s needed to build something as ambitious and technically nuanced as Kite.

Cofounder & CTO Scott Shi is a technical architect with a track record of building AI infrastructure inside some of the most data-intensive companies in the world. He led engineering at Salesforce Einstein, where he invented patented orchestration systems for managing AI workflows across business data. At Uber, he built the company’s safety analytics platform from scratch, processing billions of records to produce regulatory-grade metrics.

Later, as co-founder of RisingWave (a high-performance streaming database startup), he further sharpened his focus on real-time data at scale.

The broader team blends similar depth with range. Alumni from Alibaba, Uber, eBay, Salesforce, McKinsey, PayPal, and NEAR bring expertise in Web2 scale, AI productization, enterprise compliance, and Web3 infrastructure.

Together, the team is very well-rounded and qualified in the AI x crypto category.

Since inception, Kite AI has secured funding 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.

The capital will accelerate Kite’s infrastructure rollout, support new developer APIs like Kite AIR, and expand its network of service integrations.

If Kite wants to be the transaction layer for real-world agents, it needs more than AI agents and crypto infra: it needs real-world services.

By that I mean the services people actually use: Shopify stores, fintech APIs, food delivery platforms, SaaS tools, streaming content providers, travel booking engines

If agents can’t book a ride, stream a podcast, or make a purchase from real vendors, their usefulness collapses. And then Kite risks becoming a closed crypto playground. Impressive, but isolated.

In that sense, the biggest existential risk is whether the off-chain world chooses to plug in.

That makes Kite just as much a business development engine as a technical platform. Success depends on:

For Kite to reach full potential, it needs to become the easiest way for a traditional business to go “agent-ready.” A single deep integration, like Shopify, Doordash, or PayPal, could do more for adoption than any technical milestone.

Kite has a rare opportunity to become the bridge between AI agents and the internet as we know it. That requires thinking like a partner company, not just a protocol.

In a recent report on the Crypto x AI landscape, Coinbase Ventures grouped Kite and Bittensor into the same category, under the “decentralized intelligence and coordination” banner.

Both projects share a bold architectural bet. They’re building crypto-native networks where AI providers and agents coordinate and get rewarded on-chain. Bittensor pioneered this idea with its subnet model. Kite is extending it into the real economy of AI agents.

The goal is similar. Open participation, transparent incentives, and accountability enforced by the chain.

Of course, Kite’s approach is structurally different.

Bittensor relies on Yuma Consensus, where peers evaluate each other’s model outputs to allocate TAO rewards. It’s a reputation game based on peer assessments. Kite, on the other hand, uses Proof of AI. Value attribution is tied to task execution. Agents complete verifiable actions, and rewards are distributed across data providers, model builders, and infrastructure nodes based on contributions.

Bittensor’s success is a proof point for what happens when a well-designed incentive flywheel starts spinning. Over 100 subnets, $60M+ in monthly token emissions, and a thriving community of contributors. Kite wants to trigger the same momentum, but anchored in agent transactions, not just inference.

There’s a lot to learn from Bittensor’s early growth. Where emissions created traction, where consensus slowed things down, and how incentives shaped network behavior. Kite has a chance to refine the model, and make it its own.

The internet’s next layer will be built by software that acts on its own and earns as it works.

Most AI engineers don’t speak Solidity. They work in Python, use REST APIs, and deploy models to hosted endpoints. If Kite wants to attract serious agent builders, the crypto infrastructure needs to fade into the background.

Kite recognizes this. 

Their developer stack leans on SDKs, templates, and automation. Registering agents, configuring SLAs, or wiring up payment flows can all be handled through a CLI or prebuilt SDKs.

Because for mass adoption, crypto has to feel optional:

Stripe wins by hiding complexity. Developers get paid without understanding the rails. Kite needs to do the same for agents. The first real wave will come when agent builders realize Kite is the easiest way to launch, manage, and get paid. No blockchain expertise required.

Most AI agents today are like self-driving cars stuck in the car park. They can think. They just can’t act when real-world coordination is needed.  

Kite is changing that. It’s building the rails that turn agents from passive tools into economic actors, with identity, incentives, and the power to coordinate.

The protocol is early. The vision is ambitious. But the direction? Dead on.

The next internet will be driven by agents. And they’re almost ready to roll.

Thanks for reading,

0xAce and Teng Yan

Want More? Follow Teng Yan, Ace & Chain of Thought on X

Join our Telegram research channel and Discord community.

Subscribe for timely research and insights delivered to your inbox.

This research essay was commissioned by Kite, with Chain of Thought receiving funding for this initiative. All insights and analysis are our own. We uphold strict standards of objectivity in all our viewpoints.

To learn more about our approach to commissioned Deep Dives, please see our note here.

This essay is intended solely for educational purposes and does not constitute financial advice. It is not an endorsement to buy or sell assets or make financial decisions. Always conduct your own research and exercise caution when making investments.