From Day Zero to Today: Why We Reinvested in Kite AI

Founder Spotlight

2025-09-02T17:48:32

Kite raises $33 million to build trust infrastructure for the agentic web.

We’re thrilled to announce Kite AI’s $18M Series A fundraise, bringing total funding to $33M to build the trust infrastructure for the agentic web. The round was co-led by General Catalyst and PayPal Ventures, with participation from 8VC, Vertex Ventures, Samsung Next, SBI Holdings, Avalanche Foundation, GSR, LayerZero, Alumni Ventures, Hashed, HashKey Capital, Animoca Brands, Essence VC, and Alchemy Ventures.

As pre-seed investors, we’re proud to double down on Kite’s vision to build the trust and data backbone for the agent economy. This investment will fuel infrastructure expansion, new developer APIs, and a growing network of integrated services, cementing Kite’s role as the runtime for autonomous agents.

When we first met the Kite AI team, they weren’t pitching the next shiny chatbot or blockchain gimmick. They were nerding out over something far less sexy: real-time data infrastructure that doesn’t choke under pressure. Think of it as plumbing for the internet’s future, unglamorous but essential when your AI agents are trying to book a ride or trade crypto faster than you can say “schema drift.” Their focus was on trust, speed, and verifiability, not market hype. That’s why we doubled down.

Kite didn’t start with flashy apps. They started with infrastructure, solving problems most AI startups ignore: brittle data feeds, unverifiable inputs, and systems that lag when the world moves at warp speed. Their early work tamed the chaos of blockchain data, think herding cats on a moving train, ingesting transactions from multiple chains, adapting to protocol changes, and serving queries with cryptographic proof that the data wasn’t fudged. This wasn’t theory; it was live, battle-tested code for clients who couldn’t afford a single hiccup.

The team’s origins in ZettaBlock gave them a head start. ZettaBlock handled Netflix’s scale of data, processing petabytes of blockchain data with sub-100ms ingestion. They integrated with Sui and Polygon for scalable indexing and EigenLayer for restaking, addressing gaps in decentralized systems. This foundation enabled Kite to inherit production-grade tools for high-throughput data and consensus, including Proof of Artificial Intelligence, a mechanism designed to ensure integrity and fairness in distributed AI workloads.

Fast-forward to 2025, and autonomous AI agents are no longer sci-fi. They’re here, but they’re stuck in the digital equivalent of a parking lot, unable to transact or coordinate without human hand-holding. Kite’s infrastructure, forged in the crucible of blockchain’s toughest demands, is the key to setting them free. It’s why we reinvested: Kite’s already built the pipes, and the agent economy is just now realizing it needs them. With over 1.2 billion agent calls processed to date, more than 53 million cumulative users, and daily peaks exceeding 20 million interactions, 200,000 active users, and 100,000 first-time AI users, the network is now live in production. It supports high-throughput agent workflows through an EVM-compatible L1 chain and a growing agent network designed to handle coordination, execution, and programmable incentives at scale.

The agentic internet requires identity, authorization, and payments at the protocol layer, not manual gatekeeping.

The Architecture: Trust Baked In, Not Bolted On

Kite’s platform isn’t a single “aha” moment; it’s years of deliberate engineering, each layer hardened by real-world chaos. Picture it as a three-tiered cake, but instead of frosting, it’s packed with trust, speed, and a pinch of cryptographic magic. The system handles everything from raw ingestion to agent coordination, ensuring data is not just fast but verifiable at every step.

Kite’s programmable trust layer supports identity, governance, payments, and verifiable execution, all tailored for autonomous agents

Application Layer
This is where developers and agents plug in. It’s not just an API, it’s an API with a conscience. Every query comes with a cryptographic receipt proving the data’s freshness and untampered. Want to know if your trading agent’s price feed is legit? Kite’s got you covered with proof that screams, “I’m real, and I’m not lying.” This layer supports frameworks like LangChain or DSPy, exposing GraphQL endpoints that agents can query for structured views, complete with versioned snapshots for time-travel analysis.

Kite-Powered Trust Layer
Here’s the secret sauce: trust isn’t an afterthought; it’s the main course. This layer embeds identity, governance, and context management into the data path, making Kite a full runtime for agents.

  • Identity: Every agent gets an Agent Passport, a cryptographic ID that defines who created it, what it’s allowed to do, and how much it can spend. No more rogue bots buying Ferraris on your dime. These passports encode spend limits, whitelisted APIs, time windows, and multi-sig approvals, enforced at runtime.
  • Governance: Rules are enforced at the metal, not tacked on. Want your agent to only trade during market hours? That’s coded into its DNA. Kite envisions a policy framework, potentially named KiteAIR, for access and authorization, with auditable logs for signed executions.
  • Payments: Micropayments flow like water, no human approval needed. As a key launch partner, PayPal collaborates on agentic commerce, enabling features like automated invoice management and shipment tracking within workflows. But Kite aims to develop a broader economic layer, potentially called KitePay, with stablecoin escrow and metering to support usage-based billing across the network.
  • Context: Agents don’t just get data, they get context with a pedigree, ensuring decisions are based on verified, up-to-date info. Kite plans to offer optimized query endpoints, possibly named KiteView, delivering permissioned data with low latency and cost.

This layer turns Kite into more than infrastructure; it’s a coordination network where agents interact securely across domains, with PoAI consensus rewarding verified contributions.

This diagram illustrates how agents are authorized to interact with services and data providers using stablecoin payments, programmable permissions, and cryptographic identity (KitePass). Human users create or delegate agents, which then operate autonomously through pre-approved guardrails and runtime enforcement. The economic flows are settled across a permissionless agent network.

Base Infrastructure Layer

This is the data foundation enabling real-time, verifiable agentic workflows. It combines modular components that scale across environments and adapt to evolving data patterns:

1. High-Scale Data Lake

At its core is a production-grade data lake built with Apache Iceberg, Presto, and Parquet — architected to handle petabyte-scale workloads and currently operating at approximately half the data volume of Netflix. This infrastructure powers fast analytical queries across historical and live data, offering agents persistent memory, stateful context, and efficient access to long-tail records.

2. Intelligent Query Routing

Instead of routing all requests to a single store, Kite’s system analyzes query patterns and dynamically directs each request to the optimal backend — transactional database, data lake, or cache — based on latency sensitivity, complexity, and cost. This adaptive routing layer improves reliability and cost-efficiency, supporting agentic demands without operator tuning.

3. Multi-Chain Connectors

The infra natively integrates with major blockchains like Avalanche, Filecoin, and Ethereum. Using event-driven ingestion pipelines, it captures on-chain activity, adapts to schema changes, and aligns disparate protocols into a unified, agent-readable format. This ensures agents can operate across ecosystems with consistent data quality and semantics.

4. Schema-Adaptive ETL

Live protocol upgrades, dynamic field mappings, and unstructured inputs are handled through modular ETL pipelines. These flows normalize inputs into structured records and enable agents to reason over evolving ecosystems without manual updates or hardcoded logic.

5. Verifiable Proof Store

Every data record can be anchored with cryptographic proofs — providing auditability, provenance, and trust. This proof layer is tamper-evident and chain-agnostic, forming the backbone of secure agent workflows in regulated or high-risk environments.

6. Programmable Query Layer

Developers can expose precise, filtered datasets to agents or external apps using SQL, REST, or GraphQL interfaces. The system compiles queries into safe, performant endpoints that respect permission models and guardrails — enabling composable, agent-facing APIs from raw blockchain or off-chain data.

Kite’s team didn’t take shortcuts. They could’ve slapped together a quick API and called it a day, but they chose to embed trust at every layer. It’s like building a house with steel beams instead of duct tape – slower, but it won’t collapse when the economic storm hits. The result: a sovereign L1 optimized for sub-second finality, fusing data handling with settlement.

Origins: From Blockchain Chaos to Agent Clarity

Kite’s roots aren’t in some AI lab, but in the wild west of blockchain data. Back when “agent economy” was just a buzzword, Kite, then ZettaBlock, was wrestling with a nightmare: indexing data from blockchains with different rules, speeds, and quirks, all in real time. It was like juggling flaming torches while riding a unicycle. They built pipelines to ingest transactions without dropping a single packet, adapted to schema changes on the fly, and served queries with cryptographic proof that the data wasn’t tampered with. This wasn’t for fun; it was for clients like EigenLayer and Chainlink, who needed rock-solid reliability. ZettaBlock’s federated data lake, using Presto, Iceberg, and Parquet, scaled on-chain queries, while the query routing engine balanced latency and cost. Integrations with Polygon for indexing and Filecoin for storage honed their chops for high-throughput data and consensus, like Proof of Artificial Intelligence (PoAI), which ensures fair credit in AI workflows.

These lessons, speed, adaptability, and trust became Kite’s DNA, perfectly suited for agents that can’t afford stale or sketchy data. The pivot to agents wasn’t a leap; it was a natural extension. Blockchain’s chaos mirrors agent challenges: unstructured streams, verifiable execution, and cross-system coordination. Kite fills the void, providing memory, trust, and economics for agents across frameworks like LangChain, DSPy, AutoGen, or custom models from OpenAI, Claude, or Mistral.

Data Infrastructure: The Heart of Agent Autonomy

Kite’s data infrastructure is the unsung hero that makes agent autonomy possible, far beyond just enabling payments. While others focus on model orchestration, Kite’s ZettaBlock roots deliver real-time data ingestion and structuring that agents crave to act on the world’s pulse. Kite envisions a system, potentially called KiteStream, to ingest unstructured streams, PDF contracts, IoT sensor feeds, live call transcripts with sub-100ms latency, transforming them into structured tables via schema-adaptive ETL. For instance, a healthcare agent might ingest biometric data from wearables, normalize it with a federated data lake, envisioned as KiteLake, and query it via a future query system, possibly KiteView, to detect anomalies in seconds, logging decisions for HIPAA-compliant audits. In retail, an agent could process competitor price feeds and customer chats, adjusting offers in minutes to beat the competition, all without human intervention. These use cases are illustrative of Kite’s potential, grounded in its testnet capabilities.

This isn’t just data plumbing; it’s the backbone for agents to reason and act in operational timeframes. Unlike traditional platforms like Snowflake, which excel at static analytics, Kite’s infrastructure handles dynamic, future multi-modal streams (text, audio, video) with versioning and time-travel capabilities. A supply chain agent, for example, could rewind IoT signals to pinpoint a shipment delay’s root cause, then trigger rerouting via future governance protocols, potentially KiteNet. This data-first approach, built on ZettaBlock’s battle-tested stack, ensures agents aren’t stuck with stale snapshots but operate synchronously with reality, setting Kite apart as the agent economy’s data engine.

Real-World Validation: Stress-Testing Kite’s Infrastructure

Kite’s architecture wasn’t honed in a lab but through real-world stress tests that proved its readiness for autonomous agents. These testnet pilots and illustrative use cases, drawn from Kite’s capabilities and ZettaBlock’s blockchain expertise, showcase how its components handle high-stakes workloads, validated by over 21 million agent calls and 27 million transactions in the Ozone phase alone.

Testnet Pilot: Agent Coordination
In the Aero phase, Kite’s Professor agent guided users through its ecosystem, processing queries and logging interactions on-chain with PoAI attribution. It handled millions of calls daily, scaling to 450 inferences per second, proving the ability to track verifiable actions. Takeaway: Agents need auditable logs to coordinate without human oversight, enabling trusted ecosystems.

Testnet Pilot: Cross-Chain Bridging
Ozone’s cross-chain bridge enabled token transfers across blockchains, handling 27 million transactions with sub-second finality via Avalanche’s EVM compatibility. Data ingestion and query layers ensured seamless flow. Takeaway: Agents require real-time, cross-system data to act reliably in dynamic settings.

Potential Use Case: NFT Analytics
Kite’s infrastructure, built on ZettaBlock’s indexing for Polygon, could power real-time analytics for NFT marketplaces, ingesting transaction streams and normalizing schema changes. This enables agents to detect market trends without delays, as shown in the testnet’s high-throughput processing. Takeaway: Agents need adaptive data pipelines for live insights.

Potential Use Case: DAO Coordination
Kite’s PoAI and logging systems could support DAO governance by tracking votes with cryptographic proof, as demonstrated in the testnet’s attribution engine. This ensures transparent coordination, cutting report times for decentralized workflows. Takeaway: Agents thrive on verifiable data for cross-org trust.

These pilots and scenarios, rooted in Kite’s testnet and ZettaBlock’s integrations, confirm its stack is ready for agent-scale demands.

Developer Experience: Stripe for Agents

Kite’s not just for blockchain nerds; it’s built for developers who speak Python, not Solidity. With three lines of code, you can register an agent, set permissions, and query planned GraphQL endpoints, no PhD in smart contracts required. Dashboards let you monitor usage or tweak policies without touching a blockchain node. It’s like Stripe for payments: you get the power without the pain. This ease is critical; most AI engineers want to build agents, not wrestle with token mechanics. Kite’s SDKs, templates, and onboarding kits make it as simple as publishing to HuggingFace, ensuring mass adoption. For example, a developer building a pricing agent can integrate Shopify APIs via a planned Agent App Store, with authentication and logging handled seamlessly, all in a familiar Python workflow.

The Agent-Native Blueprint

Kite’s platform is a layered beast, each part honed by testnet pilots and envisioned for future scalability:

  • L1 & L2 Connectors: Ingest data like a vacuum cleaner on steroids, leveraging Avalanche’s EVM compatibility for sub-second finality.
  • Schema-Adaptive ETL: Adapts like a chameleon in a paint store, normalizing PDFs, audio, or APIs via a planned system, potentially KiteStream.
  • Verifiable Proof Store: Tags every byte with a trust certificate, enabling zero-knowledge audits for privacy.
  • Decentralized API Routing: Queries fly faster than your pizza guy on a good day, with a planned geo-balanced mesh, possibly KiteView.
  • Programmable Query Layer: Developers get what they need, no rebuilds required, compiling SQL to GraphQL.
  • Agent Passports: Verifiable IDs ensure no random bots crash the party, encoding constraints for autonomy. Potentially working with Primus with ZKTLS capabilities. 
  • Autonomous Transaction Engine: Settles payments faster than you can say “Venmo who?” PayPal’s integration aids commerce, but Kite’s envisioned network, potentially KitePay, spans verifiable data and governance.

This isn’t a generic platform; it’s a runtime for agents, blending Stripe’s payment ease, Auth0’s identity rigor, and AWS’s compute scale, all tailored for autonomy. The modular ecosystem drives AI value growth through composable design, incentivizing supply and demand for agent services, like data providers earning from diagnostic improvements in healthcare or model builders getting per-usage cuts in financial advisory tools.

Beyond Payments: Outshining Competitors

Kite isn’t just another agent infrastructure player. Bittensor’s Yuma Consensus relies on peer-reviewed scoring of model outputs, which can drift into circular validation where nodes agree without a clear source of truth. Kite takes a distinct approach with its Proof of Artificial Intelligence (PoAI), focusing on cryptographically confirming that a task, like paying a data provider for a timely trade signal or rerouting a supply chain, was completed and delivered value. This makes Kite better suited to drive real-world agent coordination, not just chase leaderboard glory in benchmark environments.

While orchestration libraries like LangChain chain tool calls in static flows, Kite builds deeper infrastructure layers. It includes a custom agent runtime with decentralized API routing across domains, letting agents fetch data or services without a centralized middleman. Kite also offers a programmable query layer and a trusted, permissionless data lake. These systems ensure agents work with live data backed by traceable provenance, not stale snapshots.

This isn’t a generic marketplace or agent ranking board. Kite is crafting the foundation for agent-driven commerce and coordination, where autonomous systems reliably interact, query trusted sources, and execute tangible actions, like processing payments or managing logistics, with confidence.

The Road Ahead: Agents Unleashed

Kite’s testnet has surpassed 1.2 billion total agent calls and 30 million transactions, with notable phases like Aero (546 million calls) and Ozone (27 million transactions) serving as key validation points. The network now supports over 53 million cumulative users, with daily peaks of 20 million agent interactions, 200,000 active users, and 100,000 first-time AI users. On the busiest days, over 100,000 new users sign up. This explosive growth reflects Kite’s ability to scale to 450 inferences per second today, with a clear path toward exponentially expanding agent interactions and industry adoption by 2026, powering industries with envisioned systems like:

  • Healthcare: Agents ingest biometric streams, normalize data, and flag anomalies in real-time, logging for HIPAA audits, unlike Snowflake’s static data lakes, which lack live structuring or governance.
  • Retail: Agents process competitor feeds and chats, adjusting prices in minutes via planned live RAG systems, outpacing LangChain’s static retrieval.
  • Finance: Agents query live market signals with PoAI-verified attribution, settling via a future payment system, contrasting Bittensor’s focus on model scoring.
  • Logistics: Agents verify IoT shipment signals, rerouting deliveries with planned governance protocols, unlike Databricks’ batch analytics.

Next steps:

  • Multi-Modal Provenance: Extend trust beyond text by verifying provenance across video, audio, sensor, and geospatial data. Kite enables agents to perform real-world inference tasks such as confirming shipments through OCR, authenticating surveillance footage via audio transcription, or responding to IoT sensor signals. These capabilities push beyond today’s text-focused systems and unlock richer, verified agent action in complex environments.
  • Agent Services and Reputation Layer:  Kite is not about optimizing models or incentivizing compute. It is building the infrastructure for agents to offer real services, fulfill real tasks, and accumulate real reputation. Proof of AI (PoAI) ensures each agent action is cryptographically verifiable. This is not peer voting or probabilistic scoring — it is about recording whether an agent did what it claimed to do, under what context, and with what result.
  • Decentralized Governance and Role-Based Discovery:  Kite introduces protocol-level primitives for how agents discover each other, authenticate across domains, and interact with access permissions. This is not another orchestration layer or wrapper for chaining prompts. The focus is on establishing who can see what, who can act on what, and under what terms — across public and private ecosystems — to support secure, permissioned agent interaction at scale.
  • Interoperable Coordination and Payments: The goal is not just wallets or ramps. Kite allows agents to coordinate across domains, manage service-level agreements, and enforce terms with trust-minimized guarantees. Payments are only one dimension. The deeper infrastructure supports authenticated interaction, real-time execution, and verifiable settlement between autonomous agents and services.
  • Agent Runtime and Decentralized API Fabric:  Kite is not a toolchain or orchestration script. It is a decentralized agent runtime that executes tasks, routes requests, and verifies inputs across networks. Once an agent is built — whether via LangChain, custom stack, or LLM wrappers — Kite steps in to provide identity, authentication, authorization, and trusted execution. No central controller. No gatekeeping. Just a scalable foundation for permissionless agents to act and interact.

Kite’s not just infrastructure, it’s the backbone for an internet where agents act, trust, and coordinate without permission. That’s why we’re all in.