WildProof: Go Outside With a Question, Come Back With Evidence

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

Most “go outside” apps stop at reminders, routes, or motivational messages.

I built WildProof: an offline-first field observation app that turns a short walk into a small investigation.

Go outside with a question. Come back with evidence.

WildProof is for hikers, students, citizen scientists, and anyone who wants to spend less time scrolling and more time paying attention to the world around them.

The experience is intentionally simple:

1. Choose a mission such as Habitat Comparison or Pattern Hunt.
2. Leave the screen and collect observations.
3. Capture written notes and photo evidence references.
4. Save the expedition locally, even without connectivity.
5. Return to analysis when a backend is available.
6. Review a structured report that makes uncertainty visible.

WildProof is not a “guess the species from this photo” app. It does not pretend that uncertain AI guesses are facts.

Every report separates:

• Observed — directly supported by the submitted evidence.
• Inferred — a reasoned deduction from the available evidence.
• Unknown — a claim that needs more evidence.

The product rule is:

Never let a successful-looking report hide an unsuccessful analysis.

Demo

Live demo: wildproof.onrender.com

The main walkthrough is:

• Start a Pattern Hunt mission.
• Add a field note and photo evidence.
• Generate a report through the Temporal-backed path.
• Review observed, inferred, and unknown claims.
• Inspect missing evidence, the suggested next step, and the evidence-quality score.

The repository contains the working MVP and setup instructions:

{% github JaniDhruv/wildproof %}

Code

Repository: github.com/JaniDhruv/wildproof

The project is released under the MIT License.

How I Built It

WildProof is a React and TypeScript progressive web app backed by FastAPI, Ollama, Gemma 2B, and Temporal.

Offline-first evidence capture

The frontend stores expeditions using IndexedDB through the idb package.

That means a user can:

• Start a mission without signing in.
• Capture notes and photo evidence references without a network connection.
• Refresh the page without losing the expedition.
• Return to analysis later when the backend is available.

Photos are currently stored locally as evidence references. The current text-only Gemma path receives written notes and photo metadata; it does not receive image pixels or claim to visually identify the contents of a photo.

Local open-weight AI

The core analysis uses Gemma 2B through Ollama.

The backend sends the mission type and collected field notes to Gemma and requests a strict JSON report:

{
  "summary": "A concise expedition summary.",
  "observations": [
    {
      "claim": "A claim grounded in the submitted evidence.",
      "confidence": "observed",
      "supportingEvidenceIds": ["note-1"]
    }
  ],
  "missing_evidence": ["What would strengthen the conclusion."],
  "suggested_next_step": "One practical next action."
}

The response is validated against a Pydantic schema before it reaches the frontend. If Gemma returns malformed JSON, the API makes one repair attempt. If that also fails, the application surfaces an explicit failure instead of manufacturing a successful report.

If the local model is unavailable, the expedition remains preserved locally and the UI shows a clearly labeled fallback state.

Durable analysis with Temporal

Local model inference can fail because of timeouts, unavailable services, or temporary infrastructure problems. WildProof uses a Temporal workflow to coordinate the analysis stages:

Normalize evidence
        ↓
Run Gemma analysis
        ↓
Validate the report
        ↓
Calculate evidence quality
        ↓
Return the durable report

The frontend uses the Temporal-backed endpoint by default and includes a switch for the direct FastAPI path.

The value of Temporal here is not just adding another service. A failed activity can be retried without discarding the evidence collected during the walk or restarting the entire expedition.

Evidence-quality scoring

WildProof calculates a transparent quality score from structured evidence features such as:

• Number of photos.
• Number of notes.
• Total note length.
• Expedition duration.

The repository includes a reproducible baseline-versus-TabPFN experiment for small tabular datasets in api/tabpfn_experiment.py.

The production endpoint currently uses an explicitly labeled baseline heuristic when the installed TabPFN/Torch combination is unavailable. That limitation is visible in the API and UI; the app does not claim that TabPFN is running when it is not.

Observability

The frontend and backend include Sentry instrumentation for:

• Request failures.
• Model-analysis errors.
• Request and analysis timing.
• Frontend errors.
• Durable workflow failures.

Sentry events require a configured SENTRY_DSN, so the project can run locally without secrets or a hosted observability account.

Why Does Open Innovation Matter?

WildProof is about trust, privacy, and control over personal observations.

Outdoor evidence can include photos from private locations, movement patterns, and notes about a person’s home or routine. Connectivity is also unreliable in exactly the places where the app is meant to be used.

A closed, cloud-only AI API would make it harder to:

• Capture evidence offline.
• Keep field notes under the user’s control.
• Inspect and change the model workflow.
• Reproduce the output format.
• Make uncertainty and failure visible.

Using an open-weight model through local inference makes the core analysis inspectable and adaptable. The model can be replaced, the prompt can be audited, and the report schema can enforce explicit distinctions between observation and inference.

Open innovation also makes failure easier to discuss honestly. WildProof can show when Gemma is unavailable, when the app falls back to a baseline score, and when an image was stored as evidence without being sent to a vision model.

For this project, open AI is not just a cheaper way to add a chatbot. It is what makes a privacy-aware, offline-first, uncertainty-aware field tool practical.

What I Learned

The hardest part was not sending a prompt to a model.

The harder problems were:

• Designing an output schema that does not reward confident hallucinations.
• Preserving evidence when the network disappears.
• Making AI failures visible without losing the user’s work.
• Making a durable workflow useful instead of merely adding infrastructure.
• Being honest when a dependency such as TabPFN cannot run in the current environment.

The biggest change in the project was narrowing the claims to match the evidence. Photos are currently evidence references, not visual input to Gemma. TabPFN is a reproducible experiment with a production-safe baseline fallback. These constraints make the MVP less flashy, but more trustworthy.

My Agent Session

I used GitHub Copilot to explore the product direction, review the implementation against the challenge requirements, identify overstated claims, and tighten the final MVP narrative.

{% agent_session building-wildproof-for-hacktoberfest-touch-grass-gthham %}

The session is a focused engineering review. It captures the decisions to separate photo metadata from image understanding, make fallback behavior visible, document TabPFN’s runtime limitation, and align the prize-category claims with verifiable implementation evidence.

The session is available on DEV at Building WildProof for Hacktoberfest Touch Grass.

Prize Categories

Overall Winner

WildProof directly addresses Touch Grass by turning time outdoors into purposeful evidence gathering rather than another screen-based reminder.

Best Use of Gemma

Gemma is the core open-weight model that converts field notes and mission context into a structured report with explicit observed, inferred, and unknown confidence labels.

Best Use of Temporal

Temporal coordinates the multi-stage analysis workflow and allows model activities to retry without discarding the evidence collected during the expedition.

Best Use of Sentry Agent Tracing

Sentry hooks cover frontend and FastAPI errors, request timing, and model/workflow failures when SENTRY_DSN is configured.

Best Use of Render

Render deployment configuration is included for hosting the frontend and backend. A verified public deployment URL will be added after end-to-end deployment testing.

Best Use of GitHub Copilot

GitHub Copilot supported product exploration, implementation, review, debugging, validation, and the final accuracy pass on the project’s technical claims.

Best Use of TabPFN

WildProof includes a reproducible baseline-versus-TabPFN experiment for small tabular evidence-quality data. The production endpoint uses an explicitly labeled baseline when the local TabPFN runtime is unavailable.

What’s Next

• Add an opt-in local vision-model path for image-aware analysis.
• Add audio capture and local sound transcription.
• Add opt-in geolocation with clear privacy controls.
• Compare repeated observations over time.
• Replace synthetic quality data with a human-labeled field dataset.
• Add background synchronization when connectivity returns.

For now, WildProof is intentionally small: choose a mission, go outside, collect evidence, and return with a report that is honest about what was actually observed.