Mohid Faraz

AlphaZero Connect 4 bot 2026

A Connect 4 bot that learns by playing against itself, based on the AlphaZero paper. I built it in four steps: the game itself, minimax with alpha-beta pruning, Monte Carlo tree search, and then a neural network trained on its own games with PUCT search on top. Each new network has to beat the previous one in a match before it gets kept.

• After about 16 hours of training on my laptop's GPU, the network plus search beats my alpha-beta engine at every depth I tried (0.78 score against depth 6 over 30 games with random openings).
• I measure how good it is by comparing its moves to a perfect Connect 4 solver on 6,000 test positions. The self-play network got stuck at around 26.5% wrong moves.
• I wasn't sure if that was because the network was too small or because it didn't have enough training data, so I trained the same network on 300k positions labeled by the solver instead. That got it down to 7.4%, so the problem was the data, not the network.
• Early on my results were inflated because two deterministic bots play the exact same game every time, so a 12 game match was really 2 games. All matches use random openings now.
• 291 pytest tests. The JavaScript version is tested against the Python version on 120 positions to make sure they play the same moves, and the ONNX exports are checked against PyTorch.

Python, PyTorch, NumPy, pytest. Browser version in JavaScript with onnxruntime-web. Code and writeup on GitHub

Tic-Tac-Toe with minimax, alpha-beta and MCTS 2026

I did this before Connect 4 to learn the search algorithms on a game small enough to check by hand. Minimax, then alpha-beta pruning, then basic Monte Carlo tree search. A lot of the bugs I would have hit in Connect 4 I hit here first.

Python, pytest. Code

ModelBandit 2026

A service that reads an LLM prompt, works out what kind of task it is, and sends it to the cheapest model that should be able to handle it. It keeps running averages of how every model does on every kind of task and uses those to make the next decision, so it gets better with use. Built after I kept paying GPT-4o prices for questions a 7B model could answer.

• Classification is two stages: weighted regexes decide clear prompts in under a millisecond, and ambiguous ones fall through to nearest-neighbour search over 120 embedded example prompts. Confidence is the margin between the top two candidates, not the raw match score.
• Every model is scored per task type from its own history: confidence, cost, latency and how often it needed escalating, normalised and weighted differently for code, math, chat and so on. 10% of requests pick a random model instead so it keeps finding cheaper options.
• Low-confidence requests are retried one tier up, and both calls are recorded. Learning that those retries were the classifier's fault, not the cheap model's, and lowering that penalty was the change that made cheap models win where they should.
• Every model, open-weight or not, is called through OpenRouter with one key. When a call fails outright the request moves to another model at the same tier and the failure counts against the one that broke. Accounts with per-user keys, per-IP rate limiting, and 154 Jest tests, most of them prompts I once misclassified.

Node.js, Express, TypeScript, React, Postgres on Neon with Drizzle, Better Auth, OpenRouter, Jest, Docker. Code and writeup on GitHub