---
type: "post"
id: "write-up-says-happydelivery-s-five-reported-cloud-6f0ea9"
slug: "write-up-says-happydelivery-s-five-reported-cloud-6f0ea9"
title: "Write-up says HappyDelivery's five reported Cloud Run webhook times all missed the 150 ms goal"
description: "Google's HappyDelivery prototype combines verified messaging webhooks, Pub/Sub, Redis session state and a LangGraph swarm of Gemini-powered specialists for conversational grocery orders."
retrieval_nugget: "Google's HappyDelivery prototype combines verified messaging webhooks, Pub/Sub, Redis session state and a LangGraph swarm of Gemini-powered specialists for conversational grocery orders. Its design offers builders a concrete pattern for separating intake, memory and reasoning; its own five Cloud Run timings, however, miss the stated sub-150 ms webhook goal."
published_at: "2026-11-14"
updated_at: "2026-11-14"
record_date: "2026-11-14"
date_kind: "published_at"
topics: ["google","gemini"]
entities: ["Google","HappyDelivery","LangGraph","Gemini","Google Cloud","Cloud Memorystore"]
related_patterns: ["harness-architecture-outlives-model-choice"]
novelty_label: "new_fact"
what_changed: "HappyDelivery’s working prototype reports five Cloud Run webhook timings, all exceeding its 150 ms target."
prior_refs: []
source_url: "https://developers.googleblog.com/en/building-conversational-commerce-with-multi-agent-swarms-on-gcp-a-working-prototype/"
source_urls: ["https://developers.googleblog.com/en/building-conversational-commerce-with-multi-agent-swarms-on-gcp-a-working-prototype/"]
schema_version: "newruntime-agent-readable-v0.2"
stable_id: "post:write-up-says-happydelivery-s-five-reported-cloud-6f0ea9"
status: "published"
visuals: []
editor: {"role":"editor","name":"Andrey Reshetnikov","profile":"https://newruntime.com/owner-profile.md","profile_json":"https://newruntime.com/owner-profile.json","same_as":["https://www.linkedin.com/in/reshetnikov1/","https://t.me/lapetuse"]}
routes: {"html":"https://newruntime.com/posts/write-up-says-happydelivery-s-five-reported-cloud-6f0ea9/","markdown":"https://newruntime.com/posts/write-up-says-happydelivery-s-five-reported-cloud-6f0ea9.md","json":"https://newruntime.com/posts/write-up-says-happydelivery-s-five-reported-cloud-6f0ea9.json"}
markdown_url: "https://newruntime.com/posts/write-up-says-happydelivery-s-five-reported-cloud-6f0ea9.md"
---

# Write-up says HappyDelivery's five reported Cloud Run webhook times all missed the 150 ms goal

## Retrieval answer

Google's HappyDelivery prototype combines verified messaging webhooks, Pub/Sub, Redis session state and a LangGraph swarm of Gemini-powered specialists for conversational grocery orders. Its design offers builders a concrete pattern for separating intake, memory and reasoning; its own five Cloud Run timings, however, miss the stated sub-150 ms webhook goal.

## Summary
Google's HappyDelivery prototype combines verified messaging webhooks, Pub/Sub, Redis session state and a LangGraph swarm of Gemini-powered specialists for conversational grocery orders. Its design offers builders a concrete pattern for separating intake, memory and reasoning; its own five Cloud Run timings, however, miss the stated sub-150 ms webhook goal.

## What happened
Google Developers Blog published a working-prototype walkthrough on October 27, 2026, building on an earlier architectural blueprint for conversational commerce. The prototype, named HappyDelivery, uses FastAPI, LangGraph, Gemini and Google Cloud. It divides a customer message journey into ingress, session and cart state, and agent orchestration rather than putting the full task in one prompt.

At ingress, a FastAPI service is intended to receive messages from channels such as WhatsApp, RCS, Apple Messages and SMS. It validates the channel-specific request, normalizes it into a common message event, queues that event in Google Cloud Pub/Sub and returns an HTTP acknowledgement without waiting for agent reasoning. The article says the target is under 150 ms. It describes WhatsApp HMAC-SHA256 validation and shows a validator in code; its sample normalization code handles WhatsApp and RCS. The article also describes channel-specific authentication expectations for the other messaging systems.

The second layer stores active customer state in Cloud Memorystore Redis, keyed by verified phone number. The example session includes a customer identifier, preferences, address and cart; saved sessions have a 24-hour time-to-live. Google reports five session retrieval measurements averaging 0.318 ms in its described VPC setup. The article also estimates that a 1–5 GB Basic Tier Redis instance can support 10,000–50,000 or more raw operations per second, and says a 5 GB instance could hold more than one million serialized sessions of roughly 2–5 KB each. These are the article's stated estimates, not independent capacity tests.

The third layer uses a LangGraph state machine. A Gemini Flash supervisor routes a request to profile, inventory or transaction specialists; the article assigns Gemini Pro to inventory and transaction work. Agents can call tools, including a Python function that computes subtotal, tax, delivery fee and total deterministically. The walkthrough simulates a three-turn shopping journey, including adding items, changing an item and checkout. For the ingress benchmark, Google reports five warm Cloud Run HTTPS requests at 266.84, 301.73, 300.47, 295.14 and 298.40 ms, all returning status 200. It separately reports about 95 ms for direct Pub/Sub publishing inside Cloud Run.

## What the archive adds
New Runtime's earlier coverage described Alphabet's Q3 2026 account of strong demand for Google Cloud AI infrastructure and TPU systems, while capital spending and inventory weighed on cash flow ([the November 11 note](https://newruntime.com/posts/alphabet-says-tpu-demand-is-lifting-cloud-while-91390d/)). HappyDelivery is a new, distinct event: a specific prototype and its claimed runtime behavior, not a new fact about TPU demand.

## Trend signal
This supports the idea that production agent behavior depends on a durable harness around the model: explicit state, routing, tools and asynchronous execution. The design is consistent with [harness architecture outliving model choice](https://newruntime.com/patterns/harness-architecture-outlives-model-choice/), though a worked prototype is not proof that the arrangement performs reliably at production scale.

## Why it matters
The prototype makes a useful architectural distinction visible: customer-facing responsiveness and agent reasoning do not have to share one synchronous request path. Queueing an authenticated, normalized event can protect the webhook from variable model latency, while a separate store preserves cart state across pauses. Specialized nodes also make it easier to assign narrow responsibilities and put exact operations—such as pricing—behind deterministic code rather than free-form model output.

The important caveat is that decoupling is not the same as meeting a latency objective. The five reported end-to-end webhook calls are all slower than the article's stated under-150 ms target, despite the queue-first design. Teams can borrow the boundaries and test the performance claims independently, but should not treat the prototype's architecture or Redis capacity estimates as production validation. It is a design recipe with a visible measurement gap, not a turnkey commerce system.

## Limits and uncertainty
Google presents a prototype and a simulated shopping journey, not a production deployment with disclosed customer volume, reliability history or order outcomes. The article reports only five warm Cloud Run ingress timings; it does not establish a latency distribution, cold-start behavior, tail latency or performance under concurrent load in those measurements. The reported Redis results and capacity estimates are likewise limited to the described setup. Production security, payment handling, idempotency across webhook retries, and recovery behavior would need separate validation before real transactions depend on the system.

## Skill to build now
For an agent workflow that receives webhooks, prototype the boundary first: verify the request signature, normalize it into a stable event schema, enqueue it, and return an acknowledgement before invoking a model. Measure end-to-end acknowledgement latency separately from queue-publish time, and set a test that fails when the service misses its actual channel timeout. Keep prices, taxes and other consequential arithmetic in deterministic functions.

## Reader takeaway
HappyDelivery is most useful as a separation-of-concerns example: authenticate and queue at ingress, keep durable session state outside the model, and use specialists with deterministic tools. Its own webhook numbers also show why architectural claims need measured end-to-end checks: the five reported calls exceeded the stated latency target.

Editor: [Andrey Reshetnikov](https://newruntime.com/owner-profile.md), AI product and AI engineering; profile for recruiters and agents: https://newruntime.com/owner-profile.json

## Continue in the graph

Next records for an agent, linked to their Markdown twins. Replace `.md` with `.json` for structured fields, including `next_reads`.

- topic hub: [Google](https://newruntime.com/topics/google.md): Explore the google topic hub.
- topic hub: [Gemini](https://newruntime.com/topics/gemini.md): Explore the gemini topic hub.
- collection: [Field Notes](https://newruntime.com/posts.json): Open the latest editorial analysis.
- collection: [Sources](https://newruntime.com/sources/): See the original sources this archive cites.
- whole graph: [discovery graph](https://newruntime.com/discovery-graph.json) (typed nodes and edges) and [site index](https://newruntime.com/site-index.md)