Agent Orchestration in Practice: Google ADK vs LangGraph vs AWS Strands
Build the same live NOAA, Open-Meteo, and NWS marine report workflow in Google ADK 2.x and LangGraph on Vertex AI, then compare state graphs, parallel fan-out, failure handling, and LLM round-trip costs against AWS Strands.
Series · Part 1 of 3
Production Agents on Vertex AI
- 01 Agent Orchestration in Practice: Google ADK vs LangGraph vs AWS Strands
- 02 Stateful Agent Memory: Rolling Sessions vs Vector RAG vs Vertex AI Memory Bank
- 03 Open-Weight Agent Serving: LoRA-Tuning Gemma 4 26B-A4B MoE on Vertex AI with vLLM
On this page (12 sections)
- Three Control Philosophies on the Same Workload
- Step 1: Isolate the Domain Layer Once
- Startup Settings and Endpoint Validation
- Frozen Pydantic Contracts
- Fixing Two Subtle Real-World Bugs from the Prototype
- Step 2: Building the Pipeline in Google ADK 2.x (Workflow)
- Step 3: Building the Equivalent State Machine in LangGraph
- Step 4: Hermetic Testing Without Cloud Credentials
- Step 5: Running Live on Vertex AI and adk web
- Latency and Round-Trip Profile
- When I Reach for Each Framework
- What’s Next in Part 2
Most agent framework comparisons test toy get_weather("NYC") stubs where nothing times out, tools have zero data dependencies, and latency does not matter. Everything looks clean in ten lines of demo code.
Production agent workloads break those assumptions immediately. Earlier on this site, I built a Florida Keys Fishing Report Agent with AWS Strands that combines Nominatim geocoding, NOAA CO-OPS tide tables, Open-Meteo marine wave models, National Weather Service (NWS) wind forecasts, and lunar phase calculations. Running that agent against live coastal APIs exposed a classic orchestration constraint: you cannot fetch tides, swell, or wind until geocoding resolves coordinates and a 7-digit NOAA station ID, and once you have those coordinates, calling the remaining four sources sequentially wastes nearly two-thirds of your network budget.
This tutorial kicks off a three-part engineering series on building, remembering, and serving agents on Google Cloud Vertex AI:
- Part 1 (this guide): Agent control flow in practice, comparing Google Agent Development Kit (
google-adk2.x) and LangGraph (langgraph1.x) head-to-head against our existing AWS Strands baseline. - Part 2: Stateful Agent Memory: Long-term agent memory across sessions, comparing rolling chat transcripts, local vector retrieval, and LLM fact consolidation with Vertex AI Memory Bank.
- Part 3: Open-Weight Agent Serving: LoRA-tuning and hosting Gemma 4 (
26B-A4BMoE) on Vertex AI with vLLM for high-frequency tool calling.
Before Setting Sail
- Python 3.11+ with a virtual environment
- A personal Google Cloud project with the Vertex AI API enabled (only needed for LLM synthesis; data fan-out and tests run keyless)
- gcloud CLI installed for Application Default Credentials (gcloud auth application-default login)
- Familiarity with async Python (asyncio, httpx) and Pydantic v2
Complete Runnable Repository
All code and offline tests for Part 1 live in github.com/steve-largo/largo-tutorials/tree/main/agents/adk-vs-langgraph. You can run the test suite and the live NOAA/NWS/Open-Meteo telemetry benchmark right away without cloud credentials, then enable Vertex AI to compare the synthesized reports.
Three Control Philosophies on the Same Workload
Every marine report request follows the same dependency graph:
[1. Geocode Location + Find Nearest 7-Digit NOAA Station + Parse Target Date]
│
┌───────────────────────────┼───────────────────────────┐
│ (on error: short-circuit) │ (on ok: parallel fan-out) │
▼ ▼ ▼
[Return Error] ┌──────────────┼──────────────┬────────────┐
(0 LLM calls) ▼ ▼ ▼ ▼
[NOAA Tides] [Open-Meteo] [NWS Weather] [Moon Math]
└──────────────┴──────────────┴────────────┘
│
[2. Synthesize Captain's Brief]
(1 Gemini Call)
Even when three frameworks connect to the exact same tools and models, they represent that dependency graph in fundamentally different ways:
| Dimension | AWS Strands | LangGraph 1.2 | Google ADK 2.14 |
|---|---|---|---|
| Control model | Model-driven @tool loop | Cyclic and parallel StateGraph | Event Runner + typed Workflow |
| Ordering rule | System prompt instructions | Explicit graph edges | Workflow edges + JoinNode |
| State contract | Conversation message history | TypedDict + Annotated reducers | Build-checked BaseModel schema |
| Bad-input exit | 1+ LLM turn to read error | Conditional edge to END (0 LLM calls) | ctx.route branch skip (0 LLM calls) |
| Persistence | Session managers | InMemorySaver or Postgres | SessionService + MemoryService |
| Trace UI | OpenTelemetry logs | LangSmith or get_state_history | Built-in adk web inspector |
In the original Strands agent, ordering lived inside a system prompt string. That keeps the initial code under 70 lines, which is great for fast prototypes. The trade-off shows up in production: the model spends an extra inference round-trip deciding to call resolve_location, and if NWS returns HTTP 503 offshore, prompt wording alone determines whether the model fabricates wind speeds or reports a degraded sensor.
Both LangGraph and Google ADK 2.x let us move deterministic dependencies out of the prompt and into verified graph edges, reserving the LLM strictly for reasoning and synthesis.
Step 1: Isolate the Domain Layer Once
Before touching either agent framework, separate configuration, data contracts, and HTTP adapters from orchestration. Sharing one pure-Python domain package guarantees that any behavior or latency difference we observe comes from ADK or LangGraph rather than subtly different API parsers.
Create the project workspace and install pinned dependencies inside an isolated .venv:
mkdir -p adk-vs-langgraph && cd adk-vs-langgraph
python3 -m venv .venv
.venv/bin/pip install \
"google-adk>=2.14.0,<3.0.0" \
"google-genai>=2.34.0,<3.0.0" \
"langgraph>=1.2.19,<2.0.0" \
"langchain-google-genai>=4.4.2,<5.0.0" \
"pydantic>=2.14.2,<3.0.0" \
"pydantic-settings>=2.16.2,<3.0.0" \
"httpx>=0.28.1,<1.0.0" \
"python-dateutil>=2.9.0,<3.0.0" \
"pytest>=9.0.0,<10.0.0" \
"pytest-asyncio>=1.4.0,<2.0.0"
Startup Settings and Endpoint Validation
Load Vertex AI settings and upstream API endpoints once at startup via BaseSettings. Validating https:// schemes and an explicit hostname allowlist prevents untrusted configuration overrides from redirecting server-side HTTP calls:
# marine_bench/config.py
from functools import lru_cache
from urllib.parse import urlparse
from pydantic import AliasChoices, Field, field_validator
from pydantic_settings import BaseSettings, SettingsConfigDict
ALLOWED_UPSTREAM_HOSTS = frozenset(
{
"api.tidesandcurrents.noaa.gov",
"marine-api.open-meteo.com",
"api.weather.gov",
"nominatim.openstreetmap.org",
}
)
class MarineBenchSettings(BaseSettings):
model_config = SettingsConfigDict(
frozen=True,
env_prefix="MARINE_BENCH_",
extra="ignore",
)
google_cloud_project: str | None = Field(
default=None,
validation_alias=AliasChoices(
"GOOGLE_CLOUD_PROJECT",
"MARINE_BENCH_GOOGLE_CLOUD_PROJECT",
),
)
google_cloud_location: str = Field(
default="us-central1",
validation_alias=AliasChoices(
"GOOGLE_CLOUD_LOCATION",
"MARINE_BENCH_GOOGLE_CLOUD_LOCATION",
),
)
use_vertexai: bool = Field(
default=True,
validation_alias=AliasChoices(
"GOOGLE_GENAI_USE_VERTEXAI",
"MARINE_BENCH_USE_VERTEXAI",
),
)
gemini_model: str = Field(default="gemini-2.5-flash")
http_timeout_seconds: float = Field(default=10.0, gt=0.5, le=60.0)
user_agent: str = Field(default="largo-marine-bench/1.0 (+https://largo.dev)")
noaa_stations_url: str = Field(
default="https://api.tidesandcurrents.noaa.gov/mdapi/prod/webapi/stations.json"
)
noaa_datagetter_url: str = Field(
default="https://api.tidesandcurrents.noaa.gov/api/prod/datagetter"
)
open_meteo_marine_url: str = Field(
default="https://marine-api.open-meteo.com/v1/marine"
)
nws_base_url: str = Field(default="https://api.weather.gov")
nominatim_search_url: str = Field(
default="https://nominatim.openstreetmap.org/search"
)
@field_validator(
"noaa_stations_url",
"noaa_datagetter_url",
"open_meteo_marine_url",
"nws_base_url",
"nominatim_search_url",
)
@classmethod
def validate_https_endpoint(cls, value: str) -> str:
parsed = urlparse(value)
if parsed.scheme != "https":
raise ValueError(f"Endpoint must use https:// scheme: {value}")
if parsed.hostname not in ALLOWED_UPSTREAM_HOSTS:
raise ValueError(
f"Hostname '{parsed.hostname}' is outside ALLOWED_UPSTREAM_HOSTS"
)
return value.rstrip("/")
@lru_cache(maxsize=1)
def load_settings() -> MarineBenchSettings:
return MarineBenchSettings()
Frozen Pydantic Contracts
Next, define frozen Pydantic models in marine_bench/schemas.py. Enforcing a 7-digit regex on station_id (^\d{7}$) and WGS84 coordinate bounds ([-90, 90], [-180, 180]) stops malformed geocoding output at the boundary before it touches downstream URLs:
# marine_bench/schemas.py
from typing import Literal
from pydantic import BaseModel, ConfigDict, Field
class NoaaStation(BaseModel):
model_config = ConfigDict(frozen=True)
station_id: str = Field(pattern=r"^\d{7}$")
station_name: str = Field(min_length=1, max_length=120)
latitude: float = Field(ge=-90.0, le=90.0)
longitude: float = Field(ge=-180.0, le=180.0)
distance_miles: float = Field(ge=0.0)
class ResolvedLocation(BaseModel):
model_config = ConfigDict(frozen=True)
query: str = Field(min_length=1, max_length=160)
resolved_name: str = Field(min_length=1, max_length=200)
latitude: float = Field(ge=-90.0, le=90.0)
longitude: float = Field(ge=-180.0, le=180.0)
station: NoaaStation
class MarineBriefContext(BaseModel):
model_config = ConfigDict(frozen=True)
location: ResolvedLocation
target_date: str = Field(pattern=r"^\d{4}-\d{2}-\d{2}$")
tides: "TideWindow | None" = None
sea_state: "SeaState | None" = None
weather: "WeatherWindow | None" = None
lunar: "LunarPhaseInfo"
degraded_sources: tuple[str, ...] = ()
Fixing Two Subtle Real-World Bugs from the Prototype
Revisiting the original prototype’s tool parsers turned up two bugs worth fixing in marine_bench/domain.py and marine_bench/clients.py:
- NWS wind range parsing: NWS returns strings such as
"10 to 15 mph"or"Calm". Callingint(wind.split()[0])raises aValueErroron"Calm"and reports 10 mph instead of the 15 mph gusts that actually matter in a flats skiff. Extractingmax(int(n) for n in re.findall(r"\d+", raw_wind))(defaulting to 0) handles both safely. - Real swell and sea surface temperature aligned to
target_date: Instead of readingperiods[0](right now) when a user asks about Saturday,MarineDataClientfilters NWS periods bytarget_date.isoformat()and queries Open-Meteo’s actualswell_wave_height_maxand hourlysea_surface_temperatureseries.
Running the shared MarineDataClient directly against live public endpoints for Marathon, FL (Vaca Key USCG Station #8723970) shows why concurrent fan-out matters before any LLM is even involved:
.venv/bin/python -m marine_bench.cli --mode data-only --location "Marathon, FL" --date tomorrow
Location: Marathon (24.7138, -81.0904) Nearest NOAA Station: VACA KEY, USCG STATION, FLORIDA BAY (#8723970, 1.0 mi) Target Date: 2026-11-12 Lunar Phase: Waxing Crescent (7% illumination, Fair) - Transitional tidal range; match wind direction with moving water. High Tides (MLLW): 1:46 AM (+1.36 ft) Low Tides (MLLW): 8:11 AM (+0.11 ft) Sea State: waves 1.2 ft from SE @ 4.0s period, swell 1.1 ft, SST 82.6 F NWS Forecast (Thursday): 82 F, wind SW up to 10 mph, Slight Chance Rain Showers (precip 16%) Degraded Sources: none
Measuring the HTTP layer directly against those live endpoints from Linux (httpx==0.28.1):
- Geocode + cold NOAA 3,200-station catalog lookup (measured): 826.7 ms
- Sequential fetch across NOAA, Open-Meteo, and NWS (measured): 1,010.5 ms
- Concurrent fan-out across the same three APIs (measured): 344.6 ms (2.93x faster)
Step 2: Building the Pipeline in Google ADK 2.x (Workflow)
Rough Waters Ahead
ADK 2.x Migration Gotcha: Most tutorials written for ADK 1.x compose multi-step pipelines out of SequentialAgent and ParallelAgent. In google-adk 2.14.0, instantiating either class emits a DeprecationWarning directing you to google.adk.workflow.Workflow. In addition, SequentialAgent ignores EventActions(escalate=True) (which only terminates LoopAgent), so an upstream failure in Stage 1 still triggers downstream LlmAgent stages and throws a KeyError on missing template variables unless you switch to Workflow routing.
ADK 2.x’s Workflow class (from google.adk.workflow import Workflow, START, JoinNode, RetryConfig, node) solves both problems cleanly and avoids burning 4 extra LLM calls inside parallel collectors:
- Compile-time
state_schemachecking: Passingstate_schema=MarineWorkflowStatevalidates at graph construction time that every parameter declared on a@nodefunction exists onMarineWorkflowState. Typos fail immediately withStateSchemaErrorbefore a single request runs. - Automatic Pydantic coercion: When
fetch_tides_stepannotatesresolved_location: ResolvedLocation, ADK’sFunctionNodeautomatically validates and coerces the JSON dict stored inctx.state["resolved_location"]back into a frozenResolvedLocationinstance via Pydantic’sTypeAdapter. - Zero-LLM conditional short-circuiting: Setting
ctx.route = "error"when geocoding fails skips the"ok"route dictionary entry, returning the error message immediately with 0 downstream HTTP or Gemini calls.
Here is the complete ADK 2.x workflow graph in marine_bench/adk_agent.py:
# marine_bench/adk_agent.py (excerpt)
from datetime import date
from typing import Any
from google.adk.agents import Context, LlmAgent
from google.adk.models.base_llm import BaseLlm
from google.adk.workflow import START, JoinNode, RetryConfig, Workflow, node
from google.genai import types
from pydantic import BaseModel, Field
from marine_bench.clients import LocationResolutionError, MarineDataClient
from marine_bench.domain import (
SYNTHESIS_SYSTEM_INSTRUCTION,
calculate_lunar_phase,
format_snapshot_for_synthesis,
resolve_target_date,
)
from marine_bench.schemas import (
LunarPhaseInfo,
MarineBriefContext,
ResolvedLocation,
SeaState,
TideWindow,
WeatherWindow,
)
class MarineWorkflowState(BaseModel):
location_query: str = ""
date_query: str = "tomorrow"
target_date: str = ""
resolved_location: dict[str, Any] | None = None
resolution_error: str | None = None
tides: dict[str, Any] | None = None
sea_state: dict[str, Any] | None = None
weather: dict[str, Any] | None = None
lunar: dict[str, Any] | None = None
degraded_noaa_tides: str | None = None
degraded_open_meteo_marine: str | None = None
degraded_nws_weather: str | None = None
degraded_sources: list[str] = Field(default_factory=list)
formatted_snapshot: str = ""
final_fishing_report: str = ""
def build_adk_workflow_pipeline(
client: MarineDataClient,
model: str | BaseLlm = "gemini-2.5-flash",
reference_date: date | None = None,
) -> Workflow:
upstream_retry = RetryConfig(max_attempts=2, initial_delay=0.2, backoff_factor=2.0)
@node(name="LocationIntake", timeout=15.0)
async def resolve_location_step(
ctx: Context,
location_query: str,
date_query: str = "tomorrow",
) -> types.Content | None:
target = resolve_target_date(date_query, reference_date=reference_date)
ctx.state["target_date"] = target.isoformat()
try:
resolved = await client.resolve_location(location_query)
except LocationResolutionError as exc:
ctx.state["resolution_error"] = str(exc)
ctx.route = "error"
return types.Content(
role="model",
parts=[types.Part(text=f"Location resolution failed: {exc}")],
)
ctx.state["resolved_location"] = resolved.model_dump(mode="json")
ctx.state["resolution_error"] = None
ctx.route = "ok"
return None
@node(name="TideCollector", retry_config=upstream_retry, timeout=12.0)
async def fetch_tides_step(
ctx: Context,
resolved_location: ResolvedLocation,
target_date: str,
) -> None:
try:
tides = await client.fetch_tides(
resolved_location.station,
date.fromisoformat(target_date),
)
ctx.state["tides"] = tides.model_dump(mode="json")
except Exception as exc:
ctx.state["tides"] = None
ctx.state["degraded_noaa_tides"] = str(exc)
# SeaStateCollector, WeatherCollector, and LunarCollector follow the same pattern...
join_collectors = JoinNode(name="JoinMarineCollectors")
collectors = (
fetch_tides_step,
fetch_sea_state_step,
fetch_weather_step,
compute_lunar_step,
)
synthesizer = LlmAgent(
name="CaptainReportSynthesizer",
model=model,
instruction=(
SYNTHESIS_SYSTEM_INSTRUCTION
+ "\n\nTelemetry Snapshot:\n{formatted_snapshot}"
),
output_key="final_fishing_report",
)
return Workflow(
name="MarineReportWorkflow",
state_schema=MarineWorkflowState,
edges=[
(START, resolve_location_step, {"ok": collectors}),
(collectors, join_collectors, assemble_snapshot_step, synthesizer),
],
)
Why Four Parallel LlmAgents Multiply Token Cost
A common anti-pattern in multi-agent tutorials is placing four separate LlmAgent instances inside a parallel stage just to call four REST endpoints whose parameters (lat, lon, station_id, target_date) are already known. That burns four extra model round-trips and 4x system-prompt input tokens with zero reasoning benefit. Using @node functions (with built-in RetryConfig and timeout) inside Workflow gives you full per-node event tracing (event.node_info.path, e.g., LocationIntake@1, TideCollector@1) while keeping the entire pipeline down to 1 LLM call.
Step 3: Building the Equivalent State Machine in LangGraph
Now let’s build the exact same topology in langgraph 1.2.19 paired with langchain-google-genai 4.4.2. Note that langchain-google-genai 4.x supports Vertex AI natively via ChatGoogleGenerativeAI(model="gemini-2.5-flash", vertexai=True, project=..., location=...), so you no longer need the older langchain-google-vertexai package.
Where ADK Workflow uses JoinNode and per-source state keys, LangGraph shines with channel reducers (Annotated[list[str], operator.add]) and thread-scoped checkpointing (InMemorySaver, or AsyncPostgresSaver in production):
# marine_bench/langgraph_agent.py (excerpt)
import operator
from datetime import date
from typing import Annotated, Any, TypedDict
from langchain_core.language_models.chat_models import BaseChatModel
from langchain_core.messages import HumanMessage, SystemMessage
from langchain_google_genai import ChatGoogleGenerativeAI
from langgraph.checkpoint.base import BaseCheckpointSaver
from langgraph.checkpoint.memory import InMemorySaver
from langgraph.graph import END, START, StateGraph
class MarineGraphState(TypedDict, total=False):
location_query: str
date_query: str
target_date: str
resolved_location: dict[str, Any] | None
resolution_error: str | None
tides: dict[str, Any] | None
sea_state: dict[str, Any] | None
weather: dict[str, Any] | None
lunar: dict[str, Any] | None
degraded_sources: Annotated[list[str], operator.add]
formatted_snapshot: str
final_report: str
llm_calls: int
def build_langgraph_marine_app(
*,
client: MarineDataClient,
chat_model: BaseChatModel,
checkpointer: BaseCheckpointSaver | None = None,
reference_date: date | None = None,
):
async def resolve_node(state: MarineGraphState) -> dict[str, Any]:
loc_query = state.get("location_query", "").strip()
target = resolve_target_date(state.get("date_query"), reference_date=reference_date)
# Reuse checkpointed station on follow-up turns when location is unchanged
existing_raw = state.get("resolved_location")
if existing_raw and existing_raw.get("query") == loc_query:
return {"target_date": target.isoformat(), "resolution_error": None}
try:
resolved = await client.resolve_location(loc_query)
return {
"resolved_location": resolved.model_dump(mode="json"),
"target_date": target.isoformat(),
"resolution_error": None,
}
except LocationResolutionError as exc:
return {
"resolved_location": None,
"target_date": target.isoformat(),
"resolution_error": str(exc),
}
def route_after_resolve(state: MarineGraphState) -> list[str] | str:
if state.get("resolution_error") or not state.get("resolved_location"):
return "handle_resolution_error"
return ["fetch_tides", "fetch_sea_state", "fetch_weather", "compute_lunar"]
# Four parallel superstep nodes + synthesize_report node...
builder = StateGraph(MarineGraphState)
builder.add_node("resolve_location", resolve_node)
builder.add_node("handle_resolution_error", handle_resolution_error_node)
builder.add_node("fetch_tides", fetch_tides_node)
builder.add_node("fetch_sea_state", fetch_sea_state_node)
builder.add_node("fetch_weather", fetch_weather_node)
builder.add_node("compute_lunar", compute_lunar_node)
builder.add_node("synthesize_report", synthesize_node)
builder.add_edge(START, "resolve_location")
builder.add_conditional_edges(
"resolve_location",
route_after_resolve,
[
"handle_resolution_error",
"fetch_tides",
"fetch_sea_state",
"fetch_weather",
"compute_lunar",
],
)
builder.add_edge("handle_resolution_error", END)
for branch in ("fetch_tides", "fetch_sea_state", "fetch_weather", "compute_lunar"):
builder.add_edge(branch, "synthesize_report")
builder.add_edge("synthesize_report", END)
return builder.compile(checkpointer=checkpointer or InMemorySaver())
Look at two architectural details in that LangGraph code:
- Additive reducer on
degraded_sources: Becausefetch_tides,fetch_sea_state, andfetch_weatherexecute concurrently in the same superstep, writing plain"degraded_sources": ["nws_weather"]without a reducer would cause concurrent branch writes to collide (InvalidUpdateError). DeclaringAnnotated[list[str], operator.add]lets any failing branch emit{"degraded_sources": ["nws_weather"]}independently while LangGraph merges them deterministically beforesynthesize_report. - Zero-re-geocode follow-ups via
thread_id: BecauseInMemorySaverpersistsresolved_locationunderthread_id, a second turn asking “What if we wait until Saturday?” skips Nominatim and the 3,200-station distance scan altogether, saving ~825 ms on every follow-up question.
Step 4: Hermetic Testing Without Cloud Credentials
One of the cleanest tests of an agent framework’s design is how hard it makes unit testing without mocking away the framework itself.
Both ADK and LangGraph pass this test cleanly because each exposes a thin, subclassable model interface (google.adk.models.base_llm.BaseLlm with a single generate_content_async method in ADK, and langchain_core.language_models.chat_models.BaseChatModel in LangGraph). Combined with httpx.MockTransport, we can execute the real InMemoryRunner and real StateGraph superstep engine offline across happy paths, NWS HTTP 503 outages, and invalid locations:
.venv/bin/pytest -v
============================= test session starts ============================== platform linux — Python 3.13.15, pytest-9.2.0, pluggy-1.7.0 collected 6 items
tests/test_marine_bench.py::test_pure_domain_helpers PASSED [ 16%] tests/test_marine_bench.py::test_security_url_and_schema_guards PASSED [ 33%] tests/test_marine_bench.py::test_adk_workflow_happy_path_and_degradation PASSED [ 50%] tests/test_marine_bench.py::test_adk_workflow_escalates_on_unknown_location_without_llm_call PASSED [ 66%] tests/test_marine_bench.py::test_langgraph_parallel_degradation_and_checkpoint_reuse PASSED [ 83%] tests/test_marine_bench.py::test_langgraph_short_circuits_on_unknown_location PASSED [100%]
============================== 6 passed in 1.62s ===============================
Step 5: Running Live on Vertex AI and adk web
To run both orchestrators end-to-end against gemini-2.5-flash on your personal Google Cloud project, authenticate via Application Default Credentials and export your project settings:
gcloud auth application-default login
export GOOGLE_CLOUD_PROJECT="your-personal-gcp-project"
export GOOGLE_CLOUD_LOCATION="us-central1"
export GOOGLE_GENAI_USE_VERTEXAI="TRUE"
.venv/bin/python -m marine_bench.cli --mode both --location "Marathon, FL" --date tomorrow
To inspect ADK’s interactive session state and tool events visually in your browser, the companion repo also includes marine_agent_app/agent.py exposing root_agent. Always bind local development servers strictly to loopback (127.0.0.1) rather than 0.0.0.0:
.venv/bin/adk web --host 127.0.0.1 .
Latency and Round-Trip Profile
Comparing the three orchestrators on the same marine data workflow highlights where explicit graph edges pay off:
| Metric | Strands Tool Loop | LangGraph StateGraph | ADK 2.x Workflow |
|---|---|---|---|
| Upstream data fetch | 345 ms batched; 1,011 ms sequential | 345 ms parallel superstep | 345 ms parallel JoinNode |
| Follow-up date shift | Re-runs loop unless cached | 0 geocode calls via thread_id | 0 geocode calls via session.state |
| LLM calls (happy path) | 2 to 3 turns | 1 synthesis call | 1 synthesis call |
| LLM calls (bad input) | 1 call | 0 calls | 0 calls |
| End-to-end wall time | ~3.2s to 5.0s | ~1.8s to 2.6s | ~1.8s to 2.6s |
| Orchestration footprint | ~65 lines | ~145 lines | ~155 lines |
Note: Upstream HTTP timings and geocoding/validation counts come from live runs against NOAA, Open-Meteo, and NWS on November 11, 2026; end-to-end wall-time ranges reflect typical single-pass vs multi-turn gemini-2.5-flash inference latency.
When I Reach for Each Framework
Having built and tested the same coastal agent across all three ecosystems, here is the practical decision rule I use:
- Reach for AWS Strands (or ADK’s single
LlmAgenttool mode) when the workflow is genuinely open-ended, tool order cannot be predicted ahead of time, and keeping orchestration under 70 lines matters more than saving one extra LLM round-trip. - Reach for LangGraph when your team wants explicit state-machine semantics,
Annotatedchannel reducers for concurrent branch merges, time-travel or human-in-the-loop pause/resume across arbitrary nodes, and vendor-neutral portability across clouds. - Reach for Google ADK 2.x when you are building on Vertex AI and want both worlds in one runtime: Pydantic-validated
Workflowgraphs (@node,JoinNode, per-nodeRetryConfigandrequire_confirmation) alongside hierarchicalLlmAgentteams, localadk webtrace inspection, and first-classSessionServiceandMemoryServiceabstractions.
What’s Next in Part 2
Notice one limitation shared by every run above: as soon as a new session starts next week, our marine captain forgets that your flats skiff draws 9 inches of water, launches out of Tavernier Creek, and got blown off Ocean Reef in 18-knot east wind last Saturday.
In Part 2: Stateful Agent Memory, we wire ADK’s SessionService and MemoryService (VertexAiMemoryBankService on Vertex AI Agent Engine) against sliding session windows and a local SQLite vector store across an 8-session coastal history to measure what holds up when user facts mutate over months of conversations. Then in Part 3: Open-Weight Agent Serving, we LoRA-tune Gemma 4 (26B-A4B MoE) and connect ADK directly to vLLM on Vertex AI GPUs.
Keep Exploring
Related Guides
Open-Weight Agent Serving: LoRA-Tuning Gemma 4 26B-A4B MoE on Vertex AI with vLLM
Size Gemma 4 26B-A4B MoE memory and hybrid KV caches, scope LoRA adapters around multimodal vision layers, and connect Google ADK 2.14 directly to vLLM on Vertex AI.
Building a Fishing Report Agent with AWS Strands
Create an AI agent that combines tide, weather, and marine data to generate fishing reports. Learn tool-calling patterns with the Strands SDK, NOAA APIs, and Claude on AWS Bedrock.
Building an AI Trading Agent with Claude and News Signals
Build an automated trading agent that extracts market signals from news using Claude Haiku, executes trades via Alpaca, and manages positions with trailing stops and sentiment monitoring.
Discussion
to join the discussion.