Building 'Offline Brain': How I Wrote My First Custom Agent Skill for Android (Google I/O 2026) 📱🧠

#googleiochallenge #devchallenge #android #ai

Google I/O Writing Challenge Submission

This is a submission for the Google I/O Writing Challenge

The Sandbox Revolution 🚀

When the Google I/O 2026 keynotes dropped, the internet immediately started buzzing about Gemini and cloud-scale model reasoning. But as a mobile developer, the most paradigm-shifting announcement was much quieter: Agent Skills support in Google AI Edge Gallery.

We aren't just talking about chatbots anymore. Google has effectively dropped a full-fledged agent runtime—powered by the new LiteRT-LM engine and a massive 32K context window via Gemma-4-E2B-it—directly into our pockets.

I wanted to see just how deep this rabbit hole went. Instead of just testing the built-in integrations, I decided to build one myself. Here is a hands-on walkthrough of how I built and sideloaded "Offline Brain", a custom on-device Agent Skill that stores and retrieves personal development notes without a single byte ever touching a server.

Why Local Agents Change the Game 🔒

Before we write code, we need to understand why this matters.

Historically, if you wanted an AI to read your daily diary or check your private health logs, you had to proxy that data through an API. With Edge Gallery’s new architecture, you can import a Local Skill directly from your device storage. The inference happens on your silicon. The tool execution happens in your local sandbox.

This is the holy grail of privacy: Zero-Trust Agents.

Step 1: The Skill Manifest

Building a skill for Edge Gallery doesn't require compiling an Android APK. Instead, Google has adopted an open standard very similar to the Model Context Protocol (MCP), but optimized for mobile sandbox execution.

Everything starts with a single JSON file. I created offline-brain.json:

{
  "skill_id": "com.developer.offline_brain",
  "name": "Offline Brain",
  "description": "Store and retrieve encrypted development notes locally.",
  "version": "1.0.0",
  "permissions": [
    "storage.read_local",
    "storage.write_local"
  ],
  "tools": [
    {
      "name": "save_note",
      "description": "Saves a markdown note to local storage.",
      "parameters": {
        "type": "object",
        "properties": {
          "topic": { "type": "string" },
          "content": { "type": "string" }
        },
        "required": ["topic", "content"]
      }
    },
    {
      "name": "search_notes",
      "description": "Searches stored local notes by topic.",
      "parameters": {
        "type": "object",
        "properties": {
          "query": { "type": "string" }
        },
        "required": ["query"]
      }
    }
  ]
}

Notice the permissions block. Edge Gallery treats skills like micro-apps. If my skill attempts to read the device calendar without requesting calendar.read, LiteRT-LM will intercept and block the tool call entirely.

Step 2: The Logic Layer (JavaScript runtime)

To make the tool actually do something offline without a server, I discovered Edge Gallery supports a lightweight V8 JavaScript runtime for local skills. I added a script bundle alongside the manifest to handle the File I/O:

// brain_logic.js
export async function save_note(args) {
    const timestamp = new Date().toISOString();
    const data = `${timestamp}\n\n${args.content}`;
    // Using the sandbox FileSystem API exposed by Edge Gallery
    await SandboxFS.writeFile(`notes/${args.topic}.md`, data);
    return { status: "success", message: `Note saved under ${args.topic}` };
}

export async function search_notes(args) {
    const files = await SandboxFS.listFiles('notes/');
    const matches = files.filter(f => f.includes(args.query));

    if (matches.length === 0) return { result: "No notes found." };

    const content = await SandboxFS.readFile(`notes/${matches[0]}`);
    return { result: content };
}

Step 3: Sideloading into Edge Gallery

This is where the magic happened.

I zipped the JSON manifest and the JS script into offline-brain.skill.
I downloaded the Gemma-4-E2B-it (2.6 GB) model inside Edge Gallery. (You absolutely need the Gemma 4 variant; older models like Gemma 3 lack the tool-calling fine-tunes required for Agent Skills).
I went to the Agent Skills tab, tapped the floating action button, and selected "Import Local Skill".
I pointed it to my .skill file.

Immediately, the skill populated in my UI with a toggle switch next to it.

Step 4: The 32K Context Test

I opened the AI Chat and enabled my "Offline Brain" skill.

Me: "Save a note about my new React Native architecture idea. It involves using Zustand for state and separating the API layer."

Gemma 4 (Thinking): Evaluating tools... Found 'save_note' in Offline Brain.

Gemma 4: "I've saved your note about the React Native architecture!"

I then spent 20 minutes throwing unrelated questions at the model, trying to push the boundaries of its context window. I fed it code snippets, asked for bug fixes, and generated text.

Finally, I tested the recall:

Me: "What was that architecture idea I had earlier?"

Gemma 4 (Thinking): Calling 'search_notes' with query 'React Native architecture'

Gemma 4: "You were planning to use Zustand for state management and keep your API layer separated!"

It worked flawlessly. The 32K context window of Gemma 4 on the edge is arguably the biggest technical leap here. In previous iterations, tool execution outputs would crowd out the context window within a few turns. Now, the model remembers the conversation and the data it pulls from the local file system.

Final Thoughts 💭

While the cloud gets all the glory, the real revolution for developers is happening locally.

Google AI Edge Gallery isn't just a tech demo; it is an open playground for the future of mobile OS architecture. By opening the doors to custom Agent Skills and local MCP servers, they've given us a glimpse into a world where our AI assistants actually know us, completely offline, completely secure.

If you have a modern Android device, do yourself a favor: download Edge Gallery, pull down a Gemma 4 model, and try writing your own local skill. It will change how you think about mobile development.

Happy Hacking! ✨