Gemma 4: Google's Free AI Agents Run on Raspberry Pi

Google just open-sourced Gemma 4, a family of on-device AI models that can plan and execute multi-step tasks entirely offline — no cloud required, no subscription fees. Paired with ADK Go 1.0, the first production-stable Agent Development Kit for the Go programming language, this week's releases mark a concrete turning point: agentic AI automation is leaving the cloud and landing on your phone.

From Cloud-Only Experiments to AI Agents on Your Raspberry Pi

For two years, "agentic AI" (AI that takes autonomous, multi-step actions to complete a goal — like booking a flight by reading your calendar and checking prices on its own) was almost exclusively a cloud service. You paid per API call, sent your data to a remote server, and accepted the latency.

Gemma 4 changes that equation. The model runs directly on Android phones, iPhones, desktops, and IoT devices (small internet-connected computers) including the Raspberry Pi — a $35 single-board computer popular with developers and hobbyists. It supports over 140 languages and requires no internet connection once downloaded.

The enabling technology is FunctionGemma — a 270-million-parameter (parameters are the numerical weights inside an AI model; more generally means more capable) specialized model built for on-device function calling (letting the AI trigger specific app features or external tools automatically, without a human clicking anything). At 270M parameters, it fits comfortably on a phone's NPU (neural processing unit — a dedicated chip for AI calculations), while still executing complex, multi-step workflows.

Google AI Edge Gallery — available now on Android and iOS — lets you experiment with Gemma 4's "Agent Skills" (pre-built bundles of instructions and tools that give the AI specific real-world capabilities) directly on your device. Zero data is sent to Google's servers.

90% Token Cost Cut — Why AI Automation Economics Just Changed

The most impactful number in this release: a 90% reduction in token usage. Tokens are the units AI services charge you for — roughly 1 token per word of input or output. On cloud AI platforms, every word costs money. A 90% token reduction on a complex multi-step agent workflow means costs can drop from hundreds of dollars per month to tens.

That savings comes from Google's new "Agent Skills" architecture, which uses progressive disclosure (loading only the tools and instructions relevant to the current task, not a monolithic wall of text). Traditional approaches pack every possible instruction into one giant prompt — a "monolithic" prompt — wasting tokens on irrelevant context the model never uses for the task at hand.

• Traditional monolithic prompt: 10,000 tokens loaded per request → expensive, slow, and often confusing for the AI
• Agent Skills (progressive disclosure): ~1,000 tokens of relevant context loaded dynamically → 90% cheaper, faster, more accurate

The benchmark numbers back this up sharply. When Google applied its Gemini API Developer Skill to the gemini-3.1-pro-preview model, task success rate jumped from 28.2% to 96.6%. Critically, the underlying model didn't change — what changed was giving it real-time access to current documentation about the tools it was using, instead of relying on potentially outdated training data.

This exposes one of the biggest unspoken pain points in production AI deployments: agents fail not because models are too weak, but because they're operating on stale information about the tools they're supposed to control. Fixing information delivery matters more than scaling raw model size.

ADK Go 1.0: Production-Ready AI Agent Development Kit

"Experimental" software is fine for demos but shouldn't run real products that users depend on. ADK Go 1.0 is Google's signal that its Agent Development Kit has crossed that line — meaning stable APIs (programming interfaces that don't change unpredictably between software updates), proper error handling, and the observability (real-time visibility into what the software is doing and why) that engineering teams require before deploying anything to real users.

ADK Go 1.0 production capabilities at a glance:

• Native OpenTelemetry integration: OpenTelemetry is an open standard for monitoring software behavior in real time — now built in, so you can trace every decision your AI agent makes without additional instrumentation
• Self-healing plugin system: agents detect errors and attempt automatic recovery, reducing the need for manual human restarts mid-task
• Human-in-the-Loop confirmations: sensitive operations (sending emails, making purchases, modifying production databases) require explicit human approval before executing — a non-negotiable safety mechanism for real deployments
• YAML-based agent configuration: YAML (a simple, readable text format for settings, pronounced "yam-el") lets non-engineers adjust agent behavior without touching source code
• Continuous checkpointing via Orbax/MaxText: the agent saves its progress at regular intervals, so a crash doesn't force a restart of the entire multi-step workflow from zero

ADK Java 1.0.0 shipped simultaneously, extending these production guarantees to enterprise Java environments. Third-party integrations — GitHub, Notion, and Hugging Face — now work out of the box, reducing the custom "wiring tax" of connecting an agent to tools your team already uses daily.

# Install ADK Go 1.0
go get github.com/googleapis/google-cloud-go/vertexai

# Try Gemma 4 on-device — search your app store for:
# "Google AI Edge Gallery" (Android & iOS, free download)

Six Protocols and the Network Effect for AI Agents

Less covered but strategically important: Google standardized 6 communication protocols (MCP, A2A, UCP, AP2, A2UI, AG-UI) for agent-to-agent interaction. In plain terms — an AI agent written in Python can hand a task off to an agent written in Go, which then delegates to a third agent running locally on a mobile phone, with no custom translation code required between them.

ADK SkillToolset offers 4 distinct skill patterns (design blueprints for how agents share and access capabilities), using progressive disclosure so only the relevant capability is loaded at any moment. For developers building multi-step workflows — a Python agent that fetches data, a Go agent that processes it, a mobile agent that presents results — this removes a significant integration burden that previously required weeks of custom plumbing.

The Agent2Agent (A2A) protocol standardizes this cross-language communication in a way that mirrors how HTTP standardized web communication in the 1990s — except for AI agents talking to each other across environments and languages. If adoption spreads beyond Google's own ecosystem, the compounding network effects could be significant.

The Honest Catch: Open Entry, Familiar Destination

Apache 2.0 is genuinely permissive licensing — commercial use, modification, and redistribution are all allowed, no royalties, no restrictions. Gemma 4 works fully offline. FunctionGemma runs on a $35 Raspberry Pi. These aren't marketing qualifications with asterisks.

But reading the default integration priorities tells the fuller story: Firestore (Google's cloud database), Vertex AI (Google's paid cloud AI platform), and Google Cloud monitoring are the deeply supported backends. Teams that want the full production stack will find the path of least resistance consistently pointing toward Google's paid services. The open-source entry point is real; the long-term destination is Vertex AI.

For Go developers who've been waiting for a stable agentic framework, this is it — today. For teams building apps with on-device AI capabilities and no appetite for monthly API bills, Gemma 4 via Google AI Edge Gallery is worth testing now. You can explore practical edge AI development approaches in our guides — or use our developer setup guide to configure your environment and start building today.

Related Content — Get Started | Guides | More News