# 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
```python
# 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))
```