• 

• 

• 

• 

• 

CourseCorrect - Cooking Rescue

Inspiration

While making chocolate mousse for a dinner party, I discovered the heavy cream had already gone into the mashed potatoes. A hurried search for “heavy cream alternatives” led me to try whole milk. When it wouldn’t whip, we ordered ice cream instead. I’d asked about the ingredient; I needed an answer about its role in my recipe.

That experience exposed how much work a substitution leaves to the cook. Would the alternative do the same job? How much should I use? Which other steps would change, and what would happen to the finished dish? CourseCorrect grew from wanting those answers together, in the context of what I was making and what I’d already done.

What it does

CourseCorrect is a cooking-rescue assistant that helps home cooks adapt recipes to missing ingredients, available alternatives, and the steps they’ve already completed. Its MCP tools let connected agents access the recipe and coordinate changes. A voice-enabled companion app demonstrates the experience, so cooks can ask for help while their hands are busy.

Before you cook

Understand the recipe. Import a recipe, and CourseCorrect connects each ingredient to its quantities, the steps that use it, and the job it performs. Amazon Nova interprets the recipe and proposes alternatives, while culinary relationships and deterministic policies govern supported replacements. An ingredient used in several places is considered in each context.

Prepare alternatives. CourseCorrect prepares replacement amounts, revised instructions, and tradeoffs, along with the conditions under which a change can work. You review and save the recipe with those plans ready to use. The preparation brings together decisions you would otherwise have to make while cooking.

While you cook

Keep your place. CourseCorrect retains your recorded progress and accepted changes. Recommendations account for what you’ve already done and which ingredients have entered the dish. As cooking progresses, the current recipe remains the basis for the next decision.

Coordinate the change. Say what’s missing, and CourseCorrect checks alternatives against your available ingredients and cooking state. It asks for missing information and explains the proposed quantities, method, and tradeoff. Once you accept, affected ingredients and instructions update together. Further supported substitutions build on that amended recipe, including replacements for ingredients introduced by an earlier change.

Recognize the limits. When an alternative cannot perform the required job, comes too late in the method, or conflicts with an accepted change, CourseCorrect explains why and leaves the recipe unchanged.

You get a coordinated way forward: what to use, what to change, and what to expect from the result.

How Amazon technology powers CourseCorrect

CourseCorrect separates interpreting a recipe, determining a supported change, and applying it. Amazon services connect those responsibilities: Nova interprets and proposes, the engine checks, and the cook accepts.

What CourseCorrect needs	Amazon technology	What it makes possible
Understand recipes and requests	Amazon Nova through Amazon Bedrock	Structures imported recipes, proposes alternatives, and interprets cooking requests into information the deterministic engine can evaluate.
Maintain culinary knowledge	Amazon DynamoDB - ingredients and policies	Stores versioned ingredient identities, culinary roles, and recovery policies. Each prepared recipe references a specific knowledge release, preserving the rules behind its recommendations as the knowledge base evolves.
Maintain the recipe being cooked	Amazon DynamoDB - recipes and cooking state	Preserves prepared plans, recorded progress, and accepted amendments. Conditional transactions apply coordinated changes against the expected recipe revision, so subsequent decisions start from the amended recipe.
Run preparation and cooking decisions	AWS Lambda	Runs the MCP tools and deterministic engine, serves the companion, and processes imports through a separate worker. It connects policy lookup, recipe evaluation, and accepted changes within the application’s execution path.
Speak replies in the companion app	Amazon Polly	Voices the companion app’s explanations and instructions while the cook’s hands are occupied. The MCP tools return structured results independently of Polly, allowing other clients to provide their own voice or text interface.

The culinary engine determines whether a change is supported. DynamoDB preserves the knowledge and recipe state behind that decision, while Lambda runs the checks before an accepted change is committed.

How we built it

We built CourseCorrect around two phases: prepare possible recipe changes before cooking, then evaluate them against the kitchen’s current state when they’re needed. A TypeScript engine connects those phases through explicit culinary rules, saved plans, and recorded progress.

Separate culinary knowledge from the recipe being cooked. Two DynamoDB tables hold different kinds of information. The knowledge table contains versioned ingredient identities, functional relationships, and recovery policies. The application table holds imported recipes, prepared plans, cooking sessions, and accepted amendments. Each saved recipe references the knowledge release used to prepare it, so publishing new policies does not silently change an active cooking session.

Use Nova to interpret, then compile supported changes. Amazon Nova, through Bedrock, structures recipe text and proposes alternatives. Code validates those outputs, resolves ingredient uses against the culinary knowledge base, and binds applicable policies. Policy-backed quantities are calculated deterministically; model-proposed alternatives retain their provisional status and undergo separate checks. The compiler produces plans containing replacement amounts, instruction changes, tradeoffs, and conditions for use.

Run cooking decisions through MCP on Lambda. A Streamable HTTP MCP interface exposes recipe and cooking actions, while a separate Lambda worker handles longer-running imports. Structured cooking requests reach the deterministic engine without repeating recipe analysis. The engine checks availability, recorded progress, and prior amendments, then proposes or refuses a change. Before applying an accepted proposal, it rechecks the recipe revision and commits the coordinated update transactionally. Subsequent substitutions use the amended recipe, including ingredients introduced by earlier changes.

Build a companion to exercise the experience. The web companion makes recipe state, proposals, and accepted changes visible while supporting voice interaction. Browser speech recognition captures the cook’s request; Amazon Polly voices the companion’s replies. MCP results remain independent of that speech layer, allowing other clients to provide their own interface. Upload, draft review, and saving use dedicated web routes alongside the MCP cooking tools.

This separation keeps expensive preparation outside the immediate cooking decision while preserving the context needed to make and apply a supported change.

Challenges we ran into

• Finding a reason to use voice. I started and stopped two other ideas before choosing cooking, where occupied hands make spoken assistance useful.
• Parsing messy recipe exports. Ingredients could appear below the method, while introductory prose discussed alternatives. We tuned extraction to distinguish the actual recipe from surrounding commentary.
• Coordinating a replacement. One ingredient can serve several purposes across multiple steps. Changes needed to preserve those relationships and respect recorded cooking progress.

Accomplishments that we're proud of

• Designing for Alexa’s response budget. We separated expensive recipe preparation from immediate cooking decisions to support the 500 ms MCP target.
• Creating an extensible culinary framework. Explicit ingredient roles and recovery policies provide a foundation for broader coverage and future dietary constraints.
• Completing the cooking-rescue loop. A request leads to a proposal, explicit acceptance, and coordinated recipe updates-with refusal when a replacement cannot perform the required job.

What we learned

• Voice needs deliberate sequencing. Ask for missing information, explain the consequence, and request acceptance without making the cook listen to every internal detail.
• Give models and code distinct jobs. Nova interprets and proposes; deterministic rules check supported quantities, eligibility, and state before applying a change.

What’s next for CourseCorrect

Adapt recipes to dietary needs. Extend preparation to account for stated dietary preferences and ingredient exclusions, with supported changes to quantities and method. Allergy-specific support would require additional validation before making safety claims.

Deepen the culinary knowledge base. Expand coverage across ingredients, techniques, and replacement policies, supported by stronger source evidence and kitchen testing. Broader knowledge would help CourseCorrect handle more recipes and explain the limits of each alternative.

Take the revised recipe shopping. Let cooks select recipes and export a consolidated shopping list that reflects accepted substitutions and combines compatible quantities, making it easier to buy what their planned meals actually need.

Built With

• amazon-bedrock
• amazon-dynamodb
• amazon-nova
• amazon-polly
• aws-lambda
• aws-sts
• model-context-protocol
• node.js
• react
• typescript