# Building WeddingPlannerEnv: A Chaos-Aware RL Benchmark for Indian Weddings

*A submission for the AR'26 Meta OpenEnv Hackathon*

When we looked at the current landscape of Reinforcement Learning environments for LLMs, we noticed a pattern: they are either highly abstract (like GridWorld), perfectly deterministic (like Tic-Tac-Toe), or purely physical (like Mujoco). Real-world planning—especially in culturally nuanced, high-stakes contexts—is vastly underrepresented. 

That's why we built **WeddingPlannerEnv**: a native OpenEnv-compatible simulation that challenges an AI to plan a 3-day Indian wedding. But we didn't just build a scheduling app. We built an adversarial, stochastic simulation designed to break brittle agent logic.

## The Problem: Long-Horizon Constraints

Planning an Indian wedding is a multidimensional, non-linear optimization problem. The agent must manage:
- A strict budget (often running into tens of lakhs).
- A sprawling, multi-day schedule without any overlapping ceremonies.
- A requirement to book over a dozen interdependent vendors (venues, caterers, decorators, priests, etc.). 

But the hardest constraint isn't money; it's **time**. Ceremonies must align perfectly with *Muhurat* (auspicious astrological timing windows). If the venue is booked during *Rahu Kaal* (inauspicious time), the entire plan is invalid. 

## Technical Architecture

To make this rigorous enough for research-grade RL training, we engineered the environment from the ground up using FastAPI and Pydantic:

### 1. Strongly Typed State & Action Spaces
We completely avoided loose JSON parsing. Every observation and action is strictly governed by Pydantic `BaseModel` schemas. The environment enforces strict payload validation at the `POST /step` boundary. If an LLM hallucinates an action type or a malformed date string, the Pydantic validator catches it and immediately issues a heavy negative reward, forcing the policy model to quickly learn exact schema compliance.

### 2. Composable Rubrics & Dense Rewards
Instead of a sparse `0/1` reward at the end of the episode, we built a highly dense, multi-dimensional reward function composited from specialized modules:
- **Coverage Reward (35%)**: Calculates the percentage of mandatory vendors booked.
- **Budget Reward (25%)**: Exponentially decays as the agent nears bankruptcy.
- **Muhurat Reward (20%)**: Uses intersection over union (IoU) to evaluate how well booked time slots overlap with astrological windows.
- **Chaos Resolution (10%)**: Rewards the agent for quickly neutralizing active stochastic events.
- **Guest UX (10%)**: Penalizes scheduling gaps or missing caterers that would cause family stress.

### 3. The Chaos Engine (Stochastic Adversary)
Real weddings don't go according to plan. Vendors cancel. Prices surge. Traffic delays the priest. 

To simulate this, we built the **Chaos Engine**. It is a stochastic adversarial system that fires random `ChaosEvent` triggers mid-episode. A vendor might suddenly cancel, injecting an active conflict into the state observation. The agent must pause its planning, parse the `active_chaos` array, and use emergency actions like `resolve_conflict` or `negotiate` to recover its deposit and find a replacement within the remaining budget constraints. 

## Curriculum Learning with GRPO

We fine-tuned `Qwen2.5-7B-Instruct` using **Group Relative Policy Optimization (GRPO)** and a 3-stage curriculum on Lightning AI:

1. **Stage 1 (Easy):** The agent learns the strict Pydantic output schema and basic vendor booking mechanics, quickly escaping the -500 penalty floor.
2. **Stage 2 (Medium):** Budgets tighten. The agent initially dips into negative rewards as it hits limits, but quickly adapts its policy to seek cheaper vendors and respect Muhurat windows.
3. **Stage 3 (Hard):** The Chaos Engine activates. The agent learns to detect conflicts and recover gracefully without falling into an infinite action loop.

## The Results

In a baseline zero-shot test, standard LLMs fail entirely—they hallucinate years (e.g., "2224"), blow the budget, or output invalid keys. 

After our curriculum training, our agent achieved a stable **positive average score of ~24/100** on the Hard difficulty setting. While a score of 100 represents theoretical perfection, a recovery from -500 to a consistent +24 means the agent successfully mastered constraint avoidance under chaos. It learned the rules of a highly adversarial simulation from scratch.

We believe WeddingPlannerEnv represents a step forward in evaluating LLMs for complex, long-horizon planning tasks in the real world. You can try the live environment via our HuggingFace Space API and test the model yourself!