Helius for Agents

To build production-ready apps on Solana, AI agents need structured tools, clear workflows, and the right context to ship fast and sound. 

Without these, agents guess at API calls, hallucinate endpoints, hardcode fees that should be dynamic, and miss faster paths like Helius Sender and LaserStream.

To fix this, we’re releasing a suite of tools for agents building on Helius:

1. Helius MCP Server
2. Helius Skills
3. Helius CLI
4. Helius Claude Code Plugin

We’ve also relentlessly optimized our TypeScript and Rust SDKs, as well as our documentation, to make it easier for autonomous agents and AI assistants to recommend and use these tools effectively. 

Here’s what each tool does and how they fit together:

The Helius MCP Server: The Tools

The Model Context Protocol (MCP) is an open-source standard introduced by Anthropic to enable AI models to securely connect to external data sources, tools, and APIs. It replaces custom integrations with a universal, standardized interface. 

The Helius MCP Server exposes Helius—and Solana—to any MCP client.

Without MCP, an agent trying to check a wallet balance has to open a shell, construct a curl command, send it, parse the JSON output, and hope it got the endpoint and parameters right.

Multiply that by every API call in a given workflow, and you get slow, fragile, error-prone interactions that get bogged down by the need to spawn shell instances for every single command.

With the MCP, none of that happens.

The agent calls getBalance as a structured tool call and receives a typed response. No shell. No curl. No output parsing—it just works.

The same applies to parseTransaction, getAssetsByOwner, createWebhook, and all 60+ other tools. Agents can now use Helius directly with the right parameters to get structured data in return. 

The Helius MCP server provides tools for:

• Autonomous signup: create accounts, get API keys, upgrade, etc.
• Live blockchain data: RPC, DAS API, ZK Compression, and more
• Data streaming:  WebSockets (standard and enhanced), LaserStream gRPC (shred-level latency)
• Transaction sending: Priority Fee API, SPL transfers, and Sender
• Webhooks: Create, update, and delete event-driven notifications
• Wallet and history: balances, transfers, transaction parsing, wallet identity, and perform funding analysis
• Solana knowledge: SIMDs, Agave and Firedancer source references, Helius blog content, official Solana docs search

Quick Installation

To add the Helius MCP Server with Claude Code, run:

claude mcp add helius npx helius-mcp@latest

For Codex, run:

codex mcp add helius -- npx helius-mcp@latest

For Cursor, VS Code, or similar tools, add to your MCP config:

{
  "mcpServers": {
    "helius": {
      "command": "npx",
      "args": ["helius-mcp@latest"]
    }
  }
}

Then set your API key using the setHeliusApiKey tool or an environment variable (e.g., HELIUS_API_KEY), and start shipping.

For new users, your agent can autonomously create an account for you—it generates a keypair, you fund it, and then call agenticSignup to buy your desired plan starting at $1. 

Helius Skills: The Brain

The MCP gives agents access to 60+ tools. However, access alone isn’t enough—an agent with a tool catalog is akin to a developer with documentation tabs open and zero experience. It can call the tools, but it doesn’t know which tool to reach for, how to combine them for a given task, or what mistakes to avoid. 

Skills are the brain. They’re expert instruction sets—carefully crafted prompts with routing logic, reference files, and rules—that teach an agent how to be an expert Solana developer.

When a skill is loaded, the agent knows that searchAssets is better than getProgramAccounts for NFT lookups, that priority fees should be fetched dynamically via getPriorityFeeEstimates, and that transactions should go through Sender for the highest landing rates. Skills give your agent domain expertise.

Today, we’re launching four main Helius Skills:

Build

The Build skill is for core Solana development. It routes to the right tools for DAS, Sender, WebSockets, LaserStream, Webhooks, Wallet API, Enhanced Transactions, and onboarding (e.g., using RPCs, Sender, WSS, etc.). This is the default skill for building anything on Solana with Helius. 

DFlow

The DFlow skill is for building trading apps. It combines DFlow APIs (i.e., spot swaps, prediction markets, real-time streaming, Proof KYC) with Helius infrastructure for transaction submission, fee optimization, and on-chain monitoring. 

Phantom

The Phantom skill is for building frontend apps with the Phantom Connect SDK. It covers wallet connections, token gating, NFT minting, crypto payments, portfolio displays, and secure frontend architecture.

SVM

The SVM skill is so agents can understand Solana protocol internals. Explore how sBPF bytecode gets executed, Alpenglow design considerations, validator economics, and more by fetching live content from the Helius blog, SIMDs, and Agave/Firedancer source code. No API key required.

How Skills Work

Skills are model-agnostic. Each one ships with pre-built system prompt variants to work across all platforms, and not just Claude.

Use openai.developer.md for the OpenAI API, claude.system.md for the Claude API, or full.md for Cursor Rules, ChatGPT custom instructions, or any other tool. See the Skills overview for platform-specific setup.

Skills are installed automatically when using the Helius Claude Code Plugin. Standalone skills can be installed as Agent Skills—auto-invoked, no slash command needed:

# Clone our AI tooling repo
git clone https://github.com/helius-labs/core-ai.git

# Navigate to helius-skills
cd core-ai/helius-skills

# Install your desired skill
./helius/install.sh            # Build skill → ~/.claude/skills/helius/
./helius-dflow/install.sh      # DFlow skill → ~/.claude/skills/helius-dflow/
./svm/install.sh               # SVM skill   → ~/.claude/skills/svm/

With these skills, agents can build practically any Solana application—from trading frontends to prediction market apps to stablecoin payment processors—all with the correct patterns from the start.

The Helius Claude Code Plugin: The Bundle

The MCP provides the tools, while the skills are the brain. The Helius Claude Code Plugin is the bundle—a single install that wires everything together. It just works.

The plugin bundles the Helius MCP, the DFlow MCP, all four skills, and deep reference files for every Helius product.

No manual MCP configuration. No separate skill setup.

One install, and your agent now has structured blockchain access and expert Solana knowledge in a single session.

Quick Installation

Here’s how to install the Helius Plugin from the Claude Code marketplace:

/plugin marketplace add helius-labs/claude-plugins
/plugin install helius@helius

That’s it. The plugin auto-starts both MCP servers and currently gives you four slash commands:

The API key setup is the same as with the standalone MCP: use an existing key, enable autonomous signup, or use the Helius CLI. 

What This Looks Like in Practice

With the plugin installed, you can go from a single prompt to a working application. For example:

“Build me a tax reporting CLI so I can fetch Toly’s on-chain activity using his wallet address 86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY. Start with last month (February) and output a CSV file that outlines all of his taxable events. Build it so it works for any wallet and timeframe.”

Claude one-shots it:   

The /helius:build skill kicks in and correctly suggests getTransactionsByAddress with pagination and timestamp filtering to return a fully parsed transaction history based on Toly’s recent activity.

No manual tool selection, no intermediate prompting. The agent reads the correct reference files, invokes the correct MCP tools, and produces a working CLI that supports any wallet and any date range.

Of course, agents can build more complex apps, such as trading bots:

For this example, we installed the Helius MCP and asked Claude to build a trading bot that tracks PumpFun tokens in real-time, streaming token creations and trades via LaserStream.

We also asked it to display market data and provide basic charting so we could make paper trades. That's it. Claude built out this trading bot, complete with live token streaming and trading, in less than 10 minutes.

That’s the difference between giving an agent tools and giving it expertise.

The Helius CLI

The Helius CLI is a full-featured command-line interface with 95+ CLI commands covering everything from account management, to querying Solana, sending transactions, managing webhooks, real-time streaming, staking, ZK Compression, and more.

While we recommend the MCP for AI-driven workflows—structured tool calls beat spawning shell instances and parsing output—the CLI is the right choice for shell scripts, building CI/CD pipelines, or working in environments where MCP isn’t available. Every command supports the --json option for machine-readable output and returns structured exit codes, allowing automations to handle errors programmatically.

Quick Installation

For new users, the flow is simple:

# Install the CLI
npm install -g helius-cli
helius keygen                    # Generate keypair

# Fund wallet with ~0.001 SOL + 1 USDC
helius signup --json             # Create account, get API key
helius projects                  # List projects
helius apikeys <project-id>      # Get API keys

For existing users, simply:

helius config set-api-key YOUR_API_KEY

SDKs Optimized for Agents

For agents building applications programmatically, we’ve published agent-optimized documentation for our TypeScript SDK and Rust SDKs.

These pages cover recommended patterns for common agent workflows, including sending transactions via Sender, batching, real-time data, pagination, and error handling. 

TypeScript SDK

The Helius TypeScript SDK provides type-safe methods for every Helius API call. The key insight for agents is that Helius-specific methods collapse multi-step Solana workflows into single calls. 

For example, getTransactionsForAddress replaces the archaic standard two-step pattern of fetching signatures, then fetching transactions—one call with server-side filtering, time ranges, and token account support: 

import { createHelius } from "helius-sdk";

const helius = createHelius({ apiKey: "YOUR_API_KEY" });

// Single call: full transaction history with token activity
const txs = await helius.getTransactionsForAddress([
  "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY",
  {
    transactionDetails: "full",
    limit: 100,
    filters: { tokenAccounts: "balanceChanged" },
  },
]);

Similarly, sendSmartTransaction handles simulation, compute unit estimation, priority fees, and confirmation automatically.

sendTransactionWithSender takes this to the next level, optimized for ultra-low latency transaction submission.

See the TypeScript best practices for batching, pagination, real-time data via webhook and WebSockets, incremental account fetching, error handling, and common pitfalls that agents should avoid. 

Rust SDK

The Helius Rust SDK provides async Rust bindings with the same Helius methods, making it ideal for high-performance agentic workflows:

use helius::Helius;
use helius::types::*;

let helius = Helius::new("YOUR_API_KEY", Cluster::MainnetBeta)?;

// Same single-call pattern as TypeScript
let txs = helius.rpc().get_transactions_for_address(
    "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY".to_string(),
    GetTransactionsForAddressOptions {
        transaction_details: Some(TransactionDetails::Full),
        limit: Some(100),
        filters: Some(GetTransactionsFilters {
            token_accounts: Some(TokenAccountsFilter::BalanceChanged),
            ..Default::default()
        }),
        ..Default::default()
    },
).await?;

The Rust SDK also provides typed error variants (e.g., HeliusError::RateLimitExceeded), so agents can match on errors directly instead of parsing strings.

See the Rust best practices for the same patterns in Rust (i.e., batching, pagination, Sender, retry strategies, and common pitfalls). 

Get Started

Helius gives agents the most comprehensive toolkit for building production-ready apps on Solana. Here’s how to start:

• Fastest Path: Install the Claude Code Plugin 
• Any MCP Client: Add the Helius MCP Server to Claude Desktop, Cursor, VS Code, Codex, or Windsurf
• Shell Automation: Install the Helius CLI for scripts and CI/CD
• API Integration: Drop a skill system prompt into the OpenAI API, Claude API, or ChatGPT

Read our docs, explore the GitHub repo, pitch a skill integration, and contact our support team if you have any questions.