Please see PROBLEM.md.

We are hosting two distinct tracks to celebrate both systems engineering and AI reasoning. Teams may participate in one or both tracks.

Submissions will be accepted via the Official Submission Form. You will be asked to provide your team details and upload your solution as a single .zip archive.

• Deadline: April 24, 2026, 11:59 PM PT.
• File Naming: Please name your archive using the format: TeamName_Track_SubmissionNumber.zip (e.g., DeepRunners_TrackA_1.zip).
• Form Settings Note: when uploading, ensure your file is a standard .zip archive.

This track focuses on the efficiency and robustness of the scheduling algorithm itself.

• Deliverable: A compiled binary executable named mlsys.
• Interface: your binary must accept two command-line arguments:

�$ ./mlsys <path_to_input.json> <path_to_output.json>

• Note: The timeout is enforced by the organizer's harness, not passed as an argument. Your binary simply needs to write the solution file before it gets killed.
• Zip Contents:
  • mlsys: The statically linked binary (must run on Ubuntu 22.04 LTS).
  • source/: Complete source code (C++/Rust/etc.) for verification.
  • writeup.pdf: a 2-page summary of your approach.

This track benchmarks the ability of Gemini-powered Agents to solve scheduling puzzles. To ensure fair comparison, your agent must exclusively utilize the Google Gemini API for its reasoning and generation.

• Deliverable: a Python script named agent.py.
• Interface: Your script will be executed as follows:

$ python3 agent.py <path_to_input.json> <path_to_output.json>

• Environment:
  1. The organizers will inject the GOOGLE_API_KEY environment variable.
  2. Network access is strictly blocked except to the Gemini API endpoint (generativelanguage.googleapis.com). Calls to any other LLM provider (OpenAI, Anthropic, etc.) will fail.
  3. Timeout: Your agent script is strictly limited to 10 minutes of execution time per benchmark (including all API calls and local processing).
• Zip Contents:
  1. agent.py: The entry point script.
  2. requirements.txt: A list of Python dependencies (e.g., google-generativeai, numpy).
  3. prompts/: A folder containing your system prompts, few-shot examples, or agent definitions (required for reproducibility).
  4. writeup.pdf: A short (1-2 page) summary of your prompting strategy and agent architecture.

Both tracks share the same set of 25 benchmark problems.

To ensure fair play and broad accessibility, this contest is designed to be Zero Cost for all participants.

For Track A (Systems):

• Standard Hardware: since the problem is a specialized graph scheduling puzzle (JSON-to-JSON), no special hardware is required for the solution itself. A standard laptop or free Colab CPU instance is sufficient to run the mlsys binary and generate schedules.

For Track B (Agents):

• Free Intelligence: participants are encouraged to use Gemini 1.5 Flash via Google AI Studio. The free tier provides approximately 1,500 requests per day, which is sufficient for developing and testing robust agentic schedulers.

To help you get started, we have released a separate GitHub repository containing several C++ files that define the basic problem and solution classes, along with various utilities. You are under no obligation to use these source codes.

Please don't hesitate reaching out to the Contest Organizers if you encounter any trouble getting these materials to work.

The contest will involve twenty-five industrial benchmarks; five have been released in advance to contest participants (for testing purposes), and the remaining twenty will be withheld for evaluation:

Note on Timeouts: The timeouts listed below apply strictly to Track A (Systems). For Track B (Agents), a fixed timeout of 10 minutes is applied to every benchmark to accommodate LLM inference latency.

All benchmarks will become publicly available after the contest is complete.

The contest organizers will execute each team's binary across the twenty withheld benchmarks on a dedicated 8-core Linux workstation with 32GB of RAM. Rankings will be established by calculating the total number of points per team, where points are derived by normalizing cost values against the best submitted solution.

For example, assume the following raw costs:

The points that a team earns for a particular benchmark is then equal to min_team_cost / team_cost

Thanks to our sponsor Google, we are offering a $50,000 Total Prize Pool, split evenly between the two tracks to encourage diversity in approaches.

Award Rules:

1. Open Source: To be eligible for cash prizes, winning teams must open-source their solution (code or agent prompts) under an MIT/Apache 2.0 license within 2 months of the award.
2. One Prize Per Team: A single team can compete in both tracks but may only claim the highest monetary prize earned across tracks (the unclaimed prize passes to the next rank).
3. Agent Reproducibility: For Track B, the organizers will re-run your agent 3 times. The median score will be used to mitigate non-deterministic LLM outputs.

Teams who win the gold awards will be invited to present a ~10 minute informal overview of their approach at a special session held during the conference days. Presentations will be linked from the main MLSys competition website.

All are welcome to participate in the contest -- including teams from academia, industry, and elsewhere -- with the exception of the Contest Organizers and employees of the Contest Sponsor. Individuals are prohibited from participating in multiple teams. In order to be eligible for prizes, contestants must commit to releasing an open-source version of their implementation 1 month after winning (allowing teams sufficient time to write & submit papers detailing their approach).

To raise a question, please create an issue in this repository, or feel free to reach out to the contest organizers directly.

ASPLOS 2025 contest track, which is a prequel of this problem.
Tensor processing primitives: a programming abstraction for efficiency and portability in deep learning workloads (2021)
Apollo: Automatic Partition-based Operator Fusion through Layer by Layer Optimization (2022)
Optimus: An Operator Fusion Framework for Deep Neural Networks (2022)
FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness (2022
Operator Fusion in XLA: Analysis and Evaluation (2023)
How Much Can We Gain From Tensor Kernel Fusion on GPUs? (2024)

Yarong Mu (ymu@google.com) & Weiren Yu (weirenyu@google.com)