← All tutorials
Agent Development Kits

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.

🧩 Orchestration

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).

Primitives Agent/LlmAgent, SequentialAgentΒ·ParallelAgentΒ·LoopAgent, sub-agents, Runner, Session/State/Memory, tools, callbacks.

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.

Primitives Agent(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

Option 3  Amazon Bedrock AgentCore

Bedrock AgentCore managed agent runtime & services Β· AWS

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.

Primitives Runtime (serverless, session-isolated, long-running), Memory, Gateway (API→MCP), Identity, Browser tool, Code Interpreter, 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.

Primitives StateGraph, nodes, conditional edges, ToolNode, checkpointers (durable/resumable state).

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

KitWhat it isStyleModel / cloudWatch out for
Google ADKStructured authoring frameworkWorkflow agents + LLM delegationModel-agnostic, Gemini/Vertex-optimizedYoung API; best on Google stack
AWS StrandsLightweight authoring SDKModel-driven agentic loopModel-agnostic, Bedrock-defaultNew; thin higher-level structure
Bedrock AgentCoreRuntime, not a frameworkHosts any framework's agentAWS / BedrockAWS-only; preview; platform cost
LangGraphLow-level authoring libraryExplicit graph (nodes/edges/state)Framework-neutralMore boilerplate; steeper curve
CrewAIOpinionated authoring frameworkRole-based "crews"Framework-neutralOpinionated; 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 boxGoogle ADK
Want the fewest lines to a working, autonomous agent on AWSStrands Agents
Need deterministic multi-step pipelines and LLM delegation togetherGoogle ADK (workflow agents)
Need precise control over a complex, custom, cyclical flowLangGraph
Have an agent (any framework) and need to run it at scale on AWSBedrock AgentCore
Want quick role-based multi-agent collaborationCrewAI
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.

1. What core problem does an Agent Development Kit solve?

2. Which of these is not an authoring framework but a managed runtime that can host agents from any framework?

3. Google ADK's deterministic orchestration is expressed with…

4. You need maximum control over a complex, cyclical custom flow with explicit shared state. Best fit?

5. Which kit emphasizes a model-driven loop and the fewest lines to a working agent?

6. A limitation shared by Google ADK, Strands and AgentCore right now is…

Next steps

🧭 Google ADK docs

Official documentation β€” quickstarts, agents, tools, and deployment to Vertex AI.

🟠 Strands Agents

AWS Strands SDK β€” the model-driven, few-lines agent framework.

πŸ—οΈ Bedrock AgentCore

AgentCore β€” managed runtime, memory, gateway and identity for agents.

πŸ” Anthropic architectures

Workflows & the agent loop β€” the patterns these kits implement.

🧭 Google agent patterns

Design-pattern taxonomy β€” predetermined vs dynamic routing (ADK's workflow agents map onto it).

πŸ”Œ APIs vs MCP

How agents get tools β€” MCP standardizes connecting agents to tools & data (these kits support it).

πŸ€– LLM apps tutorial

The companion guide β€” build the LangGraph agent this page uses as a baseline.

☁️ AWS services guide

The AWS field guide β€” where Bedrock, Lambda and the rest fit.

πŸ“‘ IoT Γ— Agents

A worked example β€” an AWS IoT Core device driving a Strands + AgentCore agent (self-restocking fridge).