Agent Development Kits β from a demo loop to a production agent
A raw model plus a while loop gets you a demo. A production agent needs tools, multi-agent delegation, memory, streaming, guardrails, evaluation, observability and deployment. An Agent Development Kit (ADK) packages those so you don't rebuild them each time.
What this compares. "ADK" most often means Google's Agent Development Kit, but it's really a category. This guide frames the category, then puts four options side by side in a Problem β Solution β Limits format:
Google ADK, AWS's Strands Agents SDK and Bedrock AgentCore, and the LangGraph approach this repo's LLM tutorial already teaches.
Structured framework
Google ADK
Batteries-included agents with workflow + LLM orchestration; deploys to Vertex AI.
Lightweight SDK
AWS Strands
Model-driven agent loop in a few lines; model-agnostic, Bedrock-default.
Managed runtime
Bedrock AgentCore
Not a framework β hosts any framework's agent with memory, identity, tools.
Low-level graph
LangGraph
Explicit nodes/edges/state β maximum control, more wiring.
They aren't mutually exclusive: you might build with Google ADK or Strands and deploy on AgentCore, or drop to LangGraph when you need control an opinionated framework won't give you.
The category What an ADK gives you
Every ADK exists to turn the same eight production concerns into library features instead of bespoke code. When you evaluate one, you're really asking how well it handles each of these:
π Reasoning loop
The reasonβactβobserve cycle that lets an agent call tools repeatedly until it can answer.
π οΈ Tools
Turning functions, APIs, and MCP servers into things the model can invoke β safely and with typed I/O.
Coordinating multiple agents: deterministic (sequential/parallel/loop) vs. model-driven delegation.
π§ Memory & sessions
Short-term state within a run and long-term memory across conversations.
π‘ Streaming
Token, event, and (increasingly) bidirectional audio/video streaming to the client.
π‘οΈ Guardrails
Input/output validation, policy checks, and human-in-the-loop approval gates.
π Evaluation
Test agents against datasets β trajectory and final-answer scoring β to catch regressions.
π Deploy & observe
Getting the agent to a scalable runtime with tracing, logging and session isolation.
The axis that matters most:who decides the route β your code (deterministic workflow agents) or the model (autonomous delegation). Frameworks differ mostly in how much of each they make easy. It's the same predetermined-vs-AI-decides split from the agentic patterns section.
Option 1 Google ADK
Google Agent Development Kit google-adk Β· Python & Java Β· open source
Solves Building and deploying agents with a batteries-included, code-first framework. It gives you both LLM-driven agents and deterministic workflow agents (Sequential, Parallel, Loop), multi-agent hierarchies, a rich tool ecosystem (functions, OpenAPI, MCP, even LangChain/CrewAI tools), sessions/state/memory, bidirectional streaming, a built-in eval framework, and a local dev UI (adk web).
Limits Young and fast-moving β the API still has breaking changes between versions. Model-agnostic in principle (via LiteLLM) but the smoothest path is Gemini + Vertex AI, so you lean into Google's ecosystem. Smaller community and less third-party content than LangChain. Documentation is still maturing.
Choose You want a structured, opinionated framework with orchestration and deployment built in β especially if you're on Google Cloud / Gemini or want first-class deterministic multi-agent workflows.
weather_agent.py
# pip install google-adk
from google.adk.agents import Agent
def get_weather(city: str) -> dict:
"""Return the current weather for a city."""
return {"status": "success", "report": f"Sunny, 24Β°C in {city}."}
root_agent = Agent(
name="weather_agent",
model="gemini-2.0-flash", # or Claude/GPT via LiteLLM
instruction="Answer weather questions with get_weather.",
tools=[get_weather], # a plain function becomes a tool
)
# run it locally in the dev UI: adk web
Deterministic orchestration β the part LangGraph makes you wire by hand
Workflow agents give you predictable control flow without writing a graph. A SequentialAgent runs sub-agents in order; ParallelAgent fans out; LoopAgent repeats until an exit condition β while LlmAgent sub-agents still delegate autonomously where you want the model to decide.
from google.adk.agents import SequentialAgent
pipeline = SequentialAgent(
name="research_pipeline",
sub_agents=[researcher, summarizer, critic], # deterministic order
)
Option 2 AWS Strands Agents SDK
Strands Agents strands-agents Β· Python Β· open source
Solves Building an agent in a handful of lines with a model-driven philosophy: you give it a model, a prompt, and tools, and let the model plan-and-act in a loop β instead of you hand-coding the orchestration graph. Tools are just decorated Python functions or MCP servers.
PrimitivesAgent(model, tools, system_prompt), the @tool decorator, model providers (Bedrock, Anthropic, OpenAI, Ollama, LiteLLM), MCP integration, session/state.
Limits New (open-sourced 2025) with a still-growing ecosystem. Model-driven simplicity means less explicit structure than Google ADK's workflow agents β great for autonomy, less so when you need tightly deterministic multi-step control. Defaults and best integration lean toward AWS Bedrock.
Choose You want the fastest path from idea to working agent, prefer autonomous model-driven behavior over rigid graphs, and are comfortable in (or targeting) the AWS/Bedrock ecosystem.
agent.py
# pip install strands-agents strands-agents-tools
from strands import Agent, tool
from strands_tools import calculator
@tool
def word_count(text: str) -> int:
"""Count the words in a piece of text."""
return len(text.split())
agent = Agent(tools=[calculator, word_count]) # defaults to a Bedrock model
agent("What is 1234 * 5678, and how many words are in this sentence?")
# the model loops: calls calculator, calls word_count, then answers
Solves The other half of the problem: not authoring the agent, but running it in production at scale. AgentCore is framework-agnostic infrastructure β take an agent built with Strands, LangGraph, CrewAI or Google ADK and get serverless hosting with session isolation, plus managed Memory, Identity, a Gateway that turns APIs/Lambdas into MCP tools, and sandboxed Browser & Code-Interpreter tools, all with built-in observability.
Limits AWS-only and newer (launched in preview in 2025) β expect evolving APIs and quotas. It's a managed platform, so you pay for the convenience and accept its runtime constraints. It doesn't design your agent's logic β you still pick a framework for that.
Choose You've built an agent (in any framework) and need production-grade hosting, memory, tool gateways and identity on AWS without assembling that plumbing yourself.
deploy.py
# Wrap ANY framework's agent for managed, serverless hosting.
from bedrock_agentcore.runtime import BedrockAgentCoreApp
app = BedrockAgentCoreApp()
@app.entrypoint
def invoke(payload):
# `agent` could be a Strands, LangGraph, CrewAI, or Google ADK agent
return agent(payload["prompt"])
app.run() # AgentCore Runtime handles scaling + session isolation
Build vs. run. Google ADK and Strands are authoring frameworks; AgentCore is a runtime. They compose β a common shape is "author in Strands or ADK, deploy on AgentCore."
Baseline LangGraph β the low-level comparison
LangGraph langgraph Β· Python & JS Β· already used in this repo
Solves Modeling an agent as an explicit graph β nodes (steps), edges (control flow, including cycles), and a shared state object. You get maximum control: custom branching, loops, checkpointing, and human-in-the-loop pauses, with no opinions imposed.
Limits Lower-level than Google ADK or Strands β you assemble more yourself (define the state schema, wire every edge), so simple agents need more boilerplate and the learning curve is steeper. It's an authoring library, not a deployment platform (pair with LangGraph Platform or AgentCore).
Choose You need precise, custom control over complex or unusual agent flows that an opinionated framework can't express cleanly β and you value framework neutrality.
See it in action. The LLM apps tutorial builds a full LangGraph agent β tools loop and a support-agent capstone β a concrete reference point for "how much do I have to wire by hand?" versus the kits above.
Comparison cheat sheet
Kit
What it is
Style
Model / cloud
Watch out for
Google ADK
Structured authoring framework
Workflow agents + LLM delegation
Model-agnostic, Gemini/Vertex-optimized
Young API; best on Google stack
AWS Strands
Lightweight authoring SDK
Model-driven agentic loop
Model-agnostic, Bedrock-default
New; thin higher-level structure
Bedrock AgentCore
Runtime, not a framework
Hosts any framework's agent
AWS / Bedrock
AWS-only; preview; platform cost
LangGraph
Low-level authoring library
Explicit graph (nodes/edges/state)
Framework-neutral
More boilerplate; steeper curve
CrewAI
Opinionated authoring framework
Role-based "crews"
Framework-neutral
Opinionated; less fine control
Notice two are authoring tools (Google ADK, Strands, LangGraph, CrewAI) and one is a runtime (AgentCore). The first question isn't "which is best" β it's "am I choosing how to build the agent, or how to run it?"
Choosing guide
If youβ¦
Reach forβ¦
Are on Google Cloud / Gemini and want structure out of the box
Google ADK
Want the fewest lines to a working, autonomous agent on AWS
Strands Agents
Need deterministic multi-step pipelines and LLM delegation together
Google ADK (workflow agents)
Need precise control over a complex, custom, cyclical flow
LangGraph
Have an agent (any framework) and need to run it at scale on AWS
Bedrock AgentCore
Want quick role-based multi-agent collaboration
CrewAI
Rule of thumb: start with the most opinionated kit that still fits your problem (ADK or Strands) for speed, and only drop to LangGraph when you hit a wall its abstractions can't express. Keep authoring and runtime decisions separate β you can host any of them on AgentCore.
Knowledge check
Six questions on the ADK landscape. Pick an answer for each, then check your score.