Sentinel

Zero-Delay Humanitarian Aid

Comment

Inspiration

We live in an era where information travels at the speed of light, but humanitarian aid travels at the speed of bureaucracy.

When a massive earthquake hits or a hurricane makes landfall, the world knows instantly. But the funds needed for water, shelter, and medical supplies often sit locked in bank accounts for days, sometimes weeks, waiting for human signatures and committee approvals.

We asked ourselves: Why can’t money move as fast as the news?

We realized that the bottleneck isn't the banking system; it's the decision to release funds. We wanted to build a system that removes the human latency from humanitarian aid, turning philanthropy into a programmable, zero-delay reflex.

What it does

Universal Sentinel is an autonomous treasury that monitors the planet for disasters and instantly disburses funds to verified NGOs without human intervention.

Think of it as a "dead man's switch" for charity, but instead of waiting for silence, it waits for chaos.

  1. The Observer (Eyes): Our Python agent monitors real-time disaster feeds from NASA EONET, GDACS, and NOAA every 60 seconds. It watches for earthquakes, wildfires, and floods.
  2. The Judge (Brain): When a disaster is detected, the data is fed to Google Gemini 1.5 Flash. The AI analyzes the telemetry (magnitude, location, population density) and makes a strict, binary decision: YES (authorize aid) or NO (ignore).
  3. The Vault (Hands): If the AI authorizes it, a smart contract on the blockchain automatically unlocks funds. It matches the disaster type (e.g., Earthquake) and location (e.g., Asia) to a pre-verified NGO (e.g., Red Cross) and executes the transaction on-chain.

The result? Money lands in the NGO's wallet minutes after the disaster strikes, not weeks.

How we built it

We architected the system around three distinct "agents" to ensure security and separation of concerns:

  • The Backend (The Nervous System): Built with Python (FastAPI). It orchestrates the flow between data ingestion and blockchain execution. We built a dual-mode engine: LIVE mode for real-world monitoring and MOCK mode for reliable offline demos.
  • The AI Layer: We used Google Gemini 1.5 Flash for the decision logic. We engineered prompts to force the LLM into a "Risk Officer" persona, requiring it to output structured reasoning and a strict boolean authorization.
  • The Blockchain: The treasury is a Solidity smart contract deployed on the Sepolia testnet. It holds the funds and enforces logic that only allows the AI agent's wallet to trigger a payout.
  • The Frontend: A "War Room" dashboard built with React, Vite, and Three.js. We created an interactive 3D globe to visualize disasters in real-time, providing total transparency into what the AI is "thinking" and who is getting paid.

Challenges we ran into

  • AI "Hallucinations" with Money: Giving an AI control over a bank account is terrifying. We had to ensure Gemini didn't donate money for a stiff breeze. We solved this by implementing a Strict Boolean Gate. If the AI's response is ambiguous, malformed, or low-confidence, the system defaults to "NO." It fails safely.
  • Matching NGOs to Disasters: It’s not enough to just release money; it has to go to the right people. We built a logic layer that filters our NGO whitelist based on region and disaster type—ensuring that flood relief funds in Asia go to UNICEF Asia Pacific, not a wildcard address.
  • The "Demo" Problem: Real disasters don't happen on schedule during a 3-minute hackathon pitch. We had to build a robust MOCK mode that simulates API responses and generates mock transaction hashes, allowing us to show the full end-to-end flow reliably while still keeping the code production-ready.

Accomplishments that we're proud of

  • Zero-Delay Payouts: We successfully automated the entire chain: from an API signal (like a NASA wildfire alert) to a blockchain transaction hash, in under 30 seconds.
  • Transparent Reasoning: The system doesn't just pay; it explains why. Our dashboard logs the AI's internal monologue (e.g., "Magnitude 8.2 detected near populated area... Triggering payout"), making the "black box" transparent.
  • Robust Architecture: We built a system that handles API failures gracefully and validates every Ethereum address before sending, preventing burned funds.

What we learned

  • AI is a distinct architectural layer: We learned to treat the LLM not as a chatbot, but as a logic component, a function that takes messy unstructured data (news/telemetry) and returns structured, actionable JSON.
  • Trust is UI: In blockchain and AI, people are skeptical. We learned that for a system like this to be trusted, the UI needs to show everything: the wallet address, the timestamp, the specific NGO selected, and the exact reason why.

What's next for Sentinel

  • Multi-Chain Support: Expanding "The Vault" to Solana and Polygon to minimize gas fees for smaller payouts.
  • Stablecoin Integration: Currently we transact in native tokens, but moving to USDC/USDT is the next step for real-world NGO utility.
  • DAO Governance: We want to decentralize the "NGO Whitelist." Instead of a static JSON file, the community could vote on which NGOs are trusted enough to be in the automated receiver pool.
Share this project:

Updates