PawWarrior

• 

  Agents Who connects to Community to Animals Nearby

• 

  Agents

• 

  Flow

• 

  Landing page

• 

  Map Marker for dogs

• 

  Animal profile

Inspiration

It starts with one simple real-world moment.

A community dog is standing outside a shop.

• One person wants to help.
• Another person thinks someone else may have already helped.
• Someone notices the dog looks weak.
• No one knows when food or water was last given.
• No one knows whether the dog has already been reported.
• No one knows if vet help is needed.
• No one has a shared record.

The problem is not that people do not care.

The problem is that care is scattered.

Street and community animals are helped by many kind people, but those actions often disappear after the moment passes.

That gap inspired PawWarrior.

What it does

PawWarrior is a Gemini-powered community animal care system that turns scattered help for street and community animals into coordinated action.

The long-term vision is to support dogs, cats, cows, injured animals, abandoned pets, and other community animals. For this hackathon MVP, we focused on dogs first because they are the most visible in our local field demo and we had real images, locations, care logs, vet cases, and map data to validate the complete workflow.

PawWarrior works through a multi-agent care workflow:

• 🗺️ Map Discovery Agent: Shows nearby community dogs with care status, location, and urgency markers.
• 📸 Scan & Match Agent: Lets a helper scan a dog, capture visible details, and check nearby profiles before creating a new record, reducing duplicate animal profiles.
• 🧠 Care Memory Agent: Reads MongoDB-backed food, water, observation, case, vet, and support history so helpers know what already happened.
• 🩺 Vet Escalation Agent: Helps identify when a dog may need vet guidance, follow-up support, or safer care decisions.
• ✅ Safety Confirmation Agent: Asks for human confirmation before saving important write actions like creating a profile, logging care, requesting vet support, or recording support activity.
• 📋 Action Report Agent: Creates a visible timeline of what happened, what was logged, who helped, and what needs follow-up.
• 💚 Care Support Ledger: Tracks estimated care needs, raised support, remaining amount, contributors, and proof-based release rules so support does not become invisible or uncontrolled.
• 👥 Community Helper Profile: Builds toward a social care layer where helpers can have PawWarrior profiles, record care actions, follow animals, discuss safe care practices, and coordinate with vets or local volunteers.

Key innovation: PawWarrior does not just answer questions. It connects Gemini reasoning with real-world care actions — map discovery, scan verification, MongoDB memory, care logs, vet support, transparent care support tracking, and agent timelines.

Instead of asking “What should I do?”, a helper can see what already happened and take the next responsible action.

The future vision is to become a social care platform for community animals: each animal has a memory, each helper has a care profile, vets can provide safe guidance, and care support can be tracked transparently from need to proof.

How we built it

We built PawWarrior as a full-stack, Gemini-powered care workflow instead of a simple chatbot.

The first step was not code.

We started by observing real community dogs around us. Over 10 days, we explored nearby areas within roughly a 10 km radius, observed around 28 street/community dogs, studied their visible condition, usual locations, and care needs, and then selected real dogs to represent on the map and profile flows.

That field data helped us design the product around real care problems:

• dogs seen near shops, streets, and local areas
• dogs needing food or water
• dogs that may need vet guidance
• dogs that should not be duplicated when scanned again
• dogs that need a shared care history

Then we built the technical system:

• Frontend: React + Vite for the map, scan flow, animal profile, care actions, care logs, and agent timeline.
• Map layer: Leaflet + OpenStreetMap to show nearby community dogs with status colors and urgency markers.
• Backend: Node.js + Express API deployed on Google Cloud Run.
• Database: MongoDB Atlas for persistent animal memory, including profiles, locations, food/water logs, observations, cases, vets, funds, and agent runs.
• AI workflow: Gemini-powered mission orchestration to decide which backend tools to call and what action should happen next.
• Deployment: Netlify for frontend and Google Cloud Run for backend.

We built two main demo flows:

• Existing dog care flow: open map → select a real dog profile → read care memory → log food/water/observation → confirm and save the action.
• New dog scan flow: scan a new dog → check nearby profiles → avoid duplicates → confirm creation → create profile, care log, case, vet suggestion, and agent timeline.

The most important design choice was safety.

PawWarrior does not silently save important AI decisions. For actions like creating a profile, logging care, or escalating vet support, Gemini prepares the action and PawWarrior asks for human confirmation before writing to MongoDB.

Challenges we ran into

1. Turning real field observations into structured animal memory: PawWarrior started with real dog observations from nearby local areas. But field data was messy: images, names, locations, visible conditions, care tags, food/water logs, vet notes, cases, and support records were all scattered. The challenge was converting real-world observation into a clean MongoDB-backed memory system that both the app and Gemini agents could trust.

2. Avoiding duplicate animal profiles: A community dog may be seen by different people at different times. If every scan creates a new profile, the system becomes confusing very quickly. We had to build a scan-and-match workflow that checks nearby profiles before creating a new animal record.

3. Making the map useful, not just visual: A simple map pin is not enough. Helpers need to know which animals need food, water, follow-up, or vet guidance. We converted care history, observation data, case status, and vet needs into simple map status colors so users can understand urgency quickly.

4. Making AI write actions safe: Gemini can understand natural-language missions like “I gave water” or “create a new dog profile,” but real care records should not be changed silently. We added human confirmation before important write actions such as creating profiles, logging care, opening cases, recording support, or requesting vet help.

5. Connecting scan, image, location, and cloud memory: The scan flow had to feel simple for the user, but technically it connects many parts: camera capture, image upload, GPS/location context, backend processing, MongoDB profile creation, and Gemini reasoning. The challenge was making a real-world scan become a reliable animal profile and care timeline.

6. Balancing a dog-first MVP with an all-animal vision: PawWarrior is designed for community animals, but our working MVP focuses on dogs because we had real local images, locations, observations, and care data to validate the full workflow. The challenge was building the architecture around dogs today while keeping it flexible enough to expand later to cats, cows, injured animals, abandoned pets, and other community animals.

Accomplishments that we're proud of

• Real field-backed MVP: We started from real community dog observations, not only dummy data.
• MongoDB-backed care memory: Animal profiles, locations, care logs, cases, vets, funds, and agent runs are stored as persistent memory.
• Gemini-powered agent workflow: Gemini can understand a care mission, choose the right backend action, and prepare the next step.
• Human-in-the-loop safety: Important write actions require confirmation before saving to the database.
• Map-based discovery: Nearby dogs are shown with care status, urgency markers, and profile access.
• Scan-and-match flow: New dog creation checks nearby profiles first to reduce duplicate animal records.
• End-to-end deployment: React frontend, Cloud Run backend, MongoDB Atlas database, and Gemini orchestration are connected into a working demo.

What we learned

• Real-world care needs memory: Kind actions are not enough if nobody knows what already happened.
• AI should not directly control sensitive records: Human confirmation makes the system safer and more trustworthy.
• Maps make care actionable: Location, status colors, and nearby profiles help helpers decide faster.
• MongoDB fits living profiles well: Animal care data changes over time, so flexible document memory helped us model profiles, logs, cases, vets, and support history.
• Multi-agent workflows are better than one generic answer: Scan matching, care memory, safety, vet escalation, and action reporting need different responsibilities.
• Dog-first does not mean dog-only: Starting with dogs helped us validate the workflow, but the same architecture can expand to other community animals.

What's next for PawWarrior

• All-animal expansion: Add cats, cows, injured animals, abandoned pets, and other community animals.
• Helper profiles: Let volunteers follow animals, record care actions, and build trusted care history.
• Vet network integration: Allow vets and NGOs to receive structured care summaries and respond to cases.
• Transparent care support: Improve fund tracking with proof-based release, contributor history, and case-level visibility.
• Better scan intelligence: Use stronger image matching and location history to reduce duplicate profiles further.
• Community coordination: Add task assignment, alerts, discussions, and local volunteer groups around animal profiles.
• Mobile-first field use: Make the scan, map, and care logging experience faster for people helping animals on the street.

Built With

• express.js
• gemini
• google-agent-workflow
• google-cloud
• google-cloud-run
• leaflet.js
• mongodb-atlas
• mongoose
• netlify
• node.js
• react
• react-router
• vite