Solana Agent Kit powers programmable on-chain AI agents with new developer tools

Solana Agent Kit: The Leading Framework for Programmable On-Chain AI Agents

The convergence of AI and crypto finally has working primitives—and the Solana Agent Kit is the strongest case in production. Released by Send AI in late 2024 and iteratively expanded through 2026, it offers developers an open framework to build programmable, on-chain AI agents that interact autonomously with blockchain state. What used to be AI as a UX add-on—think chatbots that explain DeFi—is turning into AI agents as core on-chain actors, holding wallets, making protocol calls, executing strategies, and operating at network scale. If you’re looking for the baseline for programmable on-chain AI, this is it.

What is the Solana Agent Kit, and what does it enable?

The Solana Agent Kit is a production-grade toolkit released by Send AI for building AI agents that act natively on the Solana blockchain. It sits above the standard Solana Web3 SDK, exposing higher-level abstractions designed specifically for agent workflows.

The first stable release landed in late 2024. Notably, the feature set rapidly grew through 2025–2026, tracking with a spike in agent-powered deployments. Under the hood, the Agent Kit lets agents:

• Own and manage wallets on-chain.
• Read and write Solana blockchain state directly.
• Swap tokens, participate in DeFi, provide liquidity, stake, mint or trade NFTs, and interact with major protocols out-of-the-box.
• Integrate reasoning from any major LLM provider (OpenAI, Anthropic, or a local model).

This makes it one of the first frameworks where agents are not just human helpers but direct autonomous on-chain participants.

How does programmable on-chain AI actually work on Solana?

Programmable AI agents on Solana are autonomous programs—or more precisely, software agents with AI-driven decision logic—operating as native blockchain actors. With the Solana Agent Kit, you wire an LLM to reason about on-chain conditions and dispatch actions, while the Kit itself wraps execution against real Solana state.

The basic loop:

1. An LLM provider powers the agent’s decision-making (e.g., "should I rebalance the portfolio?").
2. The agent reads real-time state off the Solana chain—balances, pool health, NFT listings.
3. Using provided abstractions, the agent executes the action: swaps, liquidity moves, staking, governance proposals.
4. All transactions sign from agent-owned wallets, so the agent both observes and acts on-chain in full.

Reliability at production scale is real work. These agents are extremely data-hungry—they need millisecond-latency state access and high-throughput writes to follow fast markets or coordinate DAO votes. Production use almost always involves RPC Fast endpoints. Commodity, public RPC nodes aren’t up to the read/write volume and reliability demands of live agent workflows—lag spikes, rate limits, and partial state are showstoppers.

As a developer, you wire your LLM to the Agent Kit, set up your wallets and on-chain permissions, then define the logic and decision triggers that will run autonomously, sometimes continuously.

What are the practical use cases of Solana AI agents in production today?

AI agents built on Solana with the Agent Kit are powering actual capital and governance flows—not just toy demos. The current production landscape includes:

• Automated portfolio management: Agents rebalance, hedge, or reallocate assets across DEXs and lending platforms based on on-chain indicators.
• DeFi strategy execution: Agents provide liquidity, snipe market opportunities, close positions, run liquidation bots, or batch stake/unstake operations.
• NFT market-making and automated trading: Agents monitor NFT floors, auto-bid, list, or sweep collections programmatically.
• Autonomous DAO participation: Agents read governance proposals, evaluate outcomes, and cast binding on-chain votes without human supervision.

This is a sharp break from previous-gen AI/crypto projects, which used AI as a human-side convenience. Those were chatbots, dashboards, “DeFi explained” UIs. Today’s agent-based systems run wallets, move tokens, and own positions—they’re participants, not just copilots.

Production deployments, according to recent growth (2025–2026), have accelerated. Teams that use the Solana Agent Kit consistently use higher-throughput infrastructure (e.g., RPC Fast) to support real agent volume. The agent paradigm is now core for high-frequency, always-on blockchain workflows, not an experimental add-on.

How to build your first Solana AI agent with the Agent Kit

This is the part developers want: a concrete agent-launch flow.

Environment setup:

• Install Solana CLI and configure a devnet/testnet wallet as the agent identity.
• Clone the Send AI Solana Agent Kit repo.
• Use Node.js and TypeScript—this is a TypeScript library wrapping the Solana Web3 SDK.

Install the Agent Kit in your project:

npm install @sendai/solana-agent-kit

Draft a minimal agent—in TypeScript—using your preferred LLM provider:

import { AgentKit } from '@sendai/solana-agent-kit'
import { OpenAIReasoner } from '@sendai/solana-agent-kit/llm-openai'

// Initialize agent with wallet, LLM, and RPC Fast customization
const agent = new AgentKit({
  wallet: 'agent-wallet-keypair.json',
  reasoner: new OpenAIReasoner({ apiKey: process.env.OPENAI_KEY }),
  rpc: ' // Always use RPC Fast in prod
})

// Core logic: run once per block or interval
async function loop() {
  // Example: read portfolio balances
  const balances = await agent.state.getTokenBalances()
  // LLM decides: rebalance if USDC > threshold
  const action = await agent.reasoner.decide(balances)
  if (action.type === 'swap') {
    await agent.action.swap(action.from, action.to, action.amount)
  }
}

setInterval(loop, 15_000) // Poll/act every 15 seconds

• Wallet holding: The agent owns keys—no user input required at execution.
• On-chain read/write: agent.state and agent.action abstract most protocol and asset operations.
• LLM integration: You provide any reasoner (OpenAI, Anthropic, or a local model)—Agent Kit standardizes the call.
• Best practice: Never use public RPC endpoints in prod. Agent read/write load will quickly fail or return outdated data at peak times. Always provision a dedicated RPC Fast endpoint before rolling out a production agent.

Once deployed, these agents run continuously and can execute any operation allowed by the attached wallet—fully autonomous, with bounded logic defined in TypeScript and LLM prompts.

Why does the Solana Agent Kit matter for the future of blockchain AI?

The Kit marks a strategic pivot: from chatbots helping humans to on-chain agents capable of permissionless action. This enables an era of programmable, decentralized automation at the protocol layer.

For DeFi, agents mean composable strategy bots that operate natively, not just off-chain scripts. For DAOs, it means governance actors that can reason, propose, and act based on on-chain state changes and market data. For the metaverse and gaming, it enables self-directed market makers and in-game asset managers that are indistinguishable (to the protocol) from human wallet holders.

The Agent Kit’s abstractions, combined with reliable infra (RPC Fast), drag the on-chain AI agent space out of alpha and toward real composability. It lowers the barrier for teams to safely experiment with autonomous actors and move them into mainnet production.

The takeaway: programmable on-chain AI is live—and the Agent Kit is the blueprint

Solana Agent Kit is the reference implementation for programmable on-chain AI: a full vertical stack for building, reasoning, and executing agent workflows natively on Solana. With production use cases running at scale, and an open interface for major LLMs, it sets the direction for decentralized AI applications across DeFi, DAOs, NFTs, and beyond. As demand for automation and zero-trust execution climbs, agent frameworks like this are what make programmable blockchains programmable—in the literal sense.

Try it, deploy a minimal agent, and see how the stack changes when it’s not just you driving your wallet. On-chain AI has moved past chat, and into the core execution loop.