Solana Agent Kit: A TypeScript Toolkit for Autonomous AI Agents on Solana

What Solana Agent Kit Is and the Problem It Solves

Connecting an AI agent to blockchain protocols requires translating natural language or model tool calls into signed transactions, handling wallet initialization, managing RPC connections, and understanding the specific transaction format of each Solana program. Without an abstraction layer, this work must be done once per protocol, per model framework, and maintained as those protocols update their APIs.

Solana Agent Kit provides that abstraction. It defines a set of typed action methods (deployToken, transferAsset, swapTokens, mintNFT, and more) and exposes them as tools compatible with LangChain, the Vercel AI SDK, or OpenAI function calling. Any model that can call tools can trigger onchain actions on Solana without knowing the specifics of the Solana transaction model.

The README states the toolkit supports over 60 Solana actions. It is version 2 of the project; the repository's default branch is `v2`. A migration guide (`MIGRATING.md`) documents the breaking changes from v1. The project is developed by Sendai (sendaifun) and promoted alongside their Suzi trading product. The repository targets developers who already understand Solana's account model and key pairs and want to add AI-driven onchain logic to an existing TypeScript project.

V2 Plugin Architecture and Package Layout

Version 2 restructures the toolkit into a core package and five optional plugin packages, each installable independently. The five plugins are:

- `@solana-agent-kit/plugin-token`: SPL token operations including transfers, swaps, bridging, and rug checking. - `@solana-agent-kit/plugin-nft`: Metaplex NFT operations including minting, listing, and metadata management. - `@solana-agent-kit/plugin-defi`: DeFi operations covering staking, lending, borrowing, spot and perpetual trading across protocols including Jupiter, Raydium, Orca, and Drift. - `@solana-agent-kit/plugin-misc`: Airdrops, price feeds, CoinGecko token data, and domain registration. - `@solana-agent-kit/plugin-blinks`: Solana Blinks operations for arcade games and staking.

The monorepo uses pnpm workspaces and Turborepo for builds. The `package.json` at the root specifies Node.js >=22.0.0 and pnpm >=8.0.0 as engine requirements. The packages follow a changeset-based release workflow.

Installing and Initializing the Agent

Install the core package:

npm install solana-agent-kit

Install all five plugins:

npm install @solana-agent-kit/plugin-token @solana-agent-kit/plugin-nft @solana-agent-kit/plugin-defi @solana-agent-kit/plugin-misc @solana-agent-kit/plugin-blinks

Initialize the agent by importing the core and plugins, creating a wallet, and calling `use()` to attach plugins:

import { SolanaAgentKit, createVercelAITools, KeypairWallet } from "solana-agent-kit";
import TokenPlugin from "@solana-agent-kit/plugin-token";
import NFTPlugin from "@solana-agent-kit/plugin-nft";
import DefiPlugin from "@solana-agent-kit/plugin-defi";
import MiscPlugin from "@solana-agent-kit/plugin-misc";
import BlinksPlugin from "@solana-agent-kit/plugin-blinks";

Create a wallet from a keypair:

const keyPair = Keypair.fromSecretKey(bs58.decode("YOUR_SECRET_KEY"))
const wallet = new KeypairWallet(keyPair)

The `.env.example` file in the repository lists all required and optional environment variables, including `SOLANA_PRIVATE_KEY`, `RPC_URL`, and API keys for third-party services like Helius, Jupiter, OKX DEX, and Wormhole. Each variable is optional unless the corresponding plugin action is used.

Deploying Tokens and Minting NFTs

Once the agent is initialized with the token and NFT plugins, actions are called through `agent.methods`. The README shows deploying a new SPL token:

const result = await agent.methods.deployToken(
  agent,
  "my ai token", // name
  "uri", // uri
  "token", // symbol
  9, // decimals
  {
    mintAuthority: null, // by default, deployer account
    freezeAuthority: null, // by default, deployer account
    updateAuthority: undefined, // by default, deployer account
    isMutable: false // by default, true
  },
  1000000 // initial supply
);

The result includes the mint address. Token2022 (SPL Token Extensions) is also supported through a separate `deployToken2022` method with the same interface.

For NFTs, the plugin supports creating collections on 3.Land, minting individual NFTs with Metaplex, configuring royalties, and listing NFTs for sale in any SPL token. The NFT plugin's `create3LandCollection` method takes a `collectionName`, `collectionSymbol`, `collectionDescription`, and `mainImageUrl` as required fields.

DeFi Actions and Cross-Chain Bridging

The DeFi plugin covers a wide range of protocols documented in the README. On the swap side: Jupiter Exchange for token swaps, Pump via PumpPortal, Raydium pool creation in three pool types (CPMM, CLMM, AMMv4), Orca Whirlpool, and Meteora Dynamic AMM with DLMM Pools. For lending and borrowing: Lulo via Blinks (listed as best APR for USDC), and Drift vaults with both perpetuals and lending.

Cross-chain bridging is available through two protocols: Wormhole and deBridge DLN. The `.env.example` shows separate private keys for EVM chains (Ethereum private key, SUI mnemonic, Aptos private key) needed for cross-chain operations. Each bridging integration is self-contained in the DeFi plugin so you can import only the bridging functions you need without pulling in the full DeFi plugin.

Market data comes from the Misc plugin: CoinGecko Pro API integration for token prices, trending tokens, top gainers, and latest pool tracking. Pyth Price feeds provide real-time asset prices for programmatic use in agent decision making. The combination of live market data and executable DeFi actions in a single plugin lets an agent retrieve the current price of an asset and immediately execute a trade, all within a single tool-call cycle.

AI Framework Integration and the MCP Adapter

The toolkit exposes actions to AI models through three adapters: `createLangchainTools` for LangChain's ReAct agent, `createVercelAITools` for the Vercel AI SDK, and `createOpenAITools` for the OpenAI function calling API. Switching between frameworks requires only changing the import, as stated in the README.

An MCP (Model Context Protocol) adapter is available as a separate package: `@solana-agent-kit/adapter-mcp`. The `examples/mcp/` directory contains usage examples. This adapter lets any MCP-compatible client access Solana actions through the standard MCP tool interface.

The repository includes n8n integration in `examples/n8n-solana-agent/`, enabling no-code workflow builders to trigger Solana actions without writing TypeScript. The README mentions both interactive chat mode (for guided operations) and autonomous mode (where the agent acts independently at configurable intervals).

Maintenance, Limitations, and Licence

Solana Agent Kit is licensed under Apache-2.0. The most recent release is v2.0.9, published on 2025-07-24. The last push to the repository was on 2026-05-14. Prior releases include v2.0.5 (2025-05-23) and v2.0.4 (2025-05-09). The release history shows roughly one release per month since the v2 rewrite.

The toolkit is TypeScript-only. The README documents no Python SDK, which limits it to JavaScript and TypeScript environments. The RELATED SEARCHES list includes "solana agent kit python", indicating user demand for a Python version that the project does not currently provide.

The `.env.example` file lists many external API keys as optional dependencies. Certain plugin actions require specific API keys: Helius for compressed airdrops, Allora for ML-based predictions, and OKX DEX for OKX-specific swaps. Actions that use these services fail silently without the corresponding key unless the plugin validates the environment at initialization.

The repository includes a `CONTRIBUTING.md` file with guidance for adding new actions and plugins. Contributions follow a pattern of registering the action in the plugin's action index, writing a typed method, and adding examples to the `examples/` directory.

Editorial conclusion

Solana Agent Kit is the right tool for teams building AI applications that need to trigger onchain Solana actions programmatically and want the AI framework integration pre-built. It saves significant integration work if your stack is TypeScript and you are targeting the Solana protocols already covered by the five official plugins. It is the wrong tool if you need Python support (the README documents no Python SDK), if you need EVM chains without bridging, or if you need a lighter toolkit than a full monorepo with five plugins. Before deploying to mainnet, audit the `.env.example` file carefully: it requires a Solana private key, and any misconfiguration that sends that key to an external service in an LLM context is a real financial risk.

Frequently asked questions

Official sources

1. License: Apache-2.0
2. Project website
3. README
4. Releases
5. sendaifun/solana-agent-kit on GitHub