FoodLoop

An agent-ready surplus-food rescue control room with explainable safety, role-scoped WebMCP, and human-approved handoffs.

Comment

FoodLoop

FoodLoop is an agent-ready surplus-food rescue control room for moving good food before it expires.

The problem

Food rescue fails in the coordination gap. Donors know what is available, recipients know what they can safely use, and an operator must reconcile food category, dietary requirements, quantity, timing, vehicle capacity, pickup-before-delivery dependencies, and chain of custody. A generic chat box can suggest a match, but it should not silently dispatch a vehicle or claim a delivery happened.

The solution

FoodLoop gives browser agents a focused operations surface and gives the human operator one shared, inspectable control room. The agent can read current supply and community need, find compatible matches, reserve reviewable allocations, draft a dependency-safe route, independently audit timing and capacity, explain why a match won, model route delays, run sandboxed safety checks, request dispatch review, and stage delivery receipts. The operator must release the route and verify each final handoff.

The guided Springfield simulation uses fictional data to demonstrate two compatible allocations, a four-stop route, 92 servings loaded, 100/100 safety, 22 minutes of minimum slack, a visible dispatch checkpoint, and two verified handoff receipts.

Judge evidence

The live app includes a dedicated proof surface:

  • A 13-call fresh-browser walkthrough shows the Planner chain, independent Auditor checks, a forbidden Planner dispatch request, and a Dispatcher checkpoint.
  • Seven adversarial safety cases refuse expired food, allergen mismatch, insufficient capacity, late delivery, duplicate handoff, malicious donor notes, and prompt-injected partner content. Each result shows refusal, evidence, a safe alternative, and sandbox-only state protection.
  • Match counterfactuals show score components and the next-best safe alternative. Route counterfactuals show how a 15-minute departure delay changes deadline slack without mutating the plan.
  • A role map makes capabilities explicit: Planner proposes, Auditor inspects, Dispatcher requests approval, Operator approves dispatch, and Recipient verifies the final handoff.
  • The shared tool console, role trace, safety lab, decision queue, route map, impact ledger, and activity trail all reflect the same deterministic state.

Published-data benchmark

FoodLoop includes a reproducible adapter benchmark on the public FoodGo Test Dataset: 500 published food-rescue orders and 50 volunteer records from the U.S. Department of Transportation / Mobility21 at Carnegie Mellon University. Against a FIFO first-feasible baseline, the deadline-and-distance-aware adapter accepts 94 orders versus 91, reduces modeled route distance from 2,806.98 km to 2,277.92 km, and improves minimum modeled deadline slack from 4.0 to 40.1 minutes. It rejects 23,052 unsafe candidate plans before assignment. The coordination-time number is explicitly a scenario proxy, not a human study; the assumptions, source attribution, and reproduction command are in the public repository's benchmarks directory.

Why WebMCP

This is structured, stateful work shared between a person and an agent. Agents are good at scanning constraints and assembling a plan; operators are accountable for consequential actions and ambiguous real-world context. WebMCP makes that division legible in the product instead of hiding it behind an opaque assistant.

app.js registers thirteen focused tools directly through document.modelContext.registerTool(...). The portable contracts are separated into tool-contracts.js, with bounded JSON Schemas, compact outputs, readOnlyHint on read operations, and untrustedContentHint for partner-entered content. The consequential path is:

observe → propose allocation → draft route → audit route
       → request review → HUMAN APPROVES DISPATCH
       → stage receipt → HUMAN VERIFIES HANDOFF

The agent never impersonates either human approval.

How we used AI

FoodLoop itself is deterministic and self-contained for the competition. It does not call a hidden model, require an API key, or fabricate a logistics integration. OpenAI Codex/GPT-5 supported implementation, test design, browser replay, and product iteration. The refreshed demo narration uses the creator's private VoiceBank recordings; raw recordings remain private and are excluded from the repository.

Testing

The repository includes deterministic tests for matching, reservations, routing, audits, adversarial safety, counterfactual reasoning, role capabilities, approval boundaries, handoff validation, metrics, WebMCP contract annotations, and the external-data benchmark.

  • npm test passes 25 tests.
  • npm run verify passes the 13 tool contracts, JavaScript syntax checks, required judge artifacts, the benchmark result, and the compact orientation-response budget.
  • The public GitHub Pages build, the refreshed 2:42 video, and the public video page were independently checked.

Links

Live app: https://moscraciunxxx.github.io/foodloop-webmcp/

Open-source repository: https://github.com/moscraciunxxx/foodloop-webmcp/

Judge walkthrough: https://github.com/moscraciunxxx/foodloop-webmcp/blob/main/docs/JUDGE_WALKTHROUGH.md

Benchmark source record: https://rosap.ntl.bts.gov/view/dot/56260

Demo video: https://youtu.be/07p1pvKEuHI

The prototype is self-contained and uses fictional Springfield simulation data for the product demo. It does not send messages, move food, call a fulfillment service, or require API keys. Production integrations would add identity, authorization, durable storage, observability, consent, and partner-specific retention controls while preserving both human approval gates.

Built With

Share this project:

Updates

Submission history