Around two years ago, I was trying to solve a very simple problem.
I wanted to automate one trading strategy from Amibroker.
That’s it.
No startup idea.
No grand vision.
No platform.
Just one basic requirement:
When a signal is generated from my chart, the order should reach my broker automatically.
So I built a small Amibroker module.
It sent the signal to a local Python Flask server.
The Flask server formatted the request and sent it to the broker API.
It worked.
It was fast.
And at that time, it was enough.
Or so I thought.
From Script to Platform
Once the basic pipeline started working, I slowly began improving it.
First came a small UI.
Then login.
Then an order screen.
Then logs.
Then positions.
Then holdings.
Then contract downloads.
At some point, I realized:
This is no longer just a script.
This is starting to look like a platform.
That is when I gave it a name.
OpenAlgo
But the first version had one big limitation.
Everything was hardwired to one broker.
That was not scalable.
The Architecture Decision That Changed Everything
I rewrote the system around one core idea:
Support one broker at a time, but make it easy to switch brokers.
The architecture was built using an adapter pattern.
OpenAlgo would have:
- One common API
- One common symbol format
- One common WebSocket layer
- One common UI
- One common execution model
Only the broker adapter would change.
That decision made the platform scalable.
Today, OpenAlgo supports 30+ Indian brokers, including Zerodha.
The goal is not to promote any broker.
The goal is to give traders and developers a common execution layer.
Write your strategy once.
Connect it to OpenAlgo.
Change the broker without rewriting the strategy logic.
What OpenAlgo Actually Is
OpenAlgo is not a strategy-selling platform.
It does not provide ready-made profitable strategies.
It does not give tips.
It does not tell anyone what to buy or sell.
OpenAlgo is an open-source API platform for private algo trading.
Traders bring their own strategies.
Developers bring their own code.
OpenAlgo provides the infrastructure layer:
- Broker connectivity
- REST API
- WebSocket layer
- Order routing
- Strategy hosting
- Logs and observability
- Automation workflows
- Internal sandbox testing
- Execution control
Signals can come from many places:
- Amibroker
- TradingView
- ChartInk
- MetaTrader
- Python
- Node.js
- Go
- Rust
- Java
- C#
- Excel
- Google Sheets
- Webhooks
- Custom apps
The flow is simple:
Signal → OpenAlgo → Broker
OpenAlgo is released under the AGPL license.
You can self-host it.
You can inspect the source code.
You can modify it.
You can run your own private trading infrastructure.
That ownership is the main idea.
How It Started
OpenAlgo started around February 2024.
The first stable version, v1.0.0.0, was launched around April 2024.
Back then, it was small.
It had:
- A basic API layer
- A simple UI
- A few broker integrations
- Order placement logic
- Logs
- Basic execution controls
But once the foundation worked, the project kept expanding.
Every broker integration taught a new lesson.
Different brokers had different:
- Authentication flows
- Rate limits
- Order formats
- WebSocket behavior
- Error responses
- Failure modes
That is when I realized algo trading infrastructure is not just about placing orders.
It is about handling real-world complexity.
The Core Abstraction
Every broker has its own API design.
Every broker has its own WebSocket format.
Every broker has its own quirks.
OpenAlgo hides that complexity behind one common layer.
Your strategy sees:
- One REST API
- One WebSocket
- One symbol format
- One execution model
The broker-specific complexity stays inside the adapter.
This is the core abstraction OpenAlgo provides.
It is not just an API wrapper.
It is a broker abstraction and execution platform.
Then AI Changed Everything
This is where the story becomes different from a traditional software project.
From the beginning, OpenAlgo was built with AI-first development.
In April 2024, when the first version was launched, around 90% of the code was already AI-driven.
Only around 10% was manually written.
AI was not added later.
AI was part of the foundation.
By July 2024, almost 95% of the code was being written with AI assistance.
By October 2024, it was around 98%.
By January 2025, OpenAlgo reached its first 100% AI-written code milestone.
From that point onward, every commit, module, refactor, SDK, integration, tool, and documentation update has been built using AI agents under human supervision.
But this does not mean AI runs the project independently.
AI writes the code.
Humans make the decisions.
The important work is still human-led:
- Architecture
- Product direction
- Security review
- Testing
- Broker behavior
- Edge cases
- Real market validation
- Debugging production issues
My role changed from typing every line of code to directing the system.
I focus more on:
- What should be built
- How the architecture should work
- What should be rejected
- What needs more testing
- Where things can break
- How traders will actually use it
So OpenAlgo is not only an open-source trading platform.
It is also an experiment in AI-first software development.
A real trading infrastructure project where the code is written by AI agents, but the thinking, supervision, testing, and responsibility remain human.
The bottleneck is no longer typing code.
The bottleneck is thinking clearly.
The Project Grew Into a Mini FOSS Universe
OpenAlgo is no longer just one repository.
It has grown into a small FOSS ecosystem around Indian algo trading infrastructure.
There is the core platform.
Then there are SDKs:
- Python SDK
- Node.js SDK
- Java SDK
- .NET SDK
- Go SDK
- Rust SDK
There are integrations:
- Excel Add-in
- Amibroker Plugin
- PineTS integration
- Backtrader support
- Chrome Plugin
- OpenAlgo Mobile
- OpenAlgo Chart
- OpenAlgo Docs
There are also newer tools:
- OpenAlgo Flow
- Historify
- OpenQuest
- Fast Scalper
- MCP / AI Agents
- Indicator Skills
- Backtesting Skills
This has slowly become a modular collection of open-source tools, SDKs, libraries, and integrations around OpenAlgo.
Some tools are for traders.
Some are for developers.
Some are for automation.
Some are for research.
Some are for AI-assisted strategy development.
The idea is simple:
Build open infrastructure around algo trading instead of locking everything inside one closed system.
12+ Options Analytics Suite
One of the major recent additions is the Options & Strategy Analytics Suite.
It brings 12+ options-focused tools inside OpenAlgo.
This includes:
- Strategy Builder
- Strategy Portfolio
- Option Chain
- Option Greeks
- OI Tracker
- Max Pain
- Straddle Chart
- Straddle PnL
- Vol Surface
- GEX Dashboard
- IV Smile
- OI Profile
These tools are built for traders who want better visibility into options data.
They help analyze:
- Open interest
- Greeks
- Volatility
- Straddles
- IV curves
- Max pain
- Gamma exposure
- Options positioning
The important part is that these tools stream from the broker’s WebSocket feed.
No separate third-party data vendor.
No extra analytics subscription.
Just OpenAlgo using the data stream available through the user’s own broker connection.
OpenAlgo Flow
Another major addition is OpenAlgo Flow.
It is a no-code builder for trading automation.
Users can visually create workflows using nodes.
For example:
- Start at a scheduled time
- Check a condition
- Trigger an alert
- Place a multi-leg order
- Send a webhook
- Run logic
- Switch between analyze and live mode
- Deactivate a workflow
This is useful for traders who understand their strategy logic but do not want to write code for every step.
It is also useful for developers who want to prototype ideas quickly before converting them into code.
OpenAlgo Flow is not meant to replace coding.
It is meant to make automation easier.
For non-coders, it lowers the entry barrier.
For coders, it speeds up experimentation.
Internal Sandbox: Test First, Then Go Live
One important addition in OpenAlgo is the internal sandbox.
Before sending real orders, traders can test automated strategies and options strategies in a controlled environment.
The sandbox helps validate:
- Order flow
- Strategy logic
- Multi-leg execution
- Options workflows
- Entry conditions
- Exit conditions
- Automation rules
- Error handling
- Position behavior
The idea is simple:
Test first.
Review the behavior.
Then go live.
For algo trading, this is important.
A strategy should not move directly from code to live execution without being tested in a safer mode first.
The sandbox gives traders and developers a practical way to test automation before using it in production.
Security Became a Serious Focus
Once OpenAlgo became a self-hosted trading platform, security became very important.
A trading platform may handle:
- Broker sessions
- API keys
- Order flow
- Logs
- Live automation
- Strategy execution
So security cannot be treated casually.
OpenAlgo has been moving toward production-grade security defaults.
This includes:
- Secure headers
- CORS controls
- CSP policies
- CSRF protection
- Session management
- Rate limiting
- Audit trails
- Safer deployment practices
Self-hosted OpenAlgo apps have achieved an A grade on SecureHeaders.
OpenAlgo is also static IP compliant, which is useful for broker API environments and deployments where IP-based access control or whitelisting is required.
Self-hosted should not mean insecure.
Self-hosted should mean:
- Private
- Transparent
- Controllable
- Production-ready
Security is now one of the strongest focus areas of the project.
Local MCP and Skills for Agentic Trader Development
Another new direction is local MCP and skills support for agentic trader development.
This allows traders and developers to use AI agents locally with OpenAlgo-related tools.
The goal is not to let AI blindly trade.
The goal is to help humans build faster.
AI agents can help with:
- Strategy development
- Code generation
- Debugging
- Backtesting workflows
- Indicator logic
- Documentation
- Automation design
- OpenAlgo API usage
- Local tool integration
This becomes more useful when combined with skills.
There are:
- Indicator skills
- Backtesting skills
- Execution skills
This creates a more powerful development environment for traders who want to build their own systems with AI assistance.
OpenAlgo Custom GPT
OpenAlgo Custom GPT is another recent addition.
It is designed for both non-coders and coders.
If you are a trader with a strategy idea, you can explain it in simple words.
For example:
I want to sell an ATM straddle at 9:20, place stop loss rules, and exit at a fixed time.
The Custom GPT can help convert that idea into OpenAlgo-compatible code or workflow logic.
If you are a developer, it can help you:
- Generate cleaner OpenAlgo code
- Improve existing scripts
- Debug issues
- Understand API usage
- Speed up strategy development
- Convert rough ideas into working prototypes
This is useful because many traders understand their strategy but cannot code.
At the same time, many developers can code but want faster boilerplate and cleaner OpenAlgo integration.
OpenAlgo Custom GPT sits between both worlds.
It helps people build trading strategies faster.
OpenAlgo Is for Builders
The more I worked on this project, the more clear it became:
OpenAlgo is for builders.
It is for:
- Traders who want control
- Developers who prefer transparent systems
- Systematic traders who want their own infrastructure
- People who want to self-host
- People who want open-source tools
- People who want to connect their own strategies instead of buying black-box algos
OpenAlgo does not remove trading risk.
It does not magically make anyone profitable.
It provides infrastructure.
The trader still needs:
- A strategy
- Risk management
- Discipline
- Testing
- Monitoring
- Responsibility
OpenAlgo simply provides the private platform to build, test, monitor, and run that system.
Why Not Just Use Broker APIs Directly?
This is a common question.
And it is a fair one.
For a simple script, broker APIs are enough.
But once you build seriously, questions start appearing.
Where do I store logs?
How do I monitor failed orders?
How do I handle multiple strategies?
How do I switch brokers?
How do I manage WebSocket data?
How do I debug execution?
How do I test automation before going live?
How do I run strategies safely?
How do I control everything from one place?
That is when a broker SDK is not enough.
You need infrastructure.
That is where OpenAlgo fits.
Self-Hosted Means Ownership
OpenAlgo is self-hosted by design.
You can run it locally.
You can run it on your own server.
You can deploy it in Docker.
You can inspect the source.
You can modify the platform.
You can keep your trading logic private.
This is important.
In trading, your strategy is your intellectual property.
Your logs are private.
Your execution behavior is private.
Your automation system should be under your control.
That is why OpenAlgo is open source.
What OpenAlgo Is Not
Let me be very clear.
OpenAlgo is not:
- A tips platform
- A stock recommendation service
- A broker
- A PMS
- A black-box algo seller
- A ready-made profitable strategy provider
It does not promise returns.
OpenAlgo is a private algo trading platform.
You connect your own strategies.
You self-host your own infrastructure.
You test your automation.
You take responsibility for your own trading.
Where OpenAlgo Stands Today
OpenAlgo started as:
Let me automate one strategy.
Then it became a tool.
Then a platform.
Then an open-source ecosystem.
Today it includes:
- Unified trading API
- 30+ Indian broker support including Zerodha
- WebSocket abstraction
- Strategy hosting
- Logs and observability
- Internal sandbox for testing strategies
- Options analytics suite
- No-code flow builder
- SDKs in multiple languages
- Excel and Amibroker integrations
- Backtesting-related tools
- Mobile and web tools
- MCP and AI agent support
- OpenAlgo Custom GPT
- Static IP compliant deployment support
- A growing mini FOSS universe
All built with AI-first development.
All written by AI agents.
All human supervised.
All open source.
Final Thought
OpenAlgo began with a boring problem.
I wanted to automate one Amibroker strategy.
That small script slowly became a private, open-source algo trading platform for Indian traders.
The project is still evolving.
The direction is clear:
- Open infrastructure
- Self-hosted control
- Broker abstraction
- Better security
- Static IP compliant deployments
- No-code automation
- Internal sandbox testing
- Options analytics
- AI-assisted development
- A full FOSS ecosystem around trading automation
If you are a trader who wants control, or a developer who wants to build without black boxes, you may understand why OpenAlgo exists.
And honestly, it still feels like we are just getting started.
Github Link : GitHub - marketcalls/openalgo: Open Source Algo Trading Platform for Everyone · GitHub
OpenAlgo Docs : https://docs.openalgo.in/