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.

Deep Dive 15 min read November 11, 2026 Code on GitHub
0
Agent Orchestration in Practice: Google ADK vs LangGraph vs AWS Strands
On this page (12 sections)

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:

  1. Part 1 (this guide): Agent control flow in practice, comparing Google Agent Development Kit (google-adk 2.x) and LangGraph (langgraph 1.x) head-to-head against our existing AWS Strands baseline.
  2. 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.
  3. Part 3: Open-Weight Agent Serving: LoRA-tuning and hosting Gemma 4 (26B-A4B MoE) 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:

DimensionAWS StrandsLangGraph 1.2Google ADK 2.14
Control modelModel-driven @tool loopCyclic and parallel StateGraphEvent Runner + typed Workflow
Ordering ruleSystem prompt instructionsExplicit graph edgesWorkflow edges + JoinNode
State contractConversation message historyTypedDict + Annotated reducersBuild-checked BaseModel schema
Bad-input exit1+ LLM turn to read errorConditional edge to END (0 LLM calls)ctx.route branch skip (0 LLM calls)
PersistenceSession managersInMemorySaver or PostgresSessionService + MemoryService
Trace UIOpenTelemetry logsLangSmith or get_state_historyBuilt-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:

  1. NWS wind range parsing: NWS returns strings such as "10 to 15 mph" or "Calm". Calling int(wind.split()[0]) raises a ValueError on "Calm" and reports 10 mph instead of the 15 mph gusts that actually matter in a flats skiff. Extracting max(int(n) for n in re.findall(r"\d+", raw_wind)) (defaulting to 0) handles both safely.
  2. Real swell and sea surface temperature aligned to target_date: Instead of reading periods[0] (right now) when a user asks about Saturday, MarineDataClient filters NWS periods by target_date.isoformat() and queries Open-Meteo’s actual swell_wave_height_max and hourly sea_surface_temperature series.

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
Output

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:

  1. Compile-time state_schema checking: Passing state_schema=MarineWorkflowState validates at graph construction time that every parameter declared on a @node function exists on MarineWorkflowState. Typos fail immediately with StateSchemaError before a single request runs.
  2. Automatic Pydantic coercion: When fetch_tides_step annotates resolved_location: ResolvedLocation, ADK’s FunctionNode automatically validates and coerces the JSON dict stored in ctx.state["resolved_location"] back into a frozen ResolvedLocation instance via Pydantic’s TypeAdapter.
  3. 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:

  1. Additive reducer on degraded_sources: Because fetch_tides, fetch_sea_state, and fetch_weather execute concurrently in the same superstep, writing plain "degraded_sources": ["nws_weather"] without a reducer would cause concurrent branch writes to collide (InvalidUpdateError). Declaring Annotated[list[str], operator.add] lets any failing branch emit {"degraded_sources": ["nws_weather"]} independently while LangGraph merges them deterministically before synthesize_report.
  2. Zero-re-geocode follow-ups via thread_id: Because InMemorySaver persists resolved_location under thread_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
Output

============================= 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:

MetricStrands Tool LoopLangGraph StateGraphADK 2.x Workflow
Upstream data fetch345 ms batched; 1,011 ms sequential345 ms parallel superstep345 ms parallel JoinNode
Follow-up date shiftRe-runs loop unless cached0 geocode calls via thread_id0 geocode calls via session.state
LLM calls (happy path)2 to 3 turns1 synthesis call1 synthesis call
LLM calls (bad input)1 call0 calls0 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 LlmAgent tool 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, Annotated channel 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 Workflow graphs (@node, JoinNode, per-node RetryConfig and require_confirmation) alongside hierarchical LlmAgent teams, local adk web trace inspection, and first-class SessionService and MemoryService abstractions.

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.

Found this walkthrough useful?
0
Mile Marker 106 emblem

Steven W. White · Software engineer and AI systems builder writing from the Florida coast

Independent engineering notes, measured hardware benchmarks, and runnable code from Mile Marker 106.

Keep Exploring

Related Guides

Concept Map →

Discussion

Loading comments...