BatchHelm AI — Recall Command Center

Qwen-powered recall command center for small grocers, restaurants, and pharmacies — nine agents turn a supplier alert into matched inventory, verified shelf evidence, and an audit-ready packet.

Comment

Inspiration

Recall notices are chaos in slow motion for small operators. A spinach recall or an allergen mislabel doesn't come with a workflow — it comes as a PDF, a phone call, or an email, and a store manager with no recall-management software has to figure out, by hand, which lots are affected, where they are, who needs to pull them, and what to keep as proof for the regulator. Enterprise chains have this automated. Small grocers, restaurants, pharmacies, and distributors don't. BatchHelm AI exists to give that same operational clarity to operators who will never buy enterprise recall tooling.

What it does

BatchHelm turns a recall notice, an inventory CSV, and an optional shelf photo into a coordinated, auditable response:

  • Extracts the recall criteria from the notice with Qwen, and reconciles it against the authoritative inventory to find every affected lot and unit.
  • Inspects shelf photos with Qwen vision to read lot codes, UPCs, and dates directly off the product.
  • Classifies risk and generates removal, quarantine, disposal, and customer-notice tasks with owners and due times.
  • Gates every output behind human approval before anything leaves the organization — inventory impact, communications, and the regulatory evidence packet all need a reviewer's sign-off.
  • Remembers. A dedicated Memory agent persists supplier aliases, past decisions, and recurring false positives, so the system gets sharper with every incident instead of starting cold each time.

Every field in the UI is tagged with its source — qwen, deterministic, memory, or reviewer — so nothing pretends to be model output when it's actually a fallback or a human correction.

How we built it

The frontend is React + TypeScript on Vite, built as a code-split multi-page SPA (intake, review, mission control, evidence, memory, settings) with a live Mission Control dashboard subscribing to a Server-Sent Events stream. The backend is FastAPI + Pydantic on Python, with SQLite-backed durable stores for artifacts, orchestration state, reviews, and memory.

The core of the system is an Agent Society: nine specialist agents (Recall Intake, Document Extraction, Inventory Matching, Shelf Vision, Risk Scoring, Operations Task, Communications, Compliance Evidence, and Memory) coordinated by an Orchestrator as a DAG. Independent specialists — Inventory Matching and Shelf Vision, or Operations Task and Communications — run in the same parallel wave instead of one after another, with per-wave checkpoints, retries, and failure isolation baked in.

Architecture

Qwen (via Alibaba Cloud Model Studio's OpenAI-compatible endpoint) drives extraction, inventory-match reasoning, risk classification, the customer notice, shelf-photo interpretation, and the management briefing. Every Qwen call is validated against a Pydantic schema and repaired to a deterministic fallback on failure, so a bad or slow model response degrades the run instead of breaking it.

Qwen Cloud verification receipt

It's deployed as Docker containers behind Nginx on an Alibaba Cloud ECS instance in Singapore, reachable at http://47.84.199.208 — live and running for the duration of judging, not a local-only demo.

Challenges we ran into

  • Proving the Agent Society design actually helps, not just exists. We built a reproducible benchmark (scripts/benchmark_agent_society.py) comparing the DAG against a single-agent sequential baseline on identical inputs: 1.49x faster wall-clock time from wave-level parallelism; when a specialist is forced to fail, the DAG still delivers 4 of 9 completed agents with the rest cleanly skipped, while the sequential baseline aborts after 3 of 9 and loses the entire run; and after a simulated mid-run crash, the DAG's checkpoint only has to re-run 33% of the work versus 100% for the baseline.
  • A silent nginx routing bug. A deprecated-path rule was catching every request before our /api/v1/ proxy block existed, returning 410 Gone for the entire API on the live host — invisible locally, only surfaced once deployed.
  • An accidental credit-burn loop. The dashboard auto-started a full Qwen-backed orchestration run on every page visit, which meant every crawler hit or refresh spent real API credits. We reworked it so a visit only ever renders the last completed run; a new run only starts from an explicit "Run Agents" click.
  • Keeping Qwen output trustworthy under failure. Structured extraction and vision output had to be schema-validated and safely degraded to a deterministic fallback, without ever letting the UI blur the line between what Qwen actually said and what the fallback guessed.

Accomplishments that we're proud of

  • A genuinely multi-agent system with measured, not claimed, benefits — the benchmark numbers above are reproducible with one command.
  • A live, durable deployment: refreshing or reconnecting mid-run resumes the same incident and replays its event history instead of losing state or starting over.
  • A human-approval gate that's structural, not cosmetic — nothing reaches a customer notice or a compliance packet without a reviewer signing off.
  • 200+ backend tests and a green frontend typecheck/build/test suite, with CI enforcing all of it.

What we learned

Multi-agent orchestration only pays for itself once you can measure the payoff — building the benchmark harness before writing the pitch forced us to be honest about where the DAG actually helps (parallel wave latency, failure isolation, checkpoint resume) versus where it's just architectural nicety. We also learned, the hard way, that a demo environment left running with live model credentials needs the same restraint as a production one — "convenient to demo" and "safe to leave running" are different requirements.

What's next for BatchHelm AI

Queued/offline sync for the mobile shelf-photo intake (today it requires connectivity), expanding the Memory agent's learned patterns into proactive suggestions during intake instead of only post-hoc recall, and multi-tenant support so a single deployment can serve more than one operator.

Built With

Share this project:

Updates