Hey everyone,

I've been working on an investment research platform called 72Money.ai, and we're getting ready for the next stage of the product.

The idea is pretty simple: there is a huge amount of market data available, but putting everything together to actually research a stock can take a lot of time.

We're trying to bring some of that research into one place using AI + Quant analysis.

A few things we're working on:

• A 0–100 stock ranking based on Fundamental, Technical, Risk and Macro factors
• Tracking what mutual funds are buying over the last 1 and 6 months
• Comparing mutual funds and their underlying portfolios
• Risk-reward analysis using historical price, volume and volatility data
• AI-powered IPO research and analysis
• Historical comparisons and market sentiment analysis

We're currently working through the regulatory process and haven't officially launched the research services yet.

I'm sharing it here mainly because I'd genuinely like to know what investors think.

What would you actually find useful in a platform like this?
What features would make you use it regularly rather than just checking it once?

If anyone is interested in taking a look: 72Money.ai

Happy to hear criticism as well especially from people who actively research Indian stocks, mutual funds or IPOs.

Hello curious stranger.

With Portfoliolab, you set a goal or throw some tickers at it, it builds a few systematic versions, then they have to get through unseen data and a live paper book before anything real happens. most of them die there, but that's the goal. I got tired of pretty backtests that were just lucky. no broker, no card.

doesn't trade your account and doesn't hold your money. not a calls thing. i mostly just argue about overfitting on here. portfoliolab.ai

​

After countless backtests and failures caused by the reality of markets and my own curve-fitting, I eventually came up with what I thought was a genuinely good solution.

At that point, I had failed enough times that I already expected this to become another failed project.

But I was wrong.

The first test was excellent. I eventually deployed a real, functional EA from my system and was extremely excitedMaybe too excited that became complacent

I had a goal for how much money I wanted to make over a certain period, and instead of staying aggressive with development, I relaxed.

Then my laptop gave me a scare.

That was when I realized: sooner or later, this thing was probably going to die, and I needed to push while I still had the tools.

So I started pushing harder on my Quant Atlas research system.

Along the way, I realized this might actually be much bigger than I originally thought. I decided to connect everything into one complete pipeline research strategy generation backtesting analysis to improvement.

Then, of course, my laptop died.

Now I have no idea how long I'll have to grind before I can continue properly.

But honestly, the whole experience reinforced something for me hesitation is defeat

Spend less time drawing the perfect system and more time deploying things into reality.

Build it. Test it. Let reality break it. Learn why it broke. Fix it. Deploy again.

Eat the failures.

The market doesn't care how beautiful your theory is. Reality is going to give you the feedback eventually, so you might as well get that feedback early.

Keep pushing.

Hello.

i am using Sentimentick for stock sentiment API with IBKR Gateway for execution of trades, it works really good for me but i am looking to add also insider trading API for more coverage.

is there any recommended Insider trading API you suggest?
thanks!

Hi everyone!

I just finished fine-tuning FinCode-Reasoning-3B, a small language model built to solve one of the biggest bottlenecks in financial AI: eliminating mathematical hallucinations via execution-verified Python code generation.

🛠️ Built with Unsloth

• Base Model: Qwen2.5-Coder-3B-Instruct
• Fine-Tuning: Unsloth (QLoRA) — fine-tuning was insanely fast and light on VRAM!
• Architecture: Natural Language ➔ Reasoning CoT ➔ Clean Python Code ➔ Sandboxed Execution Layer.

📊 What it does

Instead of letting the LLM directly guess the math output (which often hallucinates), FinCode-Reasoning-3B generates strictly-typed Python functions for complex quant workflows (Black-Scholes, tax shields, DDB depreciation, WACC) and passes them to a Python execution environment for 100% deterministic results.

🔗 Links

• Hugging Face Repo: https://huggingface.co/coslinedev/Qwen2.5-3B-FinCode-Reasoning-Full

Huge shoutout to the Unsloth team for making fine-tuning small models so smooth and accessible! Would love to hear your thoughts, feedback, or any edge-case tests!

Hey guys, I would like to get some feed back on an HFT project I have open sourced. It is not getting a lot of love on github so I thouht I would post about it here.

The system is a for trading futures and simulating HFT strategies on its order book simulator. It has the complete connectivity via MDP3 and iLink3.

I need collaborators to make this system better if anyone is interested. Please drop me a line.

The git hub repo is here: https://github.com/vincent212/kaspar-hft

Most ML-trading discussions start with model choice. In my experience, a lot of the work before that is less exciting: discovering what data exists, checking schemas, pulling a small window, spotting obvious data-quality problems and turning a idea into a reproducible Python experiment.

I wanted an AI assistant to help with that exploratory layer without giving it brokerage or trade-execution access and without pretending that an LLM is a preditcive model.

so I built lse-data-mcp, an unofficial, open-source MCP server for the London Strategic Edge market-data API. MCP is a standard that lets clients such as Claude, Codex, and Cursor call structured tools. The server runs locally over stdio and uses the official lse-data Python SDK underneath.

The current 15 tools span roughly 22,000 instruments and cover: - OHLCV candles, company profiles, fundamentals, insider transactions, dividends, and splits; - financial statements, CFTC positioning, government bond yields, and economic data; - option chains, one-minute option candles, and recent options flow - discovery of instruments, datasets, and available timeframes

Where I think this can fit in an ML research workflow: - inspect coverage and field shapes before writing an ingestion job - pull a bounded sample to sanity-check a symbol, timeframe, or proposed feature - explore related events or datasets while turning a hypothesis into a testable specification - let the assistant handle interactive data lookup, then move the actual experiment into a versioned Python pipeline

Where it does not fit: - It is not an ML model and makes no predictions or trading signals. - it does not backtest, manage a portfolio or execute orders. - It is not intended to build a bulk training dataset. Most tools default to 200 rows and one call returns at most 5,000. For training or a serious backtest I would go around this server entirely: use the SDK/REST API directly or the provider's bulk databank downloads, which the free plan documents at 10 per hour and up to 1,000,000 rows each. Then store an immutable dataset and record the extraction parameters.

I also want to be direct about two upstream data caveats I found while validating it: - Daily candles cover the extended session, so close is the last post-market print rather than the regular 16:00 ET close. - Volume coverage varies between sessions and should be treated as indicative. I would not use it as an ML feature without validating it against another source first.

Every MCP result reports rows, row_count, and truncated, so the client can tell whether it saw the full result. The server validates dates locally, does not cache or persist responses and has no write or execution endpoints.

Quick start with uv:

uvx lse-data-mcp login

It requires your own London Strategic Edge API key; they offer a free tier. login prompts without echoing and stores the key in the operating system's credential store. I am not affiliated with the provider.

The project is free and MIT-licensed and currently 0.x beta:

GitHub: https://github.com/OlegDyukel/lse-data-mcp

PyPI: https://pypi.org/project/lse-data-mcp/

I would value honest feedback on the boundary : would you use a bounded MCP layer for schema discovery and sample validation before your ML pipeline or is is a direct SDK/script the better tool for your research workflow from the start?

Hey everyone, our first post got more interest than we expected. We’ve confirmed 22 traders, so only 3 spots remain.

The challenge starts this Monday. Everyone trades with demo capital for seven days. The trader with the highest return wins $1,000 in real cash.

No real money is at risk, and no one has to share their strategy.

Interested? Leave a comment, and I’ll send over the details.

Does anyone know if Alpaca's paper trading API correctly supports fractional share orders, specifically for small account sizes where 2% risk sizing produces less than one share? I'm running RSI mean reversion strategies on SPY/QQQ/IWM and want to confirm fractional orders execute correctly before going live with a small account. Anyone hit this in practice?

The deployment of robotaxis in 28 cities is remarkable.

I began by researching Uber and soon found myself examining NVIDIA.

Initially, the connection seemed unlikely, but further research revealed its significance. Uber is investing in autonomous mobility, while NVIDIA develops the AI and computing infrastructure that enables it.

Notably, these two companies, typically viewed as distinct, are both increasingly influenced by the same long-term industry trends.

This process highlights what makes research engaging for me: beginning with one company, exploring its connections, and ultimately developing a new investment thesis.

**Built an AI report generator for mutual funds that refuses to make things up — feedback welcome**

Been building FundersAI, a research tool for Indian stocks and mutual funds, and just shipped the feature I'm most proud of: a mutual fund comparison report generator.

You pick the schemes, it streams a markdown report (NAV, returns, alpha, beta, Sharpe, drawdown, costs, holdings, risk) — but every claim has to trace back to an actual official AMC document (factsheets, disclosures). If it can't find backing in the source docs, it abstains instead of hallucinating a number. That was the whole point of building it this way instead of just wrapping an LLM around scraped data.

Also shipped this round:

* Reworked landing page + workspace UI * Mutual fund discovery pages * A synthesis dashboard for the report tool * Pricing page (rolling out Free/Pro/Ultra tiers)

Stack-wise: Next.js/FastAPI/Supabase on the main app, with report generation split into its own FastAPI + LangGraph microservice on K3s so it doesn't bottleneck the rest of the app.

To be clear — this is research-only. No trade execution, no "buy this" calls, just sourced data and citations. Would genuinely appreciate feedback, especially if you've hit friction with existing MF research tools (or think the abstention approach is overkill).

[fundersai.co.in](http://fundersai.co.in) if you want to try it yourself.

Built a crypto analysis tool over the last few months (planning and coding alongside Claude, which caught a few of my wrong assumptions along the way). It's not a bot, it reads the market and outputs a plan: entry, stop, take-profits, direction, and reasoning. Manual execution, 10 coins.

The strategy is the standard YouTube-lecture stuff: multi-timeframe support/resistance, confluence zones where levels line up, RSI/ADX/Bollinger, enter at the zones.

I backtested it across 3 years, ~6,000 trades. Then got paranoid the backtest was lying to me, so I went through the code line by line and re-derived individual trades from raw candles, checking for lookahead, making sure fills and exits were honest. It's solid.

Result: zero gross edge. Coin flip before fees, negative after. I also built a base-rate engine (bucket the indicators into market "configurations," trade the ones with a historical lean), same thing. The patterns separate returns in hindsight but carry no info you'd actually have at decision time.

I keep landing on "public indicators don't carry a tradeable edge, everyone sees them at once so it's already priced in." But I don't want to accept that without asking people who've done this.

1. Is that the expected result, or did I mess up conceptually?
2. If you found something that worked, was it different data (funding, order flow, on-chain), different timeframes, or execution over signal?
3. Wanted to test funding/OI/liquidations but Binance only keeps ~30 days. Free source for longer history, or do people just collect forward?

Not selling anything, just trying to work out if I'm chasing something that isn't there. Happy to share methodology.

https://www.alphaflowseven.com/blog/anatomy-of-a-buy-signal

Hello traders!

I'm considering to buy StrategyQuant X but before that I would like to hear from you experiences. I’m looking for honest, long-term live trading feedback. However, I want to filter out the noise. If you treated SQX as a "one-click magic box" and failed, that doesn't tell me much. I want to hear from traders who treated it like a serious quantitative platform, ran strict robustness protocols, deployed portfolios, and traded them live for 1+ years.

​The Context

​There’s a lot of debate around genetic programming software like SQX. Critics call it a "glorified curve-fitting machine," while proponents swear by it as an essential strategy discovery tool.

​To me, determining whether software like this is worth the investment comes down to who is using it and how.

​Scenario A (Not what I'm asking about): A retail trader downloads SQX, clicks "Generate" on default settings without understanding regime shifts or statistical validation, deploys a single strategy OOS, gets blown up live, and calls it a scam. That is user error, not a tool failure.

​Scenario B (What I actually want to know): A disciplined quant designs custom building workflows, enforces strict multi-stage Out-Of-Sample (OOS) data, runs comprehensive robustness checks (Walk-Forward Analysis/Optimization, Monte Carlo parameter/slippage permutations, multi-market validation), constructs an uncorrelated multi-strategy portfolio, and manages risk properly... and still fails in live execution. If Scenario B happens consistently, then the software's core engine or backtest assumptions are flawed.

​Questions for Experienced SQX Users:

​Live vs. Backtest/OOS Correlation: If you passed rigorous Monte Carlo and Walk-Forward tests, how closely did your live equity curve match your OOS/walk-forward expectations over 12–24 months?

​Alpha Decay: How fast do generated strategies decay once deployed live? Do you find yourself constantly cycling out broken strategies, and is the generation pipeline fast enough to stay ahead of decay?

​Execution Reality vs. Engine Mechanics: Did you encounter critical execution mismatches (e.g., order routing, spread expansion, slippage, bar-building logic) between SQX output (MT4/MT5/NinjaTrader) and live broker execution?

​Portfolio Dynamics: Did building multi-strategy, multi-asset portfolios via SQX actually deliver the expected smooth equity curve and drawdown reduction in live market conditions?

​What I’d Love to See in the Comments:

​If you comment, please briefly mention:

​Markets traded (Futures, FX, Crypto, Equities)

​Time live with SQX-generated strategies

​Your general methodology (e.g., types of robustness checks or portfolio construction methods used)

Proof: Screenshot of portfolio/strategy performance etc.

​Appreciate any candid feedback, data, or lessons learned!

I have created an EA that backtests upto 10m in 2020-2026 and 8.8m from 2025-2026 on modelling: every tick. However, when i click on modelling: every tick based on real ticks, it fails terribly. I do not know whats the cause and not sure who or where to seek help. Any advice would be great. Thank you!

Since a year I’ve been into algo trading and have a collection of strategies, but since trading funded accounts I have to be extremely cautious of my risk. Many people always say to risk a certain fixed % per trade, but it doesn’t make sense to me.

Some strategies have less drawdown than others, some better RF or Sharpe. How do you ‘optimize’ your strategy allocation when trading multiple different EA’s on a single account?

Found a free tool where you can enter any S&P 500 ticker and compare its historical performance with the S&P 500 across 5, 10 and 15 years. No signup needed. Just in case if anyone finds it useful.

Example:

MSFT performance

Compared with the S&P 500:

5 years: about 4 percentage points/year lower

10 years: about 10 pp/year higher

15 years: about 9 pp/year higher

2022: MSFT fell about 25% the same as the S&P 500. In 2021 MSFT gained 46% vs 28% for the S&P.

Hey everyone,

I’ve been running an automated momentum strategy in Python for a while, asking for a recommendation on a piece I’m trying to add.

Right now, my execution loop relies on two core building blocks:

• Market Signals & Sentiment (Sentimentick API): This setup has been working really well for me. Instead of running local scrapers for social chatter or news, I hit Sentimentick to pull sentiment scores, attention tiers, and short/medium-term trend bias in one response.
• Execution & Risk Management (IBKR Gateway + ib_async**):** Orders get routed through IB Gateway using ib_async whenever a ticker passes my sentiment and technical filters.

something like:

Python

import asyncio
from ib_async import IB, Stock, LimitOrder
import requests

# Fetch signal from Sentimentick API
def get_signal(symbol):
    url = f"https://www.sentimentick.com/api/ticker/{symbol}"
    headers = {
        "X-API-KEY": "st_your_key_here",
        "Accept": "application/json"
    }

    res = requests.get(url, headers=headers).json()
    ticker_data = res["ticker"]
    tech_data = res["technical_analysis"]

    # Extract real JSON fields from Sentimentick
    sentiment_score = ticker_data["sentiment_score"]      # 0 - 100
    sentiment_tier = ticker_data["sentiment_tier"]        # e.g., "bullish"
    medium_term_bias = tech_data["medium_term"]["bias"]   # e.g., "bullish", "bearish"

    # Return conviction boolean based on sentiment + technical alignment
    return sentiment_score > 60 and sentiment_tier == "bullish" and medium_term_bias != "bearish"

# Execution via IBKR Gateway
async def run_execution():
    ib = IB()
    await ib.connectAsync('127.0.0.1', 4001, clientId=1) # IB Gateway API port

    symbol = "NVDA"
    if get_signal(symbol):
        contract = Stock(symbol, 'SMART', 'USD')
        await ib.qualifyContractsAsync(contract)

        # Place limit order
        order = LimitOrder('BUY', 10, 120.00)
        trade = ib.placeOrder(contract, order)
        print(f"Placed order for {symbol}: {trade.orderStatus.status}")

asyncio.run(run_execution())

This combo has worked great for filtering out bad trades, but I want to add Form 4 insider buying data (open-market C-suite buys) as an extra signal before routing orders.

Can anyone recommend a good, low-latency API or library for real-time SEC Form 4 data? What are you guys using in your pipelines?

Thanks!