alsk1992/CloddsBot: Self-Hosted AI Trading Terminal for 1000+ Markets

alsk1992/CloddsBot: Self-Hosted AI Trading Terminal for 1000+ Markets

Developers and quantitative traders increasingly need infrastructure that combines autonomous decision-making with direct control over execution. Running trading logic on someone else's server means accepting counterparty risk, latency, and opaque fee structures. alsk1992/CloddsBot addresses this by offering a self-hosted AI trading terminal that operates across prediction markets, cryptocurrency spot markets, perpetual futures, and on-chain DeFi protocols — all through natural language interaction.

Built in TypeScript and released under the MIT License, CloddsBot (the name merges "Claude" and "Odds") reached 505 GitHub stars and 109 forks as of its last commit on June 26, 2026. The project emerged from the Colosseum Agent Hackathon on Solana, where it was developed in 12 days as a fully-featured autonomous trading agent. This article examines what the system actually delivers, how to run it, and where it fits in the current landscape of algorithmic trading tools.

What is alsk1992/CloddsBot?

alsk1992/CloddsBot is an open-source AI trading agent designed for personal, self-hosted deployment. It integrates with Anthropic's Claude as its primary language model and exposes 119+ skills across trading, analysis, automation, and infrastructure management. The system supports 21 messaging platforms — from Telegram and Discord to Signal, Nostr, and a built-in WebChat interface — allowing users to interact with their trading infrastructure through familiar channels.

The project's architecture reflects a deliberate choice to prioritize breadth of market access over narrow specialization. Users can trade on 10 prediction market platforms (Polymarket, Kalshi, Betfair, Smarkets, Drift, Manifold, Metaculus, PredictIt, Opinion.xyz, Predict.fun), 7 perpetual futures exchanges (Binance, Bybit, Hyperliquid, MEXC, Drift, Percolator, Lighter), and multiple DeFi protocols on Solana and EVM chains. This universality comes with trade-offs: the codebase is substantial, and effective use requires understanding which components are active in a given deployment.

The technical foundation is Node.js 22+ with TypeScript 5.3. Data persistence uses SQLite for local configuration and WebChat history, LanceDB for semantic memory and embeddings, and PostgreSQL^{↗ Bright Coding Blog} for trade analytics and backtesting. The system includes a risk management layer with VaR/CVaR calculations, circuit breakers, and Kelly criterion position sizing — features typically found in institutional trading systems rather than open-source projects.

CloddsBot's relevance stems from timing: prediction markets have grown substantially in visibility, decentralized exchanges continue capturing volume from centralized counterparts, and AI agents are moving from demonstration to practical tooling. The project attempts to bridge all three trends in a single deployable package.

Key Features

Multi-Platform Market Access. The terminal connects to 10 prediction markets, 7 futures exchanges, 9 Solana DeFi protocols, and 5 EVM chains. This includes specialized integrations like Percolator for Solana-native perpetual futures and Meteora Dynamic Bonding Curves for token launches. Each integration exposes platform-specific features: Polymarket's round-based crypto markets with 5-minute to daily timeframes, Hyperliquid's 50x leverage without KYC, and Jupiter's smart routing with Jito MEV protection.

Autonomous Strategy Execution. The system bundles 118+ trading strategies spanning momentum, mean reversion, arbitrage detection, and market making. Strategies can operate with full automation or require human approval per trade. The arbitrage module, based on arXiv:2508.03474, detects internal, cross-platform, and combinatorial opportunities with semantic matching and liquidity scoring. All strategies default to dry-run mode, requiring explicit activation for live trading.

Risk Management Infrastructure. A unified risk engine provides circuit breakers, volatility regime detection, stress testing, daily loss limits, and a kill switch. Position sizing uses Kelly criterion with configurable fractions. The trade ledger maintains SHA-256 hashed audit trails with optional on-chain anchoring to Solana, Polygon, or Base for immutable record-keeping.

Natural Language Interface. Users interact through conversational commands across 21 channels. The built-in WebChat provides a Claude-style sidebar with conversation management, artifact extraction, unlimited scrollback with context compacting, and persistent sessions. The REPL mode (clodds repl) enables direct command execution for scripting and debugging.

Agent-to-Agent Infrastructure. Beyond personal trading, CloddsBot includes an agent forum for market discussion, an agent marketplace with USDC escrow for strategy sales, and an x402 protocol implementation for machine-to-machine payments on Base and Solana. These features position the project within emerging agent commerce protocols.

MCP Server Compatibility. All 119 skills expose as Model Context Protocol tools for integration with Claude Desktop and Claude Code, enabling the terminal's capabilities within Anthropic's official tooling ecosystem.

Use Cases

Prediction Market Arbitrage. A trader monitors Polymarket and Kalshi simultaneously for pricing divergences on correlated events. CloddsBot's semantic matching identifies equivalent contracts across platforms, calculates fees and settlement timing, and sizes positions using Kelly criterion. The arbitrage module runs continuously, alerting via Telegram when opportunities exceed configured thresholds.

Automated Crypto Futures Management. A developer runs CloddsBot on a VPS with API keys for Binance and Hyperliquid. The system executes momentum strategies on BTC and ETH perpetuals, manages cross/isolated margin allocation, and triggers TP/SL orders. Funding rate tracking across exchanges enables position migration to capture funding payments. The risk engine pauses all trading if daily drawdown exceeds configured limits.

Solana DeFi Operations. A trader uses natural language commands to swap via Jupiter, provide liquidity on Raydium, and launch tokens through Meteora's bonding curves. The GoPlus-powered security audit checks contracts for honeypot patterns and rug-pull indicators before execution. Jito bundles protect against MEV extraction on sensitive transactions.

Bittensor Subnet Mining. A participant configures CloddsBot to mine TAO on Bittensor subnets, particularly Chutes (SN64) for GPU compute. The system manages wallet operations, registration, and earnings tracking with SQLite persistence. Mining status integrates into the same conversational interface used for trading.

Agent Service Monetization. A developer packages a custom trading strategy and lists it on the CloddsBot marketplace. Other agents purchase access with USDC escrow on Solana, with automatic delivery upon payment verification. The compute API enables pay-per-use access to LLM inference, code execution, and data services without API key management.

Installation & Setup

The fastest path to running CloddsBot uses the published npm package:

npm install -g clodds --loglevel=error
clodds onboard

The onboard command launches an interactive wizard that configures API credentials, selects messaging channels, and initializes the local database. After completion, the WebChat interface becomes available at http://localhost:18789/webchat.

For development or customization, clone and build from source:

git clone https://github.com/alsk1992/CloddsBot.git && cd CloddsBot
npm install && cp .env.example .env
# Add ANTHROPIC_API_KEY to .env
npm run build && npm start

The .env file requires at minimum an ANTHROPIC_API_KEY for Claude integration. Additional variables enable specific integrations:

# Required
ANTHROPIC_API_KEY=sk-ant-...

# Channels (pick any)
TELEGRAM_BOT_TOKEN=...
DISCORD_BOT_TOKEN=...

# Trading
POLYMARKET_API_KEY=...
SOLANA_PRIVATE_KEY=...

Data stores automatically in ~/.clodds/ as SQLite databases. The Docker^{↗ Bright Coding Blog} path provides containerized deployment:

docker compose up --build

Post-installation, verify functionality with the diagnostic command:

clodds doctor

This checks Node.js version, dependency integrity, credential validity for configured services, and database connectivity. The clodds secure command applies additional hardening for production deployments.

Real Code Examples

The README provides concrete command patterns for trading operations. These examples demonstrate actual syntax without modification:

Perpetual Futures Trading:

/futures long BTCUSDT 0.1 10x
/futures sl BTCUSDT 95000

The first command opens a 0.1 BTC long position with 10x leverage on the configured futures exchange. The second sets a stop-loss at $95,000. CloddsBot tracks this position in its database, monitors for liquidation proximity, and can apply the risk engine's circuit breaker if market conditions shift violently.

Percolator On-Chain Perpetuals (Solana):

/percolator status          # Oracle price, OI, funding, spread
/percolator positions       # Your open positions
/percolator long 100        # Open $100 long
/percolator short 50        # Open $50 short
/percolator deposit 500     # Deposit USDC collateral
/percolator withdraw 100    # Withdraw USDC collateral

Percolator represents Anatoly Yakovenko's protocol for fully on-chain perpetual futures. The status command polls oracle feeds and orderbook state through slab parsing. Position management requires prior USDC collateral deposit. Configuration enables through environment variables: PERCOLATOR_ENABLED=true PERCOLATOR_SLAB=<pubkey> PERCOLATOR_ORACLE=<pubkey>.

Bittensor Mining Operations:

clodds bittensor setup           # Interactive wizard: Python↗ Bright Coding Blog, btcli, wallet, config
clodds bittensor status          # Check mining status
clodds bittensor wallet balance  # Check TAO balance
clodds bittensor register 64     # Register on Chutes (SN64)

The setup wizard installs Python dependencies, configures btcli, and initializes wallet management through @polkadot/api. Registration on subnet 64 (Chutes) enables GPU compute mining. Chat-based equivalents (/tao status, /tao earnings daily) provide the same functionality through conversational interfaces.

Trade Ledger Verification:

clodds ledger stats              # Show decision statistics
clodds ledger calibration        # Confidence vs accuracy analysis
clodds ledger verify <id>        # Verify record integrity
clodds ledger anchor <id>        # Anchor hash to Solana

The ledger maintains tamper-evident records of AI trading decisions. The calibration command analyzes whether the model's confidence scores correlate with actual outcomes — critical for improving strategy selection. On-chain anchoring provides immutable proof of decision timing for regulatory or audit purposes.

Advanced Usage & Best Practices

Selective Skill Loading. CloddsBot lazy-loads its 119 skills on first use, preventing missing dependency crashes. For production deployments, pre-load required skills during initialization to avoid latency on first commands. Run /skills in chat to verify loaded status.

Channel Isolation. While 21 messaging platforms are supported, running multiple channels simultaneously increases attack surface. For security-sensitive deployments, restrict to a single channel with strong authentication (Signal or Matrix with device verification) and disable unused integrations entirely.

Risk Configuration Before Live Trading. The system defaults to dry-run mode for arbitrage and strategy execution. Before enabling live trading, configure: daily loss limits as percentage of portfolio, maximum position sizes per market, correlation limits across strategies, and the kill switch contact method. The clodds config set ledger.enabled true command enables full audit trails.

Database Scaling. SQLite suffices for individual use, but the PostgreSQL backend becomes necessary for serious backtesting and analytics. The LanceDB semantic memory grows with conversation history; monitor disk usage and configure context compacting thresholds for long-running instances.

MCP Integration. For developers already using Claude Desktop or Claude Code, the MCP server (clodds mcp / clodds mcp install) exposes all trading capabilities without maintaining a separate terminal window. This integration follows Anthropic's protocol specification and receives updates with skill additions.

Comparison with Alternatives

CloddsBot's distinctive position combines AI-driven natural language interaction with genuine self-hosting and prediction market access. Hummingbot offers deeper crypto-native features but lacks the conversational interface and polymarket integration. Direct exchange APIs provide lower latency for high-frequency strategies but require substantially more development effort for equivalent functionality. The choice depends on whether the priority is execution speed (direct API), strategy sophistication (Hummingbot), or operational flexibility with AI assistance (CloddsBot).

FAQ

What are the minimum system requirements? Node.js 22+, approximately 2GB RAM for basic operation, increasing with active strategies and database size. SSD storage recommended for SQLite performance.

Is live trading enabled by default? No. Arbitrage and strategy execution default to dry-run mode. Explicit configuration and API key provisioning are required for live execution.

Which LLM providers work besides Claude? The system supports 8 providers: Claude (primary), GPT-4, Gemini, Groq, Together, Fireworks, AWS^{↗ Bright Coding Blog} Bedrock, and Ollama for local models.

How is credential security handled? AES-256-GCM encryption for stored credentials, with sandboxed execution requiring approval for shell commands. No credentials transmit to CloddsBot infrastructure.

Can I run this commercially? Yes. The MIT License permits commercial use, modification, and distribution. The compute API and marketplace include platform fees (5% for marketplace transactions).

What happens if the AI makes a bad trade? The risk engine provides circuit breakers and loss limits, but ultimate responsibility rests with the operator. The trade ledger maintains full audit trails for post-hoc analysis.

Is there cloud hosting available? No official cloud offering. Self-hosting is required, though Docker and systemd configurations are documented for VPS deployment.

Conclusion

alsk1992/CloddsBot represents a ambitious attempt to unify AI-driven natural language interaction with serious trading infrastructure across prediction markets, cryptocurrency, and decentralized finance. The 505-star project delivers genuine breadth — 1000+ markets, 119 skills, 21 messaging platforms — while maintaining MIT-licensed openness and self-hosted control.

This tool best serves technically capable traders who want AI assistance without surrendering custody or operational control. The learning curve is real: effective use requires understanding which integrations to activate, how to configure risk limits, and when the AI's reasoning needs human verification. For developers already comfortable with Node.js deployments and API key management, CloddsBot offers a foundation that would take months to replicate independently.

The project continues to evolve, with the agent marketplace, compute API, and x402 payment protocol pointing toward broader agent-commerce applications beyond personal trading. For those aligned with its self-hosted, open-source philosophy, explore the repository directly and evaluate whether its specific market coverage matches your trading requirements.

For related coverage of self-hosted AI infrastructure, see our analysis of [INTERNAL_LINK: MCP protocol tools for developer workflows].