Qadam

At a glance

Who it serves

Me and trading collaborators reviewing financial research and paper-only decisions.

What I owned

Research workflow, decision records and guarded paper operations, informed by trader feedback.

Key decision

Separate model reasoning from execution authority; block action when evidence or permissions are missing.

Current state

Operating paper-only research system. No live capital; cockpit access may require approval.

Evidence and gap

Workflow screenshots and decision records. These do not establish a trading edge, validated returns or quantum advantage.

Problem

I started Qadam when I realised something had changed in software. For most of my life, building a serious intelligent trading system would have needed a full engineering team: data engineers, backend engineers, quant researchers, frontend engineers, DevOps, and a whole room of people just to wire the infrastructure before the trading logic.

With new AI coding tools, I could suddenly build systems that were more complex than anything I would have attempted before. And because my product work had exposed me to APIs across geospatial, climate, automotive, finance, and other industries, I knew how much useful data was sitting out there disconnected.

That was the spark: could I build a transparent paper-trading system that compares different data sources, maps hypotheses to strategies I had learned from trader friends, and records what happened when those hypotheses were tested with paper money?

Qadam became that challenge: not a black-box trading bot, but a readable system that can show what it saw, what it believed, why a setup passed or failed, and what it learned afterward.

Architecture

Model: the model layer is a small fund team turned into software. A local LLM, Gemma 4, acts like the Research Analyst. It reads noisy inputs and turns them into cleaner research context.

A frontier LLM, Gemini 3.5 Pro, acts like the Strategy Lead. It challenges the trade thesis, looks for weak evidence, and asks what would prove the idea wrong.

The experimental quant-review path explores Q-CTRL Opal / IBM Quantum alongside classical methods. It is a research component, with the intended job of challenging patterns that may depend on regime, timing, and interacting sources.

That experiment needs a classical baseline, execution records, and out-of-sample evaluation before any claim of quantum advantage. Nonlinear market relationships alone do not establish that a quantum method helps.

A Python program sits underneath all of this as the COO. It runs the system, checks files, blocks unsafe paths, writes artifacts, and makes sure no model gets direct broker authority.

Context: Qadam's configured source inventory lists 50+ APIs across market and technical data, macro and policy, geopolitical and physical-world signals, social narratives, and institutional or alternative finance. That inventory includes filings, Capitol trades, broker paper state, and prediction-market context. Configured coverage is separate from working, fresh coverage; the source-state view reports availability and freshness for each run.

The point is not to collect APIs for the sake of it. The point is to compare sources that normally sit in different worlds. A geopolitical event might affect oil. A shipping signal might affect supply chains. A Reddit narrative might show retail attention forming before price fully moves. A prediction market might move before traditional media catches up.

Qadam maps that evidence to strategy frameworks inspired by friends who worked in finance and were successful traders. Their strategies were not random indicator chasing. They were built around patience, catalysts, conviction, confirmation, risk, and knowing when not to trade.

Orchestration: Qadam reads available sources, creates evidence packets, turns those into research goals, forms hypotheses, applies strategy filters, and routes eligible setups into PaperOps. Experimental quant-review outputs are research evidence, not execution authority.

If a setup passes every gate, it can move through the guarded Alpaca Paper route. Then the system watches what happened: whether the trade filled, whether it worked, whether the evidence mattered, whether the model overread the signal, and whether the strategy needs adjustment.

Governance: Qadam is paper-trading first. It does not use live capital. It does not let LLMs touch broker credentials. Its Telegram bot and dashboard cannot place trades. Backtests and shadow simulations do not count as proof. Missing evidence, stale sources, and duplicate exposure block the system.

Human: the human layer is me and my trading friends. I am the product manager; they are the operators, fund managers, and critics of the system. Together, we decide what the system should be allowed to do, inspect the dashboard, review whether the reasoning is legible, shape the strategy universe, and judge whether the system is becoming more useful or just more complex.

The dashboard is built for that job. It shows portfolio value, current holdings, trading history, connected data sources, strategy universe, detected patterns, possible trade intents, and the final PaperOps decision so a user can understand what Qadam is thinking and challenge it.

Why this approach

The easy version of this project would have been a signal bot: connect a few APIs, ask an LLM for trade ideas, show a polished explanation, and maybe add a shiny dashboard.

I wanted something harder and more useful. I wanted to see whether a complex trading system could be built like a thinking machine with receipts. Every observation, hypothesis, strategy match, risk check, paper trade, and postmortem should leave a trail.

The strategy layer also had to respect how good traders actually behave. My successful trader friends were not successful because they traded constantly. They waited, looked for catalysts, cared about timing, and knew that a good story is not the same thing as a trade.

Qadam tries to encode and democratise that discipline. It looks for patterns across previously uncompared data sources, checks whether those patterns match real trading strategies, and then tests them with paper money before making any stronger claim.

The quant experiment asks whether an additional review method helps distinguish useful source interactions from convenient stories. Its value is an open question to test against simpler classical methods, not an established benefit of the product.

Tradeoffs

Qadam gives up speed for evidence. It could place a higher frequency of paper trades if it treated every interesting signal as actionable, but that would defeat the point. A quiet day is fine if the setup is weak.

Qadam gives up simplicity for separation of roles. One AI could generate a trade, explain it, and score the risk in one response. Qadam separates research, strategy, quant review, risk, execution, and learning into different modules because each stage needs to be challenged on its own.

Qadam gives up full autonomy for safety. The models can reason and recommend, but Python enforces the rules. The broker route stays guarded. Live capital stays off for now.

Qadam also gives up easy marketing claims. A beautiful backtest is not proof of an edge. A clever quantum review is not proof either. A paper trade entered for a clear reason, managed through a real route, and reviewed afterward is much closer to proof.

The evidence presented here is the paper-only workflow, decision records, and visible reasons for acting or waiting. Performance validation still needs a dated account history, benchmark, drawdown, trade count, and treatment of trading costs before a return figure belongs in this case.

Demo / proof

Public Qadam material introduces the paper-only system. Access to the operating cockpit may require approval; the portfolio screenshots show the control-room surface without granting trading authority.

The dashboard presents Qadam as a real operating system. It starts with the fund and moves chronologically along its train of thought: portfolio value, holdings, exposure, paper trade history, and account state.

It then shows the intelligence layer: sources, categories, freshness, trust, and blockers. Then it shows the strategy layer: which trading strategies exist, which ones are active, which ones are held, and which patterns are being reviewed.

The final sections show what Qadam is thinking about now, and why PaperOps did or did not allow a trade.

What I would improve

The honest limitation is that Qadam is still proving its edge. The system is already more complex than I originally imagined I could build, so it is already a success in my eyes. But the next version needs deeper proof.

I would expand the historical replay system so Qadam can test its full data universe against its full trading universe. Not source by source, but all together: geopolitical signals, macro data, narrative pressure, prediction markets, filings, technical structure, and price.

I would improve the evaluation layer around false positives. Qadam needs to get better at knowing when a pattern is real, when it is overfit, when the story is too convenient, and when the quantum or nonlinear layer is adding value rather than using quantum for the sake of quantum.

The best version of Qadam is the one that can look back at a decision and say, in plain English: here is what I saw, here is why I acted, here is what proved me right or wrong, and here is what I changed because of it.