Overcooked¶

Originally proposed by Carroll et al. (2019), the Overcooked-AI environments have become a standard in cooperative multi-agent reinforcement learning and human-AI interaction.

Variants¶

Objects¶

Recipes¶

Recipes are defined in cogrid.envs.overcooked.recipes and declared on the Pot class:

from cogrid.core.objects.containers import Container
from cogrid.envs.overcooked.recipes import Recipe

@register_object_type("pot", scope="overcooked")
class Pot(GridObj):
    container = Container(capacity=3, pickup_requires="plate")
    recipes = [
        Recipe(["onion", "onion", "onion"], result="onion_soup", cook_time=30, reward=1.0),
        Recipe(["tomato", "tomato", "tomato"], result="tomato_soup", cook_time=30, reward=1.0),
    ]

Container is a core primitive (any object that holds items). Recipe is Overcooked-specific — it declares how ingredients combine into a result after cooking.

Pipeline: Pick up ingredient from stack -> place in pot (x3) -> pot cooks for 30 steps -> pick up plate from plate stack -> pick up soup from pot (requires plate) -> deliver at delivery zone.

The autowire system reads container and recipes and generates all interaction branches, tick handlers, extra state, and static tables.

Actions¶

All Overcooked variants use cardinal_actions:

Observations¶

Default feature set (Cramped Room config):

Rewards¶

Code Example¶

import cogrid

env = cogrid.make("Overcooked-CrampedRoom-V0")
obs, info = env.reset(seed=0)

for _ in range(100):
    actions = {a: env.action_space(a).sample() for a in env.agents}
    obs, rewards, terminateds, truncateds, info = env.step(actions)

import jax
import cogrid

env = cogrid.make("Overcooked-CrampedRoom-V0", backend="jax")
env.reset(seed=0)
n_agents = len(env.possible_agents)
n_actions = len(env.action_set)

def step_fn(carry, _):
    state, key = carry
    key, step_key, action_key = jax.random.split(key, 3)
    actions = {i: jax.random.randint(jax.random.fold_in(action_key, i), (), 0, n_actions)
               for i in range(n_agents)}
    obs, state, rewards, terminated, truncated, info = env.jax_step(step_key, state, actions)
    return (state, key), rewards

@jax.jit
def rollout(key):
    key, reset_key = jax.random.split(key)
    obs, state, info = env.jax_reset(reset_key)
    (final_state, _), all_rewards = jax.lax.scan(
        step_fn, (state, key), None, length=env.max_steps,
    )
    return all_rewards  # {agent_id: (max_steps,)}

rewards = rollout(jax.random.key(0))

Stochastic Orders (Cramped Mixed Kitchen)¶

The Overcooked-CrampedMixedKitchen-V0 layout adds a stochastic order queue to the base Overcooked mechanics. Orders spawn randomly, count down, and expire with a penalty — similar to the Overcooked video game. This introduces a planning and coordination challenge beyond the standard fixed-recipe layouts: agents must identify which recipe is needed, coordinate to fulfill it before the timer runs out, and avoid delivering the wrong soup.

Order Queue¶

Orders are controlled by an order configuration:

order_config = {
    "spawn_probs": {"onion_soup": 0.005, "tomato_soup": 0.005},
    "max_active": 2,
    "time_limit": 300,
}

At each step, each empty order slot is independently sampled — if the roll lands on a recipe, that order becomes active with a countdown timer set to time_limit. Active orders tick down by 1 each step and expire (clearing the slot) when the timer reaches zero.

Order Observation¶

The order_observation feature encodes active orders into the observation vector:

• Dimension: max_active * (n_recipes + 1).
• Per order slot: recipe one-hot (n_recipes) + normalized time remaining (0.0–1.0).
• Global: both agents see the same order state.

Inactive slots are all zeros. Add "order_observation" to the features list to enable.

Rewards¶

Custom Order Configuration¶

Enable orders on any layout by adding the order config, tick function, and extra state initializer:

import functools
from cogrid.envs.overcooked.config import build_order_extra_state, build_order_tick

config["orders"] = order_config
config["tick_fn"] = build_order_tick(order_config, recipe_results=["onion_soup", "tomato_soup"])
config["extra_state_init_fn"] = functools.partial(build_order_extra_state, order_config)

Custom Ingredients¶

Register new ingredient + stack pairs at runtime with make_ingredient_and_stack(). Call before environment creation so interaction tables include the new types.

from cogrid.envs.overcooked.overcooked_grid_objects import make_ingredient_and_stack
from cogrid.core import constants

Mushroom, MushroomStack = make_ingredient_and_stack(
    ingredient_name="mushroom",
    ingredient_char="m",
    ingredient_color=constants.Colors.Brown,
    stack_name="mushroom_stack",
    stack_char="M",
    scope="overcooked",
)

The OvercookedInventory feature auto-adjusts -- it discovers all pickupable types from the registry at compose time.

Config Reference¶

Full Cramped Room config:

cramped_room_config = {
    "name": "overcooked",
    "num_agents": 2,
    "action_set": "cardinal_actions",
    "features": [
        "agent_dir",
        "overcooked_inventory",
        "next_to_counter",
        "next_to_pot",
        "object_type_masks",
        "ordered_pot_features",
        "dist_to_other_players",
        "agent_position",
        "can_move_direction",
    ],
    "rewards": [
        DeliveryReward(coefficient=20.0, common_reward=True),
        OnionInPotReward(coefficient=3.0, common_reward=True),
        SoupInDishReward(coefficient=5.0, common_reward=True),
    ],
    "grid": {"layout": "overcooked_cramped_room_v0"},
    "max_steps": 1000,
    "scope": "overcooked",
    "pickupable_types": ["onion", "onion_soup", "plate", "tomato", "tomato_soup"],
}

Different layouts swap grid.layout. Different gameplay swaps rewards and features. The single-agent variant sets num_agents: 1.