Senior Forward Deployed Engineer, Gemini Enterprise Platform (GCP)

Role
Summary

You are the
engineer who makes the outcome real. As a Senior Forward Deployed Engineer, you
take a client's use case from a whiteboard to a governed, evaluated agent that
people genuinely use — and you measure your work by the value it creates, not
the code you shipped. Embedded with the client, you build the agents, the tools
they call and the context graph they reason over on the Gemini Enterprise Agent
Platform: composing them in ADK or on an Agent Garden template, grounding them
on a BigQuery or Spanner Graph foundation, wiring them to data and systems
through MCP, deploying on Agent Engine / Cloud Run / GKE, and publishing them
into the client's Gemini Enterprise catalog.

You are
close enough to the client's engineers to pair with them, and close enough to
the platform to debug a failing agent trajectory — and disciplined enough to
leave behind something the client can own, trust and extend.

This role
exists because the value of a Gemini Enterprise program is realised one
working, adopted agent at a time — and that takes an engineer who can build to
a production bar and operate credibly inside a client's environment.

Deployment
Model

Embedded in
a client engagement, usually alongside a Principal Forward Deployed Architect
who owns the overall design. You pair with the client's own engineers and are
expected to leave them able to maintain and extend what you built. Some
pre-sales support is expected — proofs of concept, demos and effort inputs.

Key
Responsibilities

Agent
build

- Build agents ground-up in ADK
and by forking and hardening Agent Garden templates — defining
instructions, model selection (Model Garden), tools, orchestration
(LLM-driven and deterministic workflow agents), grounding and memory.

- Select and bind models per
agent or per step for cost and latency; implement structured output,
thinking-level and safety configuration.

- Run evaluation and simulation
before ship — trajectory and response metrics, synthetic-user simulation —
and act on Agent Optimizer findings.

Tools,
MCP and integration

- Build MCP servers to expose
client systems and data as agent tools; integrate off-the-shelf and
third-party MCP servers; wire OpenAPI and Google Cloud toolsets.

- Implement multi-agent (A2A)
hand-offs where the design calls for them.

Context
graph and data

- Build the context-graph
foundation on BigQuery graph (GQL) and/or Spanner Graph, and the retrieval
/ grounding path (Vertex AI, Vector Search, Embeddings, RAG) that connects
it to agents.

- Build and operate the
supporting data stack: BigQuery models, Dataform pipelines, Dataproc jobs
and Pub/Sub streams, with cataloguing, lineage and classification in
Dataplex Universal Catalog / Knowledge Catalog.

Deploy,
operate and adopt

- Deploy agents to Agent Engine,
Cloud Run or GKE via the Agents CLI and infrastructure-as-code; instrument
observability (Cloud Trace / OpenTelemetry); apply governance (Model
Armor, Semantic Governance, Agent Identity).

- Publish agents into the
client's Gemini Enterprise app catalog and configure Google Workspace
integration.

- Support adoption: onboarding
materials, runbooks, and pairing with client users and engineers.

Outcome
Ownership

You own the
outcome of what you build — through production, handover and adoption.
Grounded, evaluated, governed, deployed, documented, and actually used. When
one of your agents fails, regresses or breaches a policy in production, you own
the fix and the honest post-incident note.

Technical
Environment

Area

Technologies

Agent build (GEAP)

ADK (Python), Agent Garden templates, Agent Studio,
Agents CLI, agent types & orchestration, tools (FunctionTool,
OpenAPIToolset, McpToolset), Model Garden model selection

MCP & integration

MCP server development, off-the-shelf and
third-party MCP servers, A2A, OpenAPI, Google Cloud connectors / toolsets

Context graph & retrieval

BigQuery graph (GQL), Spanner Graph, Vertex AI
Vector Search, embeddings, RAG / grounding pipelines, entity resolution

Data engineering

BigQuery (SQL), Dataform, Dataproc (Spark), Pub/Sub,
Python, Dataplex Universal Catalog / Knowledge Catalog

Runtime & deployment

Agent Engine, Cloud Run, GKE, Terraform, Cloud
Build, Artifact Registry, Cloud Trace / OpenTelemetry, IAM

Quality & governance

Agent Evaluation (trajectory + autoraters), Agent
Simulation, Agent Optimizer, Model Armor, Semantic Governance

Minimum
Qualifications

- Master's or Bachelor's degree
in Computer Science, Engineering or a related field, or equivalent
practical experience.

- 6+ years building and shipping
production software or data / ML systems, with strong Python.

- Hands-on experience building
LLM agents with a code-first framework (ADK preferred; LangGraph, CrewAI,
LlamaIndex or Amazon Bedrock Agents accepted) — including tools, retrieval
grounding and evaluation.

- Strong BigQuery and SQL, and
hands-on experience with at least one graph store (Spanner Graph, BigQuery
graph, Neo4j or equivalent).

- Built at least one data
pipeline in production (Dataform, Dataproc / Spark, dbt or equivalent) and
worked with a streaming / eventing system (Pub/Sub or equivalent).

- Deployed services to a managed
or container runtime (Cloud Run, GKE, Kubernetes or equivalent) with
infrastructure-as-code (Terraform).

- Client-facing or embedded
delivery experience — able to pair with a client's engineers and hand over
cleanly.

Preferred
Qualifications

- Hands-on with the Gemini
Enterprise Agent Platform — ADK, Agent Garden, Model Garden, Agent Engine,
Agent Studio, Agents CLI.

- Built or operated MCP servers,
and integrated third-party MCP servers into an agent.

- Built a retrieval / grounding
layer over a knowledge or context graph.

- Experience with Gemini
Enterprise app publishing and Google Workspace integration.

- Experience with agent
evaluation and observability at production scale (autoraters, trajectory
metrics, Cloud Trace).

- Google Cloud Professional
certification (Data Engineer, Machine Learning Engineer, or Cloud
Developer).