TinyBrains Competition Launches Small Neural Networks for Strategy Game Ants

TinyBrains launches a competition focused on ultra‑compact neural networks for the classic Ants strategy game

TinyBrains challenges developers to train neural networks that fit within strict weight‑class limits (nano ≤ 16 KiB, micro ≤ 128 KiB, mini ≤ 1 MiB, small ≤ 8 MiB, large ≤ 64 MiB) and still achieve high game performance. The competition revives the 2011 Google AI Ants Challenge, but replaces hand‑coded bots with trained models and a manifest that together determine the weight class.

Competition mechanics are centered on model size, not just strength

  • Model‑plus‑manifest size defines the class – The total byte count of the serialized network weights plus the accompanying manifest file places a submission into one of five weight classes. This rule forces participants to compress both architecture and metadata.
  • Performance is measured by Elo‑style rating – Each submitted version plays matches on a public ladder; its rating reflects win‑loss outcomes against other submissions in the same class.
  • Leaderboard visualizes size vs. rating – A logarithmic plot shows every active version, making it easy to spot the most efficient models (high rating with low byte count).

"Your class is measured, not chosen" – TinyBrains documentation emphasizes that the size constraint is enforced automatically rather than selected by the user.

Current results highlight the trade‑off between compactness and skill

Rank Model Rating
1 Media v1 (baseline) 25.0
2 Scout v1 (baseline) 24.9
3 Harvester v1 (baseline) 24.6
4 Forager v1 (baseline) 24.5
5 Minim v1 (baseline) 21.8

All top entries are labeled baseline, indicating they were produced from the starter code provided by TinyBrains. Recent matches show baseline models competing head‑to‑head, e.g., a 2‑player match on the small‑open‑2p‑3h map where gr8b8m8 v1 (rating 8) defeated Minim v1 (rating 2).

Community feedback underscores interest and areas for improvement

  • Nostalgia and learning value – The original poster, codetiger, notes personal experience in the 2011 Google Ants AI Challenge and hopes the new platform will rekindle that learning community.
  • Desire for clearer documentation – Commenter lostdog suggests simplifying the wording around weight‑class selection, while vova_hn2 finds the current phrasing ambiguous and calls for clearer language.
  • Technical accessibility concerns – cookiengineer points out that the current Python‑PyTorch stack may exclude participants using other languages (e.g., C++), and proposes a Gym‑compatible interface for custom training pipelines.
  • Curiosity about limits – Multiple commenters ask how small a network can be while still making strategic decisions and whether inference speed is also considered.
  • Broader AI competition context – Users reference related contests such as MIT Battlecode, Core War, and historic AI Wars, indicating a broader appetite for compact‑AI challenges.

How to get started

  1. Sign in with GitHub on the TinyBrains website.
  2. Read the docs – The "Weight classes" page explains size limits and manifest requirements.
  3. Clone the starter repository: https://github.com/Tiny-Brains/ants-starter.
  4. Train a model within the chosen size budget (e.g., < 16 KiB for nano).
  5. Submit the model and manifest via the "Submit a version" UI.
  6. Watch matches on the ladder and monitor your rating.

Why the focus on tiny models matters

Compressing neural networks forces developers to explore pruning, quantization, architecture search, and novel encoding schemes—techniques that are directly relevant to edge‑AI deployments, mobile inference, and low‑power hardware. By tying performance to size, TinyBrains creates a practical benchmark for efficiency that complements traditional accuracy‑oriented contests.

Outlook

The competition runs until 30 Sept 2026 (the “Nuptial Flight Open” deadline), giving participants several months to iterate. Community interest, as reflected in the Hacker News discussion, suggests the platform could expand to additional games or provide a Gym‑style API for broader algorithmic experimentation.

All information is drawn from the TinyBrains website and the associated Hacker News discussion thread; no external data has been added.

Sources

Related

  • Dispatch
    mini-AGI: Continual Learning Byte-Level Model for Consumer Hardware

    mini-AGI is a byte-level language model designed for continual learning on consumer GPUs, utilizing a paged Mixture-of-Experts (MoE) architecture to prevent catastrophic forgetting and enable training on 8GB VRAM.

  • Project
    HazyResearch/HipKittens

    HipKittens is a C++ library that provides tile‑based, low‑level primitives for writing fast AI kernels (GEMM, attention, etc.) on AMD GPUs. It includes async memory helpers, scheduling patterns, and example kernels that can be benchmarked against AITER and PyTorch. The repo supplies Docker images, unit tests, training scripts, and analysis tools for reproducing its performance results.

  • Project
    HazyResearch/ThunderKittens

    ThunderKittens is a header‑only CUDA library that provides a tiny, tile‑oriented DSL for writing fast deep‑learning kernels (e.g., GEMM, FlashAttention). It abstracts tensor‑core calls, async memory moves, and shared‑memory banking while keeping the code compact and type‑safe. Designed for Hopper/Blackwell (and Vera Rubin) GPUs, it lets researchers and engineers produce near‑peak‑performance kernels that can be called from C++ or wrapped for PyTorch.

  • Dispatch
    TinyStories LLM on a $250 KV260 FPGA achieves 60k tokens/s

    A 3.16 M‑parameter INT4 model runs entirely in on‑chip memory of an AMD KV260 FPGA, reaching 59,965 tokens per second on silicon and ~21,300 tokens per second in a live multi‑user demo.

  • Project
    codelion/adaptive-classifier

    Adaptive Classifier is a PyTorch‑based library for dynamic text classification. It supports continuous learning, runtime addition of new classes, and a strategic (adversarial‑robust) mode. Built on HuggingFace transformers, it offers hybrid prototype‑+‑neural predictions, automatic ONNX export for 2‑4× faster CPU inference, and multi‑label support with adaptive thresholds. The package can be installed via `pip install adaptive-classifier`, saved/loaded locally or to the HuggingFace Hub, and includes benchmarks showing improved robustness and cost savings.