What happened
Google Cloud forward deployed engineer Neeraj Agrawal describes three authentication layers that the built-in Gemini Enterprise web application handles behind the scenes but a custom user interface must implement. In the standard application, employees sign in through Google Identity or Workforce Identity Federation, search results respect per-user access controls, and third-party login prompts appear within the chat. A custom UI embedded in an internal portal instead calls the StreamAssist API through a customer backend, making those flows the application team’s responsibility.
The first layer is authentication to StreamAssist. Google outlines three patterns. Pattern 1A uses Google Identity directly: the UI signs in the employee, and the backend sends that employee’s access token to StreamAssist. Pattern 1B uses Workforce Identity Federation when employees sign in through an external identity provider such as Microsoft Entra ID or Okta; the backend exchanges the identity-provider token at Google Security Token Service (STS) and calls StreamAssist with the resulting short-lived token representing that employee. Both human-user patterns require an active Gemini Enterprise user license, and every principal calling StreamAssist needs the Discovery Engine User IAM role on the Google Cloud project.
Pattern 1C is Workload Identity Federation for shared backend services, webhooks, or non-personalized bots. The backend obtains a machine token from an external identity provider, exchanges it at Google STS, and calls StreamAssist without keeping service-account JSON keys on disk. Google cautions that this represents a machine, not an individual: requests share that workload identity. It recommends the human-user patterns whenever per-user document ACLs, user-specific connector authorization, or restricted custom-agent permissions matter.
The second layer is consent for Federated Connectors, including Google Drive, SharePoint Online, Jira, Box, ServiceNow, and Confluence. These connectors query third-party services in real time and enforce each employee’s permissions there. The custom backend lists the engine’s connectors and checks Gemini Enterprise’s managed Keystore for valid tokens. If a token is missing, the UI presents an authorization button and opens the provider’s three-legged OAuth flow. After consent, the callback returns through Google’s managed redirect page; the backend exchanges the code and Gemini Enterprise stores the refresh token in its Keystore. Subsequent queries include the connector data-store ID. For a custom domain, Google says teams must work with their Gemini Enterprise team to enable the custom-origin handoff for the callback.
The third layer covers custom Agent Development Kit (ADK) agents deployed on Vertex AI Agent Engine. Google says static OAuth attached to the root agent registration can block the entire agent before its code runs, even when a user wants a task that does not need every connected system. Instead, teams can wrap protected sub-agent tools in ADK’s AuthenticatedFunctionTool and GcpAuthProvider, enable Agent Identity on deployment, and configure a 3LO Auth Provider in GCP Auth Manager. When a protected tool is first called, the UI obtains consent; the backend validates the user authorization, and GCP Auth Manager stores the token in its Token Vault. The backend then retries the same StreamAssist query, allowing the agent to call the tool. Google says later queries use the cached token without another popup.
The announcement links a GitHub repository called gemini-enterprise-custom-ui-auth with Python scripts, curl commands, CLI helpers, interactive test UIs, and an ADK implementation covering all three layers.
What the archive adds
New Runtime’s earlier coverage described Anthropic’s Enterprise Managed Auth allowing administrators to provision Claude connector access without per-user OAuth prompts (November 3 note). A separate note covered administrators automatically granting connector access at login (November 4 note). Google’s guide is a new event, focused on how developers build the authorization flows into a custom Gemini Enterprise interface rather than an administrator-managed Claude connector feature.
Trend signal
This does not yet fit a pattern New Runtime tracks. Google’s guide is an implementation blueprint for one platform’s custom UI and agent stack; it does not by itself establish a broader shift in how agent security or interoperability is being implemented across the market.
Why now
Google’s guide addresses a specific architectural transition: moving from the out-of-the-box Gemini Enterprise interface to a custom UI that calls StreamAssist directly. In that setup, authentication steps previously hidden by the product become application responsibilities. The timing therefore follows the needs of teams embedding enterprise search and agents into their own portals, rather than a newly announced general change to Gemini Enterprise access or pricing.
Why it matters
Authentication design determines whether an agent sees the same information and permissions as the person asking it to work. Using a shared machine identity for a personalized workflow can collapse distinctions between employees; demanding authorization for every connected tool upfront can also make a simple question needlessly difficult. Google’s separation of user identity, connector consent, and tool-level OAuth gives builders a way to match the permission boundary to the job.
The distinctions are operational, not cosmetic. Teams can keep document ACLs tied to an employee, let Gemini Enterprise own connector refresh tokens instead of storing them in their own database, and defer a custom agent’s third-party consent until a protected tool is actually needed. The runnable examples may shorten implementation work, but the architecture still requires careful setup across identity providers, Google Cloud IAM, redirect origins, and the application backend.
Limits and uncertainty
The guide documents Google’s recommended architecture and links runnable examples, but it does not report independent security testing, production adoption, or measured implementation time. It does not quantify latency added by token exchanges or consent flows, nor compare the operational cost of the three authentication patterns. Teams will need to verify that their identity-provider configuration, callback domains, IAM roles, license assignments, and third-party OAuth scopes match their own deployments. The description also does not establish whether every listed connector or external identity-provider configuration behaves identically across customer environments.
Skill to build now
Draw the identity path for one real workflow before implementing its UI: mark whether each request represents a person or a shared service, which document ACLs must apply, and which tools need third-party consent. Then implement one representative protected tool with on-demand OAuth rather than attaching credentials to the whole agent. Use the linked repository’s test UI and scripts to validate the callback, token storage, and retry sequence before extending the pattern to additional connectors.
Reader takeaway
A custom enterprise agent interface inherits an authentication system, not just a chat window. Keep human identity where permissions are personal, reserve workload identity for genuinely shared bots, and request third-party access at the connector or tool boundary that needs it.