0 The situation, in one screen
What this meeting is, who is in it, and the single sentence that should run under everything you say.
Who & what
- Douglas Benalan — CIO & Head of Digital Transformation, CURE (also NJ PURE, Silver Rock). Ex-NJM, Chubb, Endurance. Brown Exec MBA, BITS Pilani, Stanford Web Security.
- Cathy + another colleague on the AI team join.
- Referred by Kamlesh / ITG. The summarization tool is already an ITG offshore build — collaborate with it, don't compete.
- Framed as an exploratory fit assessment, not a formal interview. But it is an audition — treat it like one.
The two workstreams
- Train A "level 1" Gemini Enterprise training for CURE developers — Mon Sep 21, ~1.5–2 hrs (navigate the tool, search folders + enterprise data).
- Build AI products: a document summarization tool and a bigger "BI Command" analytics product. Douglas wants prototypes/real work, not just one class.
The one line under everything
"AI informs, humans decide." Douglas is a founding member of the Ethical AI in Insurance Consortium; his public posture is measured — baby steps, human-in-the-loop, build the governance before the autonomy. Every claim you make tomorrow should carry a citation, a confidence signal, and a human checkpoint. That is exactly your lane.
Say this early — it makes you sound like an insider
Google renamed Agentspace → Gemini Enterprise (Oct 2025), then folded Vertex AI → "Gemini Enterprise Agent Platform" at Cloud Next '26. Names moved twice in ~18 months. Naming everything correctly — and flagging that you'll verify the exact edition/console in CURE's tenant — signals you track the platform, not just the hype.
1 The play — how to walk in
Your positioning, your real edge, and the moves that land with a cautious insurance CIO.
Your edge (own it, don't hide it)
- Player-coach who ships. 16 yrs hands-on (C#, Java, Python, React), tech-lead at Prudential, deep agentic-AI practice, and you teach executives. You can architect it, build it, and get their team building it. That combination is rare and it is exactly the train-and-build ask.
- Claude Code depth transfers. You are not "learning AI" — you are an expert translating a mature agentic toolchain into Gemini. See the Rosetta Stone: MCP, context files, custom commands, function calling, permissions all map 1:1.
- You already know Google's agent IDE. You've built apps in Antigravity — Google's own agent-first platform. Mention it; almost no one has hands-on there.
- Governance is your specialty, not an afterthought. Evals, guardrails, groundedness, human-in-the-loop — the precise disciplines an insurer needs before trusting AI.
The framing that already landed with Douglas
"If leadership has ~90% clarity on what we're building and why, the build is easy — AI makes writing code fast. The risk now is structure, monitoring, avoiding features nobody needs, and changing direction." He agreed hard on the call. Reuse it tomorrow: it positions you as the person who de-risks delivery, not just another pair of hands.
Avoid
- Selling autonomy ("let the AI decide"). He wants augmentation.
- Rip-and-replace talk, or anything implying you'd go around their team / the offshore build.
- Overclaiming Gemini parity where Claude is genuinely ahead — be candid (it builds trust).
- Raising rate / H1B / contract mechanics with Douglas. That's an ITG/Kamlesh conversation.
- Quoting exact prices, model IDs, or feature GA-status as fact — say "I'll confirm in your tenant."
Do
- Engage on requirements and architecture — behave like the builder, not a trainee.
- Mirror his "AI informs, not decides" language back to him.
- Ask sharp questions (see §6) — a good question outperforms a good answer here.
- Anchor every capability to evaluation + citations + a human checkpoint.
- Offer a concrete small first step (e.g., a summarizer Gem prototype + an eval set).
2 Gemini Enterprise 101 for the Sep 21 training
This is the product the "level 1" class is about. Teach it cold; disambiguate the name first.
What it actually is
Google's unified enterprise-search + AI-assistant + agents web app — the thing that "navigates a tool, searches folders, searches enterprise data." One chat homepage grounded on your company's data (Drive, SharePoint, Confluence, Jira, ServiceNow, 100+ connectors), with Sources/citations on every answer. Formerly Google Agentspace (renamed Oct 9 2025).
Don't confuse these five (know all cold)
| Product | What it is | Is it the class? |
|---|---|---|
| Gemini Enterprise (ex-Agentspace) | Standalone web app: unified enterprise search + grounded chat + agents + notebooks. Own URL, SSO login. | YES — this |
| Gemini for Google Workspace | AI side-panel inside Gmail/Docs/Sheets/Slides. | No — different app |
| Gemini app (gemini.google.com) | Consumer chat assistant. (This is where Gems live.) | No |
| Vertex AI → "Gemini Enterprise Agent Platform" | The developer platform (APIs, Agent Builder, evals). Where your build work lives. | No — but it's your build home |
| Google Agentspace | Old name for Gemini Enterprise. Retired. | It IS the tool, old name |
The level-1 workflow to teach (step by step)
- Sign in at CURE's Gemini Enterprise URL via corporate SSO. (Get the exact URL from CURE's admin — it's tenant-specific, not public.)
- Orient to the homepage = the Assistant chat. Chat box center; search icon upper-left (find your own chats/files/agents); left sidebar for history + pinned agents; sections: Assistant, Agents, Canvas, Skills, Notebooks.
- Ask a grounded question over company data, e.g. "Summarize our auto-claims intake SOP and list required documents." It shows its plan, then which sources it hit, then the answer.
- Always open "Sources." Hover a citation to highlight the exact sentences it supports. Drill this: grounded ≠ infallible — verify via Sources.
- Scope with Connectors toggles. To search just one place (only SharePoint, only Drive/a folder), disable the other connectors + Google Search, then ask. This is the "search a folder / search enterprise data" muscle.
- Upload a file via the ⊕ icon (PDF/DOCX/XLSX/CSV/images). Ask about it. Uploaded files are session context only — they are NOT added to the enterprise index.
- @-mention a document, person, or agent for context. Keep typing for follow-ups — context carries.
- Organize: star important chats, pin frequently used agents. (Old chats auto-delete per admin retention.)
Beginner mistakes to pre-empt in the class
- Name confusion — they'll Google "Agentspace" (old) or land in "Gemini for Workspace" (wrong app). Clear it up on slide 1.
- "It can't find my doc" — usually (a) connector not synced yet, (b) they genuinely lack permission (permissions-aware search working as intended), or (c) too many connectors on, so the answer drifted.
- Trusting answers with no citation — teach "open Sources" as a reflex.
- Upload ≠ index — a file you uploaded in your chat isn't searchable by a colleague later.
- Index freshness lag — a doc edited minutes ago may not appear until the next sync (can be hours).
- Edition gating — Deep Research, custom agents, and full connectors aren't in every edition. Confirm CURE's edition so you don't demo a feature they can't use.
Security / governance one-liners (insurance-relevant)
- Data isn't used to train Google's models. "Gemini doesn't use your prompts or its responses to train its models."
- Permissions-aware by design — answers enforce source-system ACLs via identity sync. A user can't surface documents they aren't entitled to. (Critical for claims PII.)
- Data residency (global/US/EU), CMEK encryption, VPC-SC; inherits Google Cloud's ISO 27001/17/18, SOC, FedRAMP.
- Your caveat to raise: these are platform assurances, not a substitute for CURE's own DLP + deciding which PII repositories get indexed. Start the pilot with a narrow, low-sensitivity connector set.
Verify before the class
CURE's exact edition, tenant URL/SSO flow, and live UI labels. The product rebranded twice, so screenshots drift — re-check the real tenant the morning of Sep 21.3 Gems they mentioned this
The fast path to a summarizer prototype — and knowing exactly where a Gem stops and a real build begins.
What a Gem is
A saved persona + system instruction + up to 10 knowledge files layered on a stock Gemini model. It is not a separate model, not fine-tuning, not an engineered pipeline. Closest Claude analogy: a Claude Project — not a Skill, and definitely not an API build.Gems CAN
- Hold a persistent persona + instructions, reused across chats
- Ground on ≤10 uploaded/Drive docs (live Drive sync)
- Use Gemini's built-in tools (Search grounding, Drive/Gmail/Docs)
- Be shared Drive-style (Viewer/Editor), admin-gated
Gems CANNOT (the gaps)
- Call external/custom APIs — no Actions, no MCP, no webhooks. Only Google's own apps. (Biggest gap vs ChatGPT Custom GPTs.)
- Guarantee "answer only from these docs" — silent fallback to general training if the query doesn't match
- Expose an API, versioning, eval, logging, or SLA
- Real code execution (sandbox is Python-only, 30s, no file I/O)
Build one in ~2 minutes
gemini.google.com → sidebar Gems → New Gem → write instructions in Google's four pillars Persona / Task / Context / Format → add Drive/device knowledge files → test in the preview pane → Save. The preview does NOT auto-save — hit Save.
Worked example you can pitch: a "Claims Doc Summarizer" Gem
PERSONA You are a senior auto-insurance claims analyst for a New Jersey personal-auto insurer. Precise, neutral, never speculate beyond the document provided. TASK When I attach or paste a claims document (FNOL, adjuster notes, police report, medical bill, or policy PDF), produce a structured summary. CONTEXT - Audience: a claims adjuster triaging in under 2 minutes. - Use the uploaded CURE summary template + glossary as the source of truth for field names and terminology. - If a field is not present, write "Not stated" — never infer it. FORMAT 1. Claim snapshot (claimant, policy #, date of loss, claim type) 2. What happened (3-5 bullets, facts only) 3. Coverage-relevant facts (dates, amounts, parties, injuries) 4. Open questions / missing info 5. Suggested next action (one line) Flag any figure/date you are <90% confident you read correctly with [VERIFY].
Note the guardrails baked into the prompt ("Not stated", "[VERIFY]") — they substitute for the eval a Gem doesn't have. The same instruction text ports directly as the system prompt when this graduates to a real pipeline, so the Gem doubles as the spec.
Compliance caution
Uploading real claimant PII/PHI into a Gem must clear CURE's Workspace data-region/retention controls first. Regulated-data summarization is exactly the case that pushes you toward a governed Vertex build.The line to draw out loud tomorrow
Gem = a human-in-the-loop desk assistant for one document at a time. Move to a Vertex pipeline the moment you need: an API, OCR on scanned/faxed claims (Document AI), retrieval over a large corpus (Vertex AI Search), strict "answer only from source" grounding (High-Fidelity mode), or eval/logging/versioning. Recommendation for CURE: let the offshore team's tool stay a thin grounded app for the single-doc case, but insist on clean seams (a DLP step, an eval gate, citation output) so it graduates without a rewrite.
4 Claude Code → Gemini Rosetta Stone
Your explicit ask: where your Claude Code expertise maps into a Gemini-only world, so you speak it fluently. Lead with what transfers 1:1; be honest about the two real gaps.
The three Google agentic-coding tools
| Google tool | What it is | Claude Code analog |
|---|---|---|
| Gemini CLI | Open-source (Apache-2.0) terminal agent. Files, shell, built-in tools + MCP. Config in ~/.gemini/. | Claude Code itself — the direct analog |
| Gemini Code Assist | IDE plugin (VS Code / JetBrains). Inline completion, chat, agent mode. | Claude Code's IDE integration / Copilot layer |
| Google Antigravity | Agent-first IDE. "Manager Surface" orchestrates async agents; agents produce Artifacts + can drive a browser. | Claude Code's multi-agent ambitions, as a full IDE you've used this |
Your one-liner: "Gemini CLI is the direct Claude Code analog; Code Assist is the in-IDE assistant; Antigravity is Google's agent-first IDE that supersets both — and I've already built in Antigravity."
Concept-by-concept mapping
| Claude Code | Gemini equivalent | Fit |
|---|---|---|
CLAUDE.md context file | GEMINI.md (hierarchical, project + ~/.gemini/) | 1:1 |
Slash / custom commands (.md) | Custom commands as TOML in ~/.gemini/commands/; dir = namespace (/git:commit); args via {{args}}, shell via !{...}, files via @{...} | 1:1 |
| Subagents | Gemini CLI sub-agents (.md + YAML in agents/). Production version = Vertex Agent Builder + ADK | Close · preview |
| Skills (SKILL.md) | Gemini CLI extensions (bundle commands, MCP, hooks, "agent skills") + Gems at consumer layer | Weakest — ecosystem younger |
| MCP | MCP in Gemini CLI (mcpServers in settings/manifest) — same protocol, same servers | 1:1 |
| Hooks | Gemini CLI hooks (hooks/hooks.json); Antigravity exposes hooks too | Close (docs thinner) |
| Tools / function calling | Built-in tools + function calling via Gemini API; bonus: native Search grounding | 1:1 |
| Settings / permissions / sandbox | settings.json, per-call shell confirm, --yolo (≈ bypass mode, sandbox only), command denylist | 1:1 |
| Checkpointing / memory | /memory + GEMINI.md; Antigravity "Knowledge base" | Partial — rewind weaker |
The model & platform layer
Models (mental model = same as Claude)
- Gemini Pro = Opus-class (deep reasoning, biggest context — up to ~2M tokens)
- Gemini Flash = Haiku-class (cheap, fast, high-throughput)
- The
gemini-3.xline churned fast in 2026 — don't quote a specific ID as fact; verify live.
Where you build (= your Anthropic analog)
- Google AI Studio = Anthropic Console / playground (prototype, get a key)
- Gemini API = Anthropic API (dev integration)
- Vertex AI (→ "Gemini Enterprise Agent Platform") = governed enterprise (RBAC, VPC-SC, residency). At an insurer you live here.
Path Google itself frames: prototype in AI Studio → build on the Gemini API → scale/govern on Vertex. The consumer gemini.google.com chatbot has no public API — never propose calling it programmatically.
Be candid about the gaps (this builds trust)
Where Claude Code is ahead
- Skills ecosystem (marketplaces, auto-discovery) far more mature
- Subagents are hardened vs Gemini's preview
- Agentic code quality (~87–88% vs ~76% SWE-bench Verified)
- Checkpointing / rewind more first-class
Where Gemini is ahead
- Context window (up to ~2M)
- Cost — Flash tier markedly cheaper
- Native Google integration (Search grounding, Workspace, Vertex governance) — the reason an insurer picks it
- Gemini CLI is open-source; Antigravity's async orchestration UX
Your transferable-skills pitch, compressed
"MCP, context files, custom commands, function calling, permissions and sandboxing all transfer 1:1 — I already know these. Subagent orchestration is the same mental model; the production version is Vertex Agent Builder + ADK. The one place I'd be candid is the Skills ecosystem — the primitives exist as extensions, the community library is younger. And at an insurer, everything runs through Vertex, not the consumer app."5 The summarizer & "BI Command" — talk architecture
Enough depth to discuss design, tradeoffs, evaluation, and governance credibly. Lead with where you add value: the seams, the evals, the guardrails.
Summarization tool — reference architecture
Source docs (claims PDFs, scanned FNOL, policy docs, medical/PIP)
→ [1] Ingest + OCR + structure — Document AI (layout-aware; +Healthcare NLP for medical)
→ [2] DLP de-identification — Sensitive Data Protection (redact/mask PII/PHI)
→ [3] Route: long-context OR chunk+embed+index (RAG)
— Vertex AI Search / RAG Engine / Vector Search
→ [4] Summarize — map-reduce / refine / structured extraction
→ [5] Grounding — High-Fidelity mode: sentence-level citations + confidence
→ [6] Eval gate — Gen AI Evaluation Service (faithfulness, coverage)
→ [7] Human-in-the-loop — adjuster confirms before use
→ Structured summary + citations + confidence + audit log
The first architectural fork (know this)
Single document that fits the window → send the whole thing (long-context, best faithfulness). Across many docs (a claimant's whole history) → RAG. One doc over the window → map-reduce / refine. And "1M tokens" ≠ 1M usable — quality degrades in the middle at scale.Where you add value (say these)
- Structured extraction over free text — ask for a schema (
claimant, date_of_loss, injuries[], treatments[], open_questions[]) with a citation per field. Easier to evaluate, redact, and route downstream. - The eval is the credibility centerpiece — Gen AI Evaluation Service: LLM-as-judge for groundedness / faithfulness / coverage, rubric metrics tuned to insurance ("captures all injuries", "no invented treatment"), pairwise A/B on prompt/model changes, and calibrate the judge against human labels so leadership trusts the eval, not just the model. There's a real precedent: a financial institution used it to raise the quality of advisor-conversation summaries.
- DLP before the LLM is non-negotiable — de-identify PII/PHI at step [2]; confirm CURE's HIPAA BAA covers every service in the path (Document AI, Gemini, storage) since auto insurers handle medical/PIP data; keep a controlled re-identification path for authorized adjusters.
"BI Command" — natural-language analytics
Two Google surfaces — know which is which:
- Conversational Analytics in Looker — chat-with-your-data grounded in the LookML semantic layer (the trust mechanism: it uses governed metric + join definitions instead of guessing SQL). Respects permissions/hidden fields; has a Python interpreter for forecasting.
- Conversational Analytics API (
geminidataanalytics.googleapis.com) — build data agents you embed in your own apps ("BI Command"). Sources: BigQuery, Looker, AlloyDB, Spanner, Cloud SQL. Also embedded in BigQuery Studio.
The single most expert thing you can say about BI Command
NL-to-SQL has a performance cliff. Models scoring 85%+ on public benchmarks (Spider) drop to 10–20% on real enterprise schemas; on Spider 2.0 a top model fell ~91%→~21%; on BEAVER (real warehouses) a frontier model hit ~0% end-to-end. The fix that works: a semantic layer + verified/"golden" queries — on Google that's LookML + golden queries + a domain glossary ("loss ratio", "PIP", "subrogation"). Snowflake's Cortex hits 90%+ precisely by coupling the model to a semantic model. So the first question is: does CURE have mature LookML, or raw BigQuery with no semantic layer? That one answer determines whether "BI Command" is a quarter of work or a year of it.
How you'd guardrail + evaluate the BI product
- Semantic layer first (LookML) so the model can't invent joins.
- Verified/golden queries — pair top questions with their correct SQL; the agent references them.
- Surface the generated SQL for power users; human gate anything feeding a decision or regulatory report.
- Consistency test — same question must return the same query, or scheduled reports break trust.
- Eval as a test suite — golden benchmark from CURE's own questions; score execution accuracy, consistency, refusal (declines when it can't answer from governed fields), latency, cost; re-run on every model/semantic-layer change.
Verify live before quoting
Vertex→Agent-Platform console paths, High-Fidelity grounding GA/preview status, Conversational Analytics GA/preview split, exact model IDs/limits/pricing. Say "I'll confirm current status with your Google account team" — that's the correct expert answer, not a dodge.6 Smart questions to ask them
A great question here beats a great answer. These make you sound like the person who has shipped this before. Pick 4–6 that fit the flow — don't machine-gun all of them.
Openers (frame + intent)
- "Before we dive into tools — what does success look like in 90 days for the AI team? Adjuster time saved, cycle-time, accuracy, adoption?"
- "How are you thinking about the split between enabling your developers (the training) and me building alongside the offshore team? Where do you most want my hands?"
- "What's the governance bar a new AI feature has to clear before it touches a real claim or a real number?"
On the summarization tool
- Doc types & source: FNOL, adjuster notes, policy docs, medical/PIP? Native PDF, scanned, or handwritten? (Decides whether Document AI OCR is needed.)
- Single-doc or cross-doc: summarize one file, or synthesize across a claimant's whole history? (Long-context vs RAG.)
- What has the offshore team built so far, and where does it fail today? Is there any eval set, or human-written reference summaries we could turn into one?
- Accuracy & failure cost: what's the tolerance for a missed injury or an invented treatment? What does "good" look like to an adjuster?
- PII/PHI: is there a signed HIPAA BAA covering these services? Where must redaction happen, and who may re-identify?
- Output contract & downstream: free-text or a structured schema, and where does the summary go — claims system, decisioning?
- Human-in-the-loop: does an adjuster review before a summary is used, and do we capture their edits?
On "BI Command"
- Existing BI stack: do you run Looker with mature LookML, or raw BigQuery without a semantic layer? (Biggest accuracy determinant.)
- Semantic maturity: are metrics like loss ratio, combined ratio, PIP exposure defined once and governed — or scattered across dashboards?
- Question catalog: what are the top 50–100 questions leaders actually ask? (Those become golden queries + the eval set.)
- Audience: analysts who can inspect SQL, or executives who won't? Row/column-level access needs?
- Decision vs exploration: do answers feed regulatory/financial reporting (needs a human gate) or ad-hoc exploration?
- What's been tried in text-to-SQL before, and why it did or didn't stick?
On the platform & team
- "Which Gemini Enterprise edition is CURE on, and how much of the data is indexed vs federated today?"
- "Are we building on Vertex (now the Agent Platform), or is some of this staying in Gems / the Gemini app for now?"
- "Who owns data quality and the semantic layer internally — and who's the business sponsor who signs off that a number is 'official'?"
- "For the Sep 21 training — what's the developers' current comfort level, and do you want it hands-on in your tenant with your data, or generic?"
7 If they ask you — strong answers
Likely questions and how to answer in a way that's honest, expert, and CURE-shaped. The FRAME line is the point you're making, not a script to recite.
"You're a Claude Code expert — but we're a Gemini shop. Is that a problem?"
FRAME: transferable expertise, not a gap. "The primitives are the same and they transfer 1:1 — MCP, context files (CLAUDE.md → GEMINI.md), custom commands, function calling, permissions/sandboxing. I've also built in Antigravity, Google's agent IDE, and worked in Vertex-style governed setups. What I bring isn't tool-specific — it's knowing how to structure, evaluate, and govern agentic systems so they're safe in production. I ramp on the Gemini surface fast because I already think in these concepts."
"How would you approach our summarization tool?"
FRAME: seams + evals + human-in-the-loop. "First I'd understand the docs — are they clean PDFs or scanned FNOLs, and are we summarizing one file or a whole claim history? That decides long-context vs RAG and whether we need Document AI. Then I'd insist on three seams from day one: a DLP redaction step before anything hits the model, structured output with a citation per field, and an eval gate — LLM-as-judge on faithfulness and coverage against a golden set of adjuster-written summaries. Keep the offshore team's tool moving, but make sure it can graduate to a governed pipeline without a rewrite."
"Can a Gem just do the summarizer?"
FRAME: yes for one thing, no for the real thing. "For a single document an adjuster drops in and reviews — yes, a Gem is the fastest path, I can build one in an afternoon. But the moment it needs an API, OCR on scanned claims, retrieval over many docs, strict 'only from source' grounding, or an audit trail and evals, it has to move to Vertex. The nice part: the Gem's instruction becomes the system prompt for the real build, so the prototype is the spec, not throwaway."
"What's realistic for BI Command / natural-language analytics?"
FRAME: the semantic layer is the whole game. "The honest answer: NL-to-SQL looks amazing in demos and falls off a cliff on real enterprise schemas — high-80s on benchmarks down to 10–20% on production data. What closes that gap is a governed semantic layer plus verified 'golden' queries — on Google, LookML. So the first thing I'd want to know is how mature your LookML is. If it's solid, we can get trustworthy answers fast with Conversational Analytics. If not, the honest sequence is: build the semantic layer and a golden-query eval set first, then turn on the chat."
"How do you make sure the AI doesn't hallucinate on a claim?"
FRAME: his exact posture, operationalized. "Same way you'd want it: AI informs, humans decide. Concretely — High-Fidelity grounding so every sentence carries a citation and a confidence score, a check-grounding gate that catches unsupported statements, an eval suite that scores faithfulness before anything ships, and an explicit human checkpoint where an adjuster approves and their edits feed back into the eval set. Nothing un-cited reaches a decision."
"How would you run the Sep 21 developer training?"
FRAME: hands-on, in their tenant, on their data. "Level 1, but in CURE's real tenant so it sticks: sign in, orient to the assistant, run a grounded search over your own data, and — the habit I'd drill hardest — always open Sources to verify. Then scoping searches with connector toggles, uploading a file for a one-off, and @-mentions. I'd pre-empt the three things beginners trip on: the Agentspace/Workspace name confusion, 'it can't find my doc' (usually permissions or sync), and thinking an upload gets indexed. I'll confirm your edition first so I only demo features you actually have."
"How much time can you give us / how do we structure this?"
FRAME: deflect mechanics to ITG, stay eager on the work. "Happy to start part-time and prove value fast — I'd suggest a small first slice like the summarizer prototype plus an eval set. On the contracting side, Kamlesh and ITG handle the structure, so I'd loop them in on hours and terms. My focus today is making sure I understand what you're building and where I can move the needle."
"What would you do in the first 30 days?"
FRAME: concrete, low-risk, measurable. "Week 1: sit with the offshore team and one adjuster, map the current summarizer and where it fails, and stand up a small golden eval set. Weeks 2–3: tighten the summary to a structured, cited output and get faithfulness/coverage numbers on a dashboard so we can see improvement. In parallel, scope BI Command by auditing LookML maturity and collecting the top questions leaders ask. End of month: a measurably better summarizer, an eval harness the team can run, and a clear-eyed plan for BI. Deliver the Sep 21 training in the middle of that."
8 Your 60-second intro
Douglas may ask you to introduce yourself in 30–60 seconds (he did on the call). Tight, senior, CURE-aimed.
"I'm an engineering leader with 16 years hands-on — C#, Java, Python, React — including three years as a tech lead at Prudential. The last stretch I've gone deep on production AI: building agentic and RAG systems, and coaching executives and engineering teams on how to actually adopt AI. I'm a player-coach — I architect the system, build it, and level up the team while I'm doing it. My strength is two things insurers care about: making AI customizable to the business and understandable to the people who have to trust it — which means I lead with evaluation, grounding, and human-in-the-loop, not autonomy. I know the Google stack — Gemini, Vertex, Antigravity — and the concepts carry straight over from the agentic work I've been doing. So I can help two ways: get your developers productive on Gemini Enterprise, and build the summarizer and BI products with the guardrails baked in from day one."
Trim to 30s by keeping the first sentence, the "customizable + understandable" line, and the "two ways I can help" close.
10 Glossary — every term they might drop
Recognize and correctly name anything that comes up. A = Claude analog · ⚠ = volatile name (hedge it) · CURE = insurance-specific. Type to filter.
Products & surfaces (which is which)
Gemini Enterprise
Google's unified enterprise-search + AI-assistant + agents web app — "navigate the tool, search folders, search enterprise data." SSO login, citations on every answer. This is what the Sep 21 training covers.
Google Agentspace
The old name for Gemini Enterprise (retired Oct 2025). Same product in any pre-Oct-2025 doc or video.
Gemini for Google Workspace
The AI side-panel embedded inside Gmail/Docs/Sheets/Slides. Works over your Workspace content in-app. NOT the enterprise-search app.
Gemini app (gemini.google.com)
The general/consumer chat assistant. Where Gems live. Has no public API — never propose calling it programmatically.
Vertex AI
Google's enterprise developer platform for building/hosting models + agents (APIs, Agent Builder, evals, RBAC, VPC-SC). At an insurer, you build here.
Google AI Studio
Browser playground to prototype prompts, tune params, grab an API key. Free tier.
Gemini API (Developer API)
Direct REST/SDK gateway to the models via an AI Studio key. For dev integration before enterprise governance.
Editions
Gemini Enterprise tiers: Business, Standard, Plus, Frontline, Pay-as-you-go. Features gated by edition — confirm CURE's before demoing.
Coding & agent tools
Gemini CLI
Open-source (Apache-2.0) terminal agent: files, shell, built-in tools + MCP. Config in ~/.gemini/.
Gemini Code Assist
IDE plugin (VS Code / JetBrains): inline completion, chat, agent mode.
Google Antigravity
Google's agent-first IDE. "Manager Surface" orchestrates async agents; agents produce Artifacts and can drive a browser. (You've built in it.)
GEMINI.md
Persistent project/user context file Gemini CLI loads. Hierarchical (project + ~/.gemini/).
Custom commands
Reusable slash commands as TOML in ~/.gemini/commands/; dir = namespace (/git:commit); args {{args}}, shell !{...}, files @{...}.
Sub-agents (Gemini CLI)
Delegated task agents (.md + YAML in agents/). Preview / less mature than Claude Code subagents.
Extensions (Gemini CLI)
Bundles packaging prompts, MCP servers, commands, hooks, sub-agents, "agent skills."
Hooks
Lifecycle interception in Gemini CLI (hooks/hooks.json in an extension).
--yolo
Gemini CLI flag to auto-approve tool actions. Sandbox/container only.
/memory
Gemini CLI command to view/edit persistent project memory (backed by GEMINI.md).
Agent-building (production)
Vertex AI Agent Builder
Managed platform for durable, deployed agents (not ephemeral CLI sub-agents).
ADK (Agent Development Kit)
Google's SDK/framework for building multi-agent systems, used with Agent Builder.
Agent Designer
No-code agent builder inside the Gemini Enterprise app (multi-step workflows for business users).
Prebuilt agents
Ready agents in Gemini Enterprise: Deep Research (multi-step cited reports), Data Insights, partner agents (Box/Workday/Salesforce/ServiceNow).
MCP (Model Context Protocol)
Open protocol connecting tools/data to an agent. Supported in Gemini CLI (mcpServers). Transfers directly from your Claude work.
Function calling / tool use
The model calls a defined function with structured args. Google bonus: native Google Search grounding as a built-in tool.
Models & concepts
Gemini Pro
Frontier/deep-reasoning tier; largest context (up to ~2M tokens on 3.x Pro).
Gemini Flash
Fast, cheap, high-throughput tier.
Deep Think
Explicit extended-reasoning mode on Pro models.
Model ID
e.g. gemini-3.x-pro / -flash. The 3.x line churned fast in 2026 — don't quote a specific ID as fact.
Context window
How much text (tokens) the model considers at once. "1M tokens" ≠ 1M usable — quality degrades toward the middle ("lost in the middle").
Token
The unit models read/bill in (~¾ of a word). Cost + latency scale with tokens.
Temperature
Randomness knob; lower = more deterministic (what you want for extraction/summarization).
Grounding
Tying an answer to specific source data so it's traceable, vs. free-generating from training.
Hallucination
A plausible but unsupported/false output. The core risk grounding + eval + citations control.
RAG, retrieval & documents
RAG (Retrieval-Augmented Generation)
Retrieve relevant passages from a corpus, then answer from them. Best for Q&A across many docs.
Grounding vs RAG
RAG is one way to ground. Grounding is the broader idea of tying answers to sources (a single doc, Search, or a retrieved corpus).
Vertex AI Search
Managed ("buy") RAG: retrieval over your data with citations + access controls, minimal tuning. Highest out-of-box quality.
RAG Engine
Managed orchestration for a customizable RAG pipeline (swap parsing, chunking, embedding, vector store). The sweet spot.
Vector Search
DIY vector database/index for embeddings; max control, most effort.
Embeddings
Numeric vectors representing meaning; nearest-vector search is how retrieval finds relevant passages.
Chunking
Splitting docs into retrievable pieces before embedding. Chunk quality drives retrieval quality.
High-Fidelity grounding
Vertex mode sourcing answers only from provided context, with sentence-level citations + confidence scores. Google aims it at insurance/finance/healthcare. Your money feature for a cautious CIO.
check-grounding API
Scores how well an answer is supported by the source; catches unsupported sentences.
Grounding with Google Search
Built-in tool grounding answers on live web results. Historically can't combine with function-calling/RAG tools in one request.
Document AI
Layout-aware OCR/parsing for PDFs, scanned forms, handwriting. The front door for scanned FNOLs + medical records before the LLM.
Healthcare Natural Language API
Extracts clinical entities from medical text; pair with Document AI for PIP/medical records.
Map-reduce / refine / long-context
Summarization patterns: whole doc (long-context, single doc), sections-then-merge (map-reduce, over-window), running summary (refine, order matters).
Evaluation & governance
Gen AI Evaluation Service
Vertex service scoring outputs: LLM-as-judge metrics (groundedness, faithfulness, coverage, summarization quality), reference metrics (ROUGE/BLEU), rubric metrics; pointwise + pairwise.
LLM-as-judge / autorater
Using a model to score another model's output against criteria; it explains its scores.
Judge calibration
Checking the autorater against human labels so leadership trusts the eval, not just the model. A senior move — say it.
Faithfulness / groundedness
Does every claim trace to the source? (No invented facts.)
Coverage
Did the summary capture all material facts? (Nothing important dropped.)
Golden set / golden queries
Human-verified reference examples (summaries or NL→SQL pairs) used to evaluate and to steer the model toward correct business logic.
Human-in-the-loop (HITL)
A required human checkpoint before output is used. Operationalizes "AI informs, humans decide."
Guardrails
Constraints (instructions, grounding, refusal rules, access controls) that keep outputs safe/correct.
Observability / audit log
Logging prompts, retrieved context, generated SQL, citations, confidence, eval scores, human overrides — the evidence trail for CIO + regulators.
BI / analytics ("BI Command")
Looker
Google's enterprise BI platform. Its semantic layer (LookML) is the trust backbone for NL analytics.
LookML
Looker's modeling language defining governed metrics, joins, field definitions once — so AI answers align with official definitions instead of guessing SQL.
Semantic layer
The governed map from business terms ("loss ratio", "PIP exposure") to schema. The single biggest determinant of NL-to-SQL accuracy.
Conversational Analytics (in Looker)
Chat-with-your-data grounded in LookML; respects permissions/hidden fields; Python interpreter for forecasting.
Conversational Analytics API
Programmable endpoint (geminidataanalytics.googleapis.com) to build data agents you embed in your own apps ("BI Command"). Sources: BigQuery, Looker, AlloyDB, Spanner, Cloud SQL.
Gemini in BigQuery
AI features (incl. Conversational Analytics) embedded directly in BigQuery Studio.
BigQuery
Google's serverless data warehouse; the likely home of CURE's analytics data.
NL-to-SQL / Text-to-SQL
Plain-English question → database query. The cliff: ~85%+ on benchmarks collapses to 10–20% on real enterprise schemas. Fix = semantic layer + golden queries, not a bigger model.
Execution accuracy / consistency
BI eval metrics: does the query return the correct result, and does the same question return the same query every time?
Gems
Gem
A saved persona + system instruction + up to 10 knowledge files on a stock Gemini model. Not a model, not fine-tuning, not a pipeline.
Gem Manager
Where you create/edit Gems (gemini.google.com → Gems → New Gem).
Persona / Task / Context / Format
Google's official four-pillar structure for writing Gem instructions.
Knowledge files
Up to 10 reference docs a Gem retrieves from via RAG. Silent fallback to general training if the query doesn't match.
Shared / enterprise Gems
Shared Drive-style (Viewer/Editor), admin-gated. No org-wide catalog, no versioning.
Data, security & insurance
Connector
An integration pulling a source (Drive, SharePoint, Confluence, Jira, ServiceNow, Salesforce, Slack…) into Gemini Enterprise search.
Data store
The indexed repository behind a connector (one per entity type).
Ingestion vs Federation
Ingestion copies/indexes data (higher quality; pick region + encryption); Federation queries the source live (less storage, lower quality).
Permissions-aware search
Answers enforce each user's source-system access (ACLs) via identity sync. Critical for claims PII.
CMEK
Customer-Managed Encryption Keys — you control the keys for indexed data.
VPC Service Controls (VPC-SC)
Network perimeter controls to prevent data exfiltration.
Sensitive Data Protection (Cloud DLP)
Detects + de-identifies PII/PHI (redact, mask, tokenize, format-preserving encryption). De-identify before text reaches the LLM.
PII / PHI
Personally Identifiable Information / Protected Health Information. Auto insurers handle PHI via medical/PIP records.
HIPAA BAA
The Business Associate Agreement that must cover every service in the path (Document AI, Gemini, storage) when handling medical/PIP data.
Zero Data Retention (ZDR)
Configurable option so prompts/outputs aren't retained.
FNOL (First Notice of Loss)
The initial claim report; a core "document to summarize."
PIP (Personal Injury Protection)
No-fault medical coverage in NJ auto; involves medical records → PHI → why DLP + HIPAA matter.
Subrogation
Recovering claim costs from an at-fault third party. CURE signed a Gigaforce agentic-AI subrogation deal Feb 2026.
Loss ratio / combined ratio
Core insurance metrics; the kind of governed definitions a semantic layer must pin down for BI.
No terms match — try a shorter word.
9 One-glance cheat sheet
Glance at this right before the call.
Say these
- "AI informs, humans decide."
- "Agentspace became Gemini Enterprise; Vertex became the Agent Platform."
- "The Gem is the prototype and the spec; Vertex is the production home."
- "NL-to-SQL lives or dies on the semantic layer — how mature is your LookML?"
- "Every answer ships with a citation, a confidence score, and a human checkpoint."
- "I'll confirm current status in your tenant / with your Google account team."
Remember
- Gemini Enterprise = enterprise search + assistant + agents (the class).
- Gems = persona + ≤10 files, no external API. ≈ Claude Project.
- Gemini CLI = Claude Code. GEMINI.md = CLAUDE.md. MCP = MCP.
- Summarizer: Document AI → DLP → RAG/long-context → grounding → eval → human.
- Don't quote prices / model IDs / GA-status as fact — verify.
- Rate + contract = ITG/Kamlesh, not Douglas.
If you remember one thing
You are not the guy learning Gemini. You are the senior builder who already knows how to make agentic AI safe in production, and who speaks Gemini fluently enough to prove the concepts transfer. Ask sharp questions, mirror his "informs not decides" posture, and offer one concrete first slice. That's the whole game.