TON Toolset 2026: the new SDK stack for developers

TON Foundation has published TON Toolset — a unified SDK and tooling stack for TON development in 2026. Six products covering the whole lifecycle of a TON app: from writing a smart contract to integrating into a Mini App, accepting payments, and connecting LLM agents.

Let’s break down what’s inside, how it differs from the old stack (tonweb + ton-core + tonconnect-sdk), and where to start based on your role.

Why a Toolset

Before 2026, TON’s development ecosystem looked fragmented: a separate SDK for each task, and nearly every developer rebuilt abstractions around them.

What existed:

• ton-core — low-level work with cells, BoC, contract calls.
• tonweb — the older JS client to TON nodes.
• @ton/sandbox — local emulator for tests.
• tonconnect-sdk — UI layer for wallet connection.
• Blueprint — smart-contract dev framework (on FunC).
• Many community wrappers of varying quality.

Pain points:

• Typed transactions had to be hand-written on top of ton-core.
• Every dev built their own React components for Mini Apps.
• Payment acceptance (one of the most common use cases) — no ready SDK.
• Total absence of tools for AI agents.

What Toolset does: standardises all these abstractions into one package set under the @ton/* NPM scope (plus @ton-pay/*). The old SDKs don’t go away — they’re under the hood of Toolset. New projects should start with Toolset; existing projects can migrate gradually.

Six tools: the matrix

Acton: the smart-contract toolchain

Acton is an all-in-one CLI for Tolk smart contracts. It contains scaffolding for new projects, a testing framework (mutation/coverage/fork/fuzz/gas profiling), TypeScript wrapper generation from ABI, a debugger with VS Code/JetBrains/Cursor/Zed support, and a func2tolk command for migrating old FunC contracts.

This is the conceptual successor to Blueprint for new Tolk code. If you’re already on Blueprint with FunC, migration isn’t required, but new projects should start with Acton.

More — our Acton guide and the Tolk 1.4 piece on ABI and TS wrappers.

AppKit: SDK for Mini Apps and dApps

AppKit is what a Mini App or dApp developer should use in 2026. It standardises:

• TON Connect integration (no hand-written TonConnectUIProvider).
• Typed transactions — transaction shaping with TypeScript types instead of raw cells.
• React components for wallet connection, balance display, transfer initiation.
• DNS resolution (.ton/.t.me addresses to canonical).
• DEX quotes directly from the SDK (STON.fi/DeDust pricing).
• Toncoin staking through ready helpers.

NPM:

• @ton/appkit — base.
• @ton/appkit-react — React components.

The most “frontend-friendly” piece in the Toolset. Dedicated deep-dive coming.

WalletKit: for wallet builders

WalletKit is the lower level of the same stack, but for those who make a wallet (custodial or non-custodial), not those who connect to someone else’s.

Contains:

• Full TON Connect implementation from the wallet side (receiving dApp requests, signing, sending back).
• Asset reads + transfers.
• Gasless transfer flows (via gas stations).
• Managing multiple wallets in one app.
• Cross-platform — web, iOS, Android, browser extensions.

Clearly targeted at new wallets (like Antarctic, Bitget Wallet) and large Mini Apps with built-in wallets (Wallet in Telegram).

TON Pay: SDK for accepting payments

TON Pay closes one of the most common scenarios — accepting TON in exchange for a good or service in a bot, Mini App, or web app.

What it gives you:

• Direct-to-wallet acceptance — no need to run a custodial cash register.
• Checkout components (frontend).
• One-time charges (like Stripe Payment Intent, but in TON).
• On-ramp flows — the user can buy TON right in checkout.
• Hosted payment API — backend SDK for server-side payment verification.

NPM: @ton-pay/api (backend) + @ton-pay/ui-react (UI). GitHub: RSquad/ton-pay (open source).

This competes with custom integrations via Crypto Pay API and Wallet Pay — but gives a more standardised flow.

MCP: TON for LLM agents

Model Context Protocol is a public API for language models. The TON MCP server gives LLM agents tools to:

• Check balances and transactions.
• Initiate transfers (if the agent has a key).
• Get DEX quotes.
• Manage wallets (via Agentic Wallet — see below).
• Pre-built “skills” — high-level operations like “buy USDT for 100 TON”.

Integration for an LLM-agent developer — one line of code. This drops the barrier for AI agents entering the TON ecosystem to a minimum.

Site — mcp.ton.org. NPM — @ton/mcp.

Agentic Wallet: self-custody for AI

Agentic Wallet is a smart-contract wallet purpose-built for AI agents.

Key features:

• Split keys — user has one key, agent has another. Each sees only its half.
• User-delegated budget — the user gives the agent a limit it can’t exceed (per day, per period, per counterparty).
• Revokable access — the user can revoke the agent’s access on-chain in a single transaction.
• Dashboard + programmatic management — control via UI or API.

Goal: let an AI agent make payments without granting full custody — that is, without the risk “agent drains all funds”.

Site — agents.ton.org.

How Toolset reshapes the workflow

If you’re making a Mini App in 2026:

1. Spin up a project → install @ton/appkit-react.
2. Use <TonConnect /> component to connect a wallet.
3. Transactions — through typed builders, not raw cells.
4. Payment acceptance — through TON Pay.
5. All TON links — via AppKit DNS resolver.

No tonweb, no hand-rolled TonConnectUIProvider, no manual serialisation.

If you’re writing a smart contract:

1. npx @ton/acton init → new project.
2. Write in Tolk.
3. Test via Acton’s testing framework.
4. Debug via Acton’s debugger.
5. Get an auto-generated TS wrapper for frontend integration.

If you’re building an AI agent:

1. Wire @ton/mcp client into your LLM.
2. Create an Agentic Wallet for the agent with a $50/day limit.
3. The agent calls operations via MCP — each bounded by the wallet’s limits.

What’s NOT in Toolset (yet)

Toolset focuses on the development stack. Not covered right now:

• On-chain analytics (use TonAPI, DeFiLlama, GeckoTerminal for that).
• Indexing for server-side apps (use TonAPI v3, ton-indexer-worker).
• Validator tooling — a separate stack (mytonctrl).
• NFT-specific work — partially via TonAPI, partially via ton-core.

These are either special niches or areas where community solutions are already strong. Toolset may expand into them later.

Old vs new stack

What’s next

Toolset is an infrastructure shift. The next 6-12 months will determine how broadly the ecosystem adopts it. Big projects (Tonkeeper, MyTonWallet, STON.fi) typically migrate gradually. Small/medium dApps can move in a few weeks.

We’ll cover each of the 6 tools in a separate deep-dive as real-world adoption cases land. For now:

• Acton: complete guide — already up.
• Tolk 1.4 with ABI and TS wrappers — already up, foundation of Acton.
• AppKit, WalletKit, TON Pay, MCP, Agentic Wallet — dedicated deep-dives in progress.

Official docs hub: docs.ton.org/ecosystem. Release site: ton.org/toolset.