About me

Little Learning Machines

A sandbox game where players raise and train their own AI creatures using deep reinforcement learning — every "Bot" is a live neural network that learns from the environments, rewards, and demonstrations the player sets up. The project meant turning research-grade RL into a robust gameplay feature: training has to converge under arbitrary, sometimes adversarial player setups, and inference has to stay smooth during play.

• Researched, designed and prototyped the intelligent systems behind player-trainable creatures, hardening research-grade RL into a shippable feature.
• Optimized and accelerated training and inference pipelines so on-device training stayed responsive during gameplay.
• Evaluated AI behaviour against subjective design goals and iterated based on those findings.
• Maintained and documented the codebase, followed studio coding standards and took part in code reviews.
• Designed and prototyped gameplay mechanics and intelligent agent behaviours, collaborating closely with creative and design teams to refine user experiences.
• Worked closely with development and creative teams at the intersection of ML behaviour and game design, where early assumptions often broke under real training results.
• Contributed to the overall design of how ML systems were exposed to and shaped by players.

Simia — real-time story engine

A real-time generative story engine (previously known as RobotsMakeTV), blending machine learning with interactive narrative to produce stories that respond and evolve as the audience engages with them.

• Researched and prototyped intelligent systems for driving real-time generative narrative experiences.
• Optimized inference pipelines to meet the latency demands of a real-time, audience-facing system.
• Implemented solutions around fluid and ambiguous requirements typical of generative experiences, where early design assumptions frequently shifted as the system's behaviour was observed.
• Maintained and documented the codebase, participated in code reviews and followed studio coding standards.
• Communicated actively with the development and creative teams to address outstanding issues across engineering and storytelling.
• Contributed to the overall design and development of the engine as a generative experience platform.

Fealty To The King — self-play RL opponent

A turn-based board game with a chess-RPG hybrid ruleset, featuring an AI opponent trained from scratch using reinforcement learning and self-play — the same family of techniques behind AlphaZero, applied to a custom ruleset where no prior heuristics existed.

• Designed the gameplay mechanics and ruleset — piece abilities, turn structure and the interaction between chess-style movement and RPG systems.
• Implemented those mechanics in Unity and C#: turn flow, board state, movement and combat resolution.
• Designed and trained the self-play RL agent that drives the in-game opponent.
• Defined the observation and action representation for a non-standard, mixed-mechanic ruleset.
• Tuned the training loop until the agent was a credible opponent for human players.
• Built as a team of five over six months as the capstone for the Game Design and Development program.

Dino — agents that choose when to act

A research project tackling a fundamental inefficiency in real-time game AI: agents forced to make a decision on every single frame, whether or not anything meaningful has changed. I designed and built a custom delayed-action system that lets agents decide both what to do and when their next decision should happen — cutting inference calls and producing more deliberate, game-like behaviour in continuous-time environments.

• Designed and implemented the delayed-action decision framework on top of Unity ML-Agents.
• Benchmarked against the default per-frame decision baseline across multiple scenarios.
• Published the findings in a Medium article covering motivation, implementation and results.

ML-Agents training infrastructure & PBT tools

A training infrastructure layer for Unity ML-Agents built around Population Based Training — evolving hyperparameters during training rather than fixing them upfront. Beyond PBT, the tooling handles the day-to-day reality of training agents at scale: spawning parallel environments, switching the active camera between agents, controlling timescale, surfacing per-agent debug information, and pushing custom metrics to TensorBoard live during training.

• Implemented PBT-style training orchestration on top of Unity ML-Agents.
• Built multi-environment parallel training support to maximize throughput.
• Added in-engine debugging and observability for agent state, custom values and TensorBoard integration.

Doodle Jump — attention-based perception for RL agents

A Unity platformer built as a testbed for custom perception systems in reinforcement learning. The headline contribution: a sensor that parses surrounding game objects into a variable-length vector processed by an attention module — letting the agent reason about an arbitrary number of nearby entities instead of a fixed-size observation space. It also served as a benchmark for how different sensor and network configurations affect decision sampling speed in real-time gameplay.

• Designed and implemented the attention-based variable-length sensor.
• Compared multiple perception system designs and training algorithms on the same game.
• Benchmarked inference performance across configurations to inform real-time deployment trade-offs.

Unity DOTS ML-Agents prototype — hundreds of agents on ECS

A multi-threaded multi-agent environment built on Unity's Data-Oriented Technology Stack, using the experimental DOTS branch of ML-Agents to push per-agent AI to a scale that is normally impractical in standard Unity. Hundreds of agents compete simultaneously in a battle-royale-style arena, with two adversarial networks trained against each other to see what emergent behaviour appears. Originally a research collaboration with Enhearten Media to evaluate whether per-agent learned AI could be feasible inside an RTS game.

• Built the DOTS/ECS-based multi-agent environment from the experimental ML-Agents branch.
• Ran adversarial self-play training across hundreds of concurrent agents.
• Stress-tested the stack to identify what was actually viable for RTS-scale per-agent AI.

Star Jump Commando

A commercial endless runner shipped on Android and iOS at Comet Studios — a polished, balanced game taken end-to-end, alongside the more research-focused projects here.

• Designed and implemented core gameplay systems: collectibles, equipment, enemies, bosses, wave generation and the difficulty scaling curve.
• Implemented cloud save and data persistence, plus monetization and in-app purchase workflows.
• Collaborated with other programmers on the overall code architecture and integrated with existing systems.
• Owned QA and balancing for game progression, tuning difficulty against playtest data.
• Worked closely with the design team in agile sprints and standups to translate creative direction into shipped features.

• Developed, maintained and documented modular C# codebases in Unity for interactive and generative projects.
• Optimized simulation and inference pipelines for performance, frame rate and resource use.
• Prototyped gameplay mechanics and agent behaviours with the creative and design teams.
• Built editor-facing tools that streamlined designer and artist workflows.

• Shipped core gameplay systems for a mobile title on iOS and Android.
• Implemented cloud save and persistence, plus monetization and IAP workflows.
• Designed modular architecture alongside senior programmers for easy feature scaling.
• Worked with design and QA on balance, low-end device performance and platform bugs.