🤓 Latest Submissions
AMD Router: Local-First Token-Efficient Routing
AMD Router treats remote tokens as the scarce resource they are. Track 1 imposes an 80% accuracy gate — miss 16 of 19 tasks and you don't appear on the leaderboard at all, with token count only breaking ties among teams that already pass. So the objective isn't "minimize remote calls," it's "clear the gate, then minimize remote calls." Every task first goes to a local Qwen2.5-0.5B model running CPU-only inside the container — free tokens. A heuristic classifier assigns a task type and difficulty by regex, with no model call. The local answer's confidence is measured from token logprobs and compared against a per-task-type threshold: math demands 0.80, classification 0.55, because a wrong number is worse than a clumsy label. Only when local confidence falls short does the router escalate to a Fireworks model, and it selects the cheapest capable model from ALLOWED_MODELS at runtime. On a 19-task evaluation mirroring the harness categories, the hybrid scores identically to always-remote (15/15 auto-graded) while spending 3009 remote tokens versus 4526 — a 34% reduction. Six of nineteen tasks never make a network call. The design is measurement-driven. The original policy force-escalated all code tasks as "locally unreliable"; measurement showed the 0.5B model passes them at 0.90 confidence, and removing that assumption saved 691 tokens at zero accuracy cost. The router also survives real-world failure: three of the five allowed Gemma models are undeployed and return 404, so it marks them dead and walks the list rather than collapsing to the fallback model. Reasoning models that return only a reasoning trace, and small models that recite training-data system prompts, are both handled explicitly. The router is the product; base models are interchangeable. Public image: ghcr.io/makabeez/amd-router:v0.12
12 Jul 2026
TradeGuard AI
TradeGuard AI is an autonomous multi-agent system that audits trading strategies for risk exposure and FTMO prop firm compliance. Paste a strategy or EA config, get a full professional audit in 50 seconds. THE PROBLEM FTMO and similar prop trading challenges have a 90%+ failure rate. Most traders fail not because their edge is bad, but because they violate risk rules: daily loss limits, max drawdown caps, leverage exposure. Manual self-audit is full of blind spots. A trading coach costs hundreds. TradeGuard delivers that audit in 50 seconds, free, on AMD compute. THE ARCHITECTURE Built as a true LangGraph multi-agent pipeline — not a single-prompt chatbot. Four specialized LLM nodes pass structured state: 1. Parser — extracts trading params from natural language 2. Risk Analyzer — scores position sizing, drawdown, leverage, R:R 3. FTMO Compliance — validates against real prop firm rules (5% daily loss, 10% max DD) 4. Recommendations — generates prioritized actionable fixes A final assembler combines outputs into a structured report with risk score, compliance score, FTMO readiness, and ranked corrections. THE STACK Qwen 2.5 72B Instruct running on AMD Instinct MI300X (192GB VRAM) via ROCm 7.2 + vLLM 0.17.1. FastAPI backend, React+Vite frontend on Vercel, Cloudflare Tunnel bridging the AMD VM. Full pipeline runs in ~48 seconds end-to-end. BUSINESS VALUE Prop trading is a $10B+ industry in annual challenge fees. Even a freemium SaaS capturing a fraction (free audits, paid backtesting) is viable. The same agent architecture extends to compliance-driven domains: regulatory checks, code audits, contract review. ORIGINALITY No existing tool combines structured multi-agent reasoning with prop-firm-specific compliance rules in a clean, demo-ready interface. Built fully on AMD Developer Cloud during the hackathon. MIT licensed. Live: tradeguard-ai.vercel.app Code: github.com/Makabeez/tradeguard-ai
10 May 2026
AlphaDrip
AlphaDrip is an x402-monetized trading signal API where every call is a real on-chain USDC settlement on Arc Testnet. No subscriptions, no middlemen, no batching abstractions — just direct per-call payment at $0.003 USDC, settled in sub-second time via EIP-3009 transferWithAuthorization on Arc's USDC contract. The cascade engine connects to Hyperliquid's public WebSocket trade feed, evaluates BTC trade volume against a rolling baseline, and fires liquidation cascade signals when volume spikes >2.5× with directional bias >70%. Each signal is exposed via a paywalled HTTP endpoint that returns 402 Payment Required, advertising Arc Testnet USDC as the accepted asset. Consumers sign an EIP-3009 authorization off-chain (no Gateway deposit required), the producer relays it on-chain as a real USDC transfer, the signal payload is returned with the Arc transaction hash. Every paid call is independently verifiable on the Arc Block Explorer. A recorded 326-second demo session produced 163 paid on-chain settlements, 263 cascade signals fired, $0.483 USDC settled by the consumer, $0.489 USDC earned by the producer (the difference being the producer's gas reimbursement of ~$0.0019 per tx). Net producer margin after gas: 36% — economically viable per-call pricing that's impossible on any other L1. The original architecture targeted Circle Gateway's batched-x402 facilitator. We discovered that endpoint returns "unsupported_network" for Arc Testnet (eip155:5042002) — a real bug we documented and submitted as Circle product feedback. Per the Arc team's explicit Discord guidance ("you can build x402-style logic on Arc, you'll need to implement the logic yourself"), we pivoted to direct EIP-3009 settlement, which works perfectly because Arc's USDC at 0x3600... is a fully EIP-3009-compliant Circle FiatTokenV2. Live demo: https://alphadrip.baserep.xyz Source: https://github.com/Makabeez/alphadrip
26 Apr 2026
