Inspiration
We wanted to build an autonomous agent that could think several moves ahead, anticipate opponent behavior, and adapt in real time — similar to how humans play tactical grid games like Tron or Snake Arena. The challenge of optimizing decision-making under strict time and space constraints was a perfect opportunity to blend algorithmic depth with real engineering systems.
What it does
Steamroller is an intelligent, deterministic AI agent that competes in a 2D grid-based environment where every move leaves behind a permanent wall. The agent’s goal is simple yet complex: survive longer than its opponent by strategically planning movements, predicting enemy paths, and maximizing available space.
It communicates with the competition engine via REST endpoints and uses a fast heuristic-driven Minimax search with pruning and dynamic depth control. The result is an agent that consistently evaluates thousands of potential rollouts per second, dynamically adjusting its strategy based on the opponent’s last move and available territory.
How we built it
We developed Steamroller using Python for decision logic and Go for high-performance runtime execution.
The Go layer handles real-time communication and board-state updates, enabling low-latency response cycles within strict tick limits.
The Python core runs the Minimax decision tree enhanced with advanced heuristics — including spatial control, opponent proximity, and safe zone maximization.
We containerized everything using Docker for reproducible builds and smooth deployment in isolated environments.
For remote integration testing, we used Cloudflare tunnels to securely expose and test agents against each other in real time. This hybrid Python–Go architecture gave us both flexibility for AI experimentation and near-native execution speed for runtime evaluation.
Challenges we ran into
Performance bottlenecks — Early Python-only builds were too slow for real-time simulation. Moving core state evaluation to Go improved performance by ~3–4×.
Determinism under parallelism — Ensuring consistent results across rollouts required strict random seed control and synchronization between threads.
Network stability — Simulating remote agents introduced timeout and latency issues, which we mitigated by implementing retry and fallback mechanisms within the judge engine.
Heuristic tuning — Balancing aggression (approaching opponents) versus survival (maximizing open space) required iterative fine-tuning through hundreds of simulated matches.
Accomplishments that we're proud of
Built a hybrid cross-language AI system integrating Python and Go seamlessly through REST interfaces.
Designed a highly optimized Minimax engine capable of evaluating 5,000–10,000 rollouts with 40+ future lookahead moves per decision cycle.
Successfully containerized and deployed our system using Docker with under 5GB image size, compliant with competition constraints.
Established a cloud-based testing setup using Cloudflare tunnels for realistic, latency-aware simulations between agents.
Achieved consistent low-latency decision times (<50ms) while maintaining deterministic behavior across runs.
What we learned
The trade-offs between exploration and exploitation in search-based agents.
The value of language-level optimization — how Go’s concurrency and memory management can drastically outperform Python in simulation-heavy loops.
How to design fault-tolerant agent communication over HTTP under competitive conditions.
Best practices for containerizing ML/AI applications under strict size and CPU-only constraints.
What's next for Steamroller
Integrate a Monte Carlo Tree Search (MCTS) layer on top of the Minimax core for probabilistic lookahead.
Add neural evaluation models for board state scoring (while keeping CPU-friendly builds).
Expand to multi-agent battles and collaborative survival modes.
Create a web-based visualization dashboard to replay games, inspect decisions, and visualize search depth dynamically.
Log in or sign up for Devpost to join the conversation.