mdubya

Live at chalktrade.xyz

• A full web trading terminal for a paper-trading perpetual-futures venue: a live price chart with your open position drawn on it, a tick-level chart, and an order ticket that signs and submits through the venue's own protocol. Built up from the venue contracts, with no library to lean on.
• Copy trading that keeps running with the browser closed. A server-side keeper mirrors a chosen trader's opens and closes onto a follower's account using a session key that can place trades but cannot withdraw funds. The key is held sealed, under per-copier limits the follower sets themselves.
• A trader explorer built on a full capture of the venue's on-chain tape: per-wallet performance pages, leaderboards, size and leverage cohorts, and staking, every figure reconciled to the venue's own to the cent.
• Its own EIP-712 signing, reproduced and tested byte for byte against the reference library, a hardened same-origin relay, browser cryptography vendored and integrity-pinned, and an autonomous agent reviewing the codebase on a schedule.

Stack JavaScript (no framework), Node, Python, EIP-712 signing, nginx, systemd

Live at positioning.mdubya.info

• A public data site showing how a venue's whole trader base is positioned, market by market: long versus short notional and account counts, split by account size, with crowding and taker-flow views. A tab per venue, plus a combined cross-venue view.
• The data is proprietary. Every on-chain fill carries both sides' position before the trade, so replaying the full tape reconstructs current positioning for every account, something the venue itself publishes no feed for. History runs back to the first day of capture.
• Tens of thousands of accounts, refreshed hourly, read by a client hard-capped to stay inside the venue's rate limits. Liquidation maps are rebuilt from the venue's own per-market contract rules and match its published map to the tick.
• The site is pushed one-way from the capture host and served read-only, with failure and staleness alerting into chat.

Stack Python, SQLite, static HTML and JS, nginx, systemd timers

Ran live in production

• Rewrote the production trading engine from Python to Rust: async runtime, typed venue adapters, crash-safe position persistence. Ran the same strategy across a book of perpetual-futures markets on a single live venue.
• The cutover was gated on differential testing, not on confidence. Both engines consumed the same live signals in parallel for weeks, and the rewrite had to produce zero decision disagreements before it was allowed to take over, with many fills matching digit for digit. One-shot cutover, documented rollback, never both engines live at once.
• Mid-lifecycle restarts restored open positions and reconciled against the venue with zero mutations, proven against live positions rather than in a test harness.
• Killed the feature that justified the rewrite. A split-exit that backtested well turned out to be an artifact of bar-level trailing: live results inverted the drawdown improvement it promised, so I disabled it, flipped the unsafe default in code, and added a regression test to keep it off. The engine itself earned its keep and stayed.

Stack Rust, tokio, serde, systemd

Ran in production. Engine since replaced by the Rust rewrite above

• Webhook-driven trading server running a trend-following strategy across multiple perpetual-futures markets, managing positions across 6 sub-accounts on two exchanges from a single signal source.
• ATR-based risk management, tiered slippage, race-condition guards, automatic state recovery on restart. Per-account flip, force-close, and manual size adjustment, all gated behind an admin token.
• Live operator dashboard with a two-tier auth split: separate credentials for admins (write) versus read-only monitors, so a leaked monitor credential cannot place a trade.
• Production-hardened: built and shipped fixes for infinite exit loops from API verification failures, double-order race conditions, signal repainting, and an SDK-level hang that needed a custom stack-trace dump on detection.

Stack Python, Flask, asyncio, nginx, systemd, SQLite

Ran live in production

• Signal-aware, one-sided maker: read position state from the upstream trading engine and placed passive, post-only (maker-or-reject) limit orders on the active side across three pairs, earning maker fills and reinforcing the trend rather than quoting both sides of the book.
• Per-pair PnL kill switches (intentionally pair-level, not pooled across the book). Debounce logic so a single bad tick or zero-price read cannot force a trade.
• Hang-detector sidecar that triggers a stack-trace dump on the wedged process after a configurable log-silence threshold.
• Control API never exposed to the public internet; reachable only through a privately scoped tunnel from a separate ops host.

Stack Python, asyncio, systemd, SSH ControlMaster tunneling

Live in production

• Code-review agents: three scheduled review agents covering the trading, market-maker, and macro-index codebases against a security-first rubric with tiered alerting on a 4-hour cadence. First production runs caught real bugs on day one and have continued to surface regressions.
• Performance-monitor agent: regime-aware periodic recommendation reports. Pulls multi-month price and funding history, discovered and worked around two undocumented exchange-API pagination limits, runs k-means regime clustering on 8 engineered features (with an HMM successor variant built and gate-tested against the live release).
• Log-stream monitor agent: persistent live-log stream into the model with a structured pattern catalog of 14+ matchers across four primitive families (temporal, sustained-state, filesystem-watch, HTTP snapshot-delta) and a cross-pattern correlation layer that collapses paired signals into a single combined alert.
• Fleet-briefing meta-agent: runs on a fixed twice-daily schedule, consolidating the other agents' output and live-system state into a single operator briefing and escalating only when something needs a decision. An agent that supervises the agents.
• Autonomous build agent: takes a written spec and lands working code unattended. Its first assignment shipped a market-data recorder end to end, now running as a hardened service capturing minute-resolution order books across dozens of markets on several venues plus hourly options surfaces, scored daily against a coverage gate that excuses genuine venue outages and flags everything else.
• Source code reaches the agent host only through one-way read-only mirrors, never through any external code-hosting system.

Stack Claude Code (subscription auth), systemd timers, SSH ControlMaster tunneling, Discord webhooks

Live in production

• 15+ slash commands for controlling the agent fleet and trading systems: status reads, pause/resume, position queries, kill switch, watchlist CRUD.
• Routes over a restricted private tunnel to internal control APIs; nothing exposed to the public internet. Designed for fast phone use: space-separated args with smart defaults.
• Destructive actions (kill switch) require a typed-confirmation token, run server-side timeouts, and write to an audit log on every invocation.

Stack Python, Flask, SSH ControlMaster tunneling, Discord Bot API

Live, auth-gated

• Computes and publishes a curated daily consumer-stress index from public federal economic series, corporate regulatory filings, and a market-data watchlist.
• Cached clients over each upstream, with handling for source-side outages, release-lag quirks, and rate limits.
• Composite weights driven by what the historical data actually supports; calibration window chosen after discovering and excluding an anomalous early-period revision.

Stack Python, Flask, SQLite, FRED and EDGAR APIs

Auth-gated

• Operator dashboard over the market-maker process. Periodic snapshot timer writes to a local time-series store.
• Charts above raw state dumps: PnL curve, drawdown gauge, fills volume, cycle-health sparklines.
• Kill-switch UI with typed-confirmation dialog, server-side timeout, and a confirmation guard that prevents accidental fires.

Stack Python, Flask, SQLite, vanilla JS charts

Research. Both books concluded on their own evidence, not funded

• Market-wide regime scanner: factorized hidden Markov models over global macro and crypto state, with model size chosen by information criterion and out-of-sample cross-sectional skill rather than in-sample likelihood. The validation harness scored state-conditional forward returns using quintile spreads and autocorrelation-robust t-statistics.
• Funding-rate carry book: backfilled hourly funding history across the full market universe of both venues, then ranked candidates on full-year carry after a strong 90-day read on one asset reversed sign over a full year. Short-window carry reads are now banned in the project.
• Both books ran read-only monitors and shadow harnesses on a schedule, with the pass-or-fail threshold written down before the data arrived. Both were declined on that evidence, alongside individual candidates cut earlier, including one dropped for regulatory exposure despite carrying the best yield in the universe. The framework that reliably says no is the durable asset.

Stack Python, hmmlearn, NumPy/pandas, SQLite, systemd timers

Research tooling

• Hyperparameter-search framework for trading strategies with a multi-seed robustness check baked in (parallel optimization isn't deterministic even with a fixed seed; multi-seed catches that).
• Treats the pipeline itself as the deliverable: multiple candidate strategies run through it have failed walk-forward analysis, which is the point. The framework is the durable asset.
• A library of trading-platform strategies built in parallel against a consistent architecture: ATR-based risk, trend filters, webhook-ready alerting.

Stack Python, Optuna, TradingView Pine