Vlurnex

quant / numbers talk - I just translate

[Vlurnex @vlurnex]

@fayzonnn win rate is the column that sorts by patience, not by edge.
hold the losers long enough and it goes up on its own.

sort by average loss against average win and arbi probably moves a long way down the list.

[Vlurnex @vlurnex]

HOLY SH*T. $50,000 → $53,410 IN 56 TRADES

Same market, same starting capital, same session on BTC-PERP. Five strategies, zero human intervention, one round of 56 closed trades.

The roster:

Momo — momentum, 20x
Revo — mean reversion, 15x
Arbi — stat arb, 15x
Maker — market making, 5x
Blitz — breakout, 25x

Final leaderboard:

Momo +$1,102 (+11.02%) — win rate 63.8%, 7 trades
Revo +$1,014 (+10.14%) — win rate 66.7%, 8 trades
Blitz +$666 (+6.66%) — win rate 50.0%, 6 trades
Arbi +$513 (+5.13%) — win rate 80.4%, 16 trades
Maker +$116 (+1.16%) — win rate 66.1%, 19 trades

Arena equity: $50,000 → $53,410

Now read that table again sorted by accuracy.

Arbi was right on 80.4% of its trades and finished fourth. Blitz was right exactly half the time and beat it.

The ranking has almost nothing to do with how often each bot was right. It tracks how much size was on when it was right.

Momo: 7 trades at 20x. Largest single fill +$330.
Maker: 19 trades at 5x. Largest single fill +$54.

Maker was right more often than Momo, traded nearly three times as much and earned a tenth of the money. That’s not a worse strategy, that’s a smaller bet expressed over more trades.

The part worth watching:

3 risk vetoes fired during the round. Two killed orders from Momo and Blitz for breaching the 30% notional cap. Both were mid-winning-streak when it happened.

A risk limit that only triggers when you’re losing isn’t a risk limit. It stops you precisely when you least want to be stopped, which is the entire point of putting it in code instead of in your judgment.

6 lead changes across 56 trades. The ranking flipped constantly. Any screenshot taken mid-round would have crowned a different winner and looked just as convincing.

And the honest caveat:

56 trades proves nothing. At that sample size the gap between first and fifth sits comfortably inside noise. This round shows you how five strategies behave, not which one is better. Answering that takes several hundred rounds and a tolerance for boredom.

[Bober_smart @Bober_smart]

https://t.co/SY0mmLiJBB

[Vlurnex @vlurnex]

@Synthexfr claude.md and dead mcp servers load once per session. what actually piles up is tool results and file reads during the work itself, and the audit never gets near those.

did you take the after number at startup, or after running the same real session twice?

[Vlurnex @vlurnex]

that’s the part i’d want to hear more about. carving from free space usually strips the metadata, so deleted photos come back as f1284736.jpg with yesterday’s creation date on them.

how did you pin the kitchen video to august 2013, exif that survived inside the file, or something else?

[Vlurnex @vlurnex]

@Prom_Tor the graveyard panel is the strong part, no argument there. but 44 entries at up to 8% size on pairs minutes old means the simulator had to invent a price for every entry and exit.

what did it fill at, the quoted price or the depth that was actually sitting in the pool?

[Vlurnex @vlurnex]

@HavisT83099 the 11x gap is 22 minutes against 10, and both of those move every run. one good take proves a model can do it, not that it will.

did you run the same prompt a second time on either of them, and did the camera land in the same place?

[Vlurnex @vlurnex]

A BACKTEST WITH NO COSTS IS F*CKING FAN FICTION WITH A P&L

most strategies don’t die in the market. they die months earlier, inside a backtest that forgot to pay fees.

the chart looked clean because nothing was charged for existing. no spread, no slippage, no exchange fee, no latency. by the time real money finds out, the author already calls it a system.

here’s the architecture that stops that. three layers, one loop, five gates before a single dollar is at risk.

layer 1. research, the evidence layer

turns an idea into a tested claim. signal discovery, statistical testing, walk-forward validation.

walk-forward in plain terms: train the model on an early slice of history, test it on the slice immediately after, roll the window forward, repeat. the model never grades its own homework. if performance only exists in the slice it was fitted on, this is where that gets exposed.

out-of-sample is the same idea with a harder rule. lock away a chunk of data at the start, never look at it, touch it once at the end. look twice and it stops being out-of-sample.

inputs: tick, bar and order book data, a hypothesis log with written kill criteria, and real broker data on fills, fees and latency. that last one matters. your cost model should come from actual fill history, not from an assumption.

layer 2. execution, the algo engine

a signal is not a trade. this layer converts a validated rule into a specific order: what size, routed where, filled how.

sizing, routing, execution logic. three decisions that quietly determine whether an edge survives contact with the order book. genuine 15bp of alpha with sloppy routing is no alpha.

layer 3. risk, the constraint layer

sits above both and can veto any order at any time. position limits, drawdown caps, kill-switch. risk per trade capped at 1%, hard cap per position, kill-switch at max drawdown.

the critical design choice: these limits live in code, not in intentions. a risk limit you can talk yourself out of at 2am is a preference.

the five gates

idea → backtest → walk-forward → paper → live

each gate kills a different failure. backtest kills ideas that never worked. walk-forward kills ideas that only worked on the data they were fitted to. paper kills ideas where live fills don’t match the model. live, deployed small, kills what the first three missed.

paper trading has one job people skip: run it until live fills match the model, not until you’re bored. if the model assumed a 1bp fill and you’re getting 4bp, you have a model describing a market you don’t trade in.

the six-step build

write the hypothesis and kill criteria first. decide in advance what result makes you abandon this.

build a clean, timestamped, survivorship-free dataset. survivorship bias quietly removes everything that went to zero, which makes any long strategy look brilliant

backtest with realistic costs, then walk-forward.
paper trade until live fills match the model.
deploy small, hard caps on, kill-switch armed.
review weekly. three outcomes only: retire, resize, retrain.

four red flags

live trails the backtest by more than costs explain. that gap is your overfitting, arriving on schedule.
parameters re-tuned after every losing week. that’s curve fitting with real money.

a sharpe ratio nobody else can reproduce.
risk limits overridden “just this once.”

the point

integration isn’t about adding more indicators. it’s about making research, execution and risk speak one language, inside one versioned codebase and one data pipeline, so the strategy that was tested is the exact strategy that trades.

the workflow this produces is boring, repeatable and honest. which is what a trading system is supposed to be. beautiful equity curves are easy to draw. the requirement is that they survive reality first.

[Roan @RohOnChain]

if you want to build an AI trading system from scratch, start with this article

you will end up with real market data, real backtests and a bot that trades for you 24/7 https://t.co/7bOgT1HCZf

[Vlurnex @vlurnex]

This is getting f*cking absurd. 12 models fired 2,140 orders

The one that made money said no

Everyone keeps adding signals. Almost nobody adds a veto.

A stack I watched run overnight generated 2,140 orders. The risk gate killed 47 of them before a single one reached the exchange. Nothing oversized shipped.

This is that pipeline running unattended:

Signal models → Allocator → Risk gate → Execution → Reconciler

12 models do the work: momentum mean reversion, basis, funding skew

The risk gate reads every order before it routes. Size, net exposure, correlation to open positions, remaining drawdown budget.

Vetoed orders go back to the allocator and get resized or dropped entirely

Watch for the 47 red flashes. That’s the gate saying no.

Here’s the part that matters: most vetoes weren’t bad signals. They were three models independently firing the same trade at the same time.

Twelve models agreeing feels like conviction. On the risk sheet it’s concentration wearing a disguise.

Generating signals is cheap now. Not handing the profits back is the expensive part.

Anyone can run a dozen models. Almost nobody gives one component the authority to overrule all of them.

Worth more than most $2000 algo trading courses.

Send this to the friend running nine indicators and zero position limits.

Then read how to build the risk layer in the article below ↓

[savip. @savipww]

https://t.co/YYQoOfAkKF

[Vlurnex @vlurnex]

$547K is the account balance, not accumulated profit from those cycles. the session I recorded opened at $533,000 and closed at $547,006. so the cycles in question produced $14,793, not $547K. the rest is working capital.

and 12bp isn’t applied to $15 position. it’s edge on quoted notional. a system holding 48 simultaneous lanes against bid and ask walls sitting at $1.4M to $2.4M depth isn’t risking $15 per cycle. the dashboard’s own PnL/cycle line reads $2.55 to $2.91, which backs into roughly $2,100 of notional per cycle at 12bp, not $15.

[Vlurnex @vlurnex]

$547K BUILT FROM TRADES AVERAGING $15

This bot is still running on BTC-PERP right now using an async quote-lane system to market-make both sides at once

Balance: $547,006

It’s not done. It’s still compounding.

The system runs 48 active quote lanes rebuilding the ladder every 2-3ms, built on one idea: never hold a clean directional bet when you can hold a hedged pair instead.

Here’s the mechanics:

→ Quotes both sides simultaneously

→ It’s paired across 90%+ of its inventory at any given time

→ The unpaired remainder, under 10%, sits as directional residual until the next repricing cycle folds it back into a matched pair

Runs roughly 150 cycles an hour

→ Average edge per cycle: 12bp
→ Basis cost per cycle: 1 to 4bp depending on lattice rebuild speed
→ Average cycle size: ~$10-20

→ Hit rate sits at 57-59%

Not because it predicts direction. Because two-sided quoting with a fee edge doesn’t need to predict anything.

Structural edge survives even with slip-vs-edge running 38-43%, because the volume compounds faster than the slippage bleeds it.

The lattice keeps rebuilding. The balance keeps climbing. That’s the whole pitch.

[VALIX @RetroValix]

https://t.co/BGYzevYB99

[Vlurnex @vlurnex]

@bogdanich_x device admin is the one permission that can’t be installed quietly.
did you keep the APK and the package name before you removed it? that’s the only part that points at specific build and specific installer instead of generic spyware.

[Vlurnex @vlurnex]

MICROSOFT OPENED UP THE HEDGE FUND STOCK PREDICTOR FOR FREE

Microsoft Research has created a quant system with AI that is used by hedge funds to forecast stock direction. They have now open sourced this system completely for free.

This is called Qlib, it's on GitHub with over 18k stars and is used for real research within Microsoft.

What is in the system?

1. machine learning models trained on stock price and volume data, feature engineering systems, backtesting, portfolio optimisation etc. all designed to forecast the movement of stocks and by how much
2. when using Claude to create a model it has access to the entire system. It uses Qlib’s own alpha factors rather than creating its own

How can you use this completely free?

1. use Claude Code and install the package using pip install pyqlib
2. ask Claude to retrieve daily data on the S&P 500 and create a baseline model. Qlib already contains sample data
3. for next week generate a ranking of stocks based on the predicted move. Compare the top 20 and bottom 20
4. backtest a long short strategy on the top 20 and bottom 20 stocks, rebalance weekly with fees included
5. calculate the max drawdown and Sharpe ratio in comparison to holding SPY only
6. if the long short strategy does not outperform SPY after transaction costs and slippage then the model has identified noise rather than a indicate

This is the type of analysis that is performed by analysts at most quant funds and these analysts are paid in the hundreds of thousands.

You can create your own model tonight for the cost of your electricity.

[Сarm1ne @carm1nee]

these 10 GitHub repos are the most DANGEROUS thing in trading right now

together they give you a full AI hedge fund: a research desk, an investment committee and an execution desk

in this article I've shown EXACTLY how to build it from scratch https://t.co/17pf1e63VG

[Vlurnex @vlurnex]

YOU CAN BUILD A TRADING AI TONIGHT ON THE SAME CODE JPMORGAN’S QUANTS USE

JPMorgan’s quantitative team developed an AI system for researching trading strategies and decided to share it with the public rather than keeping it confined within the institution.

It’s known as FinRL, created by AI4Finance, boasting over 10,000 stars, employing reinforcement learning for genuine trading choices.

Here’s a breakdown of what it includes:

1. Reinforcement learning agents trained on authentic market data, frameworks for stocks, cryptocurrencies, and portfolio distribution, with reward functions optimized for risk-adjusted returns rather than merely focusing on straightforward profits.

2. Claude retrieves the framework's architecture when prompted to create an agent, utilizing real environments and reward mechanisms instead of speculating on the RL configuration.

Here’s how you can implement it yourself at no cost:

1. access Claude Code, install the library: pip install finrl.

2. request Claude to establish a trading setup for 10 large-cap stocks using 5 years of daily data.

3. train a PPO agent on the initial 4 years while completely reserving the last year untouched.

4. evaluate the agent’s performance against that holdout year, ensuring no peeking at future data during the training phase.

5. contrast the agent’s returns with simply holding an equal-weighted portfolio of the same 10 stocks.

6. examine the Sharpe ratio as well; a model may outperform buy-and-hold strategies with significant fluctuations yet still provide subpar risk-adjusted outcomes.

7. if it doesn’t surpass the performance of the basket after fees, it indicates the agent learned to overfit on the training years rather than effectively trade.

Many individuals trust robo-advisors with substantial funds that operate on much less sophisticated logic than this. You can create and rigorously test your own model for free tonight.

[Hanako @hanakoxbt]

https://t.co/B3240WRGhl

[Vlurnex @vlurnex]

@thedelost Three models, three jobs, one rule: don’t pay premium for work a cheap model can do

[Vlurnex @vlurnex]

@RuOnChain1 Multi-agent systems debating trades. Because apparently one AI being confidently wrong wasn’t enough

[Vlurnex @vlurnex]

@RohOnChain The most dangerous thing on the internet is a backtest mistaken for a crystal ball.