Introduction

Function Gemma arrives to meet a simple need: turn natural language into fast, private, low-cost function calls without sacrificing understanding.

Positioning and promise

Function Gemma is a specialized version of Gemma 3 270M, designed to select the right function and generate the right arguments from a user command. The goal is clear: enable developers to build responsive, private, and resource-efficient apps.

Why 270M is strategic

A small model deploys faster, consumes less energy, and remains compatible with local execution.

Speed and on-device execution

With only 270 million parameters, Function Gemma can respond quickly, even on embedded devices. Using accelerators like GPUs or NPUs further improves response times, opening the way for smooth and immediate experiences.

Warning

A lightweight model does not remove testing needs: validate each target function on your datasets.

Mobile demos

Two demos show the concrete impact: a mobile actions app (calendar, contacts, flashlight) and a mini-game where voice drives the mechanics. In each case, the model identifies the intent and calls the exact function with the right parameters.

JavaScript 
// function schema exposed to the assistant
const tools = [
  {
    name: "createCalendarEvent",
    description: "Add an event to the calendar",
    parameters: {
      title: "string",
      date: "string",
      time: "string"
    }
  }
];

Why the function calling format changes everything

The function calling format provides explicit structure: the model does not respond in free text, it proposes an action and arguments. This increases precision and makes orchestration on the application side easier.

Reliability gain

Structured output simplifies validation and reduces ambiguity in intents.

JavaScript 
// example of structured response
const toolCall = {
  name: "turnOnFlashlight",
  arguments: { enabled: true }
};

Implementation and fine-tuning

The model is designed to be tuned on a limited set of functions. This yields a specialized model that is as effective as much larger models on a specific domain.

JavaScript 
// simple command -> function mapping pipeline
function routeCommand(text) {
  const intent = model.predict(text);
  return executeTool(intent.name, intent.arguments);
}

Targeted fine-tuning

Fewer functions to learn, more precision on your priority use cases.

Warning

Keep a security layer before executing sensitive actions on-device.

High-value use cases

Local function calling is ideal for action assistants, interactive games, or apps that must work offline. It also opens cases like data retrieval, routing to specialized agents, or navigation via natural commands.

JavaScript 
// example action in a mini-game
const action = {
  name: "plantCrop",
  arguments: { crop: "sunflower", row: 0, col: 2 }
};

Conclusion

Function Gemma combines a robust function calling format and an ultra-lightweight size to make embedded AI faster, more private, and more reliable. It is a strong lever for building local, specialized, action-oriented AI experiences.

Function Calling Embedded AI Gemma Mobile Fine-tuning On-device Developers