Lunaris: Hierarchical Multi-Agent System for Hotel Ops

Lunaris Landing Page
Main Dashboard
3D Floor Plan Page
AI Agents Page
Security Page
Operations Page
Analytics Page
Event Logs Page
Settings Page

Inspiration

The hospitality industry runs on fragmented systems. Hotel staff juggle dozens of tools, and critical decisions fall through the cracks between departments. We asked: what if a hotel had a brain? Not a chatbot , a real AI operating system where agents reason, coordinate, and act across security, operations, and finance, while keeping humans firmly in control.

What it does

Lunaris is a hierarchical multi-agent AI system for hotel chains:

Executive Agent parses natural language requests and routes tasks to domain agents
Security Agent handles access control, lockdowns, and emergency protocols
Operations Agent manages guest notifications, bookings, and housekeeping
Finance Agent logs transactions and detects billing anomalies

All agents operate under zero-trust security via Auth0 Token Vault, with a human-in-the-loop approval gate for every critical action.

How we built it

Gemini — reasoning, task decomposition, orchestration planning
FastAPI — backend orchestrator, task dispatcher, approval state manager
Auth0 Token Vault — per-agent scoped JWT tokens, zero shared credentials
React/Next.js — real-time dashboard with agent activity, approvals, and emergency controls
Twilio, Gmail, Notion — SMS approvals, notifications, structured logging
Mock IoT APIs — simulated door locks and fire systems

Challenges we ran into

Async approval flow — pausing a task graph mid-execution while awaiting an SMS approval, then resuming or aborting cleanly, required three full rewrites of the orchestrator
Agent scope creep — early agents with broad tokens triggered unintended actions; fixed with a constraint validation layer in the orchestrator
Task graph conflicts — simultaneous agents acting on overlapping resources caused race conditions; resolved with a priority-based conflict resolution protocol

Accomplishments that we're proud of

Zero-trust applied at the agent level — every agent has its own scoped, expiring identity
Human-in-the-loop approval that genuinely blocks execution until a manager responds
A fully modular, production-structured FastAPI backend ready for real deployment
Hierarchical multi-agent coordination working end-to-end across three domain agents

What we learned

Agents need identity before intelligence — security architecture must come first
Orchestration is the hardest problem — coordinating when, in what order, with what fallback, is harder than the reasoning itself
Human oversight is a feature — the approval gate felt like friction early on; by the end it felt like the most important part of the system

What's next for Lunaris: Hierarchical Multi-Agent System for Hotel Ops

Multi-property coordination across entire hotel chains
Predictive maintenance engine using live IoT sensor streams
Trained anomaly detection model inside the Finance Agent
Chaos testing mode to stress-test orchestrator resilience
GDPR and PCI-DSS compliance layer baked into the token lifecycle

Bonus Blog Post

Lunaris: When AI Agents Need Their Own Keys

When I first sat down to design lunaris, I thought the hardest part would be the multi-agent hierarchy. I was wrong. The hardest part was answering a deceptively simple question: how do you stop a rogue AI agent from doing something it shouldn't?

The answer, I discovered, lives inside the Token Vault.

Early in development, my prototype had agents sharing a single API credential pool. It was fast to build and easy to test and completely terrifying in practice. A Finance Agent requesting a billing lookup had the same access surface as a Security Agent triggering a floor lockdown. One miscommunication in the task graph, and you'd have a room-service request accidentally pinging the fire alarm API. Not ideal for a five-star hotel.

Integrating Auth0's Token Vault forced me to rethink the entire execution layer. Instead of credentials, each agent now requests a scoped token at runtime and only for the action it was assigned. The Security Agent gets unlock:doors. Nothing more. The Finance Agent gets log:transaction. That's it. When the token expires, it's gone. No lingering permissions, no credential leakage between tasks.

The real technical hurdle was the Human-in-the-Loop approval flow. Pausing execution mid-graph holding a token in a pending state while waiting for a manager's SMS approval via Twilio required careful async state management in FastAPI. Getting that orchestration stable took three complete rewrites.

But when it finally worked , when a lockdown request genuinely stopped at the approval gate, waited, then either executed or aborted cleanly that was the moment Lunaris stopped feeling like a demo and started feeling like infrastructure.

Token Vault didn't just solve security. It gave each agent an identity. And that changed everything.