monday8am/functiongemma-safety-agent

FunctionGemma Safety Agent for Outdoor Navigation

A fine-tuned FunctionGemma 270M model that acts as an intelligent safety decision orchestrator for hikers, providing proactive recommendations about when to turn around or stop based on real-time conditions.

Model Details

Model Description

Unlike traditional reactive hiking apps (Komoot, AllTrails, Gaia GPS) that only show your position on a route, this model proactively monitors conditions and answers contextual safety questions like "Given my dropping pace, fading daylight, and low battery, should I turn around?"

The model performs pattern matching and tool selection while deterministic Kotlin code handles all safety-critical computations. This hybrid architecture balances AI flexibility with reliability requirements for safety-critical applications.

• Developed by: monday8am
• Model type: Function-calling language model
• Language(s): English
• License: Gemma License
• Finetuned from model: google/functiongemma-2b-it (270M parameters)

Model Sources

• Repository: https://huggingface.co/monday8am/functiongemma-safety-agent
• Base Model: https://huggingface.co/google/functiongemma-2b-it

Uses

Direct Use

This model is designed for integration into Android hiking/outdoor navigation apps as an offline-capable safety advisor. The model orchestrates four safety tools:

1. assess_completion_risk - Evaluates probability of safe route completion
2. get_segment_ahead - Analyzes upcoming terrain difficulty
3. find_nearest_poi - Locates resources (water, shelter, trailhead)
4. get_bailout_options - Identifies alternative exit routes

Example interaction:

Context: Time 14:30, Sunset 17:45, Progress 6.2km/12km, Pace 3.1 km/h (down from 4.2), Battery 67%
User: "Should I continue or turn around?"
Model: → assess_completion_risk(query: "pace")

Downstream Use

The model outputs function calls that trigger Kotlin code execution in the host Android app. It is designed for LiteRT deployment for offline inference on mobile devices (~288MB quantized).

Architecture flow:

Sensor Data → Kotlin Orchestrator → FunctionGemma → Tool Selection → Kotlin Execution → Safety Alert

Out-of-Scope Use

• NOT for direct safety computation - The model selects tools; it does not execute risk calculations
• NOT a replacement for judgment - Users must make final decisions considering factors the model cannot observe
• NOT for emergency services - Does not contact help or provide medical advice
• NOT for other outdoor sports without fine-tuning - Trained specifically on hiking scenarios

Bias, Risks, and Limitations

Safety-Critical Context: This model informs decisions affecting user safety. The architecture intentionally separates AI decision orchestration from deterministic safety computations.

Training Distribution: Fine-tuned on hiking scenarios; performance may degrade for climbing, trail running, or winter sports without additional training.

Sensor Dependency: Accuracy depends on correct sensor input (GPS, accelerometer, battery status) from the device.

No Physical Observation: Cannot assess trail conditions, weather microclimate, or user physical state directly.

Recommendations

• Users should treat model outputs as recommendations, not commands
• Always consider personal fitness, group dynamics, and observed conditions
• Maintain traditional safety practices (tell someone your route, carry essentials)
• The model should augment, not replace, outdoor judgment and skills
• Test thoroughly before relying on the system in remote areas

How to Get Started with the Model

# Convert to LiteRT format for Android deployment
from transformers import AutoTokenizer, AutoModelForCausalLM
import ai_edge_torch

model = AutoModelForCausalLM.from_pretrained("monday8am/functiongemma-safety-agent")
tokenizer = AutoTokenizer.from_pretrained("monday8am/functiongemma-safety-agent")

# Export to LiteRT
edge_model = ai_edge_torch.convert(model, tokenizer)
edge_model.export("safety_agent.tflite")

Android Integration (Kotlin):

// Load model
val interpreter = Interpreter(loadModelFile("safety_agent.tflite"))

// Prepare context
val context = """
Time: ${getCurrentTime()}, Sunset: ${getSunsetTime()}
Progress: ${getProgressKm()}km of ${getTotalKm()}km
Pace: ${getCurrentPace()} km/h
Battery: ${getBatteryPercent()}%
""".trimIndent()

// Get tool selection from model
val toolCall = interpreter.runInference(context, userQuery)

// Execute selected tool with Kotlin
when (toolCall.name) {
    "assess_completion_risk" -> assessRisk(toolCall.args["query"])
    "get_segment_ahead" -> getSegmentInfo(toolCall.args["query"])
    // ... handle other tools
}

Training Details

Training Data

360 training examples generated from 18 carefully crafted seed scenarios covering:

• Pace decline situations (fatigue, terrain difficulty)
• Daylight management (sunset proximity, headlamp decisions)
• Resource concerns (water, battery, shelter)
• Weather changes (approaching storms, temperature drops)
• Navigation decisions (bailout options, POI location)
• "No action needed" cases (~20%) - Teaching the model when NOT to intervene

Generation Method: Gemini Flash expansion with controlled variation to ensure diversity while maintaining quality.

Data Format: FunctionGemma Tuning Lab compliant format with unified query: string parameter across all tools.

Training Procedure

Fine-tuning Platform: FunctionGemma Tuning Lab (no-code UI)

Training Hyperparameters

• Training regime: Mixed precision (bf16)
• Epochs: Tuning Lab default
• Learning rate: Tuning Lab default adaptive schedule
• Dataset: 360 examples (train/validation split handled by platform)

Speeds, Sizes, Times

• Training time: ~15-30 minutes on Tuning Lab infrastructure
• Model size: 270M parameters (~288MB quantized for mobile)
• Inference speed: ~125 tokens/sec on Samsung S25 Ultra (CPU only)

Evaluation

Testing Data, Factors & Metrics

Testing Data

Held-out validation set from the 360-example dataset, ensuring coverage across all tool types and "no action" scenarios.

Factors

Evaluation disaggregated by:

• Tool type (4 safety tools + no-tool cases)
• Scenario urgency (critical vs. marginal situations)
• Context complexity (single vs. multiple risk factors)

Metrics

Primary Metric: Tool selection accuracy (correct tool chosen for given scenario)

• Base model: 58% accuracy
• Fine-tuned model: 85% accuracy

Secondary Metrics:

• No-tool precision (avoiding false interventions)
• Critical scenario recall (catching dangerous situations)

Results

Metric	Base FunctionGemma	Fine-tuned
Overall Accuracy	58%	85%
Critical Scenario Recall	62%	91%
No-Tool Precision	45%	78%

The model shows particular improvement in recognizing when NOT to intervene (avoiding alert fatigue) while maintaining high recall on genuinely dangerous situations.

Environmental Impact

Fine-tuning performed using FunctionGemma Tuning Lab infrastructure.

• Hardware Type: Cloud TPU/GPU (managed by Google)
• Hours used: ~0.25-0.5 hours
• Cloud Provider: Google Cloud
• Compute Region: US (exact region varies)
• Carbon Emitted: Minimal due to short training time and efficient infrastructure

Technical Specifications

Model Architecture and Objective

Base Architecture: FunctionGemma 270M (Gemma-2b variant optimized for function calling)

Fine-tuning Objective: Function-calling accuracy on outdoor safety scenarios with four tools:

1. assess_completion_risk(query: string)
2. get_segment_ahead(query: string)
3. find_nearest_poi(query: string)
4. get_bailout_options(query: string)

Design Philosophy: Stateless model calls - the model performs single-turn tool selection while the Kotlin app maintains session state, sensor history, and alert logic.

Compute Infrastructure

Hardware

• Training: Google Cloud TPU/GPU via FunctionGemma Tuning Lab
• Inference: Android devices (CPU-only deployment via LiteRT)
• Target Device: Tested on Samsung S25 Ultra, compatible with most modern Android devices

Software

• Training Framework: FunctionGemma Tuning Lab
• Deployment: TensorFlow Lite Runtime (LiteRT) for Android
• Development: Kotlin for Android orchestration layer

Citation

@misc{functiongemma-safety-agent-2026,
  author = {monday8am},
  title = {FunctionGemma Safety Agent for Outdoor Navigation},
  year = {2026},
  publisher = {HuggingFace},
  howpublished = {\url{https://huggingface.co/monday8am/functiongemma-safety-agent}},
  note = {Fine-tuned from google/functiongemma-2b-it for proactive hiking safety recommendations}
}

Model Card Authors

monday8am

Model Card Contact

For questions, issues, or collaboration opportunities, please open an issue on the model repository.