Building an Event Planning Coordinator Agent in typescript with HazelJS

Planning an event—whether it's a birthday party, corporate meeting, or wedding—requires coordinating multiple moving parts simultaneously. From finding the right venue to managing guest lists, arranging logistics, and staying within budget, event planning is a complex orchestration challenge. In this post, we'll build an Event Planning Coordinator Agent using HazelJS that streamlines this process through intelligent venue search, guest coordination, and logistics planning.

The Problem

Event planners face several coordination challenges:

• Venue Selection: Finding venues that match capacity, type, and budget requirements
• Guest Management: Tracking RSVPs, dietary restrictions, and communication
• Logistics Coordination: Arranging catering, decoration, entertainment, and transportation
• Budget Optimization: Balancing quality with available budget
• Timeline Planning: Creating realistic schedules for all event components

Our agent will address these challenges using HazelJS's multi-agent architecture, RAG-powered venue search, and intelligent logistics planning.

Architecture Overview

The Event Planning Coordinator Agent uses a multi-agent architecture where each agent specializes in a specific aspect of event planning:

• EventIntakeAgent: Extracts event type, guest count, budget, date, and venue preferences
• VenueSearchAgent: Retrieves venues from a knowledge base using RAG
• GuestCoordinatorAgent: Manages guest lists, RSVP tracking, and communication plans
• LogisticsPlannerAgent: Plans event logistics including catering, decoration, entertainment, and transportation
• EventManagerAgent: Orchestrates the workflow using supervisor routing

This separation allows each agent to focus on its specialty while the supervisor ensures smooth coordination between them.

RAG-Powered Venue Search

A critical component of event planning is finding the right venue. Our agent maintains a knowledge base of venues with metadata including:

• Type (indoor, outdoor, hybrid)
• Capacity
• Price per hour
• Available amenities (audio-visual, lighting, kitchen access, etc.)
• Location
• Availability patterns

When an event planner asks about venues, the VenueSearchAgent uses semantic search to find suitable options based on their query. For example, a query like "Find indoor venues for 100 guests" would return venues that match those criteria, ranked by relevance.

The RAG implementation uses HazelJS's RAGPipeline with a MemoryVectorStore for efficient semantic search:

@Service()
export class EventKnowledgeBaseService {
  private readonly embeddings = new LocalEventEmbeddingProvider();
  private readonly vectorStore = new MemoryVectorStore(this.embeddings);
  private readonly rag = new RAGPipeline({
    vectorStore: this.vectorStore,
    embeddingProvider: this.embeddings,
    topK: 3,
  });

  async answer(query: string, topK = 3) {
    const sources = await this.search(query, topK);
    return {
      answer: sources.map((source) => source.content).join('\n\n'),
      sources: sources.map((source) => ({
        id: source.id,
        score: Number(source.score.toFixed(3)),
        type: source.metadata?.type,
        capacity: source.metadata?.capacity,
        pricePerHour: source.metadata?.pricePerHour,
        location: source.metadata?.location,
        amenities: source.metadata?.amenities,
      })),
    };
  }
}

Guest Coordination

Managing guests is another complex aspect of event planning. The GuestCoordinatorAgent handles:

• Guest List Generation: Creating structured guest lists with contact information
• RSVP Tracking: Setting up tracking systems for confirmed, declined, and pending guests
• Communication Planning: Creating communication schedules (save-the-date, formal invitation, reminders)
• Dietary Restrictions: Tracking special dietary requirements for catering

The agent generates a comprehensive guest management plan including communication methods, estimated costs, and RSVP deadlines. This ensures no guest is forgotten and communication happens at the right times.

Logistics Planning

The LogisticsPlannerAgent creates comprehensive logistics plans covering:

• Catering: Food and beverage arrangements scaled to guest count
• Decoration: Theme-appropriate decoration packages
• Entertainment: Music, DJs, or other entertainment options
• Transportation: Shuttle services or transportation coordination
• Equipment: Audio-visual equipment, lighting, and other technical needs

The planner considers:

• Budget constraints: Filters logistics items that fit within the budget
• Guest count: Scales quantities appropriately
• Event type: Tailors logistics to the specific event type (corporate vs. party)
• Timeline: Creates realistic schedules for each logistics component

The agent provides a detailed logistics timeline showing when each component should be arranged, along with cost breakdowns and category summaries.

Supervisor Routing

The EventManagerAgent uses HazelJS's supervisor routing to coordinate between the specialist agents. When an event planner makes a request, the supervisor analyzes the request and routes it to the appropriate specialist:

• Event analysis requests go to EventIntakeAgent
• Venue questions go to VenueSearchAgent
• Guest coordination requests go to GuestCoordinatorAgent
• Logistics planning requests go to LogisticsPlannerAgent

The supervisor continues delegating until it has gathered enough information to provide a comprehensive event plan, then synthesizes the results into a cohesive recommendation.

Production-Ready Features

Despite being a demo, the agent includes production-ready features:

• Observability: OpenTelemetry integration for monitoring agent performance
• Resilience: Retry logic and circuit breaker patterns for reliability
• Rate limiting: Prevents abuse and ensures fair resource usage
• Guardrails: PII redaction and content safety for secure operation
• Metrics: Built-in metrics for tracking agent performance

Running the Agent

The agent can be run with:

npm install
npm run build
npm run dev

The app runs on http://localhost:3000 with the HazelJS Inspector available at /__hazel for real-time monitoring and debugging.

Try It Out

You can test the agent with a curl request:

curl -s -X POST http://localhost:3000/event/supervisor \
  -H 'content-type: application/json' \
  -d '{"message":"Planning a party for 50 guests, budget $5000, indoor venue. Plan my event.","userId":"event-planner-1"}'

The agent will analyze your request, extract your event profile, search for suitable venues, coordinate guest management, plan logistics, and synthesize everything into a comprehensive event plan—all coordinated through the supervisor routing system.

Complete Project: Event Planner Agent

Key Takeaways

The Event Planning Coordinator Agent demonstrates several key HazelJS capabilities:

• Multi-agent architecture: Each agent specializes in a specific aspect of event planning
• RAG integration: Semantic search over venue database
• Supervisor routing: Intelligent delegation to specialist agents
• Production-ready patterns: Observability, resilience, and guardrails
• Local LLM provider: Deterministic behavior without requiring API keys

This agent shows how HazelJS can be used to build practical, everyday applications that solve complex coordination problems while maintaining production-grade quality and reliability. The multi-agent approach makes it easy to extend the system with additional specialists (like budget analyzers or timeline optimizers) as needed.