ARPO: Kitchen Ghost Shift

The AI manager that works the graveyard shift so your restaurant never sleeps on a bad review, a missed reservation, or a five-star regular you forgot to thank.

Comment

Inspiration

Independent restaurants everywhere are drowning in unstructured, chaotic signal — reservations, complaints, no-shows, and five-star regulars all buried inside one scrolling WhatsApp thread, triaged manually by an owner who's also expediting tickets on the line. We kept noticing the same silent failure mode across the industry: nothing catastrophic ever happens loudly. A regular quietly churns. A one-star review sits unanswered for 72 hours. A no-show never gets a recovery touchpoint. The business doesn't collapse from one dramatic failure — it erodes asymptotically from a hundred micro-failures nobody was instrumented to catch. We wanted to build the always-on, self-directing system that closes that observability gap in real time, at the edge, where the actual guest relationship lives — without the crippling inference costs or fragile security posture that usually keep always-on multi-agent systems out of reach for small, independent operators.

What it does

ARPO: Kitchen Ghost Shift is a fully autonomous, multi-agent orchestration layer that runs the graveyard shift no human owner can sustainably staff. A planner agent continuously ingests and triages signals across WhatsApp threads, review platforms, and reservation gaps, scoring urgency in real time. A specialist actor agent drafts and executes the response — replying, confirming, rebooking — or escalates to a human-in-the-loop checkpoint when the action is irreversible or high-stakes. An observer agent closes the feedback loop by monitoring downstream outcomes: did the guest re-engage, did they actually show up, did sentiment resolve. And a meta-correction layer sits above all three, continuously re-weighting escalation thresholds, tone, and timing based on aggregate outcome data — a genuinely self-improving, closed-loop system rather than a static, rules-based chatbot pretending to be intelligent.

Owners access all of this through an admin dashboard, secured end-to-end with Pomerium as an identity-aware access proxy in front of every route — meaning every dashboard request is authenticated and authorized at the edge, before it ever touches our application logic, rather than relying on brittle in-app session checks.

How we built it

We engineered this as a composable, event-driven multi-agent pipeline on top of our existing Arpo data infrastructure (Postgres, dbt, Airflow as the orchestration and transformation backbone), with a Next.js/Supabase front end serving as the human-facing control plane.

We orchestrated the actual multi-agent workflows using Nexla's Agent Development Kit (ADK), which turned out to be the backbone that made a genuinely composable, production-grade agent loop possible in a hackathon timeframe. Rather than hand-rolling brittle glue code between our planner, actor, and observer agents, Nexla ADK let us define each agent as a discrete, reusable node with declarative data contracts between them — so the planner's triage output flows directly into the actor's action step, and the actor's execution log flows directly into the observer's evaluation step, all orchestrated and monitored through Nexla's workflow layer instead of custom-built plumbing. This gave us production-grade data lineage across the entire agent loop almost for free, which mattered enormously once we started debugging why a given interaction triggered a specific escalation.

For inference, we deployed our planner, actor, and observer agents on Akash Network, running open-source Qwen models on Akash's decentralized GPU marketplace — giving us always-on, high-frequency multi-agent inference at a fraction of the cost of a metered proprietary API, with the flexibility to fine-tune our own weights directly.

On the security side, every admin dashboard route — guest history, escalation queue, prompt-approval panel — sits behind Pomerium, enforcing context-aware, per-route authorization (so a staff account can see the escalation queue but not the underlying prompt-mutation history, for example) without us building a custom auth layer from scratch.

Critically, we closed the loop one level deeper than outcome-tracking alone: raw customer replies — tone, corrections, explicit complaints about how the agent phrased something — are fed back into a prompt-optimization agent, itself just another node in the Nexla ADK workflow, that treats the live system prompt as a mutable artifact. When a guest pushes back on a response, that signal is scored and used to propose a targeted rewrite of the underlying instruction set, A/B tested against the incumbent prompt on our Akash-hosted Qwen instances, before being promoted.

Challenges we ran into

The hardest engineering problem wasn't prompting the model — it was formalizing agent autonomy boundaries. A missed reply is recoverable; an autonomously-cancelled reservation for a twelve-top isn't. We had to design a rigorous, machine-legible taxonomy of reversible vs. irreversible actions and wire a hard approval gate around the latter. A close second was getting our agent topology correctly modeled inside Nexla ADK — mapping a recursive, self-correcting loop (rather than a simple linear pipeline) into its workflow abstractions took real iteration. On the infrastructure side, wiring Pomerium's policy engine to distinguish between different admin roles at the route level, and orchestrating multi-agent workloads across Akash's decentralized provider network, were both non-trivial but paid off well beyond the hackathon window.

Accomplishments that we're proud of

Getting a true multi-agent system — orchestrated end-to-end through Nexla ADK, running on open-source Qwen models hosted on Akash, and locked down behind Pomerium at every admin route — to demonstrably self-correct inside a single hackathon sprint, at two levels simultaneously: adjusting its own urgency thresholds, and rewriting its own prompt based on real customer pushback. Watching the meta-correction layer autonomously downgrade its own urgency threshold after a false-positive escalation, and separately watching the prompt-optimization agent propose a warmer phrasing after a guest flagged a reply as cold, felt like the qualitative difference between a scripted chatbot and an emergent, adaptive nervous system operating in production — one we could actually afford to run continuously and trust with real admin access.

What we learned

Cutting-edge loop engineering isn't primarily a modeling problem — it's a feedback-signal design problem, at every layer of the stack. The genuinely hard technical work was defining measurable, machine-actionable reward signals and extracting a second, subtler signal — customer feedback on the agent's own communication style — that could safely reshape the system's own instructions. We also learned that the orchestration layer matters as much as the model layer: Nexla ADK's declarative agent-to-agent contracts made our recursive loop far easier to reason about and debug than hand-rolled glue code would have been, and Pomerium's identity-aware proxy meant we never had to trade security for shipping speed on the admin surface. And hosting open-source models on Akash gave us the deep customization and iteration speed a self-improving prompt loop actually needs.

What's next for ARPO: Kitchen Ghost Shift

Extending the observer agent's surface area to ingest Google Reviews, Instagram DMs, and voice-call transcripts as additional prompt-correction signal, adding a dedicated forecasting agent — as a new node inside our existing Nexla ADK workflow — to proactively predict churn and no-show risk, scaling our Akash deployment across a larger Qwen fine-tune tailored to hospitality dialogue, expanding Pomerium's policy engine to support fine-grained, per-restaurant-chain admin roles, and running a longitudinal pilot across our existing merchant network to stress-test the full loop against weeks of messy, high-entropy human behavior.

Built With

Share this project:

Updates