Adaptive Approval Orchestrator

Inspiration

Every enterprise agentic workflow eventually hits a human-in-the-loop approval step — a refund, an access request, a production change. Companies obsess over agent hallucination rates, latency, and cost per token, but nobody measures how fast a human reviewer's judgment decays across their tenth, twentieth, or fortieth approval of the day. We found this described as a real, named failure mode — "approval fatigue" — with no existing tooling or metric attached to it. That gap became the project: not another dashboard, but a system that actually does something about fatigue instead of just displaying it.

What it does

Adaptive Approval Orchestrator is a multi-agent system built around a Sense → Decide → Act → Learn loop:

• Sense — infers reviewer fatigue live from six weighted signals: response-time decay, approval streaks, rubber-stamp ratio, session progress, digest-batch pressure, and SLA pressure. The formula is fully transparent, not a black box.
• Decide — a learned, per-reviewer confidence model (seeded from the reviewer's own early decisions) determines when it's actually safe to act without a human.
• Act — four concrete mechanisms, not one gate:
  • Autonomously resolves safe, low-risk requests when fatigue is high and confidence is high, with a one-click override window.
  • Locks and escalates high-risk requests to a second reviewer when fatigue crosses a critical threshold — instead of letting them get rubber-stamped.
  • Runs a retroactive cold audit on decisions made during high-fatigue windows, catching mistakes after the fact (e.g. a fraud-risk gift-card cashout that was rubber-stamped in seconds during peak fatigue).
  • Sends coaching feedback upstream to the requesting AI agents themselves when one agent is flooding the review queue.
• Learn — every human override adjusts the confidence model for next time.

Requests don't arrive on a steady drip either — we modeled realistic, bursty, multi-channel arrival (instant alerts, live-queue items, and batched digests) with live SLA countdowns and a visible competing "other work" load, because that's how approval queues actually behave inside real companies.

How we built it

• Frontend: React + TypeScript + Vite, styled with Tailwind CSS against a custom design system (dark, dense, restrained — inspired by professional dev-tool products) rather than default component-library styling.
• Simulation & scoring engine: a fully client-side TypeScript engine driving the entire scripted 40+ request scenario, fatigue formula, autonomous resolution logic, and retroactive audit — no backend server at all, so the whole app deploys as a static site.
• Visualization: Recharts for the gradient-filled fatigue trajectory chart, decision-breakdown donut, and response-time sparklines, with interactive hover tooltips.
• Reusability layer: the core fatigue/escalation logic is wrapped as MCP tools, so any agentic workflow with a human-approval step (e.g. one built on Agent Studio) can call check_fatigue() or should_escalate() before finalizing an action, without adopting the dashboard itself.
• Build process: we used Google Antigravity's agentic coding environment to execute the build from a detailed architecture and design spec, with its browser subagent verifying the scripted demo scenario end-to-end.
• Deployment: Vercel's free tier, deployed directly from GitHub.

Challenges we ran into

• Designing a fatigue score that is genuinely explainable rather than a black box — we deliberately kept it a transparent weighted formula so every intervention can be justified in plain language to a reviewer.
• Making the request arrival pattern realistic (bursty, multi-channel, SLA-bound) instead of a flat, evenly-spaced queue, which is what most "monitoring dashboard" demos default to and what made our first pass feel generic.
• Scoping which agentic mechanisms to build fully live versus honestly present as designed-but-lightly-wired, given hackathon time constraints — we chose to be transparent about this split rather than overstate autonomy that wasn't fully implemented.
• Debugging response-time capture and threshold-trigger logic so the autonomous-resolution and escalation mechanisms actually fire during the live scripted demo, not just in theory.

Accomplishments that we're proud of

• A genuinely closed multi-agent loop — sensing, autonomous action, retroactive correction, and upstream feedback — rather than a single monitoring view.
• Zero backend, zero hosting cost, fully reusable as an MCP skill for other agentic platforms.
• A retroactive audit mechanism that catches and explains a real rubber-stamped mistake after the fact — the "aha" moment of the whole project.

What we learned

That the most valuable agentic systems aren't the ones with the most AI in every corner — some decisions (like the safety-critical escalation gate) are better left transparent and deterministic, while others (like decomposing a messy request into reviewable sub-decisions) genuinely benefit from a real language model. Knowing which is which mattered more than adding AI everywhere.

What's next

Fully wiring the two currently-stubbed mechanisms (agent-coaching and request-decomposition) with a live LLM call via a small serverless proxy, and testing the fatigue formula against real reviewer behavior data rather than a scripted scenario.

Built With

• gemini
• react
• recharts
• tailwind
• typescript
• vite