Portfolio

Little Learning Machines

A sandbox game shipped on Steam 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. Developed at Transitional Forms. The project required 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.

Developer

• Researched, designed, and prototyped the intelligent systems that power player-trainable creatures, hardening research-grade RL into a shippable feature.
• Optimized and accelerated deep learning training and inference pipelines so on-device training stayed responsive during gameplay.
• Evaluated AI behavior against subjective and iterated based on those findings.
• Maintained and documented the codebase, followed studio coding standards, and participated in code reviews.
• Worked closely with development and creative teams at the intersection of ML behavior 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) developed at Transitional Forms, blending machine learning with interactive narrative to produce stories that respond and evolve as the audience engages with them. Developer

• 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 behavior 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.

Dino - Agents that choose when to act

A research project tackling a fundamental inefficiency in real-time game AI: agents that are forced to make a decision on every single frame, regardless of whether 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 — dramatically reducing inference calls and producing more deliberate, game-like behavior 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 the motivation, implementation, and results.

ML-Agents Training Infrastructure & PBT Tools

A training infrastructure layer for Unity ML-Agents built around Population Based Training — a technique used by DeepMind to evolve hyperparameters during training rather than fix them upfront. Beyond PBT, the tooling streamlines 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, rather than being locked to a fixed-size observation space the way most ML-Agents setups are. The project also served as a benchmark to measure 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.

Fealty To The King - Self-play RL opponent in a turn-based game

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. I designed the agent’s observation and action spaces, set up the self-play training loop, and tuned the system until the trained agent was a credible opponent for human players.

• Designed and trained the self-play RL agent that drives the in-game opponent.
• Defined the observation/action representation for a non-standard, mixed-mechanic ruleset.
• Built as a team of five over six months as the capstone for the Game Design and Development program.

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’s typically 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 behaviors appear. 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 - Shipped mobile game

A commercial endless runner shipped on Android and iOS in April 2022 — included here as evidence of shipping a polished, balanced game end-to-end alongside the more research-focused projects above.

Unity Developer / Programmer

• Designed and implemented core gameplay systems: collectibles, equipment, enemies, bosses, wave generation, and the difficulty scaling curve.
• 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.