Solana Agent Kit is an open-source toolkit from SendAI that connects AI agents to Solana protocols, so an agent can trade tokens, lend assets, launch tokens and send airdrops from a wallet. The project describes it as letting "any agent, using any model" perform 60+ Solana actions, and it is published under the Apache-2 license (Solana Agent Kit on GitHub).
​

This article covers what the kit includes, which protocols it reaches, how it plugs into agent frameworks, and what to decide before an agent built with it holds funds.
​

Solana Agent Kit is a TypeScript library that wraps common Solana protocol actions as tools an AI agent can call. Instead of writing transaction code for each protocol, a developer gives the agent a wallet and a set of actions, and the model chooses which action to run in response to a request.
​

The repository lists actions such as "Trade tokens," "Launch new tokens," "Lend assets" and "Send compressed airdrops," with integrations for Jupiter Exchange, Raydium, Orca Whirlpool, Meteora and Pyth price feeds (GitHub). It is maintained under the sendaifun organization.
​

Solana Agent Kit works by exposing protocol actions as functions that agent frameworks register as tools. The agent's model decides which tool to call and with what arguments, the kit builds the Solana transaction, and the configured wallet signs and sends it. The developer controls which actions are exposed and which wallet is used.
​

The README describes integrations for LangChain, the Vercel AI SDK and OpenAI agents, so the kit can sit behind chat agents and web apps (GitHub). Solana's own developer docs separately describe Solana MCP and Agent Skills for coding agents that build on Solana (Solana docs).
​

Solana Agent Kit supports token trades, token launches, lending, compressed airdrops and price reads, grouped by the protocols that perform them. The exact list changes as the project adds plugins, so the GitHub repository is the reference for what a given version can do.
​

Before an agent built with Solana Agent Kit holds funds, decide which actions to expose, how much the wallet holds, and where spending limits are checked. The kit makes actions easy to call. It is the developer's job to make sure the agent cannot call them outside the limits the owner intends.
​

Three practical steps cover most of the risk. Expose only the actions the agent needs, so a swap agent cannot also launch tokens. Fund a dedicated wallet with only what the agent may use. Add checks before signing, such as a minimum amount received on swaps. Programs that enforce conditions inside the transaction are another option: Eco's Sauce SDK compiles the same program for EVM chains and Solana and reverts the transaction if its checks fail (Sauce docs; Sauce on GitHub). For the broader picture, see AI agent spend controls and security risks of autonomous AI agents.
​

Solana Agent Kit is a set of Solana tools, while elizaOS is a full agent framework with character files, chat clients and plugins across several chains. Teams often use them for different layers: a framework to run the agent and a toolkit to give it protocol actions on one chain.
​

See elizaOS explained for the framework side and Arc and Solana for AI agent payments for how Solana compares as a payment chain for agents.
​

Installing Solana Agent Kit starts with the core package, npm install solana-agent-kit, then adding the plugins the agent needs (Solana Agent Kit on GitHub). Version 2 of the kit splits actions into plugins, so a developer can install only what a given agent should be able to do:
​

The plugin split is a security feature as much as a convenience. An agent that only pays invoices does not need the DeFi or NFT plugins, and leaving them out removes whole categories of actions the agent could be tricked into taking.
​

The README's quick start shows the basic shape. A developer creates a wallet object from a keypair, creates a SolanaAgentKit instance with that wallet, an RPC URL and a model API key, attaches plugins with .use(), and then turns the kit's actions into tools for an agent framework, such as with createVercelAITools, LangChain tools or OpenAI tools (Solana Agent Kit on GitHub). The README also notes that the Solana wallet adapter interface can be used for embedded wallets.
​

The step that deserves the most care is the first one. The quick start loads a secret key directly. That is fine for a testnet experiment and risky for anything holding real funds. Production setups should keep keys out of code and configuration, use a dedicated wallet with a limited balance, and consider a signing service or embedded wallet that applies its own rules.
​

Solana Agent Kit describes two ways of running: an "interactive chat mode for guided operations" and an "autonomous mode for independent agent actions," with configurable action intervals and built-in error handling (Solana Agent Kit on GitHub).
​

A sensible path is to start interactive, review what the agent proposes and does, and move to autonomous mode only after limits are enforced outside the model.
​

Swaps are the most common action an agent built with the kit will take. The README's swap example passes the target token, the amount, the source token and a slippage value to the trade method (Solana Agent Kit on GitHub). Slippage tolerance decides how far the execution price may move from the quote before the swap fails.
​

Two habits keep swaps predictable. First, set slippage in the code that calls the tool, not in the model's arguments, so the model cannot loosen it. Second, check token addresses against an allowlist, since tokens with similar names are common. If a swap must deliver a specific minimum, conditions checked inside the transaction add another layer: Eco's Sauce SDK supports Solana and includes an Orca swap and a distributed swap among its Solana recipes, with the program reverting if its conditions fail (Sauce recipes).
​

The kit includes bridging, listing Wormhole and deBridge's DLN protocol among its integrations, and the README walks through a deBridge flow: check supported chains, find tokens, create an order, execute it, and check its status (Solana Agent Kit on GitHub). The README's own note is to "always verify addresses and amounts before executing bridge transactions."
​

Cross-chain actions deserve extra limits for agents. A bridge involves more than one transaction, on more than one chain, and the destination leg is separate from the source leg. An agent that bridges should have an allowlist of destination chains and addresses, caps on amounts, and a way for a person to check status if something stalls.
​

The repository includes a LangGraph example that splits work across specialized agents: a general agent, a transfer and swap agent, a read agent for blockchain data, and a manager agent that routes requests (Solana Agent Kit on GitHub). Splitting roles this way can improve safety, because only the transfer and swap agent needs signing power. The manager and read agents can work with untrusted input without being able to move funds directly.
​

The design only helps if the signing agent checks every request it receives against fixed limits, regardless of which agent sent it. Otherwise an injected instruction can pass from the read agent through the manager to the agent that signs.
​

Besides actions that move funds, the kit includes read-only tools for market data. The README lists CoinGecko Pro API integration with token price data, trending tokens and pools, top gainers and token information lookup, plus Pyth price feeds (Solana Agent Kit on GitHub). These tools let an agent research before it acts.
​

Read-only tools are a good place to start a new agent. An agent that can only look up prices and token information cannot lose funds, and watching what it does with that information shows how it reasons before it is trusted with a wallet. When signing actions are added later, the same data tools help it check prices at the time of a trade.
​

The README's security section says the toolkit "handles transaction generation, signing and sending, using provided wallets," and tells users to use it in a secure environment and never share private keys (Solana Agent Kit on GitHub). It also credits Coinbase AgentKit for system prompt logic. Read together, these make the division of responsibility clear: the kit makes actions available and signs with the wallet it is given; the developer decides what the agent may do and with how much.
​

It is maintained under the sendaifun organization on GitHub and licensed Apache-2.
​

An agent can sign any transaction its wallet and exposed actions allow, so limits on the wallet and checks before signing decide the maximum loss.
​

Run npm install solana-agent-kit, then install the plugins you need, such as the token or DeFi plugin, per the README.
​

Yes. The README lists bridging through Wormhole and deBridge. Treat bridge actions as higher risk and limit them tightly.
​

It supports an autonomous mode with configurable action intervals, as well as an interactive chat mode.
​

The README describes LangChain integration, Vercel AI SDK integration, and tools for OpenAI agents, so the kit can sit behind several popular frameworks.
​

The code is open source under the Apache-2 license, per the repository. Running an agent still costs Solana network fees for transactions and whatever the chosen model provider and RPC provider charge, so plan and budget for those alongside the funds the agent spends.
​

Sources: official repositories and documentation linked inline, accessed November 2026.
​