SkillAgentSearch skills...

solana-agent-kit

Comprehensive guide for building AI agents that interact with Solana blockchain using SendAI's Solana Agent Kit. Covers 60+ actions, LangChain/Vercel AI integration, MCP server setup, and autonomous agent patterns.

Install / Use

npx skills add internet-court/internet-court-skill --skill solana-agent-kit

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

96/100

Category

Operations

Supported Platforms

Claude Code

Our assessment of solana-agent-kit

solana-agent-kit scores 96/100 on our quality scale, 53rd of 746 Operations skills we index (top 8%).

Its SKILL.md is 15 KB long, well organised into 36 sections with 16 code examples: a thorough specification that gives an agent plenty to work with.

With 7,124 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
30/30
Structure
20/20
Description
15/15
Adoption
16/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated 21 days ago, so solana-agent-kit is actively maintained.
  • Our last check on 2026-11-15 found the source still online.
  • No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
  • Its trust signals score 88/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-09-28. Automated pattern scan on 2026-09-28. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

solana-agent-kit compared with similar skills

All 4 of these similar skills score higher than solana-agent-kit; compare them before choosing.

SkillScoreStarsUpdatedFormat
solana-agent-kit (this skill)by internet-court967.1k21d agoSKILL.md
Agent-Reachby Panniantong100112.3k8d agoCLAUDE.md
rufloby ruvnet10081.9ktodayCLAUDE.md
headroomby headroomlabs-ai10079.8ktodayCLAUDE.md
CowAgentby zhayujie10048.0ktodayCLAUDE.md

Frequently asked questions

How do I install solana-agent-kit?
Run npx skills add internet-court/internet-court-skill --skill solana-agent-kit. The install tabs above show the steps for each supported agent.
Which AI agents does solana-agent-kit work with?
It is written for Claude Code, as a SKILL.md file. Other agents that read the same format can often use it too.
Is solana-agent-kit safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 88/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is solana-agent-kit still maintained?
The repository was last updated 21 days ago, so solana-agent-kit is actively maintained.

name: solana-agent-kit description: Comprehensive guide for building AI agents that interact with Solana blockchain using SendAI's Solana Agent Kit. Covers 60+ actions, LangChain/Vercel AI integration, MCP server setup, and autonomous agent patterns.

Solana Agent Kit Development Guide

Build AI agents that autonomously execute 60+ Solana blockchain operations using SendAI's open-source toolkit. Compatible with LangChain, Vercel AI SDK, and Claude via MCP.

Overview

The Solana Agent Kit enables any AI model to:

  • Deploy and manage tokens (SPL & Token-2022)
  • Create and trade NFTs via Metaplex
  • Execute DeFi operations (Jupiter, Raydium, Orca, Meteora)
  • Stake SOL, bridge tokens, register domains
  • Run in interactive or fully autonomous modes

Key Features

| Feature | Description | |---------|-------------| | 60+ Actions | Token, NFT, DeFi, staking, bridging operations | | Plugin Architecture | Modular - use only what you need | | Multi-Framework | LangChain, Vercel AI SDK, MCP, Eliza | | Model Agnostic | Works with OpenAI, Claude, Llama, Gemini | | Autonomous Mode | Hands-off execution with error recovery |

Quick Start

Installation

# Core package
npm install solana-agent-kit

# With plugins (recommended)
npm install solana-agent-kit \
  @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

Environment Setup

# .env file
OPENAI_API_KEY=your_openai_api_key
RPC_URL=https://api.mainnet-beta.solana.com  # or devnet
SOLANA_PRIVATE_KEY=your_base58_private_key

# Optional API keys for enhanced features
COINGECKO_API_KEY=your_coingecko_key
HELIUS_API_KEY=your_helius_key

Basic Agent Setup

import {
  SolanaAgentKit,
  createVercelAITools,
  KeypairWallet,
} from "solana-agent-kit";
import { Keypair } from "@solana/web3.js";
import bs58 from "bs58";

// Import plugins
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 wallet from private key
const privateKey = bs58.decode(process.env.SOLANA_PRIVATE_KEY!);
const keypair = Keypair.fromSecretKey(privateKey);
const wallet = new KeypairWallet(keypair);

// Initialize agent with plugins
const agent = new SolanaAgentKit(
  wallet,
  process.env.RPC_URL!,
  {
    OPENAI_API_KEY: process.env.OPENAI_API_KEY!,
  }
)
  .use(TokenPlugin)
  .use(NFTPlugin)
  .use(DefiPlugin)
  .use(MiscPlugin)
  .use(BlinksPlugin);

// Create tools for AI framework
const tools = createVercelAITools(agent, agent.actions);

Plugins & Actions

Token Plugin (@solana-agent-kit/plugin-token)

| Action | Description | |--------|-------------| | deployToken | Deploy new SPL token or Token-2022 | | transfer | Transfer SOL or SPL tokens | | getBalance | Check token balances | | stake | Stake SOL via Jupiter/Solayer | | bridge | Bridge tokens via Wormhole | | rugCheck | Analyze token safety |

// Deploy a new token
const result = await agent.methods.deployToken({
  name: "My Token",
  symbol: "MTK",
  decimals: 9,
  initialSupply: 1000000,
});

// Transfer tokens
await agent.methods.transfer({
  to: "recipient_address",
  amount: 100,
  mint: "token_mint_address", // optional, defaults to SOL
});

// Check balance
const balance = await agent.methods.getBalance({
  tokenAddress: "toke…[redacted]", // optional
});

NFT Plugin (@solana-agent-kit/plugin-nft)

| Action | Description | |--------|-------------| | createCollection | Create NFT collection via Metaplex | | mintNFT | Mint NFT to collection | | listNFT | List NFT on marketplaces | | updateMetadata | Update NFT metadata |

// Create collection
const collection = await agent.methods.createCollection({
  name: "My Collection",
  symbol: "MYCOL",
  uri: "https://arweave.net/metadata.json",
});

// Mint NFT to collection
const nft = await agent.methods.mintNFT({
  collectionMint: collection.collectionAddress,
  name: "NFT #1",
  uri: "https://arweave.net/nft1.json",
});

DeFi Plugin (@solana-agent-kit/plugin-defi)

| Action | Description | |--------|-------------| | trade | Swap tokens via Jupiter | | createRaydiumPool | Create Raydium AMM pool | | createOrcaPool | Create Orca Whirlpool | | createMeteoraPool | Create Meteora DLMM pool | | limitOrder | Place limit order via Manifest | | lend | Lend assets via Lulo | | perpetualTrade | Trade perps via Adrena/Drift |

// Swap tokens via Jupiter
const swap = await agent.methods.trade({
  outputMint: "target_token_mint",
  inputAmount: 1.0,
  inputMint: "So11111111111111111111111111111111111111112", // SOL
  slippageBps: 50, // 0.5%
});

// Create Raydium CPMM pool
const pool = await agent.methods.createRaydiumCpmm({
  mintA: "token_a_mint",
  mintB: "token_b_mint",
  configId: "config_id",
  mintAAmount: 1000,
  mintBAmount: 1000,
});

Misc Plugin (@solana-agent-kit/plugin-misc)

| Action | Description | |--------|-------------| | airdrop | ZK-compressed airdrop via Helius | | getPrice | Get token price via CoinGecko | | registerDomain | Register .sol domain | | resolveDomain | Resolve domain to address | | getTPS | Get network TPS |

// Compressed airdrop (cost-efficient)
const airdrop = await agent.methods.sendCompressedAirdrop({
  mintAddress: "token_mint",
  amount: 100,
  recipients: ["addr1", "addr2", "addr3"],
  priorityFeeInLamports: 10000,
});

// Get token price
const price = await agent.methods.getPrice({
  tokenId: "solana", // CoinGecko ID
});

Blinks Plugin (@solana-agent-kit/plugin-blinks)

Execute Solana Actions/Blinks directly:

// Execute a Blink
const result = await agent.methods.executeBlink({
  blinkUrl: "https://example.com/blink",
  params: { /* blink-specific params */ },
});

Integration Patterns

LangChain Integration

import { SolanaAgentKit, createSolanaTools } from "solana-agent-kit";
import { ChatOpenAI } from "@langchain/openai";
import { createReactAgent } from "@langchain/langgraph/prebuilt";
import { MemorySaver } from "@langchain/langgraph";
import { HumanMessage } from "@langchain/core/messages";

async function createLangChainAgent() {
  // Initialize LLM
  const llm = new ChatOpenAI({
    modelName: "gpt-4-turbo-preview",
    temperature: 0.7,
  });

  // Initialize Solana Agent Kit
  const solanaKit = new SolanaAgentKit(
    wallet,
    process.env.RPC_URL!,
    { OPENAI_API_KEY: process.env.OPENAI_API_KEY! }
  )
    .use(TokenPlugin)
    .use(DefiPlugin);

  // Create LangChain tools
  const tools = createSolanaTools(solanaKit);

  // Create agent with memory
  const memory = new MemorySaver();
  const agent = createReactAgent({
    llm,
    tools,
    checkpointSaver: memory,
  });

  return agent;
}

// Run agent
async function chat(agent: any, message: string) {
  const config = { configurable: { thread_id: "solana-agent" } };

  const stream = await agent.stream(
    { messages: [new HumanMessage(message)] },
    config
  );

  for await (const chunk of stream) {
    if ("agent" in chunk) {
      console.log(chunk.agent.messages[0].content);
    }
  }
}

Vercel AI SDK Integration

import { SolanaAgentKit, createVercelAITools } from "solana-agent-kit";
import { openai } from "@ai-sdk/openai";
import { generateText } from "ai";

async function runVercelAgent(prompt: string) {
  const agent = new SolanaAgentKit(wallet, rpcUrl, options)
    .use(TokenPlugin)
    .use(DefiPlugin);

  const tools = createVercelAITools(agent, agent.actions);

  const result = await generateText({
    model: openai("gpt-4-turbo"),
    tools,
    maxSteps: 10,
    prompt,
  });

  return result.text;
}

// Usage
const response = await runVercelAgent(
  "Swap 0.1 SOL for USDC using the best rate"
);

MCP Server for Claude

Install and configure the MCP server for Claude Desktop:

# Install globally
npm install -g solana-mcp

# Or run directly
npx solana-mcp

Add to Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "solana": {
      "command": "npx",
      "args": ["solana-mcp"],
      "env": {
        "RPC_URL": "https://api.mainnet-beta.solana.com",
        "SOLANA_PRIVATE_KEY": "your_base58_private_key",
        "OPENAI_API_KEY": "your_openai_key"
      }
    }
  }
}

Available MCP tools:

  • GET_ASSET - Get token/asset info
  • DEPLOY_TOKEN - Create new token
  • GET_PRICE - Fetch token price
  • WALLET_ADDRESS - Get wallet address
  • BALANCE - Check balance
  • TRANSFER - Send tokens
  • MINT_NFT - Create NFT
  • TRADE - Execute swap
  • REQUEST_FUNDS - Get devnet SOL
  • RESOLVE_DOMAIN - Lookup .sol domain
  • GET_TPS - Network throughput

Autonomous Mode

Run agent in fully autonomous mode:

import { SolanaAgentKit } from "solana-agent-kit";

const agent = new SolanaAgentKit(wallet, rpcUrl, options)
  .use(TokenPlugin)
  .use(DefiPlugin);

// Configure autonomous behavior
const autonomousConfig = {
  intervalMs: 60000,        // Check every minute
  maxActions: 100,          // Max actions per session
  errorRecovery: true,      // Auto-retry on failures
  dryRun: false,            // Set true for testing
};

// Start autonomous loop
async function runAutonomous() {
  while (true) {
    try {
      // Agent decides what to do based on market conditions
      const decision = await agent.analyze({
        context: "Monitor my portfolio and rebalance if needed",
        constraints: [
          "Keep at least 1 SOL for gas",
          "Max 10% allocation per token",
        ],
      });

      if (decision.shouldAct) {
        await agent.execute(decision.action);
      }

      await sleep(autonomousConfig.intervalMs);
    } catch (error) {
      if (autonomousConfig.errorRecovery) {
        console.error("Error, recovering:", error);
        await sleep(5000);
      } else {
        throw error;
      }
    }
  }
}

Creating Custom Actions

Extend the agent with custom actions:

import { Action, Tool, SolanaAgentKit } from "solana-agent-kit";

// Define the Tool (tells LLM HOW to use it)
const myCustomTool: Tool = {
  name: "my_custom_action",
  description: "Does something custom on Solana",
  parameters: {
    type: "object",
    properties: {
      param1: {
        type: "string",
        description: "First parameter",
      },
      param2: {
        type: "number",
        description: "Second parameter",
      },
    },
    required: ["param1"],
  },
};

// Define the Action (tells agent WHEN and WHY to use it)
const myCustomAction: Action = {
  name: "my_custom_action",
  description: "Use this when you need to do something custom",
  similes: ["custom thing", "special operation"],
  examples: [
    {
      input: "Do the custom thing with value X",
      output: "Custom action executed with param1=X",
    },
  ],
  handler: async (agent: SolanaAgentKit, params: any) => {
    const { param1, param2 } = params;

    // Your custom logic here
    const connection = agent.connection;
    const wallet = agent.wallet;

    // Execute Solana operations...

    return {
      success: true,
      result: `Executed with ${param1}`,
    };
  },
};

// Register custom action
agent.registerAction(myCustomAction);
agent.registerTool(myCustomTool);

Best Practices

Security

  1. Never expose private keys - Use environment variables
  2. Use dedicated wallets - Separate agent wallet from main funds
  3. Set spending limits - Implement max transaction amounts
  4. Test on devnet first - Always test before mainnet
  5. Audit agent actions -

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars7.1k
CategoryOperations
Updated21d ago
Forks132

Languages

TypeScript

Trust signals

88/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 medium