docs/planning/hackathon-analysis.md

Meta PyTorch OpenEnv Hackathon x SST | India AI Hackathon '26

Source: https://www.scaler.com/school-of-technology/meta-pytorch-hackathon#open-ev Scraped: 2026-03-24

---

Overview

India's Biggest MEGA AI Hackathon — build at the bleeding edge of AI using Meta's OpenEnv framework. The foundation for next-gen RL environments used by leading AI labs.

• Registration: Free
• Registration Deadline: Friday, 3rd April 2026
• Team Size: 1-3 members (solo or team)
• Total Prize Pool: $30,000
• Finale Location: Scaler School of Technology, Bangalore (in-person)

---

Key Incentives

Benefit	Details
Interview Access	Winners get a direct interview opportunity at Meta & Hugging Face AI teams
Free Training	Prep courses from Hugging Face & PyTorch included at every stage
Prize Pool	$30,000 total
Open Source	Your code ships to a Meta-backed project, visible on your GitHub profile
Code Review	Work reviewed by Meta engineers shaping agentic AI
Networking	Connect with India's best AI builders over 2 days in Bangalore

---

Prize Breakdown

Position	Prize
1st Prize	Top tier (part of $30K pool)
2nd Prize	Part of $30K pool
3rd Prize	Part of $30K pool
4th - 8th	$2,000 each ($10,000 total)
9th - 15th	$650 each ($4,550 total)

Additional: Exclusive merch for all finalists. Work reviewed by Meta's global team.

---

Schedule / Timeline

Phase	Date	Details
Registrations Open	Sat, 14th Mar - Fri, 3rd Apr	Sign up solo or team (up to 3). Access free prep courses. Join Discord.
Round 1 (LIVE)	Wed, 25th Mar - Wed, 8th Apr	Build a Mini-RL environment with defined tasks, graders, and reward logic. Evaluation includes programmatic checks & LLM scoring.
Round 1 Results	Fri, 10th Apr	Results declared. Access Round 2 prep guidelines from dashboard.
Advanced RL Bootcamp	Sat, 18 Apr - Sun, 19 Apr	Intensive online weekend bootcamp for shortlisted teams. Deep-dive into advanced RL concepts, meta-learning strategies, and Round 2 optimization. Expert sessions from Meta engineers.
Round 2 - Grand Finale	Sat, 25 Apr - Sun, 26 Apr	48-hour on-campus hackathon at Scaler School of Technology, Bangalore. Mentorship from Meta engineers. Judging by Meta's global team. Closing awards ceremony.

---

What is OpenEnv?

OpenEnv is an open-source framework by Meta & Hugging Face for creating standardized, isolated, and reusable environments for training and deploying AI agents.

Key features:

• Gymnasium-style API for standardized interaction
• Containerized execution via Docker
• Central hub on Hugging Face for sharing environments
• Used by teams at Meta to define environments once and run them consistently across training, post-training, and evaluation

Think of it as the universal language for AI training environments.

Resources:

• OpenEnv spec on GitHub
• Meta-PyTorch GitHub
• HuggingFace GitHub

---

What You Build

Build RL environments on top of OpenEnv. Example project ideas:

Category	Project	Description
Infrastructure	Autonomous Traffic Control	Multi-agent environment where AI systems manage a 4-way intersection with emergency vehicle prioritization
Support	Customer Service Agents	Complex environment where agents resolve multi-step queries using external tools and APIs
Workflow	Email Triage System	Agents learn to prioritize, categorize, and route emails using contextual understanding
Gaming	Multi-Agent Strategy	Agents compete in a strategic game environment with incomplete information and evolving rules

200+ more problem statements available from Meta.

Round 1 Specifics

• Build a Mini-RL environment
• Must include defined tasks, graders, and reward logic
• Evaluation via programmatic checks & LLM scoring

Round 2 (Finale) Specifics

• 48-hour on-campus sprint in Bangalore
• Direct mentorship from Meta engineers on the ground
• Judging by Meta's global team

---

Eligibility & Prerequisites

Who It's For

• Developers, ML engineers, or CS students in India
• Anyone curious about AI agents and how they learn
• No prior RL experience required — free prep courses at every stage

Prerequisites (Honest)

• Basic Python
• Some ML familiarity
• GitHub comfort
• "If you've built anything in Python, you're ready."

What You Get

• Free prep courses from Hugging Face & PyTorch
• Live workshops with senior AI engineers
• Discord community access from day one

Team Formation

• Round 1: Solo or team of up to 3
• Finale: Option to team up with other selected builders on campus

---

Training & Support

Resource	Details
Prep Courses	Free from Hugging Face & PyTorch
Deep Dive Sessions	Meta-led sessions on OpenEnv before every round
Engineer Access	Direct access to Meta engineers during finale
Weekend Bootcamp	Intensive bootcamp for finalists (Apr 18-19, online)
Discord	Community access from registration

---

Finale Logistics (Scaler SST, Bangalore)

• Venue: Scaler School of Technology campus, Bangalore
• Duration: 48 hours (Sat 25 Apr - Sun 26 Apr)
• Food: All meals covered during the on-campus finale
• Merch: Exclusive limited-edition hackathon swag for all finalists
• Expert Talks: Live sessions from Meta, PyTorch, and Hugging Face engineers

---

Sponsors & Partners

Role	Organization
Primary Sponsor	Meta
Ecosystem Partner	Hugging Face
Framework Partner	PyTorch
Powered By	Scaler School of Technology (SST)

---

FAQs (Questions Listed on Page)

1. Who can participate?
2. Is this hackathon free to participate in?
3. How many rounds are there?
4. Where is the hackathon held?
5. Will food and accommodation be provided for the final round?
6. What is the team size?
7. Do all team members need to register individually, and how do I form a team?
8. Can team members be from different colleges or companies?
9. Are there coding requirements?
10. Do I need prior experience in Reinforcement Learning to participate?
11. What learning support is available?
12. Will there be any live sessions to help me prepare?
13. Will there be mentorship?
14. What do finalists get?
15. What happens to what I build?
16. What do the winners receive?
17. How does the interview opportunity work?

Note: FAQ answers are behind collapsible UI elements on the page. Key answers are addressed throughout this document based on other sections of the page.

---

Key Takeaways for Participation

1. Free to enter, teams of 1-3, registration closes Apr 3
2. Round 1 is remote (Mar 25 - Apr 8) — build a mini RL environment
3. Finale is in-person in Bangalore (Apr 25-26) — 48-hour hackathon
4. No RL experience needed — free training provided at every stage
5. Winners get Meta & Hugging Face interview — your hackathon performance IS your application
6. Code goes open source on a Meta-backed project — real GitHub contributions
7. $30K prize pool across top 15 positions

---

Our Team

Team Name: AI Mafias Status: Locked (no changes allowed)

Member	Email	Role
Anshuman Atrey	anshumanatrey@gmail.com	Team Lead
Sahil Shah	ss9656484@gmail.com	Member (Accepted)
Vijay Kota	vijaykota2776@gmail.com	Member (Accepted)

---

Round 1 — Problem Statement (Detailed)

The Task

Build a complete, real-world OpenEnv environment that an AI agent can learn from through the standard step() / reset() / state() API.

Key Requirements at a Glance

Requirement	Details
Real-world task	Must simulate something humans actually do (NOT games/toys). E.g.: email triage, code review, data cleaning, scheduling, customer support, content moderation
OpenEnv spec	Typed Pydantic models, step()/reset()/state(), openenv.yaml, passes openenv validate
3+ Tasks with graders	Each task has a programmatic grader scoring 0.0–1.0, difficulty range: easy → medium → hard
Reward function	Provides signal over full trajectory, rewards partial progress, penalizes bad behavior
Baseline inference script	Uses OpenAI API client, reads OPENAI_API_KEY from env vars, produces reproducible scores on all 3 tasks
HF Space deployment	Containerized, tagged with openenv
Dockerfile	Must docker build + docker run cleanly
README	Environment description, action/observation spaces, task descriptions, setup instructions, baseline scores

Additional Endpoints to Expose

Endpoint	Purpose
/baseline	Trigger inference script, return baseline score for all 3 tasks
/grader	Return grader score after an episode is completed
/tasks	Return list of tasks and the action schema (fields required for an action in a step)

Functional Requirements (Detailed)

1. Real-world task simulation

• Must simulate a task humans actually do
• NOT games, NOT toys
• Examples: email triage, code review, data cleaning, scheduling, customer support, content moderation

2. OpenEnv spec compliance

• Typed Observation, Action, and Reward Pydantic models
• step(action) → returns observation, reward, done, info
• reset() → returns initial observation
• state() → returns current state
• openenv.yaml with metadata
• Must pass openenv validate

3. Minimum 3 tasks with agent graders

• Each task = concrete objective an agent must accomplish
• Programmatic grader scores performance 0.0–1.0
• Difficulty range: easy → medium → hard
• Graders must have clear, deterministic success/failure criteria

4. Meaningful reward function

• Signal over the full trajectory (NOT just binary end-of-episode)
• Rewards partial progress toward task completion
• Penalizes clearly undesirable behavior (e.g. infinite loops, destructive actions)

5. Baseline inference script

• Uses the OpenAI API client to run a model against the environment
• Reads API credentials from environment variables (OPENAI_API_KEY)
• Produces reproducible baseline score on all 3 tasks

Non-Functional Requirements

• Deploys to HF Space — tagged with openenv
• Containerized — working Dockerfile, clean docker build + docker run
• Documented — README with: env description & motivation, action/observation space definitions, task descriptions with difficulty, setup instructions, baseline scores

---

Scoring Criteria

Parameter	Weight	Description
Real-world utility	30%	Does the environment model a genuine task? Would someone actually use this to train/evaluate agents?
Task & grader quality	25%	Well-defined tasks? Accurate graders? Meaningful difficulty progression?
Environment design	20%	Clean state, sensible action/observation spaces, good reward shaping, proper episode boundaries
Code quality & spec compliance	15%	Follows OpenEnv spec, clean structure, typed models, documented, tested, Dockerfile works
Creativity & novelty	10%	Novel domain, interesting mechanics, clever reward design, original approach

Scoring Rubric

Real-world utility (30%)

• 0–5: Toy/artificial problem with no practical application
• 6–15: Valid domain but shallow modeling of the real task
• 16–25: Good domain modeling, would be useful for agent evaluation
• 26–30: Excellent — fills a real gap, immediate value for the RL/agent community

Task & grader quality (25%)

• 3+ tasks with difficulty range?
• Graders produce scores between 0.0–1.0?
• Graders deterministic and reproducible?
• Hard task genuinely challenges frontier models?

Environment design (20%)

• reset() produces clean state?
• Action/observation types well-designed and documented?
• Reward function provides useful varying signal (not just sparse)?
• Episode boundaries sensible?

Code quality & spec compliance (15%)

• openenv validate passes?
• docker build && docker run works?
• HF Space deploys and responds?
• Baseline script runs and reproduces scores?

Creativity & novelty (10%)

• Domain we haven't seen in OpenEnv before?
• Reward design has interesting properties?
• Clever mechanics that make the environment engaging?

---

Judging Process

Phase 1: Automated Validation (Pass/Fail Gate)

• HF Space deploys
• OpenEnv spec compliance
• Dockerfile builds
• Baseline reproduces
• 3+ tasks with graders

Phase 2: Agentic Evaluation (Scored)

• Baseline agent re-run
• Standard Open LLM agent (e.g. Nemotron 3 Super) run against all environments
• Score variance check

Phase 3: Human Review

• Top submissions reviewed by Meta and Hugging Face engineers
• Evaluated for real-world utility, creativity, and exploit checks

Disqualification Criteria

• Environment does not deploy or respond
• Plagiarized or trivially modified existing environments
• Graders that always return the same score
• No baseline inference script

---

Pre-Submission Checklist (ALL must pass or disqualified)

• HF Space deploys — automated ping to Space URL returns 200 and responds to reset()
• OpenEnv spec compliance — validate openenv.yaml, typed models, step()/reset()/state() endpoints
• Dockerfile builds — automated docker build on submitted repo
• Baseline reproduces — inference script completes without error and produces scores
• 3+ tasks with graders — each grader returns scores in 0.0–1.0 range
• /baseline endpoint works
• /grader endpoint works
• /tasks endpoint works
• Run pre-submission validation script before submitting

---

Scale & Competition

• 20,000 teams registered → only 3,000 advance (top 15%)
• Deadline: 8 April 2026, 11:59 PM IST
• Round 1 is NOW LIVE

---

CRITICAL: Additional Instructions (from Dashboard — April 2026)

Environment Variables (MUST define)

Variable	Purpose
API_BASE_URL	The API endpoint for the LLM
MODEL_NAME	The model identifier to use for inference
HF_TOKEN	Your Hugging Face / API key

Note: This replaces the earlier mention of OPENAI_API_KEY. The env must read these three variables.

Inference Script Rules

• MUST be named inference.py — placed in root directory of the project
• MUST use OpenAI Client for all LLM calls (using above variables)
• Supports screenshot/image observations via image_url in messages

Infrastructure Restrictions

• Runtime: Inference script must finish in < 20 minutes
• Hardware limit: Must run on vcpu=2, memory=8GB
• This is tiny — your environment MUST be lightweight, no heavy models or large datasets

Pre-Validation

• Run the official pre-submission validation script before submitting
• Script checks: HF Space is live, Docker builds, openenv validate passes

---

Reference Projects (Top SF Hackathon Submissions)

These are the winning projects from the San Francisco edition — study their structure:

Project	GitHub Path	Type
Calendar Environment	meta-pytorch/OpenEnv/tree/main/envs/calendar_env	Scheduling/calendar management
Reasoning Gym	meta-pytorch/OpenEnv/tree/main/envs/reasoning_gym_env	Reasoning tasks
TB2 (TBench2)	meta-pytorch/OpenEnv/tree/main/envs/tbench2_env	Tool-bench environment
CARLA	meta-pytorch/OpenEnv/tree/main/envs/carla_env	Autonomous driving sim
REPL	meta-pytorch/OpenEnv/tree/main/envs/repl_env	Code execution environment

Note: "You do not need to replicate these. Use them to understand how environments are structured."

Sample Inference Script Pattern

# Key pattern from official sample:
user_prompt = build_user_prompt(step, observation, history)
user_content = [{"type": "text", "text": user_prompt}]

# Supports screenshot/image observations
screenshot_uri = extract_screenshot_uri(observation)
if screenshot_uri:
    user_content.append({
        "type": "image_url",
        "image_url": {"url": screenshot_uri},
    })

messages = [
    {"role": "system", "content": [{"type": "text", "text": SYSTEM_PROMPT}]},
    {"role": "user", "content": user_content},
]

completion = client.chat.completions.create(
    model=MODEL_NAME,
    messages=messages,
    temperature=TEMPERATURE,
    max_tokens=MAX_TOKENS,
    stream=False,
)
response_text = completion.choices[0].message.content or ""
action_str = parse_model_action(response_text)
result = env.step(Action(action_str=action_str))