PETi

Evidence-first multi-agent pet care that turns photos, videos, audio, and veterinary records into safe, traceable insights and next steps.

Comment

Inspiration

Pet owners collect a surprising amount of information about their animals: photos, short videos, sounds, veterinary documents, measurements, observations, and memories of how something looked a few weeks ago. The problem is that this evidence is fragmented, difficult to compare over time, and often interpreted when the owner is already worried.

I wanted to explore a different role for AI in pet care.

Instead of building another chatbot that tries to answer “What disease does my pet have?”, I built PETi around a more responsible question:

“What can be observed from the available evidence, what remains uncertain, what has changed, and what is the safest useful next step?”

That led to PETi: an evidence-first, safety-bounded multi-agent pet-care system.

The core idea is that AI should help organize and reason over evidence without pretending that a model is a veterinarian. PETi therefore separates observations, owner-reported information, interpretations, uncertainty, provenance, and safety guidance instead of collapsing everything into a confident paragraph.

PETi is a solo project. I designed and built the product, cloud architecture, multi-agent system, safety boundaries, backend, user experience, evaluation approach, and hackathon demo myself.

What it does

PETi turns an ambiguous pet-care concern into a bounded, reviewable workflow.

A pet owner can provide evidence associated with a specific pet. PETi then creates a controlled analysis run rather than giving one model unrestricted access to everything.

The multi-agent workflow coordinates specialized responsibilities such as:

  • understanding the user's goal;
  • validating and reviewing the available evidence;
  • extracting only supported observations;
  • applying task-specific pet analysis;
  • checking uncertainty and limitations;
  • reviewing the result for safety;
  • preserving evidence and provenance for future comparison.

The user interacts with one PETi. The specialist agents are an implementation detail rather than separate chatbot personalities.

Every material conclusion is designed to stay connected to its source evidence. PETi distinguishes between what was observed, what was reported by the owner, what came from a document or measurement, and what is only an interpretation.

When evidence is insufficient, PETi can say so. When a case deserves professional attention, the safety layer can prioritize that guidance. It does not need to invent a diagnosis to produce a useful result.

The hackathon demo uses synthetic pet evidence, deliberately labelled as synthetic. This makes the demonstration reproducible and privacy-safe while exercising the same evidence and agent workflow intended for private user data.

How I built it

I designed PETi as a hybrid system where:

Agents reason; deterministic software remains authoritative.

The hackathon architecture uses:

  • Google ADK for bounded agent orchestration;
  • Gemini through the official Google GenAI SDK for multimodal reasoning;
  • FastAPI / Python for the backend;
  • Cloud Run for the public API and private worker;
  • Cloud Tasks for asynchronous agent execution;
  • Firestore for durable run state, evidence references, provenance, and product data;
  • Cloud Storage for private media;
  • Firebase Authentication for identity;
  • Firebase Hosting for the responsive hackathon web experience.

The public API does not call the model and wait for a long synchronous response. It creates a durable run and schedules work. A private worker receives authenticated Cloud Tasks delivery, executes the bounded workflow, persists progress, and allows the client to resume or refresh the result.

For the hackathon workflow, the orchestrator coordinates specialized stages including Evidence Intake, Pet Specialist analysis, and Safety Review.

Each handoff has a defined responsibility and structured contract. Agents do not receive unrestricted database access, arbitrary tools, or permission to modify durable product state.

I also treated model context as a security and quality boundary. An agent receives only the evidence required for its current capability rather than an unrestricted dump of the pet owner's history.

Finally, safety is deliberately outside the language model. Model output is treated as an untrusted candidate that must pass structured validation and safety rules before becoming a customer-facing result.

Challenges I ran into

The hardest part was not getting several agents to talk to each other. That is comparatively easy.

The difficult part was making an agentic system controlled, durable, traceable, private, and useful.

One major challenge was preventing additional agents from simply creating additional opportunities for hallucination. I solved this by giving each agent a narrow responsibility, typed inputs and outputs, bounded context, and explicit workflow limits.

Another challenge was asynchronous reliability. Cloud Tasks provides at-least-once delivery, so PETi cannot assume that a worker will execute exactly once. Runs and steps therefore need durable state and idempotent behavior so that retries do not create duplicate results or unintended side effects.

Safety created another architectural challenge. A fluent model response can sound convincing even when the evidence is weak. PETi therefore separates model reasoning from final safety authority and treats uncertainty or insufficient evidence as valid outcomes rather than failures.

Privacy was equally important. Pet media can accidentally contain people, voices, homes, documents, addresses, or other sensitive information. I designed the system so that media remains private, model credentials stay on the backend, and agents receive only the minimum context needed for a task.

Finally, I had to resist scope creep. PETi has a much larger product architecture, but this is a hackathon demo. I focused the submission on proving the central idea: bounded multi-agent reasoning over evidence with provenance and safety, rather than pretending that every future product capability was already production-ready.

Accomplishments that I'm proud of

I am especially proud that PETi is not simply a Gemini prompt wrapped in a pet-themed interface.

It has a real agentic execution architecture with a durable boundary between orchestration, evidence, specialist reasoning, safety, and product authority.

I am proud of building:

  • a bounded multi-agent workflow instead of an unconstrained agent swarm;
  • asynchronous execution through Cloud Tasks and a private Cloud Run worker;
  • explicit evidence provenance throughout the analysis;
  • server-side authorization and pet isolation;
  • private media handling;
  • structured agent boundaries;
  • deterministic safety behavior that can override model wording;
  • explicit uncertainty and insufficient-evidence outcomes;
  • a responsive demo that lets judges inspect the product without using real clinical data;
  • a reproducible architecture and test path rather than relying entirely on a prerecorded happy path.

I am also proud of completing this as a solo project. Building the product experience, backend, cloud architecture, agent system, safety model, and demo together forced me to think about PETi as one coherent system rather than a collection of isolated AI features.

What I learned

The biggest thing I learned is that making an application agentic is not the same as adding more agents.

The useful part of an agent architecture is deciding who is allowed to reason about what, with which evidence, using which tools, under which constraints, and who has final authority.

I also learned that provenance dramatically changes how an AI product feels. When a result can explain what evidence supports it and what information was unavailable, uncertainty becomes part of the product rather than an apology at the end of a response.

Another important lesson was that deterministic software and generative AI complement each other. Gemini is excellent at multimodal interpretation and synthesis, while authorization, state transitions, idempotency, safety policy, deletion, and durable mutations are better handled by deterministic systems.

Most importantly, I learned that abstention can be a feature. In a safety-sensitive domain, “there isn't enough evidence to support that conclusion” can be more valuable than an impressive but unjustified answer.

What's next for PETi

The hackathon version proves the core multi-agent architecture. The next step is to deepen the quality of the evidence layer rather than simply adding more agents.

I want to expand PETi's longitudinal reasoning so that it can compare compatible observations over time and distinguish new, improved, stable, worsened, and not comparable evidence without turning visual change into a diagnosis.

I also want to continue developing specialized, independently evaluated capabilities for areas such as dental observations, stool appearance, veterinary records, measurements, care planning, and visit summaries.

A major next step is a richer multimodal evidence suite using a carefully designed mixture of synthetic and appropriately licensed real-world data for evaluation and demonstration.

I also plan to strengthen evaluation, adversarial safety testing, model/version tracking, and evidence-quality measurement before expanding any capability beyond its demonstrated boundaries.

The long-term vision is for PETi to become a persistent evidence and care companion for pets: a system that remembers what was actually observed, helps owners notice meaningful changes, organizes information for veterinary conversations, and knows when the responsible answer is to stop reasoning and recommend professional care.

Built With

Share this project:

Updates

Submission history