Hello, Gemini.

Pick where you want to start

Gemini is one model family with many front doors. The fastest is Google AI Studio in your browser — sign in, paste a prompt, get a key. The Gemini API (@google/genai) is what you wire into a Node, Next.js, or Python app. Vertex AI is the same models with enterprise plumbing (VPC-SC, regional residency, IAM). Google Antigravity is Google's standalone agent IDE. The Gemini app at gemini.google.com is the consumer surface. Most developers start in AI Studio and graduate to the API within an hour.

The Google AI stack, sorted by web-dev utility

Google ships a lot of AI surface area. For a web developer, the useful split isn't "consumer vs. enterprise" or "old vs. new" — it's where the inference runs and who calls it. Four categories below. Pick the row that matches the problem; pick the product inside it that matches the size.

Stateless calls from your backend. Pick a model size, send a prompt (with optional images/audio/video/PDF), get a response. Stream tokens, call tools, ground on Google Search, or run structured output with a JSON schema.

Not a single request — a job. You hand Google a goal (and optional tools, browser, code interpreter) and a managed runtime drives the loop, persists state, and reports back. Cheaper to operate than the stateless API for any task that takes more than one turn or needs to survive a redeploy.

For latency, privacy, or cost reasons, you want the model to run where the user is. Chrome ships Gemini Nano behind a set of built-in Web APIs. MediaPipe gives you the same idea for arbitrary tasks — image classification, hand tracking, on-device LLM inference — across web, Android, and iOS.

An "agent" is a loop: model → tool call → result → model. Google ships an opinionated runtime (the Agent Development Kit, ADK), an interoperability protocol (A2A), a hosted runtime (Agent Engine), and a desktop development environment (Antigravity). They compose.

From zero to streaming in five lines

The unified Google GenAI SDK (@google/genai for Node, google-genai for Python) is the SDK you want. It supersedes the older @google/generative-ai package and speaks to both the Gemini Developer API (AI Studio keys) and Vertex AI through the same surface.

Install & first call (Node)

# 1. install
$ npm install @google/genai

# 2. get a key from aistudio.google.com → "Get API key"
$ export GEMINI_API_KEY="AIza..."

# 3. five-line program
$ node --input-type=module -e '
import { GoogleGenAI } from "@google/genai";
const ai = new GoogleGenAI({});
const r = await ai.models.generateContent({
  model: "gemini-2.5-flash",
  contents: "Write a haiku about TypeScript."
});
console.log(r.text);
'

Streaming, tools, structured output, multimodal

The four things you'll reach for most often, in one place:

import { GoogleGenAI, Type } from "@google/genai";
const ai = new GoogleGenAI({});

// 1. STREAMING — token-by-token, drop into a Next.js route handler
const stream = await ai.models.generateContentStream({
  model: "gemini-2.5-flash",
  contents: "Explain rate limiting in one paragraph."
});
for await (const chunk of stream) process.stdout.write(chunk.text);

// 2. TOOL USE — let the model call your functions
const r = await ai.models.generateContent({
  model: "gemini-2.5-pro",
  contents: "What's the weather in Austin right now?",
  config: {
    tools: [{ functionDeclarations: [{
      name: "get_weather",
      description: "Current weather for a city",
      parameters: { type: Type.OBJECT, properties: {
        city: { type: Type.STRING } }, required: ["city"] }
    }]}]
  }
});

// 3. STRUCTURED OUTPUT — JSON that matches a schema, no parsing hacks
const typed = await ai.models.generateContent({
  model: "gemini-2.5-flash",
  contents: "List 3 capital cities with population.",
  config: {
    responseMimeType: "application/json",
    responseSchema: { type: Type.ARRAY, items: { type: Type.OBJECT,
      properties: { city: {type: Type.STRING}, pop: {type: Type.INTEGER}}}}
  }
});

// 4. MULTIMODAL — feed a PDF, an image, audio, a YouTube URL
const file = await ai.files.upload({ file: "./contract.pdf" });
const summary = await ai.models.generateContent({
  model: "gemini-2.5-pro",
  contents: [
    { fileData: { fileUri: file.uri, mimeType: file.mimeType }},
    "Summarize the indemnity clauses."
  ]
});

What's actually new in the unified SDK

Where keys come from

The web-developer-native agent framework

Genkit is the framework most web developers want and don't know to ask for. TypeScript-first (Go and Python in beta), flow-based authoring, a local dev UI for inspecting traces, dotprompt files for prompt-as-code, evals, and one-command deploys to Cloud Functions or Cloud Run. It composes with Gemini, Vertex, Claude, OpenAI, Ollama, and any model behind an OpenAI-shaped API.

# scaffold a new Genkit project (Node)
$ npm init -y && npm install genkit @genkit-ai/google-genai
$ npx genkit init

# start the local dev UI — inspect every flow run, every trace
$ npx genkit start -- npx tsx --watch src/index.ts

A minimal flow

import { genkit, z } from "genkit";
import { googleAI } from "@genkit-ai/google-genai";

const ai = genkit({
  plugins: [googleAI()],
  model: googleAI.model("gemini-2.5-flash")
});

export const summarize = ai.defineFlow({
  name: "summarize",
  inputSchema: z.object({ url: z.string().url() }),
  outputSchema: z.object({ bullets: z.array(z.string()) })
}, async ({ url }) => {
  const page = await fetch(url).then(r => r.text());
  const { output } = await ai.generate({
    prompt: `Summarize this page in 5 bullets:\n\n${page}`,
    output: { schema: z.object({ bullets: z.array(z.string()) }) }
  });
  return output!;
});

Why this is the right choice for a Next.js app

• Same language as the rest of your app. No Python sidecar.
• Flows are just functions. Call them from a route handler, a Server Action, or a Cloud Function.
• The dev UI is honest. Every flow run is a clickable trace tree with inputs, outputs, model latency, and token counts.
• Dotprompt files separate prompt text from code — version, review, and diff prompts like any other source file.
• Evals are built in. Hook a dataset and a scoring function; CI fails when quality regresses.
• Deploy is one command. Cloud Functions for HTTP/scheduled, Cloud Run for long-running, or Firebase Hosting for the simplest cases.

An LLM inside the browser, free

Chrome ships Gemini Nano with the browser. There is no API key, no network call, and no per-token cost — inference runs on the user's machine against a model the browser downloads and shares across sites. The JS APIs are designed for a web developer's mental model: await Summarizer.create(), then summarizer.summarize(text).

The current API surface

A real example

// 1. check availability — model may need to download on first call
const status = await Summarizer.availability();
// "unavailable" | "downloadable" | "downloading" | "available"

// 2. create a session with the parameters you want
const s = await Summarizer.create({
  type: "key-points",
  format: "markdown",
  length: "short",
  monitor(m) { m.addEventListener("downloadprogress", e => {
    console.log(`${(e.loaded * 100).toFixed(0)}%`);
  }); }
});

// 3. use it
const summary = await s.summarize(longArticleText);

// 4. stream if you want incremental output
const stream = s.summarizeStreaming(longArticleText);
for await (const chunk of stream) ui.append(chunk);

Things to know before you ship

• Hardware floor. Roughly 4GB+ VRAM or a modern integrated GPU, and ~22GB free disk for the model. Older devices will get availability() === "unavailable" — design a server-side fallback.
• First-run download. The model is shared across sites but the user still needs to fetch it once. Always monitor downloadprogress and show a UI.
• Context windows are small. Nano is in the 32K-token range. Chunk long inputs.
• Cross-browser story is partial. Edge ships Phi-based equivalents under a different API name; Safari and Firefox have nothing yet. Feature-detect, don't UA-sniff.

Gemini Spark & what you can build today

The user prompt referenced Gemini Spark as a 24/7 autonomous operations runtime announced at I/O 2026. As of this writing the public, stable surface area for "always-on, schedule-driven Gemini agents" is the combination of Vertex Agent Engine + Cloud Scheduler + Cloud Tasks, with the ADK or Genkit providing the agent loop. If Spark ships a packaged SKU that wraps this, the pattern below is the one it will encapsulate.

The pattern: a persistent worker, today

1. Define the agent as a Genkit flow or ADK agent. Tools, model, system prompt, optional memory backend (Firestore, Vertex AI Memory Bank).
2. Deploy to Cloud Run or Vertex Agent Engine. Stable HTTPS endpoint, autoscales to zero between invocations.
3. Schedule with Cloud Scheduler for periodic runs, Eventarc for event-triggered runs, or Pub/Sub for fan-out.
4. Persist state in Firestore (or the Agent Engine sessions API). Pass a session ID into every invocation; the agent picks up where it left off.
5. Observe with Cloud Trace + Logs Explorer. ADK and Genkit both emit OpenTelemetry spans by default — agent runs show up as traces you can drill into.
6. Cap with budgets & quotas. Set a per-project Vertex token quota and a billing budget alert so a stuck loop can't run away.

A scalable stack for an agent-native developer portal

The user prompt asked specifically for a Next.js/Tailwind frontend, a LAMP/Node.js backend, and integration with the unified Gemini SDK, Firebase Genkit, and an agent-commerce protocol. Below is the shape that holds up under both human and agent traffic without forking the codebase.

How the pieces talk

1. Browser → Next.js. Human visitors hit RSC-rendered pages. Each product page emits Schema.org JSON-LD, the same data that powers the API.
2. Browser → Firebase AI Logic. Client-side AI features (chat, suggest, summarize) call Gemini through Firebase AI Logic so the API key never leaves the server. App Check rejects anything that isn't your real app.
3. Next.js API route → Genkit flow. Server-side AI features (recommendations, agent-driven actions) call a Genkit flow. Each flow is a function — call it directly, no HTTP hop.
4. Genkit flow → Gemini API or Vertex. Choose per-flow via plugin config. Long-running flows that need sessions or memory deploy to Agent Engine instead of running in-process.
5. Genkit flow → MCP tools. Tool calls (search inventory, look up an order, call the legacy LAMP API) go through Model Context Protocol servers — one MCP server per backend system, mounted into every flow that needs it.
6. Agent traffic → /api/v1/*. External agents hit the same JSON API your own Genkit flows use, authenticated with OAuth device grants or signed mandates from emerging agent-commerce protocols.
7. Cloud Scheduler → Cloud Run flow. Cron-driven jobs (nightly summaries, inventory reconciliations) invoke a Genkit flow on a schedule, persist results to Firestore, fire a webhook.

The rest of the Google AI surface

Products you'll bump into often, with one paragraph on what they are and when to reach for them. Use the strip below as an index.

NotebookLM

A research workspace where every answer is grounded in sources you upload (PDFs, Google Docs, Drive, YouTube, websites). Generates "Audio Overviews" (podcast-style summaries with two synthetic hosts), mind maps, study guides, and timelines. Excellent for digesting long-form material and as a personal "ask my notes" interface. Available free; NotebookLM Plus raises quotas via Google AI Pro/Ultra.

Project Astra

Google DeepMind's prototype universal assistant — realtime multimodal, with video + audio in and audio out. The streaming primitives that power Astra ship publicly through the Gemini Live API (ai.live.connect) and the upcoming voice/video features in the Gemini app. Reach for the Live API when you want sub-second latency and a true conversation, not a turn-based chat.

Project Mariner

A research preview of an agent that drives a web browser on your behalf — clicks, types, fills forms, completes workflows across tabs. Browser-use capabilities are flowing into the Gemini SDK as a hosted browser tool and into the ADK as built-in tools. Currently behind Labs/early access for end users; developers should track the SDK release notes.

Jules

Google's async coding agent at jules.google.com. Connect a GitHub repo, file an issue, hand it off. Jules clones the repo into a cloud VM, plans, edits, runs tests, and opens a PR. Best for backlog grooming, dependency upgrades, "I wonder if this is doable," and any change small enough to verify by reading the diff. The async-PR equivalent of OpenAI's Codex Cloud or Anthropic's Claude Code in headless mode.

Gemini Code Assist

Gemini in your IDE. VS Code, IntelliJ, PyCharm, GoLand, the rest of JetBrains, plus Android Studio and Cloud Workstations. Chat panel, ghost-text completions, "explain this", "fix this", repo-wide context. The agentic mode lets it plan a change across files, propose a diff, and run terminal commands behind an approval gate. Free for individuals at modest limits; Standard and Enterprise tiers add private code awareness, audit logging, and IAM.

Imagen 4

Google's high-fidelity text-to-image model. Stronger than the Gemini Flash Image model on photorealism and on typography (rendering legible text inside images). Available via Vertex AI and the Gemini API. Use Flash Image for conversational editing, Imagen for one-shot generation that has to look like a photograph.

Veo 3

Text- and image-to-video, with native audio (dialog, sound effects, ambient). Up to 8-second clips from the API; longer compositions via the Flow product. Cinematic camera controls, character consistency across shots, and a reference-image input for style and subject. The video equivalent of the jump Imagen made.

Lyria 2

Text-to-music: instrumental pieces, vocal tracks, soundtracks, jingles. Available via the Gemini API and the consumer-facing MusicFX surface. Best for short-form generative audio (under a minute); longer compositions need stitching.

Flow

The filmmaking workspace built on Veo and Imagen. Scene-by-scene composition, camera control, frame-to-video extension, asset library. The product Google built so professional creators stop fighting raw prompts and start storyboarding.

Gems

Custom Gemini personas — a name, an instruction set, optional file knowledge, optional tool access. The Gemini-app equivalent of OpenAI's GPTs. Free for everyone (with Pro/Ultra raising limits); excellent for canned workflows ("rewrite-in-our-voice", "code reviewer", "weekly digest").

Deep Research

A multi-step research mode in the Gemini app — Gemini drafts a plan, browses dozens to hundreds of sources, drafts a brief with citations, and (optionally) generates an Audio Overview. Available on the free tier with limits, expanded on Pro/Ultra. Useful for "do a literature review on X" tasks; not a replacement for a domain expert.

Workspace AI

Gemini in Docs, Sheets, Gmail, Slides, Meet, Drive, Chat. "Help me write", "Help me organize", in-Meet note-taking and translation, in-Drive cross-document search. Included with Workspace Business and Enterprise plans (the standalone "Gemini for Workspace" add-on was rolled into the base SKUs).

Stitch

Prompt-to-UI: describe a screen and get a clean Figma-shaped layout you can export to Figma or React/HTML. Useful for spinning up wireframes and starting Tailwind components without hand-laying them out.

Firebase Studio

An in-browser, agentic app development workspace from the Firebase team (the evolution of Project IDX). Spin up a project from a prompt, get an AI-built scaffold (web, mobile, Genkit backend), preview live, deploy to Firebase Hosting / Cloud Run. The "from idea to deployed app in a session" surface.

Model Context Protocol

An open protocol for connecting LLMs to tools and data sources, originally championed by Anthropic and now broadly adopted across the industry — Gemini, the ADK, Genkit, Antigravity, Code Assist, and Claude all speak it. Run an MCP server in front of your database, your filesystem, your ticketing system, your CMS; mount that one server into every agent that needs it. The closest thing the industry has to "USB for AI tools."