TON Redesign Preview

Agentic Wallets

Self-custody smart contract wallets designed for autonomous AI agents. Split-key architecture keeps the user in control while the agent operates independently.

Split-key security

The user retains the master key. The agent receives a separate operator key that can only access funds deposited into the agentic wallet — never the owner's main wallet.

Revoke, withdraw, rotate

Owners can revoke agent access, withdraw funds, or rotate operator keys at any time from the web dashboard — no redeployment needed.

On-chain, no intermediaries

Every agentic wallet is a real TON contract deployed as a Soulbound Token. All operations are fully on-chain with no custody service in between.

Manage wallets

// Ask your AI agent:
"Create agentic wallet"

// The agent generates operator keys
// and guides you to the dashboard.

// Fund the wallet:
// 1. During creation (Initial TON deposit)
// 2. From the dashboard (Fund button)
// 3. Direct transfer to the wallet address

// Then ask:
"Send 1 TON to UQB..address"
"Swap 5 TON for USDT"
"Show my NFTs"
"Check my balance"

TON MCP Server

Model Context Protocol server that lets any AI agent operate TON wallets and perform blockchain actions. Built on WalletKit, available on npm.

One-line setup

Install skills and your agent can launch the MCP server on its own. Works with Claude Desktop, Cursor, Windsurf, and any MCP-compatible client.

Full blockchain access

Balances, transfers, NFTs, jetton swaps via DEX aggregators, TON DNS resolution, and transaction history — all through high-level intents, no raw blockchain calls.

Multiple transports

Run as standard I/O for local agents, as an HTTP server for multi-session access, or deploy serverless on AWS Lambda, Vercel, or Cloudflare Workers.

npm package GitHub

# Install skills (recommended)
npx skills add ton-connect/kit/packages/mcp

# Or configure manually
# Add to your MCP client config:
{
  "mcpServers": {
    "ton": {
      "command": "npx",
      "args": ["-y", "@ton/mcp@alpha"]
    }
  }
}

# Run directly
npx -y @ton/mcp@alpha

What your agent can do

Every capability is exposed as an MCP tool. The agent confirms transfers with the user before executing.

Transfers

Send Toncoin, jettons (USDT, custom tokens), and NFTs to any address. Amounts in human-readable format — the server handles nanoton conversion and signing internally.

Swaps

Get quotes for token swaps through DEX aggregators and execute them in one step. Use "TON" for native Toncoin or pass any jetton contract address.

Balances & history

Check Toncoin and jetton balances, list all held tokens with metadata, query recent transaction history including swaps, transfers, and jetton movements.

NFTs & DNS

List, inspect, and transfer NFTs with full metadata and collection info. Resolve TON DNS domains to wallet addresses and perform reverse lookups.

Wallet management

Create, import, and switch between multiple agentic wallets. Rotate operator keys, validate wallet addresses, and manage the full lifecycle from code.

Use cases

AgenticKit and TON MCP power different types of autonomous agent workflows.

Trading bots

Autonomous agents that monitor markets and execute token swaps on TON DEXes. The agent operates its own funded wallet while the user retains full withdrawal and revocation rights.

Payment automation

Agents that handle recurring payments, payroll distribution, or tip collection. Schedule transfers, batch payouts, and track settlement — all on-chain.

AI-powered Mini Apps

Telegram bots and Mini Apps that use MCP to handle wallet interactions. Let your AI assistant accept payments, distribute rewards, or manage NFT drops.

Portfolio management

Agents that track holdings, rebalance across jettons, and report performance. Query balances and transaction history across multiple wallets in real time.

DAO operations

Autonomous treasury management where agents execute approved proposals — fund grants, distribute rewards, or manage community assets under on-chain governance.

Developer tooling

Integrate TON MCP into Cursor, Claude Desktop, or custom dev environments. Let coding agents deploy contracts, test transfers, and inspect on-chain state.

Programmatic API

Use the library API to build custom MCP servers or embed agentic wallet operations into your own applications.

import { createTonWalletMCP } from '@ton/mcp';
import {
  Signer, WalletV5R1Adapter, TonWalletKit,
  MemoryStorageAdapter, Network,
} from '@ton/walletkit';

const network = Network.mainnet();
const kit = new TonWalletKit({
  networks: { [network.chainId]: {} },
  storage: new MemoryStorageAdapter(),
});
await kit.waitForReady();

const signer = await Signer.fromMnemonic(
  process.env.MNEMONIC.split(' '), { type: 'ton' }
);
const adapter = await WalletV5R1Adapter.create(signer, {
  client: kit.getApiClient(network),
  network,
});
const wallet = await kit.addWallet(adapter);

const server = await createTonWalletMCP({ wallet });

Why AgenticKit

Self-custody Architecture

User holds the master key. Agent holds operator key. No custodial service, no intermediaries.

MCP Standard protocol

Works with any MCP-compatible client — Claude, Cursor, Windsurf, or your own agent framework.

Alpha Mainnet ready

Safe for mainnet use today. Pin a version for production and check the changelog before upgrading.

Give your AI agent a wallet

Create an agentic wallet, install MCP skills, and let your agent operate on TON — with you in full control.

Open AgenticKit Dashboard