Projects

An open-source, local-first API and flow testing toolkit. Author a multi-step flow once in YAML or Python, then apply integration, system, load/stress, or soak profiles to the same canonical model. The Go engine is built around goroutine-per-VU concurrency and is documented for 10,000 concurrent virtual users on a single node.

Every step, protocol phase, extraction, assertion, and retry emits a span, so one result model powers the dashboard, flame graph, and waterfall view. Rate limiting stays honest with throttled as its own outcome class, while an optional target agent records CPU and memory alongside the run to separate generator pressure from target saturation.

A session-shaped platform for live classroom engagement. A lecturer opens a room; students join with a short code (no account needed) to ask questions anonymously, upvote so the best rise, answer single/multi-select polls with hidden solutions and a peer-instruction re-vote, run think-pair-share, and give presentation feedback. The whole feature set reduces to four primitives: rooms, contribution boards, polls with a reveal state machine, and activity sequencing.

Each room runs as an in-memory actor on a single asyncio event loop, backed by SQLite (aiosqlite) and rebuilt lazily on restart, no message broker, no threads. FastAPI with native Starlette WebSockets on the backend; React 19 + Vite + TypeScript as an installable PWA with Clerk auth on the front. A deliberate privacy stance separates presence from authorship: the teacher sees who is present, but posts stay anonymous and peers never see who said what.

A self-hostable research-paper management platform with AI-powered reading assistance, full-text and semantic search, and automatic relationship discovery through citations. Ingests papers directly from arXiv, ACM, IEEE, OpenReview, PMLR, NeurIPS, and friends, or via raw PDF upload, then organises them into hierarchical groups, custom tags, and reading states.

AI reading is wired to Google Gemini for chat-with-paper sessions (threaded so follow-ups stay scoped), auto-generated summaries, key-findings extraction, and smart highlights. The backend is FastAPI + SQLAlchemy 2 async on PostgreSQL 16 with pgvector for 768-dim semantic search; Celery on Redis handles background ingestion and AI tasks. Frontend is React 19 + Vite + TanStack Query + a TipTap editor, with an integrated PDF.js reader and per-user data isolation behind Google OAuth and JWT.

A custom Oware (Abapa ruleset) engine paired with three RL agents (DQN, PPO, and an AlphaZero-lite trained via MCTS self-play) pitted against a depth-limited Minimax baseline. The post is as much about what failed as what worked: a curriculum that forgets, league self-play that turns inward, and an AlphaZero that never finished its warm-up.

A round-robin Elo tournament with 100 games per pair settles the order. Minimax-d6 anchors the top, DQN comes second, PPO third, and AlphaZero-lite lands below Random, exactly what an under-trained policy on a 300-ply game with terminal-only reward should look like.

A two-stage pipeline for traffic monitoring. The first stage pairs an object detector with a spatial logic layer that filters detections against a precomputed road mask, so only on-road vehicles contribute to density measurements.

The second stage consumes the cleaned telemetry and forecasts short-horizon density with an LSTM, GRU, or TCN. Benchmarked across multiple YOLO variants and RT-DETR on hardware ranging from embedded boards to GPU servers.

A community-built platform that turns Ghana's power instability (locally called dumsor) into something legible. Anyone can log Dum (power out) or Sor (power on) for their zone, location-gated so users can only report on areas they're physically inside. Confirmed outages turn red on the map, restored zones turn green, untouched areas stay grey until enough reports come in.

Status is crowd-verified: the platform aggregates reports from the last six hours and requires multiple agreeing voices before flipping a zone, so single false alarms get filtered out. Restoration ETAs are computed per-zone from each area's own outage history, and official ECG load-management schedules sit alongside live reports so you can tell what's planned from what isn't.

Formulated traffic signal control as an MDP and trained a PPO agent that outperforms traditional fixed-time controllers, reducing wait times by 96.1% on the heavy-traffic evaluation run. Curriculum learning steps through three scenarios (single intersection → arterial road → 2×2 grid) with W&B model versioning and artifact tracking.

Custom simulator grounded in the Intelligent Driver Model (IDM) accounts for non-linear vehicle dynamics, braking inertia, and shockwave propagation. The continuous reward function balances throughput efficiency, squared-queue congestion penalties, and fairness (delay-tracking) to eliminate “starvation” of low-density lanes. Scaling from a single node to a 2×2 grid produced emergent “Green Wave” synchronization and perimeter gating under saturation (>1200 veh/hr).

Trained a DQN with an MLP policy via Stable Baselines3 to master a 6-color, 6^56 state-space grid game, achieving a 46-game win streak against random opponents. Custom Gymnasium environment with H×W×C one-hot encoded tensors so the network processes spatial relationships categorically.

Deployed the model into an interactive web app (React + FastAPI + WebSockets) that surfaces raw inference Q-values in real time. Overcame a player-perspective training mismatch by applying dynamic horizontal/vertical tensor flips on the backend prior to inference, with no model retraining needed.

A stabilizing control policy for the 29-DOF Unitree G1 humanoid trained with PPO and a small Actor-Critic network (512 → 256 → 128). Built on the mjlab framework with MuJoCo Warp to simulate 4,096 parallel environments directly on the GPU, bypassing CPU bottlenecks.

Modified pre-existing walking task algorithms by constraining velocity commands to zero and tightening reference-pose standard deviations to shape a “minimum energy basin” reward. Domain randomization across friction, mass, and actuator gains, plus NaN guards on qpos/qvel to catch numerical instabilities without crashing training.

An autonomous navigation stack for a precision-agriculture robot built on ROS/ROS2, with A* and Dynamic Window Approach (DWA) running on custom navigation controllers. Cut navigation errors significantly during in-field trials.

Authored a differential-drive controller, a keyboard teleop controller, and a custom model-based Farmland environment for navigation. Built high-fidelity agricultural simulation environments in Gazebo with custom crop models, achieving high correlation with real-world robot behaviour for the vision-based detection systems.

A custom arm robot dropped into a ROS1 workspace to make transform mechanics concrete. The TF tree is the star: each joint publishes its own frame, the chain composes into the end-effector pose, and the same arithmetic that looks abstract in slides becomes a visualizable graph in rviz.

Done alongside the SLAM coursework, so the same TF intuition (frames, parents, time-stamped lookups) carries straight over to localization and mapping work.