| --- |
| title: MarketMind |
| emoji: ⚡ |
| colorFrom: blue |
| colorTo: purple |
| sdk: gradio |
| app_file: app.py |
| pinned: false |
| python_version: 3.11 |
| --- |
| |
| # MarketMind |
|
|
| **Multi-Agent Financial Market Simulation** |
| *AMD Developer Hackathon | Track 1: AI Agents & Agentic Workflows | May 2026* |
|
|
| A multi-agent financial market simulation where competing LLM agents with distinct trading charters interact inside a continuous double auction (limit order book). The system does not predict markets — it *is* a market. |
|
|
| **The research question:** |
| > When a financial market is populated entirely by competing LLM agents with heterogeneous beliefs and strategies, does it self-organize toward efficiency — or does it bubble, crash, or fragment? |
|
|
| --- |
|
|
| ## 🏗 Architecture |
|
|
| ``` |
| ┌─────────────────────────────────────────────────────┐ |
| │ MarketMind System │ |
| │ │ |
| │ ┌──────────────┐ ┌──────────────────────────┐ │ |
| │ │ Order Book │◄───│ Agent Dispatcher │ │ |
| │ │ (CDA Engine)│ │ (round-robin tick loop) │ │ |
| │ └──────┬───────┘ └──────────────────────────┘ │ |
| │ │ ▲ │ |
| │ │ market state │ orders │ |
| │ ▼ │ │ |
| │ ┌──────────────────────────────────────────────┐ │ |
| │ │ Agent Pool (5 agents) │ │ |
| │ │ │ │ |
| │ │ [Momentum] [MeanRev] [Fundamental] │ │ |
| │ │ [MarketMaker] [NoiseTrader] │ │ |
| │ │ │ │ |
| │ │ Each agent = LLM prompt + charter config │ │ |
| │ └──────────────────────────────────────────────┘ │ |
| │ │ │ |
| │ │ inference requests │ |
| │ ▼ │ |
| │ ┌──────────────────────────────────────────────┐ │ |
| │ │ vLLM Server (AMD MI300X, ROCm) │ │ |
| │ │ Qwen2.5-7B-Instruct │ │ |
| │ │ Concurrent batched requests │ │ |
| │ └──────────────────────────────────────────────┘ │ |
| │ │ │ |
| │ ▼ │ |
| │ ┌──────────────────────────────────────────────┐ │ |
| │ │ Metrics Engine + Dashboard │ │ |
| │ │ Price series / spread / volatility / │ │ |
| │ │ crash detector / regime classifier │ │ |
| │ └──────────────────────────────────────────────┘ │ |
| └─────────────────────────────────────────────────────┘ |
| ``` |
|
|
| --- |
|
|
| ## 🔬 Experiments & Findings |
|
|
| We ran three core experiments to observe emergent market behavior based solely on varying the agent composition. All experiments ran for 200 ticks. |
|
|
| ### Experiment A — Baseline (Equal Mix) |
| *2 Momentum, 1 Mean-Reversion, 1 Fundamental, 1 Market Maker, 1 Noise* |
| - **Hypothesis:** Prices stay near fair value. Market is relatively efficient. |
| - **Result:** Validated. The market stayed largely efficient, oscillating tightly around the Fundamental agent's anchor price (100.0). The Fundamental agent emerged as the most profitable, while Momentum agents lost capital trading against noise. |
|
|
| ### Experiment B — Momentum Overload (Bubble Test) |
| *4 Momentum, 1 Market Maker, 1 Noise (No Fundamental Anchor)* |
| - **Hypothesis:** Price trends away from fair value → bubble formation. |
| - **Result:** Validated. Without a fundamental anchor to fade the moves, momentum agents bought into each other's flow. Price skyrocketed from 100 to over 200 in 200 ticks, creating a massive, unstable bubble. |
|
|
| ### Experiment C — No Market Maker (Liquidity Test) |
| *2 Momentum, 1 Mean-Reversion, 1 Fundamental, 1 Noise (No Market Maker)* |
| - **Hypothesis:** Spreads widen dramatically, liquidity fragmentation, possible crash. |
| - **Result:** Validated. Without a dedicated liquidity provider continuously quoting both sides, the order book rapidly dried up. The spread widened dramatically, and trade volume collapsed compared to the baseline. |
|
|
| --- |
|
|
| ## 🚀 AMD MI300X Hardware Advantage & Setup |
|
|
| MarketMind utilizes **vLLM on ROCm** on the AMD Developer Cloud. By dispatching 5–6 agents simultaneously each tick using `asyncio.gather`, we max out concurrent inference streams. |
|
|
| The **MI300X's massive 192GB HBM3 memory** means we never page-out the model weights between agent calls, maintaining exceptionally low latency despite heavy parallel throughput. |
|
|
| ### Local Setup Instructions (AMD Developer Cloud) |
|
|
| ```bash |
| # 1. Provision AMD MI300X Instance and install vLLM |
| pip install vllm |
| |
| # 2. Launch vLLM Inference Server |
| python -m vllm.entrypoints.openai.api_server \ |
| --model Qwen/Qwen2.5-7B-Instruct \ |
| --dtype float16 \ |
| --max-model-len 2048 \ |
| --tensor-parallel-size 1 \ |
| --port 8000 |
| ``` |
|
|
| ### Benchmarking |
| We provide a standalone benchmark script to measure the MI300X's concurrency speedup: |
| ```bash |
| python experiments/benchmark_vllm.py --url http://localhost:8000/v1 |
| ``` |
| *(Insert your benchmark latency and throughput results here before submission!)* |
|
|
| --- |
|
|
| ## 🌐 Hugging Face Spaces Deployment |
|
|
| As part of the AMD Developer Hackathon requirements, **MarketMind is fully optimized for 1-click deployment to Hugging Face Spaces**. |
|
|
| ### Premium Glassmorphic UI |
| The root `app.py` features a stunning, custom-styled Streamlit interface tailored specifically for the HF Hub. It uses transparent Plotly charts, dynamic regime badging, and a premium dark-themed gradient background. |
|
|
| ### Live Serverless HF API Integration |
| Because HF Spaces typically run on basic CPU tiers by default, the app contains an integrated **Live Hugging Face API Mode**. Users can: |
| 1. Paste their Hugging Face API Token directly into the dashboard. |
| 2. The UI natively bridges the Simulation Engine to the `api-inference.huggingface.co/v1/` endpoint using the OpenAI SDK format. |
| 3. Live models (like `meta-llama/Llama-3.2-3B-Instruct`) will directly drive the financial agents over the API without requiring a dedicated GPU inside the space itself. |
|
|
| **To deploy your own Space:** |
| 1. Create a new Streamlit Space on Hugging Face. |
| 2. Push this repository's root directly to the space. |
| 3. Streamlit will automatically find `app.py` and `requirements.txt` and launch the platform. |
|
|
| --- |
|
|
| ## 💻 Local Quickstart |
|
|
| ### Prerequisites |
| ```bash |
| pip install -r requirements.txt |
| ``` |
|
|
| ### Run Simulation Offline (No LLM Required) |
| You can run the simulation locally using the deterministic offline heuristic mode. |
| ```bash |
| python run_simulation.py --ticks 200 |
| ``` |
|
|
| ### Run Streamlit Dashboard |
| Visualize the live simulation playback and change agent parameters in real-time. |
| ```bash |
| streamlit run dashboard/app.py |
| ``` |
|
|
| --- |
| *Built for the AMD Developer Hackathon | Track 1: AI Agents & Agentic Workflows* |
|
|
