I've spent months building an autonomous trading platform. Today, I'm open-sourcing it.
Trading Buddy isn't just another trading bot. It's a framework for building your own algorithmic trading system using a multi-agent architecture. And while it's built for developers, I want to explain the thinking behind it in a way that makes sense to everyone.
The Idea: A Team, Not a Bot
Most trading bots are single systems that try to do everything. They analyze data, make decisions, manage risk, and execute trades - all in one monolithic application. That works for simple strategies, but it breaks down quickly.
Think about how a professional trading firm operates. They don't have one person doing everything. They have:
- A researcher who reads news and analyzes companies
- A risk manager who makes sure nobody bets the farm on a single trade
- An executor who actually places the orders
- A watchdog who makes sure everyone's doing their job
That's exactly what Trading Buddy is. It's not one monolithic trading bot - it's a team of specialized AI agents that work together, each doing what they're best at.
The beautiful part? They don't trust each other blindly. The executor can't place a trade unless the risk manager approves it. The risk manager won't approve it unless the researcher has done their homework. It's checks and balances, like a well-run company.
The Architecture
I like to think of Trading Buddy like a restaurant kitchen:
THE KITCHEN
[Chat Agent] [Analysis Engine] [Risk Manager]
"The Waiter" "The Head Chef" "Health Inspector"
Takes orders, Prepares the meal, Makes sure
talks to analyzes ingredients nothing's unsafe
customers
| | |
+---------------------+---------------------+
|
[Trade Executor]
"The Expeditor"
Actually sends the
food out the door
|
+---------------+---------------+
| | |
[Polygon] [Finnhub] [Yahoo]
"Supplier 1" "Supplier 2" "Backup"
Every order (trade request) goes through this pipeline. Nobody skips steps. The data suppliers provide market information, the analysis engine interprets it, the risk manager validates it, and only then does the executor take action.
Meet the Agents
The Chat Agent
This is how you interact with the system. You can say things like "What do you think about Apple stock?" or "Buy 10 shares of TSLA" and it understands your intent. It's the waiter - it takes your order and communicates it to the kitchen.
The Analysis Engine
This agent crunches numbers. Technical indicators, fundamental analysis, sentiment from news articles. It doesn't make trading decisions - it provides the data that informs them. Think of it as the head chef prepping ingredients.
The Risk Manager
This is the most important agent. Before any trade executes, the risk manager asks hard questions:
- Is this position too big? (5% max per position)
- Are we too concentrated in one sector? (20% max per sector)
- Have we hit our daily loss limit? (3% max daily loss)
- Is the conviction score high enough? (60% minimum)
If any of these checks fail, the trade is rejected. Period. The risk manager is paranoid by design - it's easier to miss a good trade than to recover from a catastrophic loss.
The Trade Executor
Only after everything else approves does this agent act. It sends orders to Alpaca and monitors execution. For large orders, it can use algorithms like TWAP (Time-Weighted Average Price) to minimize market impact.
The Watchdog
This agent monitors all the others. If any agent becomes unresponsive, it restarts them and alerts you. It's the safety net for the safety net.
Risk-First Design
Every feature in Trading Buddy was designed around one question: How could this fail?
Never Trust One Source
Trading Buddy doesn't just call one API for market data - it calls several and compares them. If Polygon says Apple is $185 but Finnhub says $183, something's wrong. By cross-checking, we catch problems before they become expensive mistakes.
Circuit Breakers
If a data provider starts failing, Trading Buddy doesn't keep hammering it. After three failures, it "opens the circuit" and stops calling that provider for 60 seconds. Better to give up quickly and try a backup than to create cascading failures.
Fail Safe, Not Fail Fast
When the risk manager is offline, all trading stops. When data is stale (more than 5 seconds old), the quote refreshes before trading. When a trade fails mid-execution, idempotency keys prevent duplicate orders.
These aren't nice-to-haves - they're essential when real money is on the line.
Lessons Learned
Building this system taught me principles that apply far beyond trading:
1. Don't Trust Any Single Data Source
APIs lie. They go down. They return stale data. Always verify, validate, cross-check.
2. Fail Safely
When things go wrong (and they will), minimize damage. A silent failure that looks like success is the worst kind of bug.
3. Make the Dangerous Path Hard
Risk checks aren't optional features - they're core architecture. If you can bypass them easily, someone eventually will.
4. Optimize for Reading, Not Writing
Code is written once but read hundreds of times. Choose clarity over cleverness every time.
5. Build for Change
Markets evolve. Regulations change. APIs get deprecated. Good code anticipates this with loose coupling and clear interfaces.
Get Started
Trading Buddy is completely open source and free to use. Here's how to start:
Quick start:
# Clone the repo
git clone https://github.com/heyhaigh/trading-buddy.git
cd trading-buddy
# Run automated setup
make setup
# Add your API keys to .env (at minimum: Alpaca + one data provider)
nano .env
# Start the application
make run
# Open http://localhost:8000 in your browserYou'll need at least an Alpaca account (free, with paper trading) and one market data provider like Finnhub (also free tier available).
What's Included
- Full Python backend with all agents
- TypeScript trading agent for advanced use cases
- Web UI for monitoring and control
- Comprehensive documentation
- Example code for custom indicators and strategies
What You Can Build
- Your own trading strategies
- Custom technical indicators
- New data provider integrations
- Specialized agents for different market conditions
The framework is designed to be extended. The documentation includes guides for adding custom agents, indicators, and data providers.
Final Thoughts
Trading Buddy isn't just a trading bot - it's a case study in building robust, maintainable software that handles real money. The lessons here apply far beyond finance: verify your data sources, fail safely, make dangerous operations hard, and always optimize for the next person who reads your code.
If you build something interesting with it, I'd love to hear about it. Star the repo, fork it, make it your own.
And most importantly: be careful out there. Markets are unforgiving, and no software can eliminate risk. But with the right architecture, you can at least manage it intelligently.