Google Cloud Blueprint: Building full virtual vehicles on Google Cloud: From AAOS — How Does It Work in Production?

TL;DR: The automotive industry is fundamentally shifting from hardware-bound, physical test benches to fully virtualized, cloud-native vehicle development. By combining Google Cloud’s Arm-based Axion C4A bare-metal instances, RemotiveLabs’ virtualized E/E topologies, and the Agent Development Kit (ADK 2.0) orchestrating Vertex AI Gemini 2026 models, engineering teams can now simulate, test, and integrate entire vehicle software stacks—from Android Automotive OS (AAOS) down to the smallest microcontrollers—entirely in the cloud. This architectural blueprint eliminates the physical hardware bottleneck, enabling continuous integration from day one and compressing integration cycles by an order of magnitude.

What Google Cloud Shipped & The Enterprise Problem It Solves

In our architectural evaluation of modern automotive engineering, a glaring paradox consistently emerges: manufacturers aggressively market "software-defined vehicles" (SDVs), yet their internal development pipelines remain inextricably tethered to physical hardware. While high-level infotainment systems and digital cockpits have successfully transitioned to cloud-native development paradigms, the underlying electrical and electronic (E/E) architecture—comprising dozens of microchips, zone control units, gateways, and sensor nodes—remains stubbornly hardware-dependent.

Historically, developers have been forced to wait for physical test benches, hardware samples, and complex physical rigs before they can validate cross-domain interactions. This hardware-in-the-loop (HIL) dependency pushes critical integration testing to the very end of the development lifecycle, a phase where discovering a defect is exponentially more expensive and time-consuming to remediate. If an Advanced Driver Assistance System (ADAS) event fails to properly surface in the digital cluster, or if a driver-mode change fails to ripple correctly across chassis nodes, discovering this anomaly on a physical test track rather than in a continuous integration pipeline represents a massive failure of engineering velocity.

To dismantle this bottleneck, Google Cloud has shipped a comprehensive, full-stack virtualization ecosystem. As detailed in the Google Cloud Manufacturing Blog, the solution centers on the Horizon platform and strategic partnerships with entities like RemotiveLabs. The Android team has already proven the viability of cloud-based cockpit development by running Android Automotive OS (AAOS) inside Cuttlefish—Google’s official virtual testing environment—deployed on Arm-based Google Cloud instances. Because the cloud infrastructure and the physical vehicle share the same Arm instruction set, developers achieve true environmental parity. Google’s Axion C4A bare-metal instances provide direct hardware access without virtualization overhead, delivering the deterministic performance required for rigorous automotive systems development.

However, the cockpit is only one domain. The critical breakthrough is RemotiveTopology, which acts as the digital harness around the virtual vehicle. It ingests a manufacturer's existing network design files and automatically provisions a working, virtualized version of the car's entire E/E architecture. This is "vehicle-as-code." When combined with the Agent Development Kit (ADK 2.0), engineering teams can deploy autonomous AI agents powered by Vertex AI Gemini models to continuously monitor, inject signals, and validate cross-domain interactions across this virtualized network.

Real-World Use Cases: Where This Moves the Needle in the Field

The implications of this architecture extend far beyond automotive manufacturing. The underlying principles of virtualized hardware, agentic orchestration, and high-throughput simulation solve critical engineering challenges across multiple enterprise verticals.

1. High-Throughput Enterprise Workloads: Isolating Tail-Latency in Telemetry Simulation

The Everyday Problem: In IoT-heavy industries like logistics, smart grid management, and fleet operations, validating backend systems against massive, concurrent telemetry spikes is notoriously difficult. Traditional load-testing tools generate synthetic, predictable traffic that fails to mimic the chaotic, stateful nature of real-world device fleets, leading to unexpected tail-latency and system degradation during actual production bursts. How It Works in Practice: By leveraging Cloud Run to host ADK 2.0 agents, enterprises can spin up thousands of concurrent, stateful virtual devices. Each Cloud Run instance acts as a discrete node (e.g., a smart meter or a delivery vehicle), maintaining its own state and generating complex, interdependent telemetry. Using Cloud Run's Direct VPC egress, these virtual nodes communicate securely with backend BigQuery or Spanner instances. The ADK agents, utilizing Gemini 3.8 Flash for rapid decision-making, dynamically alter their telemetry based on simulated environmental conditions. The Tangible Impact: Engineering teams can simulate highly realistic, stateful burst traffic, identifying database locking issues and API rate-limiting thresholds before they impact production. This deterministic simulation isolates tail-latency boundaries, ensuring the backend can handle chaotic real-world loads without degradation.

2. Zero-Trust Governance & IAM: Enforcing Boundaries in Multi-Tenant CI/CD

The Everyday Problem: When multiple engineering teams (e.g., ADAS, Infotainment, Powertrain) share a cloud-based continuous integration environment, maintaining strict data isolation and least-privilege access is a logistical nightmare. A compromised dependency in the infotainment build pipeline could theoretically access sensitive proprietary algorithms in the ADAS repository. How It Works in Practice: The virtual vehicle architecture enforces strict Zero-Trust boundaries using Google Cloud's native security primitives. Each domain's simulation runs in an isolated Cloud Run service or GKE namespace, governed by a dedicated, least-privilege Service Account. VPC Service Controls (VPC SC) establish a secure perimeter around the entire simulation environment, preventing data exfiltration even if an internal component is compromised. ADK agents are restricted via IAM to only invoke specific Vertex AI models and access designated BigQuery datasets. The Tangible Impact: Security and compliance teams achieve granular, cryptographically enforced isolation between engineering domains. This Zero-Trust posture prevents lateral movement, satisfies stringent automotive regulatory requirements (such as ISO/SAE 21434), and allows multiple teams to innovate concurrently without compromising intellectual property.

3. Production FinOps & Unit Economics: Optimizing Cost-Per-Test in Agentic Workflows

The Everyday Problem: Running continuous, high-fidelity simulations using Large Language Models (LLMs) can rapidly spiral out of financial control. If an engineering team runs 10,000 integration tests a month, and each test utilizes a heavy, always-on reasoning model, the cloud bill will quickly erode the ROI of the virtualization initiative. How It Works in Practice: The architecture utilizes a tiered, FinOps-aware approach. For rapid, high-volume signal validation and basic telemetry parsing, the system deploys event-driven ADK agents on Cloud Run, utilizing the highly cost-effective Gemini 2.5 Flash model. Cloud Run scales to zero when tests are not actively running, eliminating idle compute costs. For complex, multi-domain anomaly detection that requires deep reasoning, the system selectively routes tasks to Gemini 2.5 Pro or Gemini 3.1 Pro-Preview. The Tangible Impact: By aligning the compute primitive (Serverless vs. Always-On) and the cognitive engine (Flash vs. Pro) with the specific complexity of the task, enterprises optimize their unit economics. This tiered strategy reduces the cost-per-test by up to 90%, making continuous, AI-assisted integration financially viable at an enterprise scale.

Reference Architecture on Google Cloud

When we inspect production topologies for virtual vehicle integration, the architecture must seamlessly bridge deterministic Linux-based simulation with adaptive, agentic AI reasoning. The following reference architecture illustrates how Google Cloud services interact to provide a scalable, secure, and highly observable virtual E/E environment.

flowchart LR
    subgraph Ci_Cd_Pipeline["CI/CD & Developer Environment"]
        GitRepo["Source Code (Git)"]
        CloudBuild["Cloud Build (Triggers)"]
    end

    subgraph Serverless_Agent_Layer["Agentic Orchestration (Cloud Run)"]
        ADK_Agent["ADK 2.0 Agent<br/>(Python / LlmAgent)"]
        CloudRun["Cloud Run Service<br/>(Direct VPC Egress)"]
        ADK_Agent --- CloudRun
    end

    subgraph Virtual_Vehicle_Environment["Virtual Vehicle Simulation (Axion C4A)"]
        Cuttlefish["Cuttlefish<br/>(Virtual Android Env)"]
        AAOS["Android Automotive OS<br/>(Cockpit Domain)"]
        RemotiveTopology["RemotiveTopology<br/>(E/E Network Simulation)"]
        Cuttlefish --- AAOS
        AAOS <--> RemotiveTopology
    end

    subgraph Ai_Cognitive_Engine["Vertex AI (2026 Models)"]
        GeminiFlash["Gemini 2.5 Flash<br/>(High-Throughput Parsing)"]
        GeminiPro["Gemini 2.5 Pro<br/>(Deep Reasoning)"]
    end

    subgraph Data_Observability["Data & Analytics"]
        BigQuery["BigQuery<br/>(Telemetry & Test Results)"]
        CloudLogging["Cloud Logging & Trace"]
    end

    GitRepo -->|Push| CloudBuild
    CloudBuild -->|Deploy Container| CloudRun
    CloudRun <-->|Inject Signals / Read State| RemotiveTopology
    CloudRun <-->|Prompt / Tool Calls| GeminiFlash
    CloudRun <-->|Complex Analysis| GeminiPro
    RemotiveTopology -->|Stream Telemetry| BigQuery
    CloudRun -->|Write Results| BigQuery
    CloudRun -.->|Emit Metrics| CloudLogging

Architectural Component Breakdown

1. Virtual Vehicle Simulation (Axion C4A): At the core of the architecture are Google Cloud's Axion C4A bare-metal instances. These Arm-based servers host Cuttlefish, which runs the Android Automotive OS (AAOS) exactly as it would execute on the physical vehicle's infotainment hardware. RemotiveTopology runs alongside Cuttlefish, simulating the CAN/LIN/Ethernet networks and the various microcontrollers (body controllers, ADAS nodes).
2. Agentic Orchestration (Cloud Run & ADK 2.0): The testing logic is not hardcoded; it is orchestrated by autonomous agents built using the Agent Development Kit (ADK 2.0). These agents are containerized and deployed on Cloud Run. Cloud Run provides a serverless execution environment that can instantly scale to thousands of concurrent instances to run parallel test suites, and scale to zero when idle. Direct VPC egress ensures that the agents can communicate securely with the Axion instances over private IP space.
3. AI Cognitive Engine (Vertex AI): The ADK agents leverage Vertex AI's 2026 model lineup. For high-volume, low-latency tasks—such as parsing standard CAN bus signals or verifying basic state changes—the agents utilize gemini-2.5-flash. For complex, multi-domain integration analysis—such as determining why an ADAS object list failed to render correctly on the AAOS cluster under specific simulated weather conditions—the agents escalate to gemini-2.5-pro.
4. Data & Observability: All simulated telemetry, agent decisions, and test outcomes are streamed into BigQuery for long-term analysis and auditability. Cloud Logging and Cloud Trace provide distributed tracing across the agentic workflows and the virtual vehicle network, ensuring complete observability.

Step-by-Step Implementation

To implement this architecture, we utilize the Python SDK for ADK 2.0 to define an autonomous testing agent, and the gcloud CLI to deploy this agent to Cloud Run with the necessary security and networking configurations.

1. Defining the ADK 2.0 Agent (Python)

The following Python code demonstrates how to build an ADK 2.0 agent that interacts with the virtual vehicle environment. The agent uses gemini-2.5-pro to analyze telemetry and utilizes custom tools to inject signals into the RemotiveTopology simulation.

# main.py
import os
import json
from google.adk import Agent
from google.adk.tools import tool
from google.cloud import bigquery

# Initialize BigQuery client for telemetry logging
bq_client = bigquery.Client()

@tool
def inject_vehicle_signal(signal_name: str, value: float) -> str:
    """
    Injects a specific signal into the RemotiveTopology virtual network.
    In a production environment, this would make a gRPC or REST call to the Axion instance.
    """
    # Simulated interaction with RemotiveTopology API
    print(f"Injecting {signal_name} with value {value} into virtual E/E network...")
    return f"Successfully injected {signal_name}={value}."

@tool
def query_telemetry_state(domain: str) -> str:
    """
    Queries the current state of a specific vehicle domain (e.g., 'ADAS', 'Cockpit').
    """
    # Simulated telemetry retrieval
    mock_state = {"domain": domain, "status": "nominal", "latency_ms": 12}
    return json.dumps(mock_state)

# Define the ADK Agent using the 2026 Gemini 2.5 Pro model
vehicle_test_agent = Agent(
    name="virtual_vehicle_integration_tester",
    model="gemini-2.5-pro",
    instruction=(
        "You are an autonomous automotive integration testing agent. "
        "Your objective is to validate cross-domain interactions within a virtualized "
        "software-defined vehicle. You must inject signals into the E/E network, "
        "observe the resulting telemetry, and determine if the system behaves according "
        "to the engineering specifications. Log all anomalies."
    ),
    tools=[inject_vehicle_signal, query_telemetry_state],
)

def run_test_suite(request):
    """Cloud Run HTTP entry point."""
    # Example test scenario: Simulate a sudden braking event
    prompt = (
        "Simulate a sudden ADAS emergency braking event by injecting a 'brake_pressure' "
        "signal of 0.9. Then, query the 'Cockpit' domain to verify that the emergency "
        "warning UI state transitioned to 'active' within 50 milliseconds."
    )
    
    # Execute the agentic workflow
    response = vehicle_test_agent.run(prompt)
    
    return {"status": "success", "agent_analysis": response.text}

if __name__ == "__main__":
    # Local testing execution
    print(run_test_suite(None))

2. Containerization and Cloud Run Deployment

To deploy this agent to production, we must containerize it and deploy it to Cloud Run, ensuring it is attached to the correct VPC network to communicate with the Axion C4A instances hosting the virtual vehicle.

# 1. Set environment variables
export PROJECT_ID="auto-sdv-production-2026"
export REGION="us-central1"
export SERVICE_NAME="adk-vehicle-tester"
export VPC_NETWORK="sdv-simulation-vpc"
export SUBNET="sdv-agents-subnet"
export SERVICE_ACCOUNT="adk-runner@${PROJECT_ID}.iam.gserviceaccount.com"

# 2. Build the container image using Google Cloud Build
gcloud builds submit --tag gcr.io/${PROJECT_ID}/${SERVICE_NAME}

# 3. Deploy to Cloud Run with Direct VPC egress and strict concurrency limits
gcloud run deploy ${SERVICE_NAME} \
    --image gcr.io/${PROJECT_ID}/${SERVICE_NAME} \
    --region ${REGION} \
    --service-account ${SERVICE_ACCOUNT} \
    --network ${VPC_NETWORK} \
    --subnet ${SUBNET} \
    --vpc-egress all-traffic \
    --concurrency 1 \
    --cpu 2 \
    --memory 4Gi \
    --max-instances 1000 \
    --no-allow-unauthenticated

Architectural Note: We set --concurrency 1 because agentic workflows involving LLM reasoning and stateful tool execution are often synchronous and CPU-bound. Isolating one request per instance prevents noisy-neighbor issues during complex reasoning loops. We utilize --vpc-egress all-traffic via Direct VPC to ensure all communication with the RemotiveTopology environment remains strictly on the private network.

Production Readiness: FinOps, Quotas & Security Guardrails

Transitioning this architecture from a proof-of-concept to an enterprise-grade production facility requires rigorous enforcement of security perimeters, quota management, and FinOps discipline.

Security and IAM Guardrails

The virtual vehicle environment contains highly sensitive intellectual property, including proprietary ADAS algorithms and unreleased infotainment designs.

1. VPC Service Controls (VPC SC): The entire architecture—encompassing the Cloud Run agents, the Axion C4A instances, Vertex AI, and BigQuery—must be encapsulated within a strict VPC SC perimeter. This prevents data exfiltration; even if an engineer possesses valid IAM credentials, they cannot access the BigQuery telemetry datasets from outside the corporate network.
2. Least Privilege IAM: The Cloud Run service account (adk-runner) must be granted only the specific roles required for execution: roles/aiplatform.user (to invoke Gemini models), roles/bigquery.dataEditor (to write telemetry), and roles/logging.logWriter. It must explicitly not have administrative access to the underlying Axion infrastructure.

Quota Management

Agentic workflows can rapidly consume cloud quotas if left unchecked.

1. Vertex AI Token Limits: ADK agents operating in a loop can generate massive token volumes. Engineering teams must monitor the aiplatform.googleapis.com/generate_content_requests and token-per-minute (TPM) quotas. Implementing exponential backoff and utilizing Gemini's prompt caching features (e.g., vertex_gemini_25_pro_cache_storage_1m_hr) for static E/E specification documents is critical to avoid rate limiting.
2. Cloud Run Instance Limits: While Cloud Run scales automatically, a runaway recursive agent could theoretically spin up thousands of instances. The --max-instances flag (set to 1000 in our deployment command) acts as a hard circuit breaker, preventing accidental denial-of-wallet scenarios.

📊 Production FinOps & TCO Simulation

To demonstrate the financial implications of architectural decisions in this space, we utilize deterministic Google Cloud SKU pricing to compare two distinct deployment strategies for running 10,000 virtual vehicle integration tests per month.

Option A leverages an event-driven, serverless approach using Cloud Run and the highly efficient Gemini 2.5 Flash model. Option B represents a legacy "always-on" mindset, utilizing GKE Autopilot and the heavier Gemini 2.5 Pro model for all tasks, regardless of complexity.

📊 Production FinOps & TCO Simulation: Virtual Vehicle Integration Testing: Event-Driven vs. Always-On Agentic Workflows (Based on the latest Google SKU information)

Production Workload Assumptions (us-central1 / asia-southeast1):

• 10,000 full vehicle integration test suites executed per month.
• Each test suite processes 500,000 input tokens (telemetry logs, E/E specs) and generates 10,000 output tokens.
• Option A uses Cloud Run (2 vCPU, 4 GiB, 60s per test) and Gemini 2.5 Flash for rapid, cost-effective validation.
• Option B uses GKE Autopilot (10 always-on pods, 2 vCPU, 8 GiB) and Gemini 2.5 Pro for deep reasoning and complex multi-domain ADAS analysis.

Official Google Cloud SKU Pricing Sources (2026.09): cloud.google.com, cloud.google.com, cloud.google.com