Anindya Obi

Posted on Dec 25

🎄 Christmas is the perfect excuse to explain real Agent design 😉😁

People build “Christmas AI assistants.”

Most of them are cute.

So I used Christmas as a design probe to walk through how I’d design a real agent system, one that can handle messy intent, constraints, and confidence.

Because if your agent can’t survive gift planning under budget + deadlines, it won’t survive production either.

Why this use case is a great stress test

Christmas planning is deceptively hard:

The intent is vague: “I want to get Christmas sorted.”
Constraints are real: budget, shipping cutoffs, time.
Failure is obvious: forgotten people, overspending, last-minute chaos.

This forces you to design an agent that does more than talk. It must plan, coordinate, and validate.

Step 1: Analyzer — Turn messy intent into structure (example included)

Don’t respond yet. First, extract structure.

User says: “I need to finish gifts for my family, keep it under $250, and I’m late.”

Analyzer outputs:

deadline: Dec 25 (and “late” implies last-mile)
budget: 250
recipients: family (unknown count → must ask)
preferences: not given
urgency: high
risk: shipping constraints

Example structured output:

{
  "goal": "christmas_planning",
  "budget_limit": 250,
  "deadline": "Dec-25",
  "urgency": "high",
  "missing_info": ["recipient_list", "preferences_per_person"],
  "constraints": ["delivery_before_deadline"]
}

Insight: The analyzer’s job is to remove ambiguity early so the rest of the system doesn’t guess.

Step 2: Planner to Convert intent into a workflow (example included)

The planner shouldn’t write generic “steps.” It should generate a machine-executable workflow.

Example workflow:

Collect recipient profiles
Allocate budget across people
Generate gift candidates per person
Validate delivery feasibility
Build checklist + reminders
Produce a final “ready plan”

Example plan output:

{
  "workflow": [
    {"task": "collect_recipients", "output": "recipient_profiles"},
    {"task": "allocate_budget", "output": "budget_splits"},
    {"task": "generate_gifts", "output": "gift_options"},
    {"task": "check_delivery", "output": "feasible_gifts"},
    {"task": "build_checklist", "output": "checklist_and_reminders"},
    {"task": "final_summary", "output": "user_plan"}
  ]
}

Insight: This is where the agent stops being “chat” and starts being “orchestration.”

Step 3: Workers for Small specialized agents > one mega-agent (example included)

Trying to have one agent do everything makes outputs drift.

Instead, use narrow workers:

🎁 Gift Worker (per recipient)

Input: budget slice + preferences
Output: ranked gift ideas with reasons

Example:

Recipient: Dad
Budget slice: $60
Preferences: coffee + gadgets

Output:

Smart mug warmer (reason: daily use + fits preference)
Aeropress kit (reason: premium but within budget)
Digital gift card (fallback if shipping is late)

💰 Budget Worker

Tracks spend across recipients.

Example:

Dad: $60
Mom: $70
Sister: $50
Friend: $40 Total: $220 (safe)

📦 Delivery Feasibility Worker

Rejects suggestions that won’t arrive in time.

Example rule:

If today is Dec 20, don’t suggest items that require 5–7 business days.

Step 4: Validator — Confidence is built here (example included)

Before you show anything, validate constraints.

Example checks:

budget_total ≤ $250
every recipient has ≥ 2 feasible options
at least one “instant” fallback exists for last-minute cases
checklist exists and is non-empty

Example validator output:

{
  "is_valid": false,
  "issues": [
    "2 gifts exceed per-person budget slice",
    "1 gift cannot arrive before Dec-25"
  ],
  "suggested_fixes": [
    "replace delayed item with digital option",
    "swap premium item with alternative under $50"
  ]
}

Insight: This is what makes the agent feel trustworthy instead of “confidently wrong.”

Where automation actually matters (the part people miss)

Here’s the lesson I keep coming back to:

The real win isn’t only automating user tasks.
It’s automating the build of the agent components:

generating structured analyzers
creating planners that emit workflows
scaffolding worker interfaces consistently
enforcing validation gates by default

That removes boring glue work, keeps outputs structured, and makes the system easier to debug.

Where HuTouch fits (introduced naturally)

This is exactly why we built HuTouch: to help teams automate building these workflow components (like prompt scaffolding, baseline RAG setup, and eval wiring) so you don’t hand-wire the same structure every time.

HuTouch Mockups:

If you want early access, sign-up here

Your turn

If you were designing a Christmas agent: