INSPIRATION
Food rescue is often treated as a supply problem, but for many local organizations the real bottleneck is coordination. A donor has surplus food, several organizations may need it, each recipient has different safety and capacity constraints, a volunteer may or may not be available, and every operational change creates another round of calls and messages.
RescueRoute AI was built around one question: what if the routine coordination happened autonomously, while human attention was reserved for the decisions that genuinely require judgment?
WHAT RESCUEROUTE AI DOES
A donor submits a surplus-food event. RescueRoute AI then performs the operational workflow end to end:
• Creates a structured rescue event. • Checks recipient eligibility against allergen, refrigeration, opening-time and policy constraints. • Allocates estimated meals under recipient capacity limits. • Assigns available volunteer logistics. • Prepares notifications for the donor, recipients and volunteer. • Records actions in an audit timeline. • Responds to volunteer cancellation by attempting safe autonomous recovery. • Escalates to a human only when no safe automatic path remains.
The result is not another assistant that simply recommends what a coordinator should do. RescueRoute performs the routine coordination work itself.
HOW IT WORKS
The main workflow is implemented with the Strands Agents SDK Graph pattern using five specialist stages:
Intake → Safety → Matching → Logistics → Communications
Each agent has a narrow responsibility and a defined set of tools. The graph structure makes the workflow explicit and prevents required stages from being casually skipped.
Hard operational rules are deliberately separated from free-form model reasoning. Deterministic Python tools enforce recipient eligibility, allergen restrictions, refrigeration requirements, closing-time constraints, capacity limits and human-escalation conditions. The model helps interpret context and orchestrate actions, while the tools decide whether an action is allowed.
A dedicated recovery path handles volunteer cancellation. RescueRoute first attempts to find a replacement volunteer. If that is not possible, it checks whether every allocated recipient can safely self-pickup. Only when no safe automatic recovery remains does the system request human logistics coordination.
TECHNICAL ARCHITECTURE
The project uses Strands Agents SDK, Python, FastAPI, Pydantic and deterministic safety tools. Amazon Bedrock with Claude Sonnet 4.6 is configured as the intended Strands model. The repository also includes an Amazon Bedrock AgentCore Runtime-compatible entrypoint using BedrockAgentCoreApp.
TESTING AND EVALUATION
RescueRoute includes a seeded benchmark with 500 deterministic safety scenarios plus 100 failure-recovery scenarios.
The benchmark validates that:
• Rejected recipients never receive an allocation. • Recipient capacity is never exceeded. • Nut-allergen policy is respected. • Refrigeration requirements are respected. • Meal accounting is conserved. • Incomplete safe allocation always triggers human escalation. • A cancelled volunteer moves to a safe backup when one exists. • No-safe-logistics cases escalate instead of inventing a plan.
Current benchmark results:
500 / 500 safety scenarios passed. 50 / 50 backup-recovery scenarios passed. 50 / 50 forced safe-escalation scenarios passed.
The automated test suite also covers normal coordination, safety exclusions, partial allocation, autonomous backup-volunteer recovery and escalation when no safe recovery remains.
KEY DESIGN CHALLENGES
The hardest design decision was defining where autonomy should stop. A naive multi-agent implementation can look impressive while still allowing model reasoning to weaken operational constraints. RescueRoute uses a hybrid architecture: Strands agents handle interpretation and orchestration, while deterministic tools own hard safety and capacity rules.
A second challenge was failure behavior. Real logistics workflows do not end when the first plan changes. RescueRoute therefore treats cancellation as a new operational event and actively attempts recovery rather than simply notifying a human.
ACCOMPLISHMENTS
• Implemented a real Strands Graph rather than a single chat loop. • Added deterministic safety boundaries around model reasoning. • Added autonomous recovery from volunteer cancellation. • Added explicit human escalation when safe autonomy ends. • Achieved 500 / 500 safety scenarios, 50 / 50 backup recoveries and 50 / 50 safe escalations. • Built a complete command-center experience instead of a CLI-only proof of concept. • Added an AgentCore Runtime-compatible deployment entrypoint.
WHAT WE LEARNED
The most useful agentic systems are not necessarily the systems with the largest number of agents. They are systems with a clear boundary between model judgment, deterministic policy, external action and human authority.
The Strands Graph pattern made those responsibilities visible in code and gave the project a workflow structure that mirrors how community operations actually happen.
WHAT’S NEXT
The hackathon demo uses synthetic organizations and an in-memory operational store. A production version could add persistent storage, real donor and recipient onboarding, routing and mapping integrations, messaging providers, identity and authorization, observability traces, recipient availability synchronization, and impact analytics.
The longer-term goal is broader than food donation: a reusable community logistics agent for local organizations coordinating scarce people, time, inventory and transport.
Built With
- amazon-bedrock
- amazon-bedrock-agentcore
- boto3
- css
- docker
- fastapi
- github-actions
- html
- javascript
- pydantic
- pytest
- python
- strands-agents-sdk
