step 1
How will you compete?
Choose solo or team before you can start the assessment
Step 1 Complete Competing as Solo Warrior
👤 Sanjayprasad H S sanjuhs123@gmail.com 🔒 Locked for Round 1. You cannot switch to a team until Round 1 is over.
OpenEnv Round 1 Bootcamp
OpenEnv Round 1 Bootcamp
OpenEnv Round 1 Bootcamp
OpenEnv Round 1 Bootcamp
OpenEnv Round 1 Bootcamp
OpenEnv Round 1 Bootcamp
OpenEnv Round 1 Bootcamp
OpenEnv Round 1 Bootcamp
OpenEnv Round 1 Bootcamp
OpenEnv Round 1 Bootcamp
OpenEnv Round 1 Bootcamp
OpenEnv Round 1 Bootcamp
OpenEnv Round 1 Bootcamp: Build Your First RL Environment
Live walkthrough to submit a strong Round 1 entry
timing
8:00 PM Onwards
Wednesday, 1st April
Host
Ben Burtenshaw
Community Education in AI at Hugging Face
Pulkit Aneja
Scaler Instructor
Watch Recording
PROBLEM STATEMENT
Round 1 — Problem Statement
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
Must simulate a real-world task (not games or toys)
Implement full OpenEnv spec: typed models, step()/reset()/state(), openenv.yaml
Minimum 3 tasks with agent graders (easy → medium → hard, scores/reward 0.0–1.0)
Meaningful reward function with partial progress signals
Baseline inference script with reproducible scores
Deploy to Hugging Face Spaces + working Dockerfile
README with environment description, action/observation spaces, setup instructions
Functional Requirements
Real-world task simulation
The environment must simulate a task humans actually do. Not games, not toys. Examples: email triage, code review, data cleaning, scheduling, customer support, content moderation.
OpenEnv spec compliance
Implement the full OpenEnv interface: 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. Tested via openenv validate.
Minimum 3 tasks with agent graders
Each task defines a concrete objective an agent must accomplish, with a programmatic grader that scores performance (0.0–1.0). Tasks should range: easy → medium → hard. Graders must have clear, deterministic success/failure criteria.
Meaningful reward function
Provides 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).
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 a reproducible baseline score on all 3 tasks.
Detailed Requirements
Non-Functional Requirements
Deploys to a Hugging Face Space
Environment must run as a containerized HF Space tagged with openenv.
Containerized execution
Must include a working Dockerfile. The environment should start cleanly with docker build + docker run.
Documentation
README must include: environment description and motivation, action and observation space definitions, task descriptions with expected difficulty, setup and usage instructions, baseline scores.
Parameter
Weight
Description
Real-world utility
30%
Does the environment model a genuine task? Would someone actually use this to train or evaluate agents?
Task & grader quality
25%
Are tasks well-defined with clear objectives? Do graders accurately and fairly measure success? Meaningful difficulty progression?
Environment design
20%
Clean state management, sensible action/observation spaces, good reward shaping, proper episode boundaries.
Code quality & spec compliance
15%
Follows OpenEnv spec, clean project structure, typed models, documented, tested, Dockerfile works.
Creativity & novelty
10%
Novel problem domain, interesting mechanics, clever reward design, original approach.
Scoring Breakdown
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?
Evaluation Criteria
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 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
How Judging works
Pre-Submission Checklist — all must pass or you're disqualified
HF Space deploys
Automated ping to the Space URL — must return 200 and respond to reset()
OpenEnv spec compliance
Validate openenv.yaml, typed models, step()/reset()/state() endpoints
Dockerfile builds
Automated docker build on the submitted repo
Baseline reproduces
Run the submitted inference script — must complete without error and produce scores
3+ tasks with graders
Enumerate tasks, run each grader, verify scores/reward in 0.0–1.0 range
Mandatory Additional Instructions
Before submitting, ensure the following variables are defined in your environment configuration:
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.
The inference script must be named inference.py and placed in the root directory of the project
Participants must use OpenAI Client for all LLM calls using above variables
Participants must emit structured stdout logs strictly following the [START], [STEP], and [END] format defined in the sample inference.py provided below. Any deviation in field names, ordering, or formatting will result in incorrect evaluation scoring. Refer to the Sample Inference Script for the complete format specification and examples.
Infra Restrictions
Runtime of inference script should be less than 20min
Make sure your env and inference can run on a machine with vcpu=2, memory=8gb
Validator
Run the pre-submission validation script before submitting
NEW Sample Inference Script
""" return text if text else "hello" except Exception as exc: print(f"[DEBUG] Model request failed: {exc}", flush=True) return "hello"
async def main() -> None: client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
env = await MyEnvV4Env.from_docker_image(IMAGE_NAME)
history: List[str] = []
rewards: List[float] = []
steps_taken = 0
score = 0.0
success = False
log_start(task=TASK_NAME, env=BENCHMARK, model=MODEL_NAME)
try:
result = await env.reset() # OpenENV.reset()
last_echoed = result.observation.echoed_message
last_reward = 0.0
for step in range(1, MAX_STEPS + 1):
if result.done:
break
message = get_model_message(client, step, last_echoed, last_reward, history)
result = await env.step(MyEnvV4Action(message=message))
obs = result.observation
reward = result.reward or 0.0
done = result.done
error = None
rewards.append(reward)
steps_taken = step
last_echoed = obs.echoed_message
last_reward = reward
log_step(step=step, action=message, reward=reward, done=done, error=error)
history.append(f"Step {step}: {message!r} -> reward {reward:+.2f}")
if done:
break
score = sum(rewards) / MAX_TOTAL_REWARD if MAX_TOTAL_REWARD > 0 else 0.0
score = min(max(score, 0.0), 1.0) # clamp to [0, 1]
success = score >= SUCCESS_SCORE_THRESHOLD
finally:
try:
await env.close()
except Exception as e:
print(f"[DEBUG] env.close() error (container cleanup): {e}", flush=True)
log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
if name == "main": asyncio.run(main()) NEW Pre Validation Script
#!/usr/bin/env bash fail "HF Space not reachable (connection failed or timed out)" hint "Check your network connection and that the Space is running." hint "Try: curl -s -o /dev/null -w '%%{http_code}' -X POST $PING_URL/reset" stop_at "Step 1" else fail "HF Space /reset returned HTTP $HTTP_CODE (expected 200)" hint "Make sure your Space is running and the URL is correct." hint "Try opening $PING_URL in your browser first." stop_at "Step 1" fi
log "${BOLD}Step 2/3: Running docker build${NC} ..."
if ! command -v docker &>/dev/null; then fail "docker command not found" hint "Install Docker: https://docs.docker.com/get-docker/" stop_at "Step 2" fi
if [ -f "$REPO_DIR/Dockerfile" ]; then DOCKER_CONTEXT="$REPO_DIR" elif [ -f "$REPO_DIR/server/Dockerfile" ]; then DOCKER_CONTEXT="$REPO_DIR/server" else fail "No Dockerfile found in repo root or server/ directory" stop_at "Step 2" fi
log " Found Dockerfile in $DOCKER_CONTEXT"
BUILD_OK=false BUILD_OUTPUT=$(run_with_timeout "$DOCKER_BUILD_TIMEOUT" docker build "$DOCKER_CONTEXT" 2>&1) && BUILD_OK=true
if [ "$BUILD_OK" = true ]; then pass "Docker build succeeded" else fail "Docker build failed (timeout=${DOCKER_BUILD_TIMEOUT}s)" printf "%s\n" "$BUILD_OUTPUT" | tail -20 stop_at "Step 2" fi
log "${BOLD}Step 3/3: Running openenv validate${NC} ..."
if ! command -v openenv &>/dev/null; then fail "openenv command not found" hint "Install it: pip install openenv-core" stop_at "Step 3" fi
VALIDATE_OK=false VALIDATE_OUTPUT=$(cd "$REPO_DIR" && openenv validate 2>&1) && VALIDATE_OK=true
if [ "$VALIDATE_OK" = true ]; then pass "openenv validate passed" [ -n "$VALIDATE_OUTPUT" ] && log " $VALIDATE_OUTPUT" else fail "openenv validate failed" printf "%s\n" "$VALIDATE_OUTPUT" stop_at "Step 3" fi
printf "\n" printf "${BOLD}========================================${NC}\n" printf "${GREEN}${BOLD} All 3/3 checks passed!${NC}\n" printf "${GREEN}${BOLD} Your submission is ready to submit.${NC}\n" printf "${BOLD}========================================${NC}\n" printf "\n"
exit 0 Submission window opens on 28th March
Deadline: 8 Apr 11:59 PM
Submit your Assessment → Study material
Preparatory Course
4 modules · ~3.5 hours
Each module: read the README first, then open the notebook in Colab. No local setup needed.
What you'll do
Connect to 3 real AI environments hosted online — an Echo bot, a Catch game, and Wordle — and interact with each using the exact same code pattern.
Read Concept
Module 1: Why OpenEnv?
ESSENTIAL FOR ROUND 1
45 min
What you'll do
Write 4 different game-playing strategies for a Catch game, run a competition between them, then switch to a completely different game using the same code.
Read Concept
Module 2: Using Existing Environments
ESSENTIAL FOR ROUND 1
50 min
What you'll do
Clone an existing environment, modify it, run it on your machine, then deploy your version live to Hugging Face Spaces with one command.
Read Concept
Module 3: Deploying Environments
ESSENTIAL FOR ROUND 1
45 min
What you'll do
Build a complete word-guessing game environment from scratch — define the rules, implement the logic, test it locally, and deploy it live. About 100 lines of real code.
Read Concept
Module 4: Building Your Own Environment
MOST IMPORTANT FOR ROUND 1
60 min
View full course repository
GUIDE
Round 1 Guide
What to Expect
Prerequisites
How to Submit
When Round 1 starts on 1 April:
Step 1
Application Form Choose 1 of the 4–5 problem statements revealed on the platform.
Step 2
Scaffold $ openenv init my_env Copy Generate project structure.
Step 3
Build Define your environment in the generated files.
Step 4
Test locally $ uv run server Copy Step 5
Deploy $ openenv push --repo-id your-username/my-env Copy Step 6
Submit Paste your HF Spaces URL here before the deadline.
Deadline: 8 April 2026, 11:59 PM IST
Step 2
Submit your Assessment
Complete Step 1 first
Problem Statement is live. Build and submit.
Round 1 begins
Submission window opens on 28th March
Deadline: 8 Apr 11:59 PM
Submit your Assessment → NOTE: Only team leaders can make the final submission.
FAQs
Frequently Asked Questions
Need help? Reach out to us