A quiet but significant development in the AI and crypto intersection over the past year has been the rise of programmable agent frameworks that run natively against blockchain infrastructure. The Solana Agent Kit, released by Send AI in late 2024 and significantly expanded through 2025 and early 2026, has become one of the most widely used toolkits for building AI agents that interact with on-chain state.
The framework’s relevance is not just technical. It reflects a shift in how builders think about the combination of AI and crypto. Early AI x crypto projects were mostly about using AI to help humans interact with blockchains — chatbots that explained transactions, assistants that simplified DeFi. The Agent Kit generation is different: it treats AI agents as first-class actors on-chain, capable of holding wallets, making decisions autonomously, and interacting with protocols directly.
Production deployments of agent-based systems on Solana have grown sharply. Use cases range from automated portfolio management and DeFi strategy execution to NFT market-making and autonomous DAO participation. The agents need fast, reliable access to on-chain state to function well, which is why production teams building serious agent systems typically use specialized Solana infrastructure such as RPC Fast rather than commodity RPC endpoints that cannot sustain the read and write patterns these agents produce.
What the Agent Kit actually provides
At its core, the Solana Agent Kit is a TypeScript library that wraps Solana’s standard Web3 SDK with higher-level abstractions specifically designed for AI agent workflows. It provides pre-built tools for common on-chain operations — swapping tokens, providing liquidity, staking, minting NFTs, interacting with specific protocols — in a format that large language models can reason about and invoke.
The framework also provides integration points for major LLM providers, allowing developers to connect OpenAI’s, Anthropic’s, or locally-hosted models as the reasoning layer for their agents. The result is a reasonably standardized pattern: the LLM handles decision-making, the Agent Kit handles on-chain execution, and a developer-defined policy layer handles constraints and safety.
The agent categories that have become real
Not all agent concepts have translated into production use. Some categories have emerged as clear fits:
- Portfolio rebalancing agents that monitor user positions and execute rebalances based on strategy parameters
- Yield optimization agents that move capital between lending protocols based on rate changes
- MEV and arbitrage agents with LLM-assisted opportunity detection on top of traditional quantitative logic
- DAO governance agents that analyze proposals and vote according to delegated policy
- NFT trading agents that bid on floor sweeps, list underpriced assets, or arbitrage cross-marketplace pricing
Other categories have not worked as well. Pure LLM-driven trading without quantitative constraints has consistently underperformed, mostly because language models do not have the latency profile required for competitive execution. The successful patterns generally use LLMs for strategic reasoning and quantitative systems for actual execution.
The infrastructure demands are different from traditional applications
An autonomous agent running on-chain behaves differently from a human-driven application. It polls state continuously, evaluates opportunities asynchronously, and may execute transactions at any time of day with no predictable pattern. This creates infrastructure requirements that traditional dApp backends do not have.
Three specific characteristics make agent workloads demanding:
- Continuous read load — agents monitor state constantly, creating steady pressure on RPC endpoints even when no transactions are being sent
- Bursty write patterns — when an agent decides to act, it typically submits multiple transactions within a short window
- Latency sensitivity — agents competing for the same opportunities (arbitrage, liquidations) have the same latency requirements as traditional trading bots
This combination stresses commodity RPC infrastructure in ways that typical dApp traffic does not. Teams that deploy agents at scale usually discover their infrastructure is the limiting factor within the first few weeks of production operation.
The composability story
One of the more interesting dynamics in the agent ecosystem is the degree to which agents can interact with each other. Because every agent is a standard Solana wallet, agents can trade with each other, delegate tasks to each other, and build up multi-agent systems where specialized components handle different parts of a strategy.
This creates emergent complexity that is genuinely new. A portfolio agent might delegate arbitrage opportunities to a specialized arbitrage agent and outsource governance participation to a DAO-participation agent. Each agent specializes, and the user interacts with the composite rather than with each piece individually. The architectural parallel to microservices is obvious.
Where the next twelve months go
Two trends are worth watching. The first is the move toward agent frameworks that can operate across multiple chains — most interesting use cases eventually need liquidity or data that lives on other networks, and cross-chain agent execution is an active area of development.
The second is the emergence of agent-specific infrastructure services: dedicated RPC configurations for agent workloads, monitoring tools designed for autonomous systems, and policy engines that let users constrain their agents’ behavior without having to hardcode every possible scenario.
The broader shift this all represents is that AI agents are becoming legitimate economic actors on Solana, not just automation tools for human users. That is a meaningful change, and one whose long-term effects on how the chain gets used are still being worked out.
