Clodds Bot: Retail Bots Grow Teeth
github.com/alsk1992/CloddsBot | License: MIT
Sleep is expensive when markets never close. A prediction contract flips on Polymarket, BTC rips on Hyperliquid, some meme coin starts running on Solana, and the useful window is gone before a human even opens three tabs. That is the pitch behind Clodds Bot, and honestly the hook lands because the repo is not pretending trading is a dashboard problem. The bet here is that speed, coordination, and risk controls matter more than prettier charts. In a market full of cosplay agents, that feels refreshingly concrete.
The Drop: One Bot, Too Many Venues
Retail trading already has enough friction before AI enters the picture. Prediction markets live in one place, perpetuals in another, Solana tokens somewhere else, and each venue speaks its own API dialect, wallet flow, and order logic. Add messaging on top, because nobody wants to babysit a terminal all day, and the setup turns into a part-time ops job.
Clodds Bot exists because that fragmentation kills any chance of acting quickly across markets that increasingly rhyme with each other. A contract on Kalshi, a price move on Binance, and a thin orderbook on a Solana DEX can all express the same idea, but normal tools treat them as separate worlds. That is exactly the gap this project attacks.
Plenty of bots can place trades. Fewer can scan across 1,000 plus markets, route through chat, keep a memory of prior context, and still behave like one coherent system instead of a folder full of scripts. The frustration here is not just manual clicking. It is the absence of a unified decision layer for markets that now move as one messy, always-on graph.
The Stack: TypeScript as the Control Plane
Under the hood, TypeScript runs the core orchestration, exchange connectors, chat surfaces, and onboarding flow, with SQLite, LanceDB, and PostgreSQL splitting local history, semantic memory, and analytics duties. A small Rust service handles fast transaction broadcasting, which is a smart place to get opinionated about latency, while Claude anchors the decision layer.
The Sauce: Chat Becomes the Trading Bus
What makes Clodds Bot interesting is the Skills System, a bundled library of market actions and automations that turns natural language into executable trading behavior across venues. That sounds obvious until the architecture clicks into focus. This is not just a chatbot stapled onto exchange APIs. The project treats conversation as a control surface for a registry of capabilities, each one scoped to a market, strategy, or operational task.
Because those skills are exposed through an MCP Server, Clodds Bot can act like a local trading toolset that other AI clients can call, not just its own interface. That is the subtle move. The repo is building a portable action layer, closer to a plugin runtime than a single-purpose bot. Think Notion integrations, but for trading actions and market intelligence.
A second smart choice is the split persistence model. WebChat stores append-only history in SQLite for reliability, semantic memory in LanceDB compresses older context into retrievable summaries, and analytics can flow into PostgreSQL. That matters because trading agents fail when context gets shallow. A strategy discussion from yesterday, a wallet warning from this morning, and an execution constraint from five minutes ago all need to remain legible without flooding the model every turn.
Then there is the risk engine. Circuit breakers, position sizing, volatility checks, and kill switches are not glamorous, but they are the difference between agent theater and something that can survive contact with live markets. Honestly, the repo’s most credible trait is that it assumes autonomy without pretending risk disappears.
The Move: Turn Fragmentation Into Edge
Founders, traders, and research-heavy operators could use Clodds Bot less like a hobby bot and more like a private execution layer. Start with one workflow that already burns time, e.g. monitoring Polymarket contracts while hedging exposure on a futures venue, then push alerts and actions into Telegram or the built-in chat. That alone compresses response time and cuts tab-switching, which in trading is not a UX complaint, it is slippage.
Another practical angle is using Clodds Bot as a self-hosted market ops console. Keep the AI model, chat history, and wallet logic in a system you control, then wire in only the venues that matter. Teams experimenting with prediction markets, token launches, or copy-trading products could also treat the repo as a prototype stack for agentic finance features without starting from raw exchange integrations.
The strategic advantage is not just automation. It is coordination. A unified bot across prediction contracts, perps, and on-chain venues gives smaller operators something that used to belong to funds with internal tooling, namely one place to watch cross-market signals, execute quickly, and preserve decision history. That kind of infrastructure compounds.
The Aura: Finance Starts Talking Back
People are going to expect software that does more than notify. A price alert that still requires ten manual steps already feels outdated, and that feeling spreads fast once conversational tools can inspect balances, compare venues, and act with constraints. Clodds Bot leans into that expectation.
What this enables on a human level is delegated vigilance. Not blind trust, hopefully, but a different relationship to constant-information environments where attention is the scarcest asset. The deeper thesis seems like this: when interfaces can hold memory, permissions, and action logic together, users stop treating software as a destination and start treating it as an always-on counterpart.
The Play: Agentic Trading Leaves the Demo Stage
This looks less like pure 0-to-1 category creation and more like a better mousetrap in a very large TAM, retail and prosumer trading infrastructure, prediction markets, and AI-native financial tooling. Still, the repo hints at early PMF signals because the distribution pattern is unusually strong for a new open source trading project: roughly 1,500 stars, 10.7k clones in two weeks, broad connector coverage, and a feature set that feels product-complete rather than hackathon-thin. The moat is probably not raw code, since competitors can copy connectors, but execution speed, community extensions, and switching costs from accumulated workflows, chat history, and venue configuration could become surprisingly sticky.
Winners:
Predicate: Faster product iteration around prediction-market analytics compounds if users increasingly want execution tied directly to insight, not a separate destination.
Kalshi: More autonomous clients can increase trading frequency and liquidity depth because software becomes a repeat customer, not just a user interface.
Robinhood: Broader acceptance of agent-assisted trading normalizes API-like finance experiences and expands LTV from users who graduate from passive investing to active strategies.
Losers:
Dub: Narrow copy-trading experiences erode when users can run personalized, multi-venue strategies with their own constraints, and adapting means rebuilding the whole product thesis.
Phantom: Wallet-first consumer flows lose some gravity if higher-value users spend more time in agent consoles that abstract chains and venues behind one command layer.
CME Group: Closed, institution-shaped market access looks a bit more brittle if always-on retail tooling keeps making cross-venue execution feel normal and expected.
tl;dr
Clodds Bot turns chat into a self-hosted trading terminal across prediction markets, crypto venues, and messaging apps. The interesting part is the action architecture: skills, memory, and risk controls sit behind one conversational surface. Worth a look for anyone tracking agentic finance, market ops, or AI software that actually does something costly.
Stars: 1,497 | Language: TypeScript
