Chopped: AI Edition - Building a Meal Planner

As a dad of two toddlers with very particular tastes—one constantly wants treats for dinner and the other refuses anything that isn’t beige—I view dinnertime at my house as a nightly episode of “Chopped: Toddler Edition.” Add early bedtimes and the need to avoid meltdowns (theirs and mine), and the meal becomes less about gourmet aspirations and more about survival. The goal? Walk away with everyone fed, happy, and preferably not covered in food.

Meal planning is the ultimate balancing act: managing picky preferences, dietary needs, and time constraints while trying to avoid cooking three separate meals. 

That’s why I turned to AI. 

A multi-agent system, in which each agent has a specific job such as managing preferences or optimizing grocery lists, is the perfect way to tackle this chaos. But just like wrangling two toddlers, coordination is key, and things can go sideways fast without a good plan.

Enter event-driven architecture. 

It’s like the choreographed chaos of a well-run kitchen: Agents stay in sync, adapt to changes (like an unexpected snack raid), and recover gracefully from disasters (like burning the garlic bread). With tools like Apache Kafka®, Apache Flink®, LangChain, and Claude, I’ve built an AI meal planner that takes the stress out of dinnertime and gives me a fighting chance during those precious evening hours.

In this article, I’ll share how I did it—and maybe even convince you to let AI take on your dinner drama. After all, if it can handle my kids, it can handle anything.

Note: If you would like to just look at the code, jump to my GitHub repo here.

Why Event-Driven Multi-Agents?

At its core, an agent is like a little decision-making robot: It can analyze information, reason based on its environment, and take action.

What makes agents exciting is their ability to go beyond static, pre-programmed tasks. They can adapt to new inputs, learn from past experiences, and handle dynamic problems—essentially doing the heavy lifting for repetitive or complex tasks. Whether it’s automating your workday or optimizing grocery shopping, agents turn reactive technology into proactive problem-solvers.

Things start to get really interesting when you start to combine agents. You can combine multiple agents, having each specialize in a different task, to solve a larger problem. That’s a multi-agent system.

Instead of a single jack-of-all-trades, you have a team of experts working together: One curates recipes, another calculates nutrition, and yet another syncs with your family’s calendar. It’s collaboration at scale, unlocking solutions to problems that are too big or too messy for a single agent to handle alone.

Of course, coordinating this team is its own challenge. Without a solid system, you’re looking at overlapping responsibilities, missed updates, or agents that fail to align with each other’s goals. Managing this is where event-driven design shines.

In an event-driven architecture, agents don’t rely on rigid instructions. They respond to real-time events, like a change in schedules or a pantry update. Events act as a shared, dynamic language, letting agents stay synchronized, react quickly, and handle failures without bringing down the whole system.

This approach transforms multi-agent systems from a theoretical concept into a practical tool. But how does this apply to meal planning for a busy family? Let’s explore that now.

Designing an Event-Driven Multi-Agent Meal Planner

Dinner at my house is a nightly puzzle: two picky kids, my wife and I trying to eat healthier, and barely enough time to pull it together before bedtime.

For example, my son loves fish, but my daughter is allergic, so every meal with fish needs a substitution for her. Meanwhile, they both adore mac and cheese, but my wife and I aim for meals with a better balance of protein, carbs, and fats. Add the constraints of a busy life, and weekly manual meal planning becomes stressful to deal with.

To tackle this, I designed a multi-agent system—a team of AI experts, each specializing in a specific task. Here’s how it works:

1. Child Meal Planning Agent: This agent focuses on creating nutritious, kid-friendly meals that my little ones will actually eat.

2. Adult Meal Planning Agent: This agent is an expert in planning couples’ meals that are high-protein, low-glycemic, and carb-conscious but still tasty.

3. Shared Preferences Agent: Combines the child and adult meal plans into one cohesive menu, factoring in allergies and shared ingredients.

4. Format Output Agent: This agent takes the finalized meal plan, adds a grocery list, and reformats it into a structured grocery list in JSON.

By breaking up the work into specialized agents, the system improves accuracy and efficiency. Each agent operates like an expert chef for its domain, and the event-driven architecture keeps everything in sync without explicit dependencies.

Designing the User Interface

The web application is a standard three-tier architecture built with Next.js for the front end and MongoDB as the application database. It’s intentionally kept simple and doesn’t include any direct AI logic or knowledge of Kafka.Its primary role is to let users configure their meal planning settings, such as their kids’ likes and dislikes, and submit requests for new meal plans.

When a new meal plan request is submitted, it’s written to MongoDB with a "processing" status. This triggers the multi-agent workflow to generate a complete meal plan for the week. Once the process is finished, the status updates, and users can click on an individual meal plan to expand the user interface (UI). This reveals the full details for the week, including a breakdown of meals and an auto-generated grocery list.

Creating the Multi-Agent Workflow

To coordinate a multi-agent system effectively, you need a shared language—a structured way for agents to exchange information, interpret commands, and collaborate.

In an event-driven architecture, events serve as this shared language, acting as structured updates that keep agents aligned, responsive, and adaptable to change. Think of it as the system’s group chat, where agents broadcast updates, share context, and perform tasks independently while staying synchronized.

Kafka provides the backbone for this communication.

Agents produce and consume events from Kafka topics, which allows them to react in real time to changes like new preferences or even new agents. Apache Flink adds the ability to process these streams, enabling complex reasoning and transformations on the fly. If you’re unfamiliar with Flink, it’s an open source stream processing framework built for handling large volumes of data in real time, which is ideal for high-throughput, low-latency applications. Flink is perfect for AI applications.

With Confluent’s platform simplifying the management and scaling of this architecture, you can build a reliable, event-driven, multi-agent workflow that gracefully handles real-world complexities.

The following diagram illustrates how I used these tools in Confluent Cloud to enable seamless and scalable collaboration across the agents.

Here’s how it works.

When data is written to MongoDB, a source connector in Confluent Cloud creates an event in the Kafka topic “Meal Plan Requests.” This event starts the multi-agent workflow.

The child and adult meal planning agents operate in parallel, generating their respective plans and producing events that are joined by Flink (as shown below) into the topic “Joined Preferences.”

CREATE TABLE `default`.`dev-us-east-1-cluster`.`meal-planner.output.joined-preferences` (
    `request_id` STRING,
    `child_preference` STRING,
    `adult_preference` STRING
) WITH (
  'value.format' = 'json-registry'
);

INSERT INTO `meal-planner.output.joined-preferences`
SELECT c.`request_id`, c.content as child_preference, a.content as adult_preference FROM `meal-planner.output.child-preferences` c
  JOIN `meal-planner.output.adult-preferences` a ON c.`request_id` = a.`request_id`;

As new events are written to Joined Preferences, the shared meal plan agent is triggered, which consolidates the inputs into a unified family meal plan. The final event is written to another Kafka topic, activating the format output agent to structure the result into a user-friendly format, completing the workflow.

This setup is highly scalable and decouples agent interactions, making it easy to add new agents or downstream consumers without impacting performance or requiring changes to existing agents. 

Let’s dive deeper into the roles of the individual agents.

Creating a Meal Plan for Children and Adults

The child and adult meal planning agents follow the React design pattern. This design pattern combines reasoning and action into a single loop, enabling agents to make decisions and act iteratively based on their current understanding of a task.

1. Reasoning: The agent analyzes the situation, considers context, and determines the next best action using its internal knowledge or external input.

2. Action: The agent performs the chosen action, which may involve interacting with the environment, querying data, or generating output.

3. Feedback Loop: The result of the action provides new information, which the agent incorporates into its reasoning for the next iteration.

This pattern is ideal for dynamic tasks requiring adaptability, as it allows the agent to continuously refine its approach and adjust to new developments in real time.

I used LangGraph’s built-in support for this. The code of both the child and adult versions are quite similar, but the system prompt specifies different behaviors and sets of expertise.

Child meal planning system prompt:

SYSTEM_PROMPT = """You are an expert at designing nutritious meals that toddlers love.
   You will be prompted to generate a weekly dinner plan.
   You'll have access to meal preferences. Use these as inspiration to come up with meals but you don't have to explicitly use these items.
   You'll have access to recent meals. Factor these in so you aren't repetitive.
   You must take into account any hard requirements about meals.
   Bias towards meals that can be made in less than 30 minutes. Keep meal preparation simple.
   There is no human in the loop, so don't prompt for additional input.
   """

Adult meal planning system prompt:

SYSTEM_PROMPT = """You are an expert at designing high protein, low glycemic, low carb dinners for couples.
   You will be prompted to generate a weekly dinner plan.
   You'll have access to recent meals. Factor these in so you aren't repetitive.
   Bias towards meals that can be made in less than 30 minutes. Keep meal preparation simple.
   There is no human in the loop, so don't prompt for additional input.
   """

Both agents use tools. The child meal planner in particular uses several tools to take into account the meal planner configured settings. For example, the code below shows three tools for getting child meal preferences, hard requirements, and recent meals.

@tool
def get_kid_preferences():
   """Use this to get the likes and dislikes for the kids preferences."""
   # Connect to the MongoDB instance
   client = MongoClient(os.getenv("MONGODB_URI"))  # Replace with your MongoDB URI

   # Access the database and collection
   db = client['meal_planner']  # Database name
   collection = db['meal_preferences']  # Collection name

   projection = {"likes": 1, "dislikes": 1, "_id": 0}
   result = collection.find_one({}, projection)

   return result

@tool
def get_hard_requirements():
   """Use this to get the hard requirements for recommending a meal. These must be enforced."""
   # Connect to the MongoDB instance
   client = MongoClient(os.getenv("MONGODB_URI"))  # Replace with your MongoDB URI

   # Access the database and collection
   db = client['meal_planner']  # Database name
   collection = db['meal_preferences']  # Collection name

   projection = {"hardRequirements": 1, "_id": 0}
   result = collection.find_one({}, projection)

   return result

@tool
def get_recent_meals():
   """Use this to get recent meals."""
   # Connect to the MongoDB instance
   client = MongoClient(os.getenv("MONGODB_URI"))  # Replace with your MongoDB URI\

   # Access the database and collection
   db = client['meal_planner']
   collection = db['weekly_meal_plans']

   # Query to get the last two entries
   recent_meals = list(collection.find().sort([("$natural", -1)]).limit(2))

   return recent_meals

Creating a Shared Meal Plan

To merge the outputs of the child and adult meal planning agents, I used the Reflection design pattern, a framework that enables generative AI agents to evaluate and improve their outputs iteratively. This pattern operates through three key steps:

1. Generate: The agent produces an initial output based on its input or task.

2. Reflect: The agent critically evaluates the output, comparing it to task requirements or quality benchmarks. This step may involve self-assessment or leveraging another agent for review.

3. Revise: Based on the reflection, the agent refines its output, producing a more accurate or polished result.

This pattern is particularly effective for complex tasks where a single-pass solution may fall short. By embedding reflection, agents autonomously improve their performance, ensuring higher reliability and quality without requiring external intervention.

Implementation

In the shared meal plan agent, I created two tailored prompts to guide the generation and reflection processes:

1. Generate Content Prompt:

   generate_content_prompt = ChatPromptTemplate.from_messages(
      [
          (
              "system",
              "You are a meal planning assistant for families."
              "Your job is to combine the recommended meal plan for the children and the adults into a singular meal plan that works for the family."
              "Aim to minimize creating multiple dishes. Each meal should be able to work for both the adults and kids."
              "Make sure you include the same number of meals in the combined plan as in the original plans."
              "Output should contain the name of the meal, any modification or version for the children, any modification or version for the adults, core ingredients, prep time, and basic recipe."
              "If the user provides critique, respond with a revised version of your previous attempts.",
          ),
          MessagesPlaceholder(variable_name="messages"),
      ]
   )

   ‎ 

2. Reflection Prompt:

   reflection_prompt = ChatPromptTemplate.from_messages(
      [
          (
              "system",
              "You are a family meal planning expert grading the quality of the recommended meals on taste, variety, and nutritional value."
              "Generate critique and recommendations for the user's submission."
              "Provide detailed recommendations, including requests for greater variety, tastier meals, or higher nutritional value.",
          ),
          MessagesPlaceholder(variable_name="messages"),
      ]
   )

   ‎ 

Using LangGraph, I created a workflow graph connecting the generator node and reflection node. A conditional edge ensures that the process iterates if the reflection step identifies areas for improvement. This iterative workflow dynamically refines the combined meal plan until it meets the desired standards, resulting in meals that balance the needs of both children and adults effectively.

builder = StateGraph(State)
builder.add_node("generate", generation_node)
builder.add_node("reflect", reflection_node)
builder.add_edge(START, "generate")

def should_continue(state: State):
   if len(state["messages"]) > MAX_ITERATIONS:
       return END
   return "reflect"

builder.add_conditional_edges("generate", should_continue)
builder.add_edge("reflect", "generate")
memory = MemorySaver()
graph = builder.compile(checkpointer=memory)

Formatting the Output

The final step in the workflow involves generating a comprehensive grocery list for the combined meal plan and formatting the output into a structured, user-friendly response. For this, I again applied the React design pattern, equipping the agent with highly detailed instructions to ensure precise input interpretation and output generation. This agent features the most extensive and detailed system prompt in the entire workflow, as shown below.

You are a system that processes meal plans and reformats them into a structured JSON format.
    The input you receive contains an unstructured meal plan for a specific week in the year.
    Your task is to extract key details and output a JSON payload with the following structure:
    {
        "summary": <string>,
        "groceryList": <string>,
        "meals": [
            {
                "title": <string>,
                "coreIngredients": [<string>],
                "kidsVersion": <string>,
                "adultVersion": <string>,
                "recipe": <string>
            },
            ...
        ]
    }
    Instructions:

    1. For the summary, create a short summary for the meals of the week including the meal names.
    2. For the groceryList, analyze the existing meals and create a list of grocery items required. Format the grocery list as HTML as shown in the example.
    3. For each meal in the input:
        - Extract the meal title and assign it to title.
        - Identify the core ingredients and list them in coreIngredients.
        - Extract the description for the kids' version and assign it to kidsVersion.
        - Extract the description for the adult version and assign it to adultVersion.
        - Extract the basic recipe and assign it to recipe.
    4. Ensure all extracted data is clean, properly formatted, and follows the given JSON structure.

    Example Input:

    1. Cheesy Broccoli Chicken Pasta Bake
    - Name: Family Pasta Bake
    - Kids Version: Regular cheesy pasta with extra cheese
    - Adult Version: Herb-seasoned with added protein (ground chicken)
    - Core Ingredients: Pasta, broccoli, cheese, chicken, herbs
    - Prep Time: 35 minutes
    - Modifications: 
        * For kids: Smaller pieces, milder seasoning
        * For adults: More herbs, potential addition of red pepper flakes
    - Recipe: Instructions:
        Preheat Oven:

        Preheat your oven to 375°F (190°C).
        Cook Pasta and Broccoli:

        Bring a large pot of salted water to a boil. Cook the pasta according to package instructions, adding the broccoli to the pot for the last 3 minutes of cooking.
        Drain and set aside.
        Prepare the Chicken:

        Heat a large skillet over medium heat. Add a drizzle of olive oil and cook the ground chicken until browned and cooked through, breaking it into small pieces as it cooks.
        Season with salt, pepper, and the mixed dried herbs.
        Assemble the Pasta Bake:

        In a large mixing bowl, combine the cooked pasta, broccoli, chicken, and 1 1/2 cups of shredded cheese. Mix until evenly combined.
        If making the adult version, add Parmesan and red pepper flakes at this stage.
        Divide for Kids and Adults (Optional):

        If making separate versions, split the mixture into two baking dishes.
        For the kids' version, sprinkle extra shredded cheese on top.
        For the adults' version, sprinkle a mix of Parmesan and shredded cheese on top.
        Bake:

        Place the baking dish(es) in the preheated oven. Bake for 20–25 minutes, or until the top is golden and bubbly.
        Serve:

        Let the pasta bake cool for a few minutes before serving. Garnish the adult version with fresh herbs if desired.

    2. Teriyaki Protein Plate
    - Name: Family Teriyaki Plate
    - Kids Version: Mild teriyaki chicken, udon noodles
    - Adult Version: Spicy teriyaki option, added vegetables
    - Core Ingredients: Chicken, udon noodles, teriyaki sauce, vegetables
    - Prep Time: 25 minutes
    - Modifications:
        * For kids: Less spicy, cut into smaller pieces
        * For adults: Add chili oil, extra vegetables
    - Recipe: Instructions:
            Prep Ingredients:

            Wash and chop the vegetables into bite-sized pieces.
            Cut the chicken into small chunks.
            Cook the Udon Noodles:

            Bring a pot of water to a boil. Cook the udon noodles according to package instructions.
            Drain, rinse with cool water, and set aside.
            Prepare the Chicken:

            Heat 1 tbsp of vegetable oil in a large skillet over medium heat. Add the chicken pieces and cook until golden brown and fully cooked, about 6–8 minutes.
            Remove half of the chicken for the kids' version.
            Make Kids' Teriyaki Chicken:

            In a small pan, combine the mild teriyaki sauce with the reserved chicken and warm over low heat. Remove from heat once coated.
            Make Adults' Spicy Teriyaki Chicken:

            In the original skillet, push the remaining chicken to one side and add an additional 1 tbsp of oil.
            Add the extra vegetables and stir-fry for 2–3 minutes until slightly tender.
            Drizzle chili oil over the chicken and vegetables, then pour in the teriyaki sauce. Stir until everything is evenly coated.
            Assemble the Plates:

            For the kids' version, place udon noodles on a plate, top with mild teriyaki chicken, and garnish with a few plain veggies if desired.
            For the adults' version, layer udon noodles, spicy teriyaki chicken, and sautéed vegetables. Garnish with additional chili oil for extra heat.
            Serve:

            Divide the plates for kids and adults, ensuring everyone gets the flavor and spice level they prefer.

    Example Output:
    {
        "summary": "Family pasta bake and teriyaki protein plate",
        "grocyerList": "<p><strong>Proteins:</strong></p>
            <ul>
                <li>Ground chicken (1 lb for pasta bake, 1 lb for teriyaki plate)</li>
            </ul>
            <p><strong>Pasta and Noodles:</strong></p>
            <ul>
                <li>Pasta (e.g., penne or fusilli, 12 oz)</li>
                <li>Udon noodles (10 oz)</li>
            </ul>
            <p><strong>Vegetables:</strong></p>
            <ul>
                <li>Broccoli (2 cups)</li>
                <li>Mixed vegetables (e.g., bell peppers, broccoli, carrots, zucchini, snap peas, 3 cups total)</li>
            </ul>
            <p><strong>Cheese:</strong></p>
            <ul>
                <li>Shredded cheese (cheddar or mozzarella, 2 cups + 1/2 cup extra for kids)</li>
                <li>Parmesan cheese (1/4 cup)</li>
            </ul>
            <p><strong>Sauces and Seasonings:</strong></p>
            <ul>
                <li>Teriyaki sauce (1/2 cup mild for kids, regular or spicy for adults)</li>
                <li>Chili oil (1 tsp or to taste)</li>
                <li>Mixed dried herbs (e.g., oregano, basil, thyme, 1 tsp)</li>
                <li>Red pepper flakes (optional, 1/2 tsp)</li>
                <li>Salt and pepper</li>
            </ul>
            <p><strong>Other Pantry Items:</strong></p>
            <ul>
                <li>Olive oil (2 tbsp)</li>
                <li>Vegetable oil (2 tbsp)</li>
            </ul>",
        "meals": [
            {
                "title": "Family Pasta Bake",
                "coreIngredients": ["pasta", "broccoli", "cheese", "chicken", "herbs"],
                "kidsVersion": "Regular cheesy pasta with extra cheese",
                "adultVersion": "Herb-seasoned with added protein (ground chicken)"
                "recipe": "Instructions:
                    Preheat Oven:

                    Preheat your oven to 375°F (190°C).
                    Cook Pasta and Broccoli:

                    Bring a large pot of salted water to a boil. Cook the pasta according to package instructions, adding the broccoli to the pot for the last 3 minutes of cooking.
                    Drain and set aside.
                    Prepare the Chicken:

                    Heat a large skillet over medium heat. Add a drizzle of olive oil and cook the ground chicken until browned and cooked through, breaking it into small pieces as it cooks.
                    Season with salt, pepper, and the mixed dried herbs.
                    Assemble the Pasta Bake:

                    In a large mixing bowl, combine the cooked pasta, broccoli, chicken, and 1 1/2 cups of shredded cheese. Mix until evenly combined.
                    If making the adult version, add Parmesan and red pepper flakes at this stage.
                    Divide for Kids and Adults (Optional):

                    If making separate versions, split the mixture into two baking dishes.
                    For the kids' version, sprinkle extra shredded cheese on top.
                    For the adults' version, sprinkle a mix of Parmesan and shredded cheese on top.
                    Bake:

                    Place the baking dish(es) in the preheated oven. Bake for 20–25 minutes, or until the top is golden and bubbly.
                    Serve:

                    Let the pasta bake cool for a few minutes before serving. Garnish the adult version with fresh herbs if desired."
            },
            {
                "title": "Family Teriyaki Plate",
                "coreIngredients": ["chicken", "udon noodles", "teriyaki sauce", "vegetables"],
                "kidsVersion": "Mild teriyaki chicken, udon noodles",
                "adultVersion": "Spicy teriyaki option, added vegetables"
                "recipe": "Instructions:
                    Prep Ingredients:

                    Wash and chop the vegetables into bite-sized pieces.
                    Cut the chicken into small chunks.
                    Cook the Udon Noodles:

                    Bring a pot of water to a boil. Cook the udon noodles according to package instructions.
                    Drain, rinse with cool water, and set aside.
                    Prepare the Chicken:

                    Heat 1 tbsp of vegetable oil in a large skillet over medium heat. Add the chicken pieces and cook until golden brown and fully cooked, about 6–8 minutes.
                    Remove half of the chicken for the kids' version.
                    Make Kids' Teriyaki Chicken:

                    In a small pan, combine the mild teriyaki sauce with the reserved chicken and warm over low heat. Remove from heat once coated.
                    Make Adults' Spicy Teriyaki Chicken:

                    In the original skillet, push the remaining chicken to one side and add an additional 1 tbsp of oil.
                    Add the extra vegetables and stir-fry for 2–3 minutes until slightly tender.
                    Drizzle chili oil over the chicken and vegetables, then pour in the teriyaki sauce. Stir until everything is evenly coated.
                    Assemble the Plates:

                    For the kids' version, place udon noodles on a plate, top with mild teriyaki chicken, and garnish with a few plain veggies if desired.
                    For the adults' version, layer udon noodles, spicy teriyaki chicken, and sautéed vegetables. Garnish with additional chili oil for extra heat.
                    Serve:

                    Divide the plates for kids and adults, ensuring everyone gets the flavor and spice level they prefer."
            }
        ]
    }

    Follow this pattern strictly. If any part of the input is ambiguous or missing,
    make a best guess based on context and include placeholder values like null where appropriate.
    Respond with the JSON only. Absolutely nothing else.

Once the structured response is generated, it’s written back to a Kafka topic. A dedicated service consumes these messages and updates the corresponding weekly meal plan request in MongoDB. With this final update, the UI gains access to the fully completed meal plan and grocery list.

Things to Note on the Implementation

Both the agent services and the web application currently reside within the same repository, but they could easily be separated into distinct repositories for a more production-ready implementation. Similarly, while all the agents are part of a single project in this setup, they can be decoupled and deployed as independent serverless functions. This approach would allow each agent to operate autonomously, enhancing scalability, flexibility, and fault isolation.

Since I followed an event-driven approach, I can extend or change the system of agents in the future. For example, I might want to include a nutritional analysis agent that uses an external tool to calculate calories or macros based on the meal plan. Or I might want to incorporate human feedback into the meal plans, allowing the user to give meals a thumb up or thumb down to teach the AI about our preferences over time.

From Dinner Chaos to AI Harmony

Congratulations—you've made it through the whirlwind of AI meal planning, picky eater tantrums, and event-driven multi-agent systems. My house may still occasionally resemble “Chopped: Toddler Edition,” but with Kafka, Flink, and a set of AI agents, dinnertime is a bit less chaotic and a bit more enjoyable.

The real takeaway here is how event-driven multi-agent systems can simplify complex, real-world challenges.

These agents not only work but also collaborate, adapt, and scale effortlessly—all thanks to a shared "language" of events. It’s like having a kitchen staff that communicates and gets the job done without missing a beat.

This architecture isn’t just for meal planning. It also can be applied to any domain, from automating workflows at work to tackling everyday problems. For example, I’ve used a similar system to build a research agent and generate LinkedIn posts. Whether you're automating your own tasks or building something bigger, the recipe remains the same: a solid design, multi-agent collaboration, and event-driven magic.

Now, if you'll excuse me, there’s a suspiciously quiet toddler in the other room...