Gemini across your tools and the ecosystem

The Gemini app is the front door, but most of the value lives in the rooms behind it: Chrome, Android, Workspace, the APIAPIApplication Programming Interface: a standardised interface that lets applications communicate and exchange data without knowing each other's internal workings.View full definition →, and a growing layer of third-party tools built on Google's models. Knowing which surface to reachreachThe number of unique people exposed to your message in a given period. Unlike impressions, reach counts each person once, no matter how often they see it.View full definition → for is the difference between a clever demo and something that actually saves you hours every week.

This lesson maps those surfaces and, more importantly, tells you when each one is the right tool. We'll end with a concrete setup so you can see the decision in action.

The mental model: same brains, different bodies

Every surface here runs the same underlying Gemini models (the Pro tier for harder reasoning, the Flash tier for fast, cheap, high-volume work). What changes is the *body* around the brain: what data it can see, what it can act on, and who controls it.

Three questions decide everything:

1. Where does the context live? Your inbox? A codebase? A database you own?
2. Who triggers it? You, manually? A schedule? Another system?
3. Who needs to control or audit it? Just you? Your whole org? A compliance team?

Hold those three questions. They mapmapUsing software to automate repetitive marketing tasks and campaigns, enabling personalisation at scale across channels like email, web, and social.View full definition → cleanly onto the surfaces.

Consumer surfaces: Gemini where you already are

In the Gemini app and Gems

The app is for open-ended, interactive work. Gems (your saved, reusable custom assistants with fixed instructions) are the right call when you repeat the same *kind* of task with different inputs: a "release notes drafter" Gem, a "rewrite this in our brand voice" Gem. Build the instruction once, reuse it daily.

In chrome and android

Gemini is woven into the OS and the browser, so **the context is *whatever is on your screen***. On Android, Gemini can read the current app's context to answer "what's this email asking me to do?" without copy-paste. In Chrome, it can summarize or reason about the page you're on.

Use these when the data is ephemeral and in front of you. Don't use them for anything you need to repeat or audit, because there's no artifact to save.

In Google workspace

This is the highest-leverage consumer surface for most professionals, because the context is *your own documents and mail*, governed by your existing permissions. Gemini in Docs, Gmail, Sheets, Slides, Meet, and Drive sees only what you already have access to.

Concrete uses:

• In Gmail, draft a reply that references the actual thread.
• In Sheets, generate a formula or categorize a column.
• In Meet, get "take notes for me" and a summary with action items.
• In Drive, ask a question across files without opening them.

The rule: if the data is already in Workspace and a human is in the loop, use Workspace Gemini. You get grounding in your real content for free. Details and current capabilities live at support.google.com under the Workspace help center.

When the app isn't enough: automation with Apps Script

Workspace Gemini is interactive. The moment you want something to run *on a schedule* or *in response to an event* (a new form submission, a row added to a sheet), you cross into automation, and the right tool is Apps Script: Google's built-in JavaScript runtime for Workspace.

Apps Script can call Gemini and write the result straight back into a Doc, Sheet, or email. Here's a trigger-driven snippet that summarizes a new support ticket row using the Gemini API and writes the summary to the next column:

function summarizeNewTicket(e) {
  const apiKey = PropertiesService.getScriptProperties().getProperty('GEMINI_KEY');
  const ticket = e.values[1];
  const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key=${apiKey}`;
  const payload = {
    contents: [{ parts: [{ text: `Summarize this ticket in one sentence: ${ticket}` }] }]
  };
  const res = UrlFetchApp.fetch(url, {
    method: 'post',
    contentType: 'application/json',
    payload: JSON.stringify(payload)
  });
  const summary = JSON.parse(res.getContentValue ? res.getContentText() : res.getContentText())
    .candidates[0].content.parts[0].text;
  e.range.getSheet().getRange(e.range.getRow(), 3).setValue(summary);
}

This is the bridge surface: no servers, no deployment, and it lives inside Google's permission model. Reach for Apps Script when the trigger is a Workspace event and the output goes back into Workspace.

Builder surfaces: the API, AI studio, and the CLI

When you outgrow Workspace (custom apps, your own dataown dataData collected directly from your own customers and prospects through your own channels: your most reliable and privacy-compliant source.View full definition →, your own users), you move to the developer side.

Google AI studio and the Gemini API

Google AI Studio is the fastest place to prototype. You write a prompt, tune it, and export working code in one screen. The same models you tested are available through the Gemini API, documented at ai.google.dev. This is where you exploit the features the consumer app hides from you: explicit model selection, native multimodality (passing images, audio, video, and PDFs directly), long context for whole-document reasoning, and grounding with Google Search as a toggle.

Grounding is the one to internalize. Instead of building a full RAGRAGA method that lets an AI model answer using your own documents, retrieving relevant passages before generating a response instead of relying only on training data.View full definition → pipelinepipelineAll active sales opportunities across the stages of the sales process, together with their combined potential value and probability of closing.View full definition → for general world facts, you enable Search grounding and Gemini fetches and cites live results itself:

from google import genai
from google.genai import types

client = genai.Client(api_key="YOUR_KEY")
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="What changed in the latest EU AI Act guidance this month?",
    config=types.GenerateContentConfig(
        tools=[types.Tool(google_search=types.GoogleSearch())]
    )
)
print(response.text)

Use the API when you're building a product, embeddingembeddingAn embedding is a numerical vector that represents data (text, images, or items) in a way that captures meaning, so similar items sit close together in space.View full definition → AI in your own app, or serving users who aren't you. Use AI Studio first to get the prompt and config right.

Gemini CLI and code assist

Two developer surfaces deserve their own mention because they live where engineers actually work.

Gemini CLI brings the model into your terminal: ask it to explain a stack trace, refactor a file, or run a multi-step task against your local project. Gemini Code Assist lives in your IDE (VS Code, JetBrains) and in GitHub, doing completion, review, and chat with awareness of your codebase.

The distinction: CLI is for ad-hoc, conversational, terminal-native work and quick agentic tasks on local files. Code Assist is for the continuous, in-editor flow. Both are the right surface when the *context is your code*.

🎬 [VIDEO: "Gemini CLI: Your open-source AI agentAI agentSoftware that pursues a goal on its own: it plans steps, uses tools and takes actions with limited human input.View full definition → in the terminal" - youtube.com/watch?v= tutorial - a walkthrough of installing the CLI and running agentic tasks against a local repo]

Production and agents: ADK and vertex AI

Two more surfaces matter once you go beyond a single API call.

The agent development kit (ADK)

When your task needs *multiple steps, tools, and decisions* (call an API, check a result, decide what to do next), you're building an agent, and a raw generateContent loop gets messy fast. The Agent Development Kit is Google's open-source framework for building, structuring, and orchestrating agents with tools, memory, and multi-agent handoffs in a clean, testable way.

A minimal ADK agent that can use a tool looks like this:

from google.adk.agents import Agent

def get_order_status(order_id: str) -> dict:
    """Look up the status of a customer order by its ID."""
    return {"order_id": order_id, "status": "shipped", "eta": "2 days"}

root_agent = Agent(
    name="support_agent",
    model="gemini-2.5-flash",
    instruction="Help customers check order status. Use the tool for any order ID.",
    tools=[get_order_status]
)

Reach for ADK when the logic is genuinely agentic: branching, tool use, and steps that depend on prior results. For a single prompt-and-response, ADK is overkill; stick with the API.

Vertex AI

Vertex AI is the enterprise surface on Google Cloud. The models are the same, but the body around them is built for production: IAM permissions, VPC controls, regional data residency, monitoring, scaling, and integration with your cloud data warehouse. ADK agents deploy here, to a managed runtime, when they need to run reliably for real users.

The decision between the Gemini API and Vertex AI is about *who controls and audits it*. Solo project or startup moving fast: the Gemini API on an API key. Enterprise with security, compliance, and data-governance requirements: Vertex AI. Same models, different governance.

The third-party layer

You'll also meet Gemini *inside other tools*: products that wired Google's models into their own workflows through the API. The point isn't to list them, it's to recognize the pattern. When you evaluate one, ask the same three questions: where's the context, who triggers it, who audits it. A tool that sends your data to Gemini through someone else's account changes the answer to all three.

Putting it together: one task, the right surface

Say you run customer support and want incoming tickets summarized and routed.

• Tinkering, today: Paste a ticket into the Gemini app with a "triage" Gem. Zero setup, but manual.
• Tickets land in a Sheet: Apps Script with an on-edit trigger summarizes each new row automatically. Still inside Workspace, no servers.
• Tickets live in your own helpdesk app: Call the Gemini API (prototype the prompt in AI Studio first). You control the integration.
• You need auto-routing with lookups and decisions: Build an ADK agent that summarizes, checks the customer's plan via a tool, and assigns a queue.
• It's company-wide with compliance requirements: Deploy that agent on Vertex AI with proper IAM and monitoring.

Same job. Five surfaces. The right one is the smallest surface that satisfies your three questions, and not one step heavier.

Key Takeaways

• Match the surface to three questions: where the context lives, who triggers the task, and who must control or audit it. The answers point straight to Workspace, Apps Script, the API, ADK, or Vertex AI.
• Workspace Gemini is the highest-leverage consumer surface for professionals, because it's already grounded in your documents and your permissions. Start there before building anything.
• Apps Script is the automation bridge: when a Workspace event should trigger Gemini and the result returns to Workspace, you need no servers and no deployment.
• Prototype in AI Studio, ship on the API, and graduate to Vertex AI only when governance demands it. The models are identical; you're choosing the level of control.
• Use ADK only when the task is genuinely agentic (multiple steps, tools, and branching). A single prompt does not need a framework.