Upload your history, describe your thinking — and let AI backtest your approach, surface blind spots, and point out what's worth improving.
“Backtest Silver Bullet on NQ — last 30 days”
Still in development. Join the waitlist and we'll reach out when it's ready.
Build log
From a Python TUI hacked together while waiting for broker approval, all the way to cross-broker copy trading. The commits below are the receipts. Newest at the top.
For its whole life Moltfi's chart lived in its own window. This is the week it moved in next door. The live trading chart became a panel you can mount directly inside Meander, handed a login on the way in so it just works, and — the real shift — it grew a shared workspace where an AI agent and a person draw on the same chart: the same levels, the same annotations, the same state, read and written by both. Orders started carrying their story with them too — who placed them, on what reasoning, under which tags. Three separate Moltfi surfaces — the engine, the chart panel, and the agent — stopped being three things and started behaving like one product.
Alongside the web app, Moltfi grew a proper desktop trading terminal — a small, fast native app built in Rust that paints a live order-flow heatmap and a depth-of-market ladder, and lets you place, cancel and flatten orders straight from the screen with your position and P&L reading live in the footer. It runs two ways at once: double-click it as a standalone terminal, or let it mount inside Meander as a panel. And it doesn't trust a single wire — it can reach the exchange directly over more than one independent route, so if the usual path goes quiet, a completely separate one can still see the book and manage your orders. The terminal that used to be a Python TUI now has a face.
A dedicated replay studio plays historical bars back on a master clock — play, pause, scrub, single-step, up to 8× — across a grid of panes on their own symbols and timeframes. Pull up a journaled trade and its entry and exit draw on the matching panes with a connector between them, so you can sit and watch the whole thing happen again across several timeframes at once. No look-ahead; just the tape as it was.
A dense run of chart overlays landed — swing highs and lows and their equal-liquidity clusters, liquidity-sweep flags, the previous day's and week's highs and lows, session highs, lows and opens computed on the real futures trade day, opening-gap boxes, and demand/supply order-block zones. These are the reference levels a discretionary trader draws by hand every morning; now they're just there, shared between the live chart and the trade viewer.
The dashboard turned the journal into something you actually want to open. A full-month P&L calendar colours every trading day by whether you made or lost, each cell clickable into the day itself and marked when it carries a note or a review. Behind it sits the real accounting — win rate, expectancy, profit factor, streaks, all computed from trades imported straight from your broker and reconciled against the exchange's own timestamps, so the numbers match the book of record rather than your memory of it. A single account-and-date filter drives the whole thing, and one composite Moltfi score sums up how you're doing at a glance. The journal stopped being a chore and became a mirror.
This is the milestone the whole thing was built toward. A runner now watches the market bar by bar and, when the conditions line up and the account is flat, places an entry and immediately wraps it in a protective bracket that takes profit or cuts the loss — no human hand, no language model in the loop, just a mechanical proof that the path from signal to order actually holds. It's fenced in on every side: it goes flat before the session ends and never holds overnight, it stops for the day if losses hit a hard limit, it refuses to place a naked entry, and it won't trade with real money at all until it can read the account well enough to arm those guardrails. Defaulting to a dry run, and demanding to know it can protect you before it risks a cent — that's the shape of a trading machine you can leave alone. This was the day Moltfi did the thing its name was always promising.
Order-flow tooling arrived: a footprint chart showing bid-versus-ask volume at every price, with the point of control, a live forming bar, per-bar delta stats and a bubble overlay marking the big trades as they print — plus time-and-sales, volume profile, and absorption and imbalance detection tuned against a commercial order-flow platform until it agreed. The kind of tape reading you used to pay a specialist vendor for, now running inside Moltfi.
Testing a strategy stopped being a single number and became a discipline you can trust. The engine learned to model trades the way they really exit — scaling out in legs, moving stops to breakeven, trailing — and a run of hard correctness fixes killed the quiet lies that make a backtest look better than it was: double-counted commission, mis-sized contracts, stops that filled in the past. On top of it sits a review workbench that turns a raw run into something you actually read: a candle chart with the trades marked, an equity curve you can click into, per-trade navigation, monthly-returns heatmaps and quality metrics broken down by session and by direction. Research became reproducible, and honest.
Underneath the auto-trader, Moltfi grew its own small language for describing a strategy — a set of composable building blocks drawn from the order-flow and price-action playbook: liquidity sweeps, fair-value gaps, market-structure shifts, optimal-entry pockets, trend gates, structure-anchored stops and stepped, adaptive risk. Each strategy became a versioned thing with a fingerprint and a lineage, so a run can be traced back to exactly the rules that produced it, and a person — or an agent — can write and validate a new one without touching engine code. What exactly goes in each recipe stays in the kitchen; but the kitchen itself is now a real, self-serve place. This is the seam where "bring your own strategy" becomes possible.
Market data was lifted out of the trading engine into a service of its own — one clean feed, published once and shared by everyone who needs to watch the tape, with a backup source ready to take over if the primary goes quiet. Separating who's watching the market from who's trading it let many consumers — including the new desktop heatmap — drink from the same well instead of each opening their own straw.
A privacy mode arrived for anyone who shares their screen or streams: one switch masks account names and balances so you can show the trade without showing the bank. Alongside it, doors that had been left open got locked — debug and maintenance endpoints put behind auth, docs closed by default. Small, unglamorous, and exactly what you want from something touching real money.
A stack of hardening went into the link to the broker, because a trading system that can't stay connected isn't one. A watchdog reconnects through market hours, a login that can't get its order channel falls back to watching-only rather than failing outright, a circuit breaker and an audit log capture every reject, and a governance layer keeps reconnects polite so the system never hammers the broker. The unglamorous truth of automated trading: most of the work is staying online.
Moltfi grew a full set of tools an AI agent can actually call to trade: read the account, positions and orders; place, modify and cancel; drop a bracket that cancels its other leg the moment one fills; pull key levels and the depth ladder. But the point isn't that an agent can send orders — it's everything wrapped around that so it can't misbehave: every order checked against pre-trade limits, each key rate-limited, a daily-loss kill switch standing by, and duplicate orders refused. This is the difference between a chart that talks and an agent you'd let near a live account.
This is the pivot the whole stretch turns on. The tool that had been one trader's personal terminal became a service that could hold many: each person's broker credentials sealed in an encrypted vault, a second kind of long-lived key so programs can connect alongside the ordinary sign-in, a per-user connection that spins up and idles down on its own, and an isolation test that proves two accounts can never bleed into each other. The Python TUI hacked together while waiting for broker approval didn't get thrown away — it became the engine sitting under a real product with real users.
A pile of database migrations had been quietly failing — table ownership wasn't set up right, so each ADD COLUMN got logged as a warning and waved past. Surfacing the failures as real errors let the backlog finally land.
A worker subprocess was calling on a connection pool that didn't exist in worker mode — every 5 minutes it leaked a traceback frame plus some buffered state. Over 20 hours the orphan grew to 4.8 GB, got OOM-killed, and pegged the machine on its way out. Six lines of "if db is None, return" later, the box stops melting.
Two backtest improvements. Fills stop snapping to bar close — intrabar timing matters and gaps get detected properly. And old backtests can be re-run on the new engine and compared side by side. Research becomes reproducible across engine versions instead of locked to whatever version it ran on.
Up until this commit, if you wanted a custom strategy you had to either pick from presets or come find me. From now on you write it yourself, in the browser, in a typed mini-language. Run it, watch entries and exits draw on the chart, tweak it, run it again. Moltfi herself can write strategies the same way through her agent door — MCP. Strategy stops being something you ask for and starts being something you author.
Backtest runs go fire-and-forget — submit a strategy, get a job id back, poll for status later. The change isn't just an API ergonomics win. It's what makes Moltfi voice-driveable: until now, running a backtest from a chat session would block the agent waiting for the result. Async means Mate can hand the job to Moltfi, return to the user, and pick up the result when it's ready. The next day, Mate ships the tool calls (run_backtest, get_run_status) that turn this into the first end-to-end voice trade-research loop.
Strategy is now data, not configuration. ICT primitives — fair value gaps, order blocks, sessions — become first-class types in the DSL. The backend half of what users will see in the editor a few days later.
Same day Moltfi opens up to outside callers in general. The thesis: an agent should be able to talk to Moltfi the same way a human account holder does. MCP is the door.
The day cross-broker copy trading actually went live. Different brokers, different account sizes, different per-member multipliers — all kept in sync, all reacting to the same lead trader's moves. Most copy-trading systems out there assume everyone's on the same broker; the prop-firm world doesn't work that way. Building this was the original reason Moltfi existed in the first place. The peak of this chapter.
The feature that makes Moltfi different from every other trading tool I'd seen lands in code form. You stop thinking about one account at a time and start thinking about a leader and a group of followers as one unit. Actions on the leader fan out to the whole group at once, the engine keeps everyone in sync, and the architecture writeup landed in the same commit so future-me wouldn't forget how it worked. Everything in place for the live cross-broker run the next day.
Single-user prototype → SaaS pivot. Same day, login integrates with everydays.tools. Strangers can now use the same server safely.
Plus continuous-contract support so backtests stop breaking on futures rollover. The seed of everything in the backtesting story.
Two related commits the same morning, three hours apart. First: a standalone viewer page — read-only chart and order book, no trading buttons, just the live picture. Then: a small admin page that mints a token and gives you back a shareable link. Anyone holding the link can watch live, restricted to the symbols you allowed; without a valid token, the viewer doesn't even open. This little seed turned into the token system that today spans everydays.tools. The first place I treated tokens as something you create, not something you receive when you log in.
Until this commit the data layer had grown organically — everything piled into one big space. This is where it gets carved into proper domains: market data, orders, users, simulations, each owning its tables, no more bleeding across boundaries. The architectural inflection point for Moltfi's backend.
Two things had to land on the same day for this milestone to mean anything. First: I'd spent a couple of weeks building my own binding from Python down to Rithmic's C++ SDK, instead of using whatever wrapper happened to be lying around. Second: the broker finally approved my account for live trading. So when I sent that first market order, it went out through code I wrote — every layer between the keyboard and the exchange was my own. Market, limit, stop, cancel — all working. The loop closed for the first time. Trading carpentry.
Charts hooked up to the live quote feed instead of pulling fresh data from storage every few seconds. Quotes stream in, the current bar updates in place, the line moves. Until this commit the chart was a picture; from this commit on, the chart was breathing. The first time Moltfi felt like a chart, not a spreadsheet.
The TUI got the Rithmic protocol working in 10 days, but a web app couldn't sit on top of curses. This commit is the pivot — same protocol layer underneath, but everything above it gets rewritten for the browser. Tick data gets pulled out of in-memory dicts and lands in TimescaleDB, because regular Postgres collapses on hot-path quote streams. FastAPI sits between the protocol bridge and the frontend so a Vue 3 single-page app can consume it. Nothing visible to a user yet — but every Moltfi feature shipped after this rides on the bones laid down here.
Moltfi's real beginning. While waiting for broker approval to enable live trading, I built a TUI that talks the Rithmic protocol on a paper account. Nobody builds TUI trading terminals anymore. That was the point.
Started from the frontend. Quickly realised: without a real broker connection and historical data, there's nothing for the UI to show. Shelved — and resurrected weeks later as the foundation of Moltfi's frontend, which is where backtesting lives today.