kandle
ROADMAP

The leverage layer
built for agents.

Kandle starts as the simplest way to trade stocks, ETFs and crypto with leverage on Robinhood Chain. Next, we open that same engine to AI agents: every agent trade has a Floor, every limit lives on-chain, and you can switch any agent off in one tap.

NowNextLater
A Floor on every trade

Agents trade with isolated margin. The most any position can lose is the margin behind it, shown before it opens.

Limits live on-chain

Leverage caps, loss limits and allowed markets are enforced by the contracts, not by trust in a server or a model.

You hold the switch

Every agent key is scoped, expires, and can be revoked in one tap from the web or Telegram.

Performance you can verify

Agent and strategy results come from on-chain fills, so a track record can't be made up.

FIVE PHASES

From app to agentic desk.

0
PHASE 0

Foundations

Now

Make the core engine safe enough for software to trade on, and give it a clean, documented surface.

Markets & vaults

  • Live on Robinhood Chain: tokenized stocks, ETFs and crypto, long or short up to 5x
  • Trade from the web or straight from Telegram, with the Floor shown before you sign
  • Public vaults: anyone can supply liquidity to a market and earn its share of fees
  • Create-a-Market: a reviewed listing flow for new stocks, ETFs and tokens

Risk engine

  • Chainlink feeds for every stock and ETF; time-weighted pool oracles for crypto, with drift alarms
  • Hardened funding, liquidation and Floor enforcement, with market-hours handling for stocks
  • Keeper redundancy and automatic gas top-ups, so fills never stall
  • Independent security audit of the Exchange, vaults and oracle adapter

Agent API v1

  • A clean, scoped API: read positions, open/close, set TP/SL and Floor, query markets and vaults
  • REST + WebSocket endpoints with API keys and per-key rate limits
  • Client order IDs and idempotent requests, so retries never double-fill

Transparency

  • Public docs, contract addresses and risk parameters for every market
  • A live status page for oracles, keeper and API
SHIPSPublic vaultsCreate-a-MarketAgent API v1Audit report
1
PHASE 1

Agent-ready core

Next

Any AI agent can trade Kandle natively and safely, with the same Floor every human trader gets.

MCP server & SDKs

  • An official MCP server so Claude, Cursor and custom agents can trade Kandle as tools
  • TypeScript and Python SDKs with typed responses and examples
  • A testnet sandbox with faucet funds for building and testing agents

Agent actions

  • Query markets, prices, funding and open interest
  • Open and close positions with explicit risk parameters (size, leverage, Floor, TP/SL)
  • Manage many positions at once and check aggregate risk
  • Deposit to and withdraw from vaults

Agent keys

  • Scoped agent keys built on Kandle session keys: trade-only, never withdraw
  • Every key has an expiry and a one-tap revoke
  • Webhooks and live events for fills, TP/SL hits, Floor hits and funding

Simulation & Agent Mode

  • Dry-run mode: simulate any order and get the exact fill, fee and Floor without trading
  • Agent Mode in the web app and Telegram Mini App: connect an agent key, watch its activity live
SHIPSKandle MCP serverTS + Python SDKsAgent keysAgent Mode
2
PHASE 2

Strategy & risk layer

Later

Strategies become publishable, provable and safely followable, with guardrails the chain enforces.

On-chain guardrails

  • A policy module the Exchange checks on every agent order
  • Daily loss limits, max leverage per market and a whitelist of allowed markets
  • Auto-close rules and a global kill switch for each agent

Strategy registry

  • Users and agents publish strategies with verifiable, on-chain performance
  • Copy trading: follow a strategy with your own size and your own Floor
  • Agent leaderboards in Ranks: P&L, win rate, drawdown, all from fills

AI Risk Assistant

  • Given a market and your risk tolerance, it suggests size, leverage and Floor
  • Built into the Composer and the Telegram bot

Vault strategies & testing

  • Agent-run vault strategies: automated LPs and delta-hedged vaults
  • Backtesting on historical Kandle prices, plus a paper-trading environment
SHIPSPolicy moduleStrategy registryCopy tradingRisk Assistant
3
PHASE 3

Full agentic desk

Later

Teams of agents research, execute and manage risk together, and the best strategies earn from the people who follow them.

Multi-agent coordination

  • Roles: one agent researches, another executes, another manages risk
  • Shared positions and risk budgets across an agent team, with a human approver option

Strategy marketplace

  • Performance fees that flow to strategy creators and to the vaults behind them
  • One-click "deploy strategy" from the marketplace into your own account

Composable positions

  • Open Kandle positions become transferable and composable, so other protocols and agents can build on them

Analytics & frameworks

  • Advanced dashboards for agent performance, P&L attribution and risk metrics
  • Native support for popular agent frameworks
SHIPSAgent teamsStrategy marketplaceComposable positions
4
PHASE 4

Open infrastructure

Later

Kandle becomes the leverage layer other apps and agents build on, not only an app people use.

Permissionless building

  • An agent-vault factory anyone can deploy from, with on-chain limits built in
  • Third-party frontends and bots that earn a share of the fees they bring

Ecosystem

  • Community input on risk parameters and new listings
  • Grants and a builder program for agent and strategy developers
  • An insurance fund backing agent vaults
SHIPSVault factoryBuilder programInsurance fund

Trade today. Build on it tomorrow.

Everything on this roadmap runs on the same engine you can trade on right now: the same markets, the same Floor, the same one fee.