{"slug": "how-to-deploy-an-ai-agent-using-google-adk-in-agent-runtime-and-register-it-in", "title": "How to deploy an AI agent using Google ADK in Agent Runtime and register it in Gemini Enterprise", "summary": "A developer has published a walkthrough for packaging a Google ADK-built Corporate Policies Assistant as an installable Python distribution and deploying it to Google Cloud Agent Runtime, then registering it in Gemini Enterprise. The agent, which uses Gemini via Vertex AI and an in-memory lexical RAG system over Google Drive documents, keeps its original tools and logic while moving from local Streamlit, ADK Web and ADK CLI testing to a managed cloud environment with scalability and monitoring. The writeup also notes that connecting Streamlit to the remote agent is presented as a possible future step.", "body_md": "✋ **Note:** This article was originally published on my blog [Wiki Cloud](https://wiki-cloud.co/en/2026/11/how-deploy-ai-agent-google-adk-agent-runtime-gemini-ent).\n\nThe development of artificial intelligence agents is changing how organizations access information, automate tasks, and improve their business processes. However, building an agent is only the first step. To make the most of its potential, we need an environment where it can run continuously, serve different users, and support important requirements such as security, scalability, and monitoring.\n\nIn this context, deploying AI agents to the cloud allows us to move from a solution developed locally to an enterprise application capable of supporting an organization's needs.\n\nIn the [previous article](https://wiki-cloud.co/en/2026/11/build-ai-agent-with-google-adk/), we built a **Corporate Policies Assistant** using **Google ADK, Gemini, Google Drive, and Streamlit**. We learned how to query corporate documents using an in-memory lexical RAG system and generate natural-language answers with references to their original sources.\n\nNow we'll take the next step: deploy our agent to **Google Cloud Agent Runtime**, a managed service that allows us to run it in the cloud without relying on our local computer, and then integrate it with **Gemini Enterprise** so users can access the assistant through an enterprise platform.\n\nWe won't rebuild the application or the tools developed previously. Instead, we'll focus on preparing the agent for deployment, validating its operation in the cloud, and publishing it in Gemini Enterprise.\n\nFor this hands-on exercise, we'll continue using Windows, PowerShell, Python 3.12, and the same [project repository](https://github.com/johnbulla/google-adk-gemini-corporate-policies-agent). Both Spanish and English versions of the project are available in the repository.\n\nThe goal of this exercise is to continue developing our Corporate Policies Assistant by reusing the agent built with Google ADK, deploying it to **Google Cloud Agent Runtime**, and then integrating it with **Gemini Enterprise**.\n\nTo achieve this, we'll package the agent as an installable Python distribution so that its logic and dependencies can run in a managed cloud environment. Google Drive will remain our document repository, while Gemini, through Vertex AI, will interpret queries and generate responses.\n\n*Figure 1 – Target architecture of the Corporate Policies Assistant.*\n\nIn the previous article, we tested the assistant locally in three ways: **Streamlit**, through a custom web interface; **ADK Web**, which allowed us to interact with the agent and observe how its tools were executed; and **ADK CLI**, which we used to submit queries directly from the command line.\n\nThese tests helped us validate the integration between the different components and confirm that the agent could retrieve information from corporate policies through RAG, generate natural-language answers, and provide references to the documents it consulted.\n\nIn this second part, we'll evolve the architecture without changing its core functionality. Google Cloud Agent Runtime will host the agent in a managed environment that supports availability, scalability, and monitoring. Gemini Enterprise will add a new access layer for business users, allowing them to interact with the assistant without using development tools directly.\n\nIn this way, we'll preserve the solution built previously while making it available to more users across the organization.\n\nGoogle ADK will continue to coordinate the conversation and execute the policy search tool, while our RAG system will retrieve relevant information from documents stored in Google Drive. Gemini will use that content as context to produce grounded responses. This integration takes us from an agent validated on a local computer to a solution accessible through Gemini Enterprise.\n\n**Architecture note:** Connecting Streamlit to the remote agent is presented as a possible future enhancement. The Streamlit integration developed in the previous article ran the agent locally.\n\nTo deploy our Corporate Policies Assistant to Google Cloud and integrate it with Gemini Enterprise, we'll follow seven stages. As shown below, we'll first prepare the environment and package the agent, then deploy it to Agent Runtime, validate it with remote tests, and finally publish it in Gemini Enterprise for authorized users within the organization.\n\n*Figure 2 – Agent implementation and deployment phases.*\n\nBefore continuing, we'll assume that the local application is already responding correctly, that the policy documents are stored in an authorized Google Drive folder, and that the project's virtual environment has the dependencies listed in `requirements.txt` installed.\n\nFor deployment, we'll need a Google Cloud project with billing enabled, Google Cloud CLI, permissions to create Agent Runtime resources, a service account for runtime execution, and a Cloud Storage bucket for temporary artifacts. The user performing the deployment must also have permission to use the service account.\n\nBefore configuring the Google Cloud resources, we'll define a few PowerShell variables to use throughout the deployment. These variables identify our project, region, storage bucket, service account, and Google Cloud user. This makes the commands easier to run without repeatedly entering the same values.\n\nSimply replace the placeholders with the values for your Google Cloud environment.\n\n``` php\n# Google Cloud project\n$PROJECT_ID = \"YOUR_PROJECT_ID\"\n\n# Deployment region\n$REGION = \"europe-west1\"\n\n# Cloud Storage bucket\n$BUCKET_NAME = \"YOUR_STAGING_BUCKET_NAME\"\n\n# Agent service account\n$SA_NAME = \"YOUR_SERVICE_ACCOUNT_NAME\"\n$SA_EMAIL = \"$SA_NAME@$PROJECT_ID.iam.gserviceaccount.com\"\n\n# Staging bucket URI\n$STAGING_BUCKET = \"gs://$BUCKET_NAME\"\n\n# Google Cloud user\n$USER_EMAIL = \"YOUR_USER@YOUR_DOMAIN.com\"\n```\n\nBefore deploying our agent, we need to configure access to the Google Cloud project we'll be using. Open a PowerShell terminal in Visual Studio Code and run the following commands to verify the Google Cloud CLI installation, sign in, and select the project.\n\n```\ngcloud --version\ngcloud auth login\ngcloud config set project $PROJECT_ID\ngcloud auth application-default login\ngcloud auth application-default set-quota-project $PROJECT_ID\n```\n\nWe'll use **Application Default Credentials (ADC)**, a Google Cloud authentication mechanism that allows Python applications and libraries to obtain credentials automatically when accessing Google services.\n\nThe two sign-in commands serve different purposes: `gcloud auth login` authenticates the Google Cloud CLI, while `gcloud auth application-default login` configures the ADC credentials used by our deployment script. Finally, setting the quota project associates API usage with the selected project and helps avoid warnings about user credentials without an associated quota project, provided we have the necessary permissions.\n\nOnce access to the project is configured, we'll enable the APIs needed to deploy and run the agent on Agent Runtime and integrate it with Gemini Enterprise. These APIs provide access to the AI, storage, authentication, and enterprise resources used by our solution.\n\nRun the following command from PowerShell:\n\n```\ngcloud services enable `\n  aiplatform.googleapis.com `\n  storage.googleapis.com `\n  cloudresourcemanager.googleapis.com `\n  iam.googleapis.com `\n  iamcredentials.googleapis.com `\n  drive.googleapis.com `\n  discoveryengine.googleapis.com `\n  logging.googleapis.com `\n  --project=$PROJECT_ID\n```\n\nThis command enables the services required for Vertex AI and Agent Runtime, storing deployment artifacts in Cloud Storage, managing identities and permissions with IAM, reading documents from Google Drive, and integrating our agent with Gemini Enterprise. We also enable Cloud Logging so we can review execution logs.\n\nKeep in mind that enabling APIs does not automatically grant access permissions. We'll configure those separately using the appropriate IAM roles.\n\nNext, we'll create a Google Cloud Storage bucket to serve as temporary storage during the deployment to Agent Runtime. It will hold the Python packages and artifacts needed to prepare and deploy our agent.\n\n```\ngcloud storage buckets create $STAGING_BUCKET `\n  --project=$PROJECT_ID `\n  --location=$REGION `\n  --uniform-bucket-level-access\n```\n\nIn this example, we'll use `europe-west1` and enable uniform bucket-level access, which allows access permissions to be managed through IAM. Replace the example bucket name with a globally unique name and the project placeholder with your actual project ID.\n\nIf the bucket already exists, there's no need to create it again. We only need to confirm that we have the permissions required to use it during deployment.\n\nWith storage ready, we'll create a **service account** for our Corporate Policies Assistant to use when it runs on Google Cloud Agent Runtime. This gives the agent its own identity for accessing authorized Google Cloud services without relying on the developer's personal credentials.\n\nRun the following PowerShell command using the variables defined earlier:\n\n```\ngcloud iam service-accounts create $SA_NAME `\n  --display-name=\"Corporate Policies Agent Runtime\" `\n  --project=$PROJECT_ID\n```\n\nThis creates the service account used by the deployed agent. Its email address follows this pattern: `YOUR_SERVICE_ACCOUNT_NAME@YOUR_PROJECT_ID.iam.gserviceaccount.com`.\n\nNext, we'll grant the `roles/aiplatform.user` role so the agent can use the Vertex AI services required to interact with Gemini.\n\n```\ngcloud projects add-iam-policy-binding $PROJECT_ID `\n  --member=\"serviceAccount:$SA_EMAIL\" `\n  --role=\"roles/aiplatform.user\"\n```\n\nWe use this role in the demo to simplify execution. For production environments, we should evaluate more specific permissions and follow the principle of least privilege.\n\nBesides interacting with Gemini, our agent needs to read the documents stored in Google Drive. To enable this, share the corporate policies folder with the service account's email address and grant **Viewer** access, provided that your Google Workspace policies allow it.\n\nRemember that Google Drive permissions are managed separately from Google Cloud IAM roles. Assigning `roles/aiplatform.user` does not automatically grant access to documents.\n\nIn the previous article, we used a JSON credentials file to run the agent locally. This time, we'll use the identity attached to Agent Runtime and Application Default Credentials (ADC), avoiding private keys in the deployment package.\n\nThis gives our agent a dedicated identity for accessing authorized services and running more securely in Google Cloud.\n\nAfter configuring the service account, we need to ensure that our Google Cloud user has permission to deploy the agent and run tests from PowerShell.\n\nIt's important to distinguish these identities: the service account is used when the agent runs, while our user prepares the deployment, creates the Agent Runtime resource, and verifies that it works.\n\nFor this lab, we'll use the following roles:\n\n| IAM role | Description | \n|---|---|\n| `roles/aiplatform.user` | Allows the user to access Vertex AI and Agent Runtime services, interact with Gemini models, and send queries to deployed agents. | \n| `roles/aiplatform.sessionUser` | Allows the user to create and manage conversation sessions with agents deployed on Agent Runtime. | \n\nRun these commands from PowerShell:\n\n```\ngcloud projects add-iam-policy-binding $PROJECT_ID `\n  --member=\"user:$USER_EMAIL\" `\n  --role=\"roles/aiplatform.user\"\ngcloud projects add-iam-policy-binding $PROJECT_ID `\n  --member=\"user:$USER_EMAIL\" `\n  --role=\"roles/aiplatform.sessionUser\"\n```\n\nBefore moving on to deployment in Google Cloud Agent Runtime, let's briefly review the project structure and identify the files we'll need for this stage. Since we already developed the agent and its main components in the previous article, we don't need to change its architecture or rebuild its functionality.\n\nWe'll focus on the files responsible for creating the Python package, deploying the agent, and checking that it works once it's running in the cloud.\n\nTo make the process easier to follow, here's a simplified view of the repository highlighting the deployment and test files.\n\n```\ngoogle-adk-gemini-corporate-policies-agent/\n├── requirements.txt\n├── sources_en/\n│   ├── .env\n│   ├── corporate_agent/          # Previously developed agent code\n│   ├── pyproject.toml            # Wheel package metadata\n│   ├── deployment/\n│   │   ├── deploy_agent.py\n│   │   └── runtime_resource.txt  # Created after deployment\n│   └── test/\n│       └── test_runtime.py\n└── sources_es/                   # Equivalent Spanish version\n```\n\n| File | Description | \n|---|---|\n| `sources_en/pyproject.toml` | Defines the installable `corporate-policies-agent` package and specifies that`corporate_agent` must be included. | \n| `sources_en/deployment/deploy_agent.py` | Validates the environment, builds the wheel, deploys `AdkApp` , and saves the remote resource path. | \n| `sources_en/deployment/runtime_resource.txt` | Output file containing the full path of the created resource. | \n| `sources_es/test/test_runtime.py` | Retrieves the remote resource reference, connects to Agent Runtime, and sends test queries. | \n| `requirements.txt` | Contains the project's dependencies; the script also specifies those required by the runtime. | \n\nWith our project ready, the next step is to review the environment variables used to deploy the agent to Google Cloud Agent Runtime and verify that it works. These settings identify the project and region where the agent will run, the resources it needs, and how it will authenticate to Google Cloud services.\n\nSince we configured the variables for local development in the previous article, we'll focus only on those related to cloud deployment and testing.\n\n| Variable | Description | \n|---|---|\n| `GOOGLE_CLOUD_PROJECT` | Identifies the Google Cloud project where we'll deploy our agent. | \n| `AGENT_RUNTIME_LOCATION` | Defines the Google Cloud region where the agent will run. In this demo, we'll use `europe-west1` . | \n| `AGENT_RUNTIME_STAGING_BUCKET` | Specifies the Cloud Storage bucket used to temporarily store deployment files. Its format is `gs://YOUR_STAGING_BUCKET` . | \n| `AGENT_RUNTIME_SERVICE_ACCOUNT` | Contains the email address of the service account the agent will use to access authorized Google Cloud resources. | \n| `GOOGLE_GENAI_USE_VERTEXAI` | Indicates that the agent will connect to Gemini through Vertex AI. We'll set it to `TRUE` in Agent Runtime. | \n| `GEMINI_MODEL` | Specifies the Gemini model used to process queries and generate answers. Our project uses `gemini-3.5-flash-lite` as its default, provided the model is available to the project. | \n| `GEMINI_VERTEX_LOCATION` | Specifies the location used for Gemini model inference. In this example, we'll use `global` , which can differ from the Agent Runtime deployment region. | \n| `DRIVE_AUTH_MODE` | Controls how the agent authenticates to Google Drive. We'll use `adc` to rely on the runtime's identity without including a JSON credentials file. | \n| `AGENT_RUNTIME_RESOURCE` | Optionally specifies the deployed agent resource for remote tests. If omitted, `test_runtime.py` can also read it from`deployment/runtime_resource.txt` . | \n\nWe'll also retain `GOOGLE_DRIVE_FOLDER_ID` and `RAG_REFRESH_INTERVAL_SECONDS`, which were introduced in the previous article. The first identifies the Google Drive folder containing our corporate policies, while the second sets the refresh interval for the agent's RAG index.\n\nBefore deploying our Corporate Policies Assistant to Google Cloud Agent Runtime, we need to prepare its code so it can be installed and run in the cloud. To do that, we'll use a **wheel package (`.whl`)**, a Python distribution format that bundles an application's code and metadata into an installable file.\n\nWheel packages make it easier to distribute and install Python applications because they contain the files the target environment needs to recognize and import their modules. In our project, this mechanism will let us deploy the `corporate_agent` code to Agent Runtime and ensure its components can be imported correctly during execution.\n\nTo build the wheel, we'll use `pyproject.toml`, located in both the `sources_en/` and `sources_es/` directories. This file contains the configuration needed to build and distribute our agent as a Python package.\n\nIt defines `setuptools` as the build tool, sets the package name to `corporate-policies-agent`, and specifies that the `corporate_agent` module must be included, along with its main files such as `__init__.py`, `agent.py`, and `drive_rag.py`.\n\nThis allows Python to recognize and install our agent in the remote environment without manually copying files or changing the imports implemented earlier.\n\nBefore deployment, let's make sure our virtual environment has the tools required to build the wheel package.\n\nFrom the Visual Studio Code PowerShell terminal, run:\n\n```\ncd C:\\Projects\\google-adk-gemini-corporate-policies-agent\n.\\.venv\\Scripts\\Activate.ps1\npython -m pip install --upgrade setuptools wheel\npython -m pip check\n```\n\nThese commands activate the virtual environment, install or update the packaging tools, and check for dependency conflicts.\n\nWe won't need to build the wheel manually, because `deployment/deploy_agent.py` already handles this task, as we'll see in the next section.\n\nWhen executed, the script temporarily builds the `.whl` file, verifies that it includes the agent's main files, and adds it to the dependencies installed in Agent Runtime.\n\nThis also helps ensure compatibility between our Windows development environment and the Linux environment used by Agent Runtime, avoiding absolute local paths that won't exist in the cloud.\n\nWith this approach, our agent's code will be ready for installation in Agent Runtime while retaining its original structure and without having to rebuild the components developed in the previous article.\n\nNow that we've prepared the Google Cloud resources and configured the agent's packaging process, we're ready to deploy it to Agent Runtime. We'll use `deploy_agent.py` to perform the necessary checks, prepare the code and its dependencies, and create the agent in Google Cloud's managed environment.\n\nThis file is located at `sources_en/deployment/deploy_agent.py` (English version) or `sources_es/deployment/deploy_agent.py` (Spanish version). It is organized into nine main blocks, summarized below.\n\n| Block | Description | \n|---|---|\n| **1. Imports and project environment variables** | Imports the libraries required for deployment and loads configuration variables from `.env` . It also identifies reserved variables managed automatically by Agent Runtime that should not be passed into the remote agent configuration. | \n| **2. Configuration loading and validation** | Checks that all required information is available, including the project ID, staging bucket, service account, and Google Drive folder. These checks help catch incomplete settings before creating cloud resources. | \n| **3. Authentication environment preparation** | `prepare_deployment_environment()` configures the use of Vertex AI and prepares ADC authentication. It also prevents accidental use of an API key or local JSON credentials. | \n| **4. Credentials and Cloud Storage access checks** | `verify_deployment_credentials()` verifies that valid ADC credentials are available and confirms access to the staging bucket. | \n| **5. Remote agent environment variables** | `build_runtime_env()` prepares the Gemini model settings, ADC authentication, Google Drive document location, and RAG index refresh interval. | \n| **6. Wheel package generation** | `build_agent_wheel()` builds the installable agent package, verifies that the main files are included, and prepares its paths for the remote environment. | \n| **7. Agent Runtime resource creation** | `AdkApp` prepares the ADK agent, and`client.agent_engines.create()` creates the managed resource with its dependencies, wheel, bucket, service account, and environment variables. | \n| **8. Deployed resource identifier recording** | The script retrieves the full resource identifier and saves it to `deployment/runtime_resource.txt` for testing and later registration in Gemini Enterprise. | \n| **9. Deployment entry point** | Runs `main()` when the file is invoked as a Python module and coordinates the preceding stages. | \n\nNow that we understand what `deploy_agent.py` does, we can run the deployment. Open the PowerShell terminal in Visual Studio Code, navigate to the repository root, and make sure the virtual environment is active.\n\nFor the English version:\n\n```\n$env:PYTHONPATH = \"$PWD\\sources_en\"\npython -m sources_en.deployment.deploy_agent\n```\n\nFor the Spanish version, use the corresponding package:\n\n```\n$env:PYTHONPATH = \"$PWD\\sources_es\"\npython -m sources_es.deployment.deploy_agent\n```\n\nThis command starts the deployment using the configuration prepared earlier. During execution, the script verifies credentials, checks access to the Cloud Storage bucket, builds the wheel package, and sends the required components to Google Cloud Agent Runtime.\n\nIf everything succeeds, we'll see a message confirming that the agent was created, along with an identifier similar to the following:\n\n```\nRecurso creado:\nprojects/YOUR_PROJECT_NUMBER/locations/europe-west1/reasoningEngines/RESOURCE_ID\n```\n\nThis identifier refers to the resource created in Agent Runtime and is saved in `deployment/runtime_resource.txt`, so we won't need to copy it manually for the following tests.\n\nKeep in mind that deployment may incur Google Cloud charges and that a successful deployment doesn't necessarily mean the agent can answer queries. That's why we'll test it remotely before integrating it with Gemini Enterprise.\n\n*Figure 3 – Agent deployment in Agent Runtime.*\n\nAfter deploying our Corporate Policies Assistant, we need to verify that it runs correctly in Google Cloud and can still access the documents stored in Google Drive.\n\nWe'll use `sources_en/test/test_runtime.py` (English version) or `sources_es/test/test_runtime.py` (Spanish version) to connect to the deployed agent and submit questions from the PowerShell terminal.\n\nUnlike the tests in the previous article, these queries won't run against our local agent. They'll be sent to the resource we created in Google Cloud Agent Runtime.\n\nFrom the repository root, with the virtual environment active, run the English version:\n\n```\npython -m sources_en.test.test_runtime\n```\n\nFor the Spanish version:\n\n```\npython -m sources_es.test.test_runtime\n```\n\nThe script automatically retrieves the deployed agent's identifier and connects to Agent Runtime. If the connection is successful, the output will look similar to this:\n\n```\nProyecto: YOUR_PROJECT_ID\nRegión: europe-west1\nAgente: projects/YOUR_PROJECT_NUMBER/locations/europe-west1/reasoningEngines/RESOURCE_ID\nConexión con Agent Runtime establecida.\n```\n\nThe script will then submit several test queries, such as:\n\nDuring these tests, we need to confirm that the agent responds correctly, uses `search_corporate_policies` when it needs to retrieve information, and generates answers grounded in the documents available in Google Drive.\n\nIt's also important to inspect the events returned by Agent Runtime. A successful connection does not necessarily mean that the Gemini model request completed successfully.\n\nOnce we've completed the tests and confirmed that the agent works correctly in the cloud, we'll be ready to integrate it with Gemini Enterprise and make it available to authorized users.\n\nOnce we've deployed our Corporate Policies Assistant and confirmed that it works in Google Cloud Agent Runtime, the next step is to integrate it with Gemini Enterprise. This platform allows users across the organization to interact with our agent through a conversational interface, without having to use development tools such as Streamlit, ADK Web, or the command line.\n\nWe'll create an application in Gemini Enterprise and register the agent already deployed to Google Cloud, reusing its logic, tools, and connection to the documents stored in Google Drive.\n\nFirst, we'll create a new application in Gemini Enterprise that will serve as the entry point for our Corporate Policies Assistant.\n\nFrom the Google Cloud Console, follow these steps:\n\n`Corporate Policies Assistant`, and complete the required fields.` global`.\nDuring application creation, make sure your project has the permissions and licenses required to use Gemini Enterprise. Also note that the application's location can differ from the region where Agent Runtime is deployed, as long as the configuration is supported.\n\n*Figure 4 – Creating an application in Gemini Enterprise.*\n\nOnce created, the enterprise application will be ready for us to add the agent developed with Google ADK.\n\nWith the application created, we'll register the Corporate Policies Assistant we previously deployed to Google Cloud Agent Runtime.\n\nOpen the settings for our `Corporate Policies Assistant` application in Gemini Enterprise and follow these steps:\n\n| Field | Example value | \n|---|---|\n| **Name** | Corporate Policies Assistant | \n| **Description** | An agent that consults internal policies—covering Human Resources, Finance, Legal, Security, and other areas—based on authorized documents stored in Google Drive. | \n| **Resource path** | `projects/PROJECT_NUMBER/locations/europe-west1/reasoningEngines/RESOURCE_ID` | \n\nThe description helps identify the agent's purpose and the types of questions it can answer. The resource path establishes the connection to the agent running in Agent Runtime. It's the same identifier we obtained during deployment and saved in `deployment/runtime_resource.txt`.\n\n*Figure 5 – Registering the agent in Gemini Enterprise.*\n\nOnce the agent is registered, we'll configure its availability so authorized users or groups can access it through Gemini Enterprise.\n\nWe also need to confirm that the application has permission to invoke the agent. If Gemini Enterprise and Agent Runtime are in different Google Cloud projects, we must configure cross-project access permissions.\n\nAfter registration, we can open our Gemini Enterprise application and interact with the Corporate Policies Assistant through its conversational interface.\n\nTo verify that the integration works correctly, we'll repeat some of the questions used during our PowerShell tests, such as asking about vacation days, remote work conditions, or reimbursement procedures.\n\nDuring these tests, we should check that the agent provides coherent answers, retrieves information from documents stored in Google Drive, and includes source references when available.\n\nWe should also confirm that authorized users can access the agent and that its answers reflect the available corporate policies.\n\nIn our implementation, the agent accesses Google Drive using a service account. This means **employees' individual document permissions are not automatically applied**. If we later need to use confidential or department-restricted information, we'll need additional authorization and access-control mechanisms.\n\nWith these checks complete, we'll have integrated our Corporate Policies Assistant with Gemini Enterprise, allowing users to access the Google ADK agent from an enterprise platform while it continues to run in a managed Google Cloud Agent Runtime environment.\n\n*Figure 6 – Corporate Policies Assistant in action in Gemini Enterprise.*\n\n[View animated GIF](https://wiki-cloud.co/wp-content/uploads/2026/11/article_image_deploy_ai_agent_google_adk_agent_runtime_gemini_ent_06.gif)\n\nOnce our agent is deployed in Google Cloud Agent Runtime, we need to consider how to keep it secure and reliable. This means following the principle of least privilege, keeping sensitive credentials out of deployment artifacts, and controlling who can access the agent and corporate information.\n\nAgent Runtime also provides observability capabilities that help us monitor execution and identify problems. During this demo, we can review Google Cloud logs and metrics to examine response times, query volume, execution errors, Gemini usage, and authentication issues.\n\nWe should also remember that our RAG index is stored in memory and refreshed on demand, so changes made to Google Drive might not become available immediately across all runtime instances.\n\nIf we decide to move this solution into production, we should strengthen security controls, review document access permissions, and evaluate persistent storage, monitoring, and scaling strategies that fit the organization's requirements.\n\nThroughout this second part, we've taken an important step forward with our Corporate Policies Assistant, moving from an application developed and tested locally to a solution deployed on Google Cloud Agent Runtime and integrated with Gemini Enterprise.\n\nWe reused the agent built earlier with Google ADK, Gemini, and Google Drive, showing that we can move its existing components into a managed cloud environment without rebuilding the entire solution.\n\nThis hands-on exercise also showed why proper packaging, authentication, permissions, and post-deployment validation matter. The tests helped us identify and resolve potential issues related to dependencies, access to Google Cloud services, and Gemini model availability—all essential for a reliable integration.\n\nDeploying AI agents to the cloud creates new opportunities for organizations by making solutions developed by technical teams available to more users through platforms such as Gemini Enterprise. To realize that potential, however, we also need to consider security, scalability, observability, and agent governance.\n\nWith this implementation, we've established a practical foundation for evolving our assistant into a more robust enterprise solution capable of integrating information, tools, and business processes securely and efficiently.\n\nTo explore the concepts and procedures covered in this hands-on exercise, here are some additional resources. You'll find the demo's source code, the previous article in this series, and official Google Cloud documentation for learning more about deploying, configuring, and integrating AI agents with Agent Runtime and Gemini Enterprise:\n\nI hope you find this guide useful!\n\n**Follow us:**\n\n👉[Wiki Cloud](http://wiki-cloud.co/) | 👉[LinkedIn](https://www.linkedin.com/in/johnbulla) | 👉[X](https://x.com/johnbulla) | 👉[Github](https://github.com/johnbulla) | 👉[Youtube](https://www.youtube.com/user/johnbulla)", "url": "https://wpnews.pro/news/how-to-deploy-an-ai-agent-using-google-adk-in-agent-runtime-and-register-it-in", "canonical_source": "https://dev.to/johnbulla/how-to-deploy-an-ai-agent-using-google-adk-in-agent-runtime-and-register-it-in-gemini-enterprise-20c8", "published_at": "2026-11-18 20:33:20+00:00", "updated_at": "2026-11-18 20:42:03.566940+00:00", "lang": "en", "topics": ["ai-agents", "ai-tools", "large-language-models", "ai-products"], "entities": ["Google", "Google ADK", "Google Cloud Agent Runtime", "Gemini Enterprise", "Gemini", "Vertex AI", "Google Drive", "Streamlit"], "also_reported_by": [], "takeaway": "Packaging a Google ADK agent as an installable Python distribution lets it run on Google Cloud Agent Runtime and be registered in Gemini Enterprise without rebuilding its tools or RAG logic.", "recommendation": {"advice": "Package your ADK agent as an installable Python distribution before deploying to Agent Runtime, so its logic and dependencies run unchanged in the managed cloud environment.", "playbook": "agent-architecture", "playbook_url": "https://wpnews.pro/playbooks/agent-architecture"}, "alternates": {"html": "https://wpnews.pro/news/how-to-deploy-an-ai-agent-using-google-adk-in-agent-runtime-and-register-it-in", "markdown": "https://wpnews.pro/news/how-to-deploy-an-ai-agent-using-google-adk-in-agent-runtime-and-register-it-in.md", "text": "https://wpnews.pro/news/how-to-deploy-an-ai-agent-using-google-adk-in-agent-runtime-and-register-it-in.txt", "jsonld": "https://wpnews.pro/news/how-to-deploy-an-ai-agent-using-google-adk-in-agent-runtime-and-register-it-in.jsonld"}}