# Project export: baymax This document was generated by HackStack to give an AI agent context about a hackathon project. Sections are labeled with their provenance; content marked as truncated was cut to keep this document small. ## Project metadata - Hackathon: UC Berkeley AI Hackathon 2026 - Tagline: Baymax is a network of hospital AI agents that supports abrupt crises using weather, disease, and inventory data, then coordinates hospital-to-hospital supply transfers before crises peak. - Devpost: https://devpost.com/software/baymax-1wumi3 - GitHub: https://github.com/apollo-ullah/Baymax - Video: https://www.youtube.com/embed/uRPyS_SuhiA?enablejsapi=1&hl=en_US&rel=0&start=&version=3&wmode=transparent - Result: winner (Best Use of The Agentverse by Fetch AI) - Team: 6 GitHub contributor(s) — Claude Opus 4.8 (1M context) (19 commits), Adyan Ullah (14 commits), egomez714 (11 commits), Tvesha Shah (9 commits), Cursor (8 commits), Daksh Kumar (5 commits) ## Devpost submission (written by the team) ### Overview When a heatwave strikes, a disease outbreak surges, or a mass casualty event unfolds, hospitals are suddenly competing for the same scarce supplies, and the phone-call coordination that's supposed to fix it is far too slow. Baymax is a network of hospital AI agents built on Fetch.ai that sees crises coming by fusing live weather, disease, and inventory signals. Using Claude for reasoning, it autonomously negotiates and settles inter-facility transfers on-chain before shortages peak. Every decision is traced through Arize Phoenix, allowing the system to learn from each event and improve future responses. Baymax doesn't just respond to emergencies - it learns to anticipate them. At a Glance Baymax predicts shortages before they happen, negotiates inventory transfers between hospitals, settles them on-chain, and learns from every crisis it handles. ### Inspiration The supply crisis starts long before a hospital runs out. It starts hours earlier, when a weather forecast converges with rising illness signals and a facility that's already running lean. By the time a supply manager notices the pattern—let alone makes phone calls to neighboring facilities, negotiates terms, and arranges a transfer—the shortage has already peaked. The perception problem (counting what's on a shelf) is largely solved. The harder problem is autonomous coordination under surge conditions: seeing a crisis before it happens, negotiating transfers across institutions under real constraints, settling them quickly, and improving the system after every event. That's a multi-agent systems problem. Fetch.ai provides the agent network. Claude provides the reasoning layer. Arize Phoenix closes the learning loop. Baymax is what happens when all three work together. What it Does Baymax runs one agent per hospital. Each agent continuously combines: Live inventory from edge vision systems Weather forecasts and disease-burden signals Historical surge patterns and outcomes When a shortage is predicted: Claude detects a surge risk before inventory reaches critical levels. The requesting hospital broadcasts a transfer request through the Fetch.ai agent network. Nearby hospitals respond with constrained offers. Claude evaluates quantity, urgency, ETA, distance, and expiry dates. If no single offer satisfies demand, Baymax automatically creates a split transfer plan. The transfer is settled through the Fetch Payment Protocol on Dorado testnet. Arize Phoenix traces the entire decision process and outcome. The result is a system that can identify shortages earlier, coordinate faster, and continuously improve over time. How We Built It Baymax has two user-facing surfaces: ASI:One for natural-language interaction and approvals A live Flask dashboard for real-time monitoring and visualization Both are powered by the same Fetch.ai agent network and synchronized through Redis. Core Stack Agent Network Negotiation Flow Challenges We Ran Into ASI:One Echo Loops ASI:One occasionally interpreted our own agent narration as new user intent. We built filtering, cooldowns, and heuristics to prevent agents from responding to themselves. Payment Card Rendering The Fetch payment card depended on very specific metadata fields. Missing metadata caused silent failures with no visible error messages. Python 3.14 Event Loop Changes uAgents still relied on behavior removed in Python 3.14. We had to carefully manage initialization order to ensure a valid event loop existed before agent creation. Long-Running On-Chain Verification Transaction verification could stall agent execution for up to 20 seconds. We moved verification into background threads using asyncio.to_thread(). Accomplishments We're Proud Of Live End-to-End Settlement We successfully demonstrated: Natural-language intent → surge prediction → multi-hospital negotiation → on-chain payment → confirmed transfer Real Predictive Signals Baymax combines: Live weather data Real illness data Current inventory levels to generate structured shortage forecasts before a shortage is declared. Constraint-Aware Negotiation Baymax doesn't simply match one requester to one provider. It can automatically compose split transfers when multiple facilities are required to satisfy demand. Full Decision Traceability Every prediction, ranking decision, transfer proposal, and outcome is captured in Arize Phoenix. Parallel Development The forecasting, vision, dashboard, observability, and agent teams all built independently against a shared Redis schema and integrated successfully. What We Learned The defensible technology isn't the camera. The real value comes from creating a network that can detect, negotiate, and settle across institutional boundaries before a crisis peaks. We also learned that observability is essential for autonomous systems. The ability to trace every decision made by the system transforms Baymax from a coordination tool into a platform that can improve with experience. Finally, we learned that fail-closed design makes live demos possible. Every major dependency has deterministic fallbacks, allowing the system to remain reliable even when external services are unavailable. What's Next Predictive Pre-Positioning Move inventory before shortages occur when confidence in an incoming surge becomes sufficiently high. Disaster Response Coordination Extend the network to support regional responses for mass-casualty incidents and natural disasters. Ambulance & Patient Routing Apply the same negotiation framework to patient transfers and hospital capacity balancing. Blood & Biologics Logistics Support temperature-sensitive and blood-type-constrained transfers. Cross-System Federation Allow independent health systems to participate in a regional mutual-aid network without exposing internal inventory systems. Supplier-Side Agents Bring distributors into the negotiation process so Baymax can choose the globally optimal resolution between purchasing and transfer options. Baymax sits on top of existing hospital workflows. It doesn't replace clinical decision-making—it helps ensure critical supplies arrive where they're needed before shortages impact patient care. ## Built with fetch.ai · uagents · agentverse · asi:one · chat-protocol · payment-protocol · claude · claude-code · anthropic · redis · arize-phoenix · opencv · open-meteo · disease.sh · flask · python ## README (from the GitHub repository) # Baymax **A network of hospital AI agents that detect supply shortfalls and autonomously negotiate and settle inter-facility transfers — before anyone runs out.** A supply manager states an intent in plain English through ASI:One — *"Hospital A is short on IV fluids"* — and the network takes it from there: it broadcasts the need, collects constrained offers from facilities with surplus, ranks them with Claude, composes a (possibly split) transfer, and settles it as a real on-chain testnet FET transaction — narrating every step back into the chat. > Built at Cal Hacks for the Fetch.ai **"From Intent to Action"** challenge. > Operational logistics only — *what to move, how much, by when.* Never clinical guidance. --- ## The problem Hospitals run lean on consumable supplies and absorb uneven demand shocks. One facility runs critically short on an item while another a few miles away sits on a surplus of the exact same thing. Inside multi-facility health systems and regional mutual-aid compacts, this imbalance already gets reconciled — but slowly, by phone, and only if someone catches it in time. The perception problem (counting what's on the shelf) is a solved commodity. The hard, unsolved problem is **coordination across organizational boundaries**: detecting the imbalance, matching surplus to shortfall under real constraints, and settling the transfer — autonomously, before the shortage becomes a crisis. That's a multi-agent systems problem, and it's exactly what Fetch.ai's agent mesh and Claude's reasoning make possible. --- ## What it does Baymax runs one agent per hospital. Each agent knows its live stock (from edge vision) and its forecast demand (from weather and illness signals). The end-to-end chain: 1. **Shortfall detected** — falling stock converges with rising forecast demand. 2. **The front agent broadcasts a request** to the network over uAgents messaging. 3. **Surplus facilities answer with constrained offers** — quantity available, distance/ETA, expiry, urgency. 4. **Claude ranks the offers and composes a resolution.** When no single facility covers the need, it splits the order (e.g. **150 units from the near hospital + 50 from the far one**) or trades ETA against expiry, and re-plans on partial rejections. 5. **The transfer settles as a real transaction** via the Fetch Payment Protocol on Dorado testnet — `RequestPayment → CommitPayment → CompletePayment` — with the payment card surfacing right in the ASI:One chat for the user to sign. 6. **Everything is shown live** — a Redis-backed dashboard renders inventory, the shortfall alert, and the negotiation resolving in real time. The moment that proves it's real: the negotiation handles a constraint — a partial offer plus a re-plan into a split transfer — and then settles an actual on-chain payment. That's what separates this from scripted message-passing. --- ## Why this is hard Vision-based inventory monitoring and demand forecasting are rising but those platforms are single-tenant by design: each customer's data is walled off. Baymax is a different layer entirely: **coordination across the wall**. A perception platform could sit underneath Baymax as its camera layer — it's a component, that extends and automates. The hard problem is agent-to-agent negotiation and settlement across organizational boundaries, a multi-agent systems problem, not a computer-vision one. --- ## Tools and technologies | Layer | What we used | | :-- | :-- | | **Agent mesh, chat, settlement** | Fetch.ai **uAgents** + **Chat Protocol** (v0.3.0) + **Payment Protocol** (v0.1.0), registered on Agentverse, reachable in **ASI:One** | | **Reasoning + offer ranking** | **Claude Sonnet 4.6** via the Anthropic API — multi-constraint offer ranking and natural-language narration; entire codebase built with **Claude Code** | | **Edge inventory (vision)** | MacBook/Pi camera → **Claude Vision** counts saline units across a green-straw divider, writing qty/surplus straight to Redis | | **State + pub/sub** | **Redis Stack** — inventory, surplus, forecast, transfer audit stream, live event channels | | **Forecast inputs** | Open-Meteo weather agent + a CDC/WHO illness signal agent, both writing to `forecast:{region}` in Redis | | **Observability** | **Arize Phoenix** traces the full decision chain: inventory → forecast → reasoning → transfer → outcome | | **Human-in-the-loop** | iMessage approval pipeline with tappable Accept/Reject links via Messages.app (AppleScript) | | **Dashboard** | **Flask** UI auto-refreshing every 3s from Redis; SSE stream for live narration | --- ## Architecture ### The agent network Three Fetch.ai uAgents run the negotiation: | Agent | Facility | Role | | :-- | :-- | :-- | | `baymax_front` | Hospital A | **Requester + ASI:One surface.** Carries the Chat and Payment protocols; detects the shortfall, broadcasts the request, ranks offers with Claude, composes the transfer, settles it, narrates back. | | `baymax_hospital_b` | Hospital B | **Surplus facility** — responds with constrained offers, accepts/rejects transfer legs. | | `baymax_hospital_c` | Hospital C | Same. | ### The negotiation state machine ``` shortfall_detected → requesting → collecting_offers → evaluating → (re_planning if no single offer covers the need) → proposing → settling → confirmed ``` ### How the layers connect Two surfaces, one engine. **ASI:One** is the Fetch-qualifying conversational surface; the **live dashboard** is the visual story. Both are driven by the same agents and the same **Redis** state bus — the integration seam that let each track build in parallel without coupling. ``` ASI:One chat ──► front agent (uAgents) │ ▲ broadcast │ │ narration ▼ │ hospital B & C agents │ Redis ──► Dashboard (Flask) │ Dorado testnet (Fetch Payment Protocol) ``` ![System architecture](final_diagram.png) **The wire contract is frozen.** `protocol.py` is the single source of truth for every cross-agent message model and the negotiation state machine. The official Fetch Chat/Payment protocol classes are re-exported unchanged — ASI:One matches by schema digest, so a local redefinition would be an incompatible protocol. No module ever redefines these. **Every live dependency has a fail-closed fallback.** Redis, the camera, and the chain are each behind a seam in `interfaces.py` with a deterministic mock. The system is testnet-only by construction: mainnet is refused at startup; payment verification is pinned to `fetchai_stable_testnet`. --- ## How Claude is used Claude does two jobs: **Offer ranking.** When surplus offers arrive, Claude weighs quantity, distance, expiry date, and urgency against the shortfall. It selects a resolution — single-source if one facility covers the need, or a split transfer (e.g. 150 + 50) when none can alone. The ranking seam in `interfaces.py` sits behind a deterministic mock for offline testing. **Shelf vision.** The camera pipeline sends a JPEG of the supply shelf to Claude Vision, which counts units per hospital across a colored divider. The count writes directly into Redis as `qty` and `surplus`, feeding the same inventory the agents read for negotiation. The intent parser (`front_agent.parse_intent`) is currently a deterministic keyword/regex parser. A commented ASI:One-LLM seam sits behind the same signature, ready to swap in. --- ## Repository layout | Path | What it is | | :-- | :-- | | `agent-communication-layer/` | The Fetch agent mesh — negotiation core, front/ASI:One agent, Payment Protocol settlement, Mailbox runners | | `redis/` | The Redis integration seam — schema, inventory/forecast/alerts/transfers, pub/sub | | `fetch/` | Forecast input agents (weather, illness) + the iMessage human-approval pipeline | | `hardware/camera connection/` | Claude Vision shelf-counting → Redis | | `arize/` | Arize Phoenix decisio [README truncated for size] ## Detected evidence (automated analysis) Indexed codebase: 113 recognized source files, 656 KB. - Anthropic (technology) — detected in the code - FastAPI (technology) — detected in the code - HTML (language) — detected in the code - Python (language) — detected in the code - Redis (technology) — detected in the code - JavaScript (language) — claimed on Devpost, not found in the code - AI coding agent: Claude Code — evidence: config files committed to the repository; commit authorship or trailers - AI coding agent: Cursor — evidence: commit authorship or trailers ## Codebase structure (from repository index) ### Files (120 of 144) ``` __init__.py .env.example .gitattributes .gitignore agent-communication-layer/.env.example agent-communication-layer/.gitignore agent-communication-layer/agent_base.py agent-communication-layer/agent_network_mvp_roadmap.md agent-communication-layer/baymax_agents.py agent-communication-layer/camera_worker.py agent-communication-layer/check_interfaces_order.py agent-communication-layer/check_parse_decision.py agent-communication-layer/dashboard_bus.py agent-communication-layer/DELIVERABLES.md agent-communication-layer/DEMO_SCRIPT.md agent-communication-layer/docs/superpowers/plans/2026-06-20-admin-approval-and-supplier-order.md agent-communication-layer/docs/superpowers/plans/2026-06-20-two-camera-scan-dashboard.md agent-communication-layer/docs/superpowers/specs/2026-06-20-admin-approval-and-supplier-order-design.md agent-communication-layer/docs/superpowers/specs/2026-06-20-two-camera-scan-dashboard-design.md agent-communication-layer/front_agent.py agent-communication-layer/hello_world_agent.py agent-communication-layer/interfaces.py agent-communication-layer/protocol.py agent-communication-layer/README.md agent-communication-layer/redis_inventory.py agent-communication-layer/requirements.txt agent-communication-layer/run_dashboard_demo.py agent-communication-layer/run_front.py agent-communication-layer/run_hospital_b.py agent-communication-layer/run_hospital_c.py agent-communication-layer/scan_dashboard.py agent-communication-layer/scripts/free_demo_ports.sh agent-communication-layer/scripts/single_mac_demo.sh agent-communication-layer/scripts/tailscale_env.sh agent-communication-layer/scripts/tailscale_peer_b.sh agent-communication-layer/scripts/tailscale_server.sh agent-communication-layer/settlement.py agent-communication-layer/stockpile_agents.py agent-communication-layer/supplier_order.py agent-communication-layer/tailscale_hosts.py agent-communication-layer/tailscale_smoke_test.py agent-communication-layer/two_agent_payment_spike.py agent-communication-layer/vision_count.py agent-communication-layer/wave2_e2e_check.py agent-communication-layer/wave3_order_e2e_check.py agent-communication-layer/wave4_dashboard_e2e_check.py agent-communication-layer/wave5_handshake_e2e_check.py anthropic/README.md arize/.env.example arize/.gitignore arize/HANDOFF.md arize/README.md arize/requirements.txt arize/src/__init__.py arize/src/demo_trace.py arize/src/phoenix_client.py arize/src/trace_decision_chain.py arize/src/trace_decision_outcome.py arize/src/trace_forecast.py arize/src/trace_inventory.py arize/src/trace_reasoning.py arize/src/trace_schema.py arize/src/trace_store.py arize/src/trace_transfer.py baymax_PRD_v2.md CLAUDE.md dump.rdb fetch/__init__.py fetch/agents/__init__.py fetch/agents/illness_agent/__init__.py fetch/agents/illness_agent/agent.py fetch/agents/illness_agent/mock_cdc_feed.json fetch/agents/illness_agent/mock_illness_feed.json fetch/agents/illness_agent/models.py fetch/agents/README.md fetch/agents/requirements.txt fetch/agents/weather_agent/__init__.py fetch/agents/weather_agent/agent.py fetch/agents/weather_agent/models.py fetch/agents/who_agent/__init__.py fetch/agents/who_agent/agent.py fetch/agents/who_agent/fetcher.py fetch/agents/who_agent/models.py fetch/approval/__init__.py fetch/approval/imessage_client.py fetch/approval/README.md fetch/approval/serve_with_ngrok.sh fetch/scripts/__init__.py fetch/scripts/redis_smoke_test.py fetch/shared/__init__.py fetch/shared/protocol.py fetch/shared/README.md fetch/shared/redis_io.py hardware/camera connection/bottle_counter.py hardware/camera connection/camera.py hardware/camera connection/capture_1782006619.json hardware/camera connection/capture_1782006867.json hardware/camera connection/capture_single.py hardware/camera connection/README.md hardware/camera connection/sync_to_redis.py hardware/camera connection/take_photo.py hardware/requirements.txt hardware/test folder/BUTTON_TEST_README.md hardware/test folder/monitor.py hardware/test folder/pico_code/main.py kill_all.sh README.md redis/.env.example redis/.gitignore redis/docker-compose.redis.yml redis/HANDOFF.md redis/README.md redis/redis_contract.md redis/requirements.txt redis/src/__init__.py redis/src/alerts.py redis/src/demo_run.py redis/src/forecast.py redis/src/inventory.py redis/src/ping.py [24 more files omitted for size] ``` ### Dependencies - agent-communication-layer/requirements.txt: anthropic, cosmpy@>=0.11.0, fastapi, httpx, opencv-python, python-dotenv@>=1.0.0, redis@>=5.0.0, uagents@==0.25.2, uagents-core@==0.4.7, uvicorn[standard] - arize/requirements.txt: arize-phoenix, openinference-instrumentation, opentelemetry-exporter-otlp-proto-http, opentelemetry-sdk, python-dotenv - fetch/agents/requirements.txt: anthropic, fastapi, httpx, python-dotenv, redis, uagents, uvicorn[standard] - hardware/requirements.txt: anthropic, opencv-python, python-dotenv, redis - redis/requirements.txt: numpy, python-dotenv, redis, sentence-transformers ### Recent commits (newest first) - Merge PR #7 (revamp-ui): soft-care UI redesign - feat(ui): Baymax soft-care redesign of the live Flask dashboard - Fix missing _emit narration helper + demo launch scripts - push - Strip ASI:One @agent1 mention prefix before parsing decisions - Dashboard fixes + UI: working Bureau, live narration, Arize slide, Red Bull vision proxy - Two-tap human approval handshake on the real agent negotiation - changes - changes - changes to 2 cams - two capture - combining - Wire ngrok authtoken through .env (NGROK_AUTHTOKEN) - Add ngrok launcher for approval service so accept/reject links are phone-tappable - Merge remote-tracking branch 'origin/main' - changes - changes - Add project README (from DEVPOST writeup) for GitHub - Merge poke-approval: Hospital A<->B human approval pipeline (FR15) over iMessage - Pivot approval notifications from Poke to iMessage (osascript) ## Key source files (fetched from GitHub, selected and truncated for size) ### CLAUDE.md ```markdown # CLAUDE.md This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. ## What this is **Stockpile** — a network of Fetch.ai uAgents that detect hospital supply shortfalls and autonomously negotiate + settle inter-facility transfers. A supply manager states an intent in natural language via ASI:One ("Hospital A is short on IV fluids"); the FRONT agent broadcasts the need, ranks offers from surplus facilities, composes a (possibly split) transfer, and settles it as a real Fetch **testnet** FET transaction — narrating each step back into the chat. Built for the Fetch.ai "From Intent to Action" challenge. **All code lives in `adyan-agent-communication-layer/`.** The repo root holds only that directory, `stockpile_PRD_v2.md` (the product spec), and an image. Run every command from inside `adyan-agent-communication-layer/`; the virtualenv is at `adyan-agent-communication-layer/.venv`. ## Commands ```bash cd adyan-agent-communication-layer python -m venv .venv && source .venv/bin/activate # Python 3.12+ (developed on 3.14) pip install -r requirements.txt ``` There is **no test runner, linter, or build step.** The verification harnesses below *are* the test suite — each is a self-contained, self-exiting script. Prefer `./.venv/bin/python