ChayRa AI

Give ChayRa the crisis. It coordinates a verified response through a governed fleet of autonomous agents, live intelligence, real-world navigation, public-health analysis, and persistent memory.

Comment

Inspiration

A crisis is rarely a single-question problem.

When something goes wrong — a disaster, a conflict, collapsing infrastructure, or a public-health threat — a person may need several answers at once: Is this safe? What's nearby? Where can I actually go? Is something spreading? Can I trust the information?

Most AI is built around Ask → Answer. One question in, one response out, and the human has to coordinate the rest during the moment they have the least capacity to do that.

We wanted to try a different premise:

Give it the crisis. It coordinates the response.

That idea became ChayRa AI — not a chatbot that talks about a crisis, but a governed fleet designed to act through one.

What it does

ChayRa AI is an autonomous, multi-agent crisis-response fleet built with Google ADK and Google Cloud for the Fortified Enterprise Fleet track.

A single natural-language request — even something as simple as "I need help" — activates seven governed agents:

MindGuard → Scavenger → Radar
                ↓
   Medical | Navigator | Public Health
                ↓
              Verifier
                ↓
        Verified Action + Live Map
  • MindGuard gates the request through Google Cloud Model Armor before downstream processing.
  • Scavenger extracts crisis context and threat level.
  • Radar builds the live threat picture from NASA EONET, USGS, and conflict intelligence.
  • Medical, Navigator, and Public Health execute in parallel.
  • Navigator searches real hospitals, clinics, shelters, and bunkers within 25 km and can return verified destination coordinates and distance for the tactical map.
  • Public Health analyzes trusted disease and outbreak intelligence, keeping official-source evidence separate from model inference.
  • Verifier closes the loop with an evidence-oriented response.

ChayRa also supports background perimeter scanning and Firestore-backed operational memory, so the system can continue working beyond the immediate chat interaction.

How we built it

The frontend is a Next.js 16 / React 19 command interface written in TypeScript, with a live tactical map.

Google ADK provides the orchestration foundation. Every pillar of the Fortified Enterprise Fleet track maps onto something we actually built:

Discovery & Lifecycle. A custom enterprise agent control layer for:

  • agent metadata and versioning
  • capabilities and status
  • heartbeat and clearance
  • discovery and routing

Core Execution & State. Firestore-backed operational memory and a private autonomous runtime keep the fleet's state and background execution alive beyond a single request.

Security & Governance. MindGuard places Google Cloud Model Armor in the request path before downstream crisis processing, production services run under Google Cloud IAM / service identity, and the control layer's clearance concept governs agent trust.

Telemetry. Cloud Logging and trace infrastructure make it possible to inspect what the fleet actually did, not just what it answered.

We were careful not to overclaim here: ChayRa uses a custom registry/control layer built on Google ADK and Google Cloud, not a direct claim on every managed Gemini Enterprise Agent Platform component. We think that's the more honest — and more interesting — engineering story: we built enterprise-grade agent governance ourselves, in the open, on top of Google's primitives.

The production stack includes:

  • Gemini 3.5 Flash / Vertex AI
  • Google ADK
  • Google Cloud Model Armor
  • Cloud Run
  • Firestore
  • Cloud Build
  • Google Cloud IAM / service identity
  • Cloud Logging / trace infrastructure

ChayRa combines model reasoning with external real-world intelligence, including NASA EONET, USGS, WHO Disease Outbreak News, UN ReliefWeb when configured, and OpenStreetMap / Overpass for facility discovery.

The system runs on two Cloud Run services: a public application service and a private autonomous runtime.

Challenges we ran into

The hardest part was not building one good agent. It was making seven specialists behave like one reliable operational system.

The clearest example came from Navigator. During production testing, an OpenStreetMap / Overpass lookup returned an HTTP 504 timeout. A naive implementation could turn that into:

"No hospital exists nearby."

In a crisis system, that distinction matters.

We changed the lookup flow to retry transient failures and distinguish three states:

VERIFIED    → a real facility was found
NO_DATA     → the lookup completed but found no verified facility
UNAVAILABLE → the external lookup itself failed

That became a broader engineering principle:

"I don't know" and "there is nothing there" must never mean the same thing.

We applied the same thinking to fallback behavior elsewhere in the system: fail safely, never silently, and never disguise an upstream failure as a confident answer.

Accomplishments that we're proud of

  • Real-world action, not just recommendations. Navigator has resolved real nearby hospitals and shelter/bunker destinations in production, with distances and coordinates rendered on the tactical map.
  • Trusted public-health intelligence. WHO Disease Outbreak News is integrated into the live health pipeline, while ReliefWeb can be used when configured; official-source evidence remains separate from model inference.
  • A governed fleet, not a script. Seven agents are registered and tracked through our custom enterprise control layer with identity, versioning, status, heartbeat, capabilities, and clearance concepts.
  • Memory that survives the conversation. Firestore preserves operational state, public-health snapshots, historical intelligence, and fleet state.
  • Background autonomy. ChayRa can continue perimeter scanning after the user stops actively interacting.
  • Production, not a local prototype. The system is deployed on Cloud Run with separate public and private services and has been exercised end-to-end with real external intelligence and real destination data.
  • Observable execution. Trace IDs, ADK events, fleet heartbeat, and Cloud Logging make it possible to inspect what the fleet actually did.

What we learned

Building ChayRa changed how we think about agentic AI.

An agent is not impressive simply because it can generate a sophisticated answer.

The questions that shaped the architecture were:

  • Can it decide what needs to happen next?
  • Can it coordinate specialized capabilities?
  • Can it interact with the real world?
  • Can it preserve state?
  • Can it fail safely?
  • Can we prove what actually happened?

Reliable agentic systems turned out to be as much about orchestration, state, security, external dependencies, and failure handling as they are about model intelligence.

The unglamorous engineering is what makes autonomy trustworthy.

What's next for ChayRa AI

Next, we want to make the fleet more resilient, broader in coverage, and stronger in long-running autonomous operation:

  • More resilient multi-provider intelligence sources
  • Deeper asynchronous workflows
  • Richer agent observability and operational analytics
  • More advanced disaster and public-health forecasting
  • Broader regional and multilingual crisis coverage
  • Stronger offline and degraded-connectivity capability

The long-term goal is simple:

When the situation gets more complex, ChayRa should coordinate more — not ask the human to coordinate more.

Built With

Share this project:

Updates

Submission history