Chrome Built-in AI

On-device AI processing with Gemini Nano - private, fast, and works offline

VAssist is powered by Chrome’s Built-in AI, which brings Google’s Gemini Nano language model directly into your browser. All AI processing happens on your device - no data leaves your computer, no API keys required, and it works completely offline.

Overview

Chrome’s Built-in AI is a suite of on-device APIs that provide powerful AI capabilities while respecting your privacy.

Gemini Nano

Google’s efficient on-device language model

On-Device Processing

All AI runs locally - no cloud required

Privacy First

Your data never leaves your device

No API Keys

Works out of the box without accounts

What is Gemini Nano?

Gemini Nano is Google’s most efficient AI model, specifically designed to run on-device:

Technical Specs

Model Architecture:

• Optimized transformer architecture
• ~1.8 billion parameters
• Context window: 1024 tokens
• Output languages: English, Spanish, Japanese

Performance:

• Runs on CPU or GPU
• Typical response time: 1-3 seconds
• Memory usage: ~1.5-2GB when loaded
• Model size: ~1.5GB download

Hardware Requirements:

• GPU: 4GB+ VRAM (recommended)
• CPU: 16GB+ RAM with 4+ cores
• Supports both x86 and ARM architectures

Capabilities

What Gemini Nano Can Do:

✅ Natural language understanding ✅ Text summarization ✅ Language translation ✅ Content rewriting ✅ Question answering ✅ Text generation ✅ Sentiment analysis ✅ Information extraction ✅ Multi-modal input (images, audio)

Limitations:

❌ No real-time information (training data cutoff) ❌ 1024 token context limit ❌ Limited output languages (en, es, ja) ❌ Cannot access internet or external resources

Privacy Benefits

Why On-Device Matters:

Complete Privacy

Your conversations, documents, and data never leave your device. No servers, no logs, no tracking.

Offline Capable

Works without internet after initial model download. Perfect for sensitive work or travel.

No Data Collection

Chrome doesn’t collect or analyze your usage. Your data stays yours.

GDPR Compliant

On-device processing ensures automatic compliance with data protection regulations.

Available APIs

Chrome provides specialized APIs for different AI tasks, all powered by Gemini Nano:

1. Prompt API (LanguageModel)

The core conversational AI interface for general-purpose text generation.

Basic Usage

// Create AI session
const session = await self.LanguageModel.create({
  temperature: 1.0,  // Creativity level (0-2)
  topK: 3            // Response diversity (1-128)
});

// Send prompt
const response = await session.prompt(
  'Explain quantum computing in simple terms'
);

console.log(response);

// Clean up
session.destroy();

// Stream response word-by-word
const session = await self.LanguageModel.create();

const stream = session.promptStreaming(
  'Write a short story about a robot'
);

for await (const chunk of stream) {
  console.log(chunk);  // Display incrementally
}

session.destroy();

// Configure AI personality
const session = await self.LanguageModel.create({
  systemPrompt: 'You are a helpful coding assistant. '
    + 'Provide concise, accurate code examples with '
    + 'clear explanations.',
  temperature: 0.7,
  topK: 5
});

const code = await session.prompt(
  'How do I fetch JSON data in JavaScript?'
);

// Process images and audio
const session = await self.LanguageModel.create();

// Image analysis
const description = await session.prompt(
  'Describe what you see in this image',
  { image: imageElement }
);

// Audio transcription
const transcription = await session.prompt(
  'Transcribe this audio',
  { audio: audioBlob }
);

Parameters:

• temperature (0-2): Higher = more creative, lower = more focused
• topK (1-128): Number of top tokens to consider (affects diversity)
• outputLanguage: Output language code (en, es, ja)

2. Summarizer API

Specialized API for creating concise summaries of long text.

Different Summary Types

// TL;DR summary
const tldr = await self.aiSummarizer.create({
  type: 'tldr',
  format: 'plain-text',
  length: 'short'
});

const summary = await tldr.summarize(longArticle);

// Key points as bullets
const keyPoints = await self.aiSummarizer.create({
  type: 'key-points',
  format: 'markdown',
  length: 'medium'
});

const bullets = await keyPoints.summarize(longArticle);

// Teaser/preview
const teaser = await self.aiSummarizer.create({
  type: 'teaser',
  format: 'plain-text',
  length: 'short'
});

const preview = await teaser.summarize(longArticle);

// Check if Summarizer API is available
const availability = await self.aiSummarizer.availability();

if (availability === 'readily') {
  // API is ready to use
  const summarizer = await self.aiSummarizer.create();
} else if (availability === 'after-download') {
  // Need to trigger model download
  console.log('Model download required');
}

Summary Types:

• tldr: Concise one-paragraph summary
• key-points: Bullet list of main ideas
• teaser: Short engaging preview
• headline: Single-sentence summary

Output Formats:

• plain-text: Clean text without formatting
• markdown: Formatted with markdown syntax

Length Options:

• short: ~50-100 words
• medium: ~100-200 words
• long: ~200-300 words

3. Translator API

Translate text between 100+ languages, completely offline.

Basic Translation

// Create translator
const translator = await self.translation.createTranslator({
  sourceLanguage: 'en',
  targetLanguage: 'es'
});

const translated = await translator.translate(
  'Hello, how are you?'
);

console.log(translated);  // "Hola, ¿cómo estás?"

translator.destroy();

// Auto-detect source language
const detector = await self.translation.createDetector();

const results = await detector.detect(
  'Bonjour, comment allez-vous?'
);

console.log(results[0].detectedLanguage);  // "fr"
console.log(results[0].confidence);        // 0.95

detector.destroy();

// Check if translation pair is available
const canTranslate = await self.translation.canTranslate({
  sourceLanguage: 'en',
  targetLanguage: 'ja'
});

if (canTranslate === 'readily') {
  // Translation available immediately
} else if (canTranslate === 'after-download') {
  // Need to download language model
}

Supported Languages (100+):

• European: English, Spanish, French, German, Italian, Portuguese, Dutch, Polish, Russian, Greek
• Asian: Chinese, Japanese, Korean, Hindi, Thai, Vietnamese, Indonesian
• Middle Eastern: Arabic, Hebrew, Turkish, Farsi
• And many more…

4. Rewriter API

Rewrite and refine text with different tones and styles.

Tone Adjustment

// Formalize casual text
const formal = await self.aiRewriter.create({
  tone: 'formal'
});

const rewritten = await formal.rewrite(
  'Hey, can u send me that file?'
);
// "Could you please send me that file?"

// Casualize formal text
const casual = await self.aiRewriter.create({
  tone: 'casual'
});

const friendly = await casual.rewrite(
  'I would be grateful if you could provide assistance.'
);
// "I'd really appreciate your help!"

// Shorten text
const shorter = await self.aiRewriter.create({
  length: 'shorter'
});

const concise = await shorter.rewrite(
  'In light of the aforementioned circumstances and '
  + 'taking into account all relevant factors...'
);
// "Considering everything..."

// Expand text
const longer = await self.aiRewriter.create({
  length: 'longer'
});

const detailed = await longer.rewrite(
  'The meeting is tomorrow.'
);
// "The scheduled meeting is taking place tomorrow morning."

// Fix spelling and grammar
const fixer = await self.aiRewriter.create({
  tone: 'as-is',
  format: 'as-is',
  length: 'as-is'
});

const fixed = await fixer.rewrite(
  'Im going too the stor to by some bred'
);
// "I'm going to the store to buy some bread"

// Provide context for better rewriting
const rewriter = await self.aiRewriter.create({
  tone: 'professional'
});

const result = await rewriter.rewrite(
  'We need to talk about the numbers',
  {
    context: 'Business email to financial team about Q4 results'
  }
);
// "I would like to discuss the Q4 financial metrics with the team."

Tone Options:

• as-is: Keep original tone
• formal: Professional, polished
• casual: Friendly, conversational

Format Options:

• as-is: Keep original format
• plain-text: Remove formatting
• markdown: Add markdown formatting

Length Options:

• as-is: Keep original length
• shorter: More concise
• longer: More detailed

5. Writer API

Generate new content from scratch based on prompts.

Content Generation

// Create writer
const writer = await self.aiWriter.create({
  tone: 'neutral',
  format: 'plain-text',
  length: 'medium'
});

// Generate content
const content = await writer.write(
  'Write a product description for noise-canceling headphones'
);

writer.destroy();

// Use selected text as context
const writer = await self.aiWriter.create({
  tone: 'enthusiastic',
  length: 'short'
});

const blogIntro = await writer.write(
  'Write an engaging introduction for this blog post',
  { context: selectedText }
);

// Generate markdown
const mdWriter = await self.aiWriter.create({
  format: 'markdown',
  tone: 'professional'
});

const documentation = await mdWriter.write(
  'Create API documentation for a REST endpoint that '
  + 'returns user profile data'
);

6. Language Detector API

Identify the language of any text with confidence scores.

Basic Detection

const detector = await self.translation.createDetector();

const results = await detector.detect(
  'Это пример русского текста'
);

results.forEach(result => {
  console.log(`Language: ${result.detectedLanguage}`);
  console.log(`Confidence: ${result.confidence}`);
});

detector.destroy();

// Get top language candidates
const detector = await self.translation.createDetector();

const candidates = await detector.detect(
  'Mixed text with english y español',
  { maxCandidates: 3 }
);

// Returns array sorted by confidence:
// [{ detectedLanguage: 'en', confidence: 0.7 },
//  { detectedLanguage: 'es', confidence: 0.3 }]

Configuration

Customize Chrome AI behavior in VAssist settings:

AI Configuration

// Configure in Control Panel or via code
const aiConfig = {
  provider: 'chrome-ai',
  
  chromeAi: {
    temperature: 1.0,          // Creativity (0-2)
    topK: 3,                   // Diversity (1-128)
    outputLanguage: 'en',      // en, es, ja
    enableImageSupport: true,  // Multi-modal images
    enableAudioSupport: true,  // Multi-modal audio
    systemPrompt: 'You are a helpful assistant...'
  }
};

// Enable/disable specific features
const aiFeatures = {
  translator: {
    enabled: true,
    defaultTargetLanguage: 'es'
  },
  
  summarizer: {
    enabled: true,
    defaultType: 'tldr',
    defaultFormat: 'plain-text',
    defaultLength: 'medium'
  },
  
  rewriter: {
    enabled: true,
    defaultTone: 'as-is',
    defaultFormat: 'as-is',
    defaultLength: 'as-is'
  },
  
  writer: {
    enabled: true,
    defaultTone: 'neutral',
    defaultFormat: 'plain-text',
    defaultLength: 'medium'
  },
  
  languageDetector: {
    enabled: true
  }
};

Setup Requirements

To use Chrome’s Built-in AI, you need:

1. Chrome Version

   Chrome 138 or newer

   Check your version at chrome://version

   Update at chrome://settings/help if needed

2. Enable Flags

   Required Chrome Flags

   Visit these URLs and enable each flag:

   • chrome://flags/#optimization-guide-on-device-model → Enabled BypassPerfRequirement

   • chrome://flags/#prompt-api-for-gemini-nano → Enabled

   • chrome://flags/#prompt-api-for-gemini-nano-multimodal-input → Enabled (for voice/image features)

   • chrome://flags/#writer-api-for-gemini-nano → Enabled

   • chrome://flags/#rewriter-api-for-gemini-nano → Enabled

   • chrome://flags/#summarization-api-for-gemini-nano → Enabled

   • chrome://flags/#translation-api → Enabled

   • chrome://flags/#language-detection-api → Enabled

   Click Relaunch after enabling all flags

3. Download Model

   Download Gemini Nano (~1.5GB)

   1. Visit chrome://components
   2. Find “Optimization Guide On Device Model”
   3. Click “Check for update”
   4. Wait for download to complete
   5. Monitor at chrome://on-device-internals/
4. Verify Installation

   Test in VAssist

   1. Open VAssist Control Panel
   2. Go to Settings → AI Configuration
   3. Click “Test Connection”
   4. Should show “Chrome AI ready”

See the Installation Guide for detailed setup instructions with screenshots.

Troubleshooting

Model Not Downloading

Symptoms:

• “Check for update” does nothing
• Component not appearing in chrome://components

Solutions:

1. Verify all Chrome flags are enabled
2. Restart Chrome completely (not just relaunch)
3. Toggle flags off and on, then restart again
4. Check free disk space (~2GB needed)
5. Try unmetered network connection

API Not Available

Symptoms:

• LanguageModel is not defined
• VAssist shows “Chrome AI not available”

Solutions:

1. Confirm Chrome version 138+
2. Verify all required flags enabled
3. Restart browser after enabling flags
4. Check chrome://on-device-internals/ for errors
5. Try creating session manually in DevTools console

Context Window Full

Symptoms:

• Error: “QuotaExceededError”
• Long conversations stop working

Solutions:

1. Start a new conversation
2. Enable “Temporary Chat” mode
3. Reduce page context length
4. Gemini Nano has 1024 token limit - this is normal

Performance Issues

Symptoms:

• Slow response times
• Browser freezing

Solutions:

1. Close other tabs/applications
2. Check hardware meets minimum requirements:
   • 4GB+ VRAM (GPU) OR 16GB+ RAM (CPU)
3. Disable other Chrome extensions temporarily
4. Monitor Task Manager for memory usage

Privacy Benefits

Running AI on-device provides significant privacy advantages:

No Server Communication

Zero network requests for AI processing. Your data stays on your device.

No Usage Tracking

Chrome doesn’t log or analyze your prompts and responses.

Offline Capable

Works without internet after model download. Perfect for sensitive work.

Regulatory Compliance

Automatic GDPR, HIPAA, and data protection compliance through on-device processing.

Unlike cloud-based AI services, Chrome’s Built-in AI ensures your conversations, documents, and personal information never leave your computer.

Performance Characteristics

Speed

Typical Response Times (varies by hardware):

Task	GPU	CPU
Short prompt (10 words)	0.5-1s	1-2s
Medium prompt (50 words)	1-2s	2-4s
Long prompt (200 words)	2-4s	4-8s
Streaming (first token)	0.3-0.5s	0.5-1s

Factors Affecting Speed:

• Hardware specs (GPU vs CPU)
• Prompt complexity
• Context length
• Concurrent browser activity

Resource Usage

Memory Consumption:

• Model loaded: ~1.5-2GB RAM
• Per session: ~50-100MB additional
• Total overhead: ~2-3GB typical

CPU/GPU Usage:

• Idle: Minimal (~1%)
• Active inference: 20-60% (1-2 cores)
• GPU: More efficient, faster responses

Disk Space:

• Model download: ~1.5GB
• Cache: ~100-200MB
• Total: ~2GB

Scalability

Concurrent Sessions:

• Recommended: 1-2 active sessions
• Maximum: 5-6 before slowdown
• Each session shares model memory

Best Practices:

1. Destroy sessions when done (session.destroy())
2. Reuse sessions for multiple prompts
3. Avoid keeping idle sessions open
4. Monitor memory in chrome://task-manager

Comparison with Cloud AI

Feature	Chrome Built-in AI	Cloud AI (GPT, Claude)
Privacy	✅ 100% local	❌ Data sent to servers
Speed	✅ Fast (local)	⚠️ Network dependent
Offline	✅ Works offline	❌ Requires internet
Cost	✅ Free	❌ API costs
Setup	⚠️ Initial setup	✅ Just API key
Capabilities	⚠️ Good for most tasks	✅ More advanced
Context Window	⚠️ 1024 tokens	✅ 8k-200k tokens
Updates	⚠️ Via Chrome updates	✅ Continuous

Next Steps

Installation

Set up Chrome AI flags and download Gemini Nano

Configuration

Customize AI settings and behavior

AI Toolbar

Explore AI-powered text and image tools

Chat Interface

Learn about conversational AI features