Hybrid AI: Empowering On-Device Models with Cloud-Synced Skills

Learn how to combine Firebase’s hybrid inference with dynamic “AI Skills” to build smarter, private, and faster applications.

The landscape of Artificial Intelligence is shifting rapidly from purely cloud-based monoliths to hybrid architectures. Developers today face a critical choice: run models in the cloud for maximum power, or on-device for privacy and speed? With the recent updates to Firebase AI Logic, you no longer have to choose. You can have both.

In this post, we will explore how to implement hybrid on-device inference and take it a step further by introducing the concept of “AI Skills.” We will discuss how to architect a system where your local on-device models can dynamically learn new capabilities by syncing “skills” from the cloud.

1. The Foundation: Hybrid On-Device Inference

According to Firebase’s latest documentation, hybrid inference enables apps to attempt processing locally first and fall back to the cloud only when necessary. This approach offers significant benefits:

• Privacy: Sensitive user data stays on the device.
• Latency: Zero network round-trips for common tasks.
• Cost: Offloading processing to the user’s hardware reduces cloud API bills.
• Offline Capability: AI features work even without an internet connection.

How to Implement It

Using the Firebase AI Logic SDK, you can initialize a model with a preference for on-device execution. The SDK handles the complexity of checking if a local model (like Gemini Nano in Chrome) is available.

// Initialize the model with hybrid logic
const model = getGenerativeModel(firebase, {
  model: "gemini-1.5-flash",
  // Tells the SDK to try local execution first
  inferenceMode: "PREFER_ON_DEVICE", 
});

// Run the inference
const result = await model.generateContent("Draft a polite email declining an invitation.");
console.log(result.text());

When the app first loads, you may need to ensure the on-device model is downloaded. The SDK provides hooks to monitor this download progress, ensuring a smooth user experience rather than a silent stall.

2. What Are “AI Skills”?

Build an AI-First Enterprise

From early pilots to enterprise-wide deployment, our award-winning AI consulting and technical services help you build the right foundation, scale responsibly, and deliver meaningful business outcomes.

Learn More

While the model provides the “brain,” it needs knowledge and tools to be effective. In the evolving world of Agentic AI, we differentiate between the Agent, Tools, and Skills.

Drawing from insights at Cirrius Solutions and Data Science Collective, here is the breakdown:

Skills vs. Tools: A Tool might be a function to `send_email()`. A Skill is the procedural knowledge (often defined in a `SKILL.md` or structured JSON) that tells the agent: “When the user asks for a refund, check the policy date first, calculate the amount, and then use the email tool to send a confirmation.”

3. Adding Skills to On-Device Models via Cloud Sync

The limitation of on-device models is often their size; they cannot “know” everything. However, by combining Hybrid Inference with AI Skills, we can create a powerful architecture where the device is the engine, but the cloud provides the fuel.

Here is a strategy to dynamically add skills to your on-device model without updating the entire app binary:

The Architecture

1. Cloud “Skill Registry”: Host your skills (instruction sets, prompts, and lightweight tool definitions) in a real-time cloud database (like Firestore) or configuration service (Firebase Remote Config).
2. Synchronization: When the app launches, it syncs the latest “Skills” relevant to the user’s context.
3. Local Injection: These skills are injected into the on-device model’s system instructions or context window at runtime.

Implementation Strategy

Imagine a “Customer Support” skill. Instead of hardcoding the support rules into the app, we fetch them dynamically.

// 1. Fetch the latest 'Skill' from the Cloud (e.g., Firestore or Remote Config)
const supportSkill = await fetchSkillFromCloud("refund_policy_v2");
// supportSkill.content = "Authorized to refund if purchase < 30 days. Use tool: processRefund(id)."

// 2. Initialize the On-Device Model with this new Skill
const localModel = getGenerativeModel(firebase, {
  model: "gemini-nano",
  inferenceMode: "PREFER_ON_DEVICE",
  systemInstruction: `You are a helpful assistant. 
                      Current Skill Module: ${supportSkill.content}` 
});

// 3. Execute locally
// The on-device model now "knows" the new refund policy without an app update.
const response = await localModel.generateContent("Can I get a refund for my order from last week?");

Why This Matters

This “Cloud-Sync Skill” architecture solves the biggest problem of local AI: stale knowledge.

• Dynamic Updates: Did your business logic change? Update the Skill in the cloud, and every on-device model updates instantly.
• Personalization: Sync different skills for different users (e.g., “Admin Skills” vs. “User Skills”) while still keeping the heavy processing on their own device.

Conclusion

By leveraging Firebase’s Hybrid Inference, developers can finally bridge the gap between cloud capability and local privacy. But the true game-changer lies in treating your AI not just as a static model, but as an agent that can learn new Skills dynamically from the cloud.

This architecture—Local Brain, Cloud Skills—is the blueprint for the next generation of intelligent, responsive, and efficient applications.