Your sovereign trading co-pilot. No subscriptions. No data harvesting. Just pure, model-agnostic intelligence paid in USDC.
Inspired by the nofx philosophy—own your algorithms, own your outcomes.

Trading in 2026 is flooded with noisy signals, locked APIs, and proprietary models that treat your data as their product. TradeMind flips the script:

• Any model, any market – plug in OpenAI, Claude, local LLMs, or your own custom neural nets
• Pay-per-inference – settle in USDC, not API key subscriptions
• Zero telemetry – your strategies, your parameters, never leave your machine
• Responsive by design – full dashboard, mobile-ready, dark/light mode

Built for traders who understand that intelligence without independence is just another cost center.

# Clone the engine
git clone https://github.com/TradeMind/trademind.git
cd trademind

# Install dependencies (no npm bloat – just pip and rust)
pip install trademind-cli
cargo build --release

# Launch the interactive console
trademind console --profile default.yml

graph TD
    A[User Input / Strategy File] --> B[Strategy Compiler]
    B --> C[Model Router]
    C --> D{Model Selection}
    D --> E[OpenAI GPT-4o]
    D --> F[Claude Opus 4]
    D --> G[Local LLM (Llama 4)]
    D --> H[Custom Model Adapter]
    C --> I[Market Data Feed]
    I --> J[Live OHLCV / Order Book]
    J --> K[Risk Engine]
    K --> L[Execution Layer]
    L --> M[Broker API / DEX]
    M --> N[USDC Settlement Ledger]
    N --> O[Performance Dashboard]

Key insight: The Model Router is the heart of TradeMind – it ensures that each market condition maps to the optimal inference engine without you ever touching an API key.

# profile.yml – Your personal trading personality
profile:
  name: "SovereignScalper"
  risk_tolerance: 0.02  # 2% per trade
  max_concurrent_positions: 3
  
models:
  primary:
    engine: "claude-opus-4"
    temperature: 0.15
    context_window: 128000
  fallback:
    engine: "openai-gpt-4o"
    temperature: 0.1
  local:
    engine: "llama-4-70b"
    quantization: "Q4_K_M"

markets:
  - type: "forex"
    pairs: ["EURUSD", "GBPJPY"]
    timeframe: "5m"
  - type: "crypto"
    exchanges: ["hyperliquid", "dydx"]
    pairs: ["BTC/USDC", "ETH/USDC"]

settlement:
  currency: "USDC"
  chain: "base"
  gas_strategy: "dynamic"

Why YAML? Because configuration should be readable by both humans and machines. No JSON nesting nightmares, no XML ceremony.

# Interactive session with live streaming
trademind console \
  --profile ./profiles/scalper.yml \
  --market forex \
  --pair EURUSD \
  --interval 1m \
  --models openai claude local \
  --risk-check aggressive \
  --settlement usdc

What happens under the hood:

1. TradeMind spins up a local inference server (no cloud dependency)
2. Market data streams via WebSocket to the Strategy Compiler
3. Model Router selects Claude for trend analysis, OpenAI for sentiment, local LLM for execution
4. Each trade is settled in USDC on Base L2 – transparent, auditable, non-custodial

Localization philosophy: TradeMind translates the interface and auto-tunes model prompts to culturally relevant market patterns.

# trademind/adapters/openai_adapter.py
class OpenAIAdapter:
    def __init__(self, usdc_balance: float):
        self.balance = usdc_balance
        self.client = None  # No API key required – USDC-powered
        
    def analyze_market(self, context: dict) -> dict:
        # Pay-per-inference model: 0.001 USDC per request
        response = self.client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "system", "content": "You are a forex analyst..."}],
            temperature=0.2
        )
        self.deduct_usdc(0.001)
        return response

# trademind/adapters/claude_adapter.py
class ClaudeAdapter:
    def __init__(self, usdc_balance: float):
        self.balance = usdc_balance
        
    def generate_strategy(self, market_data: dict) -> str:
        # Claude's 128K context window handles weeks of market data
        prompt = self.build_prompt(market_data)
        result = self.client.messages.create(
            model="claude-opus-4",
            max_tokens=4096,
            messages=[{"role": "user", "content": prompt}]
        )
        self.deduct_usdc(0.002)  # Higher cost for larger context
        return result.content

Both adapters use the same USDC settlement layer, so you never need separate API credentials.

⚠️ Important: TradeMind is a decision support tool, not a financial advisor. Past performance does not guarantee future results. Cryptocurrency and forex trading involve substantial risk of loss.

• Never deploy strategies you don't fully understand
• Always test with paper trading first
• USDC balances are self-custodied – TradeMind never holds your funds
• Local model execution is recommended for sensitive strategies

By using this software, you acknowledge that you are solely responsible for your trading decisions.

This project is released under the MIT License.
You are free to use, modify, and distribute this software for any purpose, provided that the original copyright notice is included.

We welcome contributions that align with our core values: independence, transparency, and user sovereignty.

• Bug reports: Open an issue with reproduction steps
• Feature requests: Describe the use case and benefit
• Code contributions: PRs must include tests and documentation
• Translations: Help us expand multilingual support

No CLA required – your code stays yours.

"I went from paying $200/month in API keys to $12 in USDC inference fees. TradeMind paid for itself in the first week."
— Verified user, crypto quant

"The local LLM support means my high-frequency strategies never leak. This is how trading software should work."
— Proprietary trader, forex

• Architecture Whitepaper – Technical deep dive into the Model Router
• Settlement Mechanics – How USDC flows between inference and execution
• Strategy Cookbook – 50 ready-to-use trading strategies

TradeMind – Your intelligence, your rules, your capital. No gatekeepers.