Analysis updated 2026-05-18
Study how a code-based verifier can filter AI-generated trading signals to reduce false positives from fast, low-accuracy models.
Run the v1 demo to see 34 agents generate a trading opinion in under 7 seconds using Cerebras inference speed.
Fork the architecture as a starting point for building a multi-agent pipeline where AI generates scored opinions and deterministic code makes final decisions.
| aniketshahane/gemma-4-cerebras-trading-system | a-bissell/unleash-lite | abhiinnovates/whatsapp-hr-assistant | |
|---|---|---|---|
| Stars | 1 | 1 | 1 |
| Language | Python | Python | Python |
| Setup difficulty | hard | hard | hard |
| Complexity | 5/5 | 4/5 | 3/5 |
| Audience | researcher | researcher | developer |
Figures from each repo's GitHub metadata at analysis time.
Requires a Cerebras API key and Alpaca account, the current version is a paper-trading prototype rebuilt from a hackathon demo.
This is a research demo built for a 24-hour hackathon, not a production trading system. It explores a specific question: can a swarm of fast, low-accuracy AI models make better trading decisions than one slow, high-accuracy model, if a reliable code-based verifier filters out the bad outputs? The core idea is that the Gemma 4 model running on Cerebras hardware is extremely fast (around 1,850 tokens per second) but not very accurate on its own. Rather than making one model smarter, the system runs dozens of narrow sub-agents in parallel: some read pre-computed technical indicators like RSI and MACD, others are vision agents reading candlestick chart images. Each agent outputs a single score from 0 to 100 plus a one-line reason. No agent sees raw price data or does arithmetic, all data fetching and indicator calculation is done by deterministic code. Those raw opinions pass through a layered verifier, also mostly deterministic code, that checks schema validity, whether scores are consistent with underlying features, whether the agents agree with each other, and whether past backtest grades support a trade. After the verifier, a risk-and-compliance layer enforces hard limits like stop-loss amounts, position sizing, and drawdown caps. Only after all stages does the system place an order, via the Alpaca broker API in paper-trading mode by default. The model never places orders directly. A key design choice is that doing nothing (called ABSTAIN) is a valid output. If the swarm disagrees, the verifier is not satisfied, or the risk layer vetoes the trade, the system sits out. The README is unusually candid: it includes a self-audit of the first version of this demo, which the authors found was a confident generator with no real verifier, using model knowledge instead of live data, and producing unanimous buy signals that were artifacts rather than insights. The current work is rebuilding around a genuine verifier, point-in-time data, and real execution. This is not financial advice. Paper trades only.
A hackathon research demo that runs a swarm of fast Gemma AI agents to generate trading signals, then filters them through a code-based verifier before placing paper trades via Alpaca.
Mainly Python. The stack also includes Python, Gemma 4, Cerebras.
No license information was found in the README.
Setup difficulty is rated hard, with roughly 1h+ to a first successful run.
Mainly researcher.
This repo across BitVibe Labs
Verify against the repo before relying on details.