The crypto toolbox

Most of what people want an agent to do in crypto composes a few tool families: price feeds, DEX quotes, token discovery, on-chain reads, prediction markets, analytics, news, and the places communities live (Telegram, Discord, X, Farcaster). Each family has ready-made templates in the gallery, common bots compose them with the SDK, and one boundary matters: the marketplace sells data and quotes; keys and signing stay in the agent's own wallet. It is also the shelf an app agent searches when you let it find its own tools.

What is in the box

Every family is a set of templates an operator lists in one command; the names are what you pass to npm run templates -- add. Keyless means the upstream needs no account; keyed means the operator brings a key and the template does the rest.

Everything keyless above is live-verified by npm run templates -- verify; the keyed ones are validated for shape and run the moment the key is in the operator's environment.

Your agent finds all of this itself. An app assistant that may find its own tools searches the marketplace during its run and calls what it finds, within its budget, trying one feed against another when two operators list the same kind. A bot you write with the SDK asks the same shelf through discover, ranked by the reputation those agents wrote and then by price. Either way the agent chooses; the person who deployed it only set the budget.

The custody boundary

A marketplace node never holds a buyer's keys and never signs for them. So trading templates return quotes, routes and calldata rather than executing: the agent that bought the quote signs the transaction with its own wallet (or its owner's smart account, if it holds a session key), and pays the node only for the information. Social tools likewise: the operator's bot token posts to the operator's channels, so an operator sells "post to my community's channel", not access to the buyer's account. Personal accounts stay on the buyer's side, in the private node. This boundary lets a person hand an agent a budget without handing it their savings: the worst a bad quote can cost is the price of the quote. The same holds off-chain: an order on Binance, Coinbase, Kraken, Bybit, OKX or Alpaca (US stocks and ETFs) is placed by the private node with the person's own API key and USD caps, never by a listing.

Three bots, composed

The examples use the TypeScript SDK; aioum is an AIOUMClient and agent a budget-capped agent. Sessions open by tool name: given { tool }, the SDK ignores the category string and hands the bot the best-rated, then cheapest, live service exposing a tool of that name, so the same code works whichever operator lists it, and the bot is never told who that is. Where a tool name is shared across families (quote, token, ticker, post), pass a ServiceInfo from aioum.discover({ category, tool }) instead of the category string so the bot lands in the right family.

A price-alert and trading bot watches an oracle and a DEX route, posts when a threshold is crossed, and hands the route to a signer.

const feed  = await agent.openSession("feed:chainlink",  { tool: "latestRoundData", deposit: "0.20 USDC" });
const route = await agent.openSession("dex:kyberswap",   { tool: "route",           deposit: "0.30 USDC" });
const tg    = await agent.openSession("social:telegram", { tool: "send",            deposit: "0.20 USDC" });

const hex = (await feed.call({ feed: "0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419" })).text; // ETH/USD
const answer = Number(BigInt("0x" + hex.slice(2 + 64, 2 + 128))) / 1e8;                     // word 2, 8 decimals
if (answer < 2000) {
  const r = JSON.parse((await route.call({ chain: "ethereum", tokenIn: "0xEeee…EEeE", tokenOut: "0xA0b8…eB48", amountIn: "1000000000000000000" })).text);
  await tg.call({ chat_id: "@mydesk", text: `ETH ${answer} — best route out: ${r.amountOut} USDC via ${r.route?.length ?? "?"} hops` });
  // execute: build the swap tx from `r` and sign it with the bot's own wallet — not through the marketplace
}
await Promise.all([feed.close(), route.close(), tg.close()]);

A community bot reads a Discord channel, lets a model draft a reply in the community's voice, and posts it.

const dc  = await agent.openSession("social:discord", { deposit: "0.30 USDC" });          // post / read / guild
const llm = await agent.openSession("llm:", { tool: "complete", deposit: "0.50 USDC" });
const recent = (await dc.call({ channel_id: CHANNEL }, { tool: "read" })).text;
const draft = (await llm.call({ prompt: `You moderate a crypto community. Summarize these messages and answer open questions briefly:\n${recent}` })).text;
await dc.call({ channel_id: CHANNEL, text: draft }, { tool: "post" });

A memecoin scanner takes new pools on Base, filters them by liquidity and buy pressure, and posts the survivors to X.

const gt = await agent.openSession("token:geckoterminal", { tool: "newPools", deposit: "0.20 USDC" });
const ds = await agent.openSession("token:dexscreener",   { tool: "token",    deposit: "0.40 USDC" });
const x  = await agent.openSession("social:x",            { tool: "post",     deposit: "0.20 USDC" });
const pools = JSON.parse((await gt.call({ network: "base" })).text) as { attributes: { name: string; reserve_in_usd: string; address: string } }[];
for (const p of pools.filter((p) => Number(p.attributes.reserve_in_usd) > 50_000).slice(0, 3)) {
  const pairs = JSON.parse((await ds.call({ address: p.attributes.address })).text) as { txns: { h1: { buys: number; sells: number } }; url: string }[];
  const hot = pairs[0] && pairs[0].txns.h1.buys > 2 * pairs[0].txns.h1.sells;
  if (hot) await x.call({ text: `New on Base: ${p.attributes.name} — $${Number(p.attributes.reserve_in_usd).toFixed(0)} liquidity, buys ${pairs[0].txns.h1.buys}/h ${pairs[0].url}` });
}

Each session is one escrow deposit and one settlement; every call between is a signed receipt. A bot that runs all day keeps its sessions open and settles on close, so a hundred price checks cost a hundred signatures and one transaction.

A cross-chain swap quotes with LI.FI, signs the returned transaction with the bot's wallet, and polls status until the funds land on the destination chain.

const lifi = await agent.openSession("xchain:lifi", { tool: "quote", deposit: "0.30 USDC" });
const q = JSON.parse((await lifi.call({ fromChain: 1, toChain: 8453, fromToken: USDT_ETH, toToken: USDC_BASE, fromAmount: "100000000", fromAddress: bot.address })).text);
// q.transactionRequest = { to, data, value, gasLimit } — sign and send it from the bot's wallet on chain 1
// q.estimate.toAmount, q.estimate.executionDuration, q.tool (which bridge won: across, stargate, …)

An arbitrage scanner compares a CEX last price with a DEX route and a stablecoin leg, and alerts when the spread beats fees. Execution is the bot's own business; the marketplace sells the numbers.

const cex  = await agent.openSession("feed:kraken",     { tool: "ticker",    deposit: "0.20 USDC" });
const dex  = await agent.openSession("dex:kyberswap",   { tool: "route",     deposit: "0.30 USDC" });
const base = await agent.openSession("dex:stables",     { tool: "baseRoute", deposit: "0.30 USDC" });
const tg   = await agent.openSession("social:telegram", { tool: "send",      deposit: "0.20 USDC" });

const k = JSON.parse((await cex.call({ pair: "ETHUSD" })).text) as Record<string, { c: string[] }>;
const last = Number(Object.values(k)[0].c[0]);                                     // Kraken last trade
const r = JSON.parse((await dex.call({ chain: "ethereum", tokenIn: WETH, tokenOut: USDC, amountIn: "1000000000000000000" })).text);
const dexPx = Number(r.amountOutUsd);                                              // 1 ETH → USDC on-chain, in USD
const spreadBps = ((dexPx - last) / last) * 1e4;
if (Math.abs(spreadBps) > 25) await tg.call({ chat_id: "@arbdesk", text: `ETH: Kraken ${last} vs DEX ${dexPx.toFixed(2)} → ${spreadBps.toFixed(0)} bps` });

const s = JSON.parse((await base.call({ tokenIn: USDT_BASE, tokenOut: USDC_BASE, amountIn: "100000000" })).text);
if (Number(s.amountOut) > 100_300_000) await tg.call({ chat_id: "@arbdesk", text: `USDT→USDC on Base pays ${(Number(s.amountOut) / 1e6).toFixed(3)} per 100` });

Low-gas execution belongs on Base or Arbitrum; gasless execution means CoW (solvers pay gas, you sign an order) or 0x Gasless (fees in the sold token). Cross-chain arbitrage adds bridge time and fees to the spread you need: Across and Relay fill in seconds, LI.FI picks the cheapest of many. The app builds every bot above without code: the same tool families, ticked on the Its services screen or found by the agent itself, with the budget enforced by the runner instead of your loop.

Selling to bots

From the operator's side, this shelf is a business plan. The edge is curation and reliability: a feeds node that bundles Chainlink, DefiLlama prices and two exchanges; a trading-data node with KyberSwap, CoW, Jupiter, DexScreener and GeckoTerminal; a prediction node; a community node with its own Telegram and Discord bots for the communities it runs. Start with the gallery:

npm run templates -- add feed-chainlink-onchain feed-defillama-prices crypto-coingecko feed-kraken feed-binance --out feeds.json
npm run templates -- add dex-kyberswap-routes dex-cow-quote dex-jupiter-swap dex-sushi-quote token-dexscreener token-geckoterminal --out trading.json
npm run templates -- add xchain-lifi xchain-across xchain-debridge xchain-relay dex-stable-swaps gas-owlracle --out crosschain.json
npm run templates -- add social-telegram-bot social-discord-bot social-x social-farcaster-neynar meme-templates-imgflip --out community.json
AIOUM_SERVICES_CONFIG=./trading.json npm run multinode

Price above the upstream's cost and rate limits (most keyless APIs allow tens of requests per minute; a busy bot will pay for a keyed tier), keep responses small (responsePath), and set commitRequired on feeds so buyers can prove what you returned. The bots that find your node rate it after every settled session, so a feed that answers fast and correctly is the one the next bot's search prefers. The rest: selling guide.

Next: Ready-made listings — every template in the gallery, what each needs, and how to verify it against its real upstream.