← 피드로
AI agents are moving from experimental chatbots into production systems.
But as soon as an agent needs tools, memory, multiple steps, validation, retries, human approval, or collaboration with other agents, a new architectural question appears:
Which agent framework should we use?
LangGraph.
CrewAI.
Google Agent Development Kit (ADK).
All three can build agentic applications.
But they are designed around different abstractions and different levels of orchestration control.
The important question is therefore not:
“Which framework is the best?”
It is:
“Which orchestration model best fits the system we are building?”
1. First: What Is an Agent?
A production agent is more than an LLM wrapped in a prompt.
A useful mental model is:
text
Agent
│
├── Model
├── Instructions
├── Tools
├── State / Context
├── Memory
├── Control Flow
├── Guardrails
└── Evaluation
The model provides reasoning capability.
Tools allow the agent to interact with external systems.
State provides continuity.
Control flow determines what happens next.
Guardrails constrain what the agent is allowed to do.
Evaluation determines whether the agent actually works.
This distinction becomes important when comparing frameworks.
2. The Architectural Difference
At a high level:
Agent Application
│
┌─────────────┼─────────────┐
│ │ │
LangGraph CrewAI Google ADK
│ │ │
Graph + State Agents + Agents +
Crews/Flows Workflows
│ │ │
Fine-grained Collaborative Agent +
orchestration teams workflow
The frameworks overlap, but their abstractions are different.
LangGraph emphasizes explicit graph-based orchestration and stateful execution.
CrewAI provides agent and task abstractions through Crews, alongside Flows for structured event-driven orchestration.
Google ADK provides agents, tools, and workflow mechanisms, with a strong focus on building, evaluating, deploying, and operating agents in the Google ecosystem.
3. LangGraph: Think in Graphs and State
LangGraph is designed around explicit orchestration.
The application can be modeled as:
START
│
▼
Planner
│
▼
Researcher
│
├──────────────┐
▼ ▼
Retriever Validator
│ │
└──────┬───────┘
▼
Writer
│
▼
Reviewer
│
┌────┴────┐
│ │
Retry END
The important idea is that the developer explicitly defines the nodes, state, and transitions.
This becomes powerful when the workflow contains:
Conditional routing
Retries
Human approval
Long-running execution
Persistent state
Checkpoints
Multiple agent stages
Complex branching
Instead of allowing an LLM to decide everything, the application can keep important control-flow decisions deterministic.
LangGraph mental model
State
+
Nodes
+
Edges
+
Persistence
=
Controlled Agent Workflow
This makes LangGraph particularly attractive when workflow control and state management are first-class requirements.
4. CrewAI: Think in Agents, Crews and Flows
CrewAI approaches agentic systems from another direction.
The core abstraction is collaboration between specialized agents.
For example:
Research Crew
│
┌──────────────┼──────────────┐
│ │ │
Researcher Analyst Reviewer
│ │ │
└──────────────┼──────────────┘
▼
Final Report
Each agent can have a role, goal, tools, and responsibilities.
A Crew coordinates those agents around tasks.
But an important distinction is that CrewAI is not only about autonomous agent teams.
CrewAI also provides Flows for structured, event-driven orchestration.
That means a production CrewAI application can combine:
Deterministic Flow
│
▼
Crew / Agents
│
▼
Validation
│
▼
Next Flow Step
This allows CrewAI to support both collaborative agent behavior and more controlled application workflows.
5. Google ADK: Think in Agents + Workflows
Google's Agent Development Kit provides an agent abstraction built around a model, instructions, and optional tools.
As applications become more complex, ADK provides workflow mechanisms for composing multiple agents and executable nodes.
Conceptually:
Root Agent
│
├── Research Agent
│
├── Analysis Agent
│
└── Validation Agent
ADK supports workflow patterns such as:
Sequential
Parallel
Loop
Custom / Graph-based workflows
A sequential workflow might look like:
Input
│
▼
Research Agent
│
▼
Analysis Agent
│
▼
Reviewer Agent
│
▼
Final Response
A parallel workflow can execute independent agents concurrently:
┌── Researcher A ──┐
│ │
Input ───────────┼── Researcher B ──┼──► Aggregator
│ │
└── Researcher C ──┘
The important architectural point is that workflow orchestration does not have to be delegated to an LLM.
Deterministic workflow components can control execution.
That is valuable for production systems where predictability matters.
6. The Core Comparison
Dimension LangGraph CrewAI Google ADK
Primary abstraction Graph + state Agents + Crews + Flows Agents + workflows
Orchestration control Very high High High
Stateful workflows Strong Strong through Flows Strong
Agent collaboration Strong Core strength Strong
Deterministic workflows Strong Strong through Flows Strong
Conditional routing Strong Strong Strong
Parallel execution Supported Supported Supported
Human-in-the-loop Supported Supported Supported
Tool integration Strong Strong Strong
Multi-agent systems Strong Core use case Strong
A2A interoperability Possible through integrations Possible through integrations Strong ecosystem support
Best fit Complex stateful orchestration Collaborative agent teams Agent + workflow systems, especially in Google ecosystem
This table should not be interpreted as a benchmark.
There is no universal "winner."
7. Graph vs Crew vs Workflow
A useful way to think about the three approaches is:
LangGraph
↓
"What state exists and what transition happens next?"
CrewAI
↓
"Which specialized agents collaborate to accomplish this goal?"
Google ADK
↓
"Which agents and workflow primitives should execute this application?"
These are different architectural questions.
8. When LangGraph Makes Sense
Choose LangGraph when the system requires explicit control over execution.
Typical architecture:
User Request
│
▼
Intent Classification
│
┌───┴────┐
│ │
RAG API Tool
│ │
└───┬────┘
▼
Validation
│
▼
Human Approval
│
▼
Execution
This type of architecture benefits from explicit state and transitions.
Good use cases include:
Complex RAG agents
Approval workflows
Research pipelines
Stateful assistants
Long-running workflows
Agentic validation
Multi-step decision systems
9. When CrewAI Makes Sense
CrewAI becomes attractive when the problem naturally maps to specialized roles.
For example:
Project Manager
│
┌───────────────┼───────────────┐
│ │ │
Researcher Developer Reviewer
│ │ │
└───────────────┼───────────────┘
▼
Final Output
Each agent has a clearly defined responsibility.
Good use cases include:
Research teams
Content workflows
Business analysis
Multi-role automation
Collaborative task execution
Agent teams with specialized responsibilities
But use Flows when the application requires stronger deterministic orchestration around those agents.
10. When Google ADK Makes Sense
ADK is particularly compelling when you want an agent development framework that connects naturally with Google's agent and cloud ecosystem.
A typical architecture can look like:
Root Agent
│
┌─────────┼─────────┐
│ │ │
Search RAG Tools
│ │ │
└─────────┼─────────┘
▼
Validator
│
▼
Output
ADK also provides a broader development lifecycle around agents, including evaluation, deployment, and observability tooling.
This matters because production agent engineering is not only about writing the agent.
It is also:
Build
↓
Evaluate
↓
Deploy
↓
Observe
↓
Improve
11. Deterministic vs Agentic Control
This is probably the most important architectural distinction.
Not every step should be controlled by an LLM.
Consider:
Validate JSON
Check authentication
Check required fields
Check API status
Check authorization
These are deterministic operations.
They should normally remain deterministic.
But:
Interpret user intent
Summarize evidence
Choose research strategy
Explain anomalies
Generate recommendations
are better candidates for model-based reasoning.
A strong production architecture combines both.
Deterministic Code
+
LLM Reasoning
+
Explicit State
+
Guardrails
=
Production Agent
12. MCP and A2A Are Different from Agent Frameworks
Another common mistake is treating MCP and A2A as competitors to LangGraph, CrewAI, or ADK.
They solve different problems.
MCP
MCP primarily provides a standardized way for AI applications to connect with tools and external context.
Conceptually:
Agent
│
▼
MCP
│
├── Database
├── API
├── Files
└── Enterprise Tools
A2A
A2A is focused on communication between agents.
Agent A
│
│ A2A
▼
Agent B
│
▼
Agent C
Therefore:
LangGraph / CrewAI / ADK
↓
Agent orchestration
MCP
↓
Agent ↔ Tools / Context
A2A
↓
Agent ↔ Agent
These technologies can coexist.
13. Production Architecture
A mature enterprise agent system may combine several layers:
User
│
▼
API / Gateway
│
▼
Agent Runtime
│
┌─────────────┼─────────────┐
│ │ │
State Tools Memory
│ │ │
│ MCP │
│ │ │
└─────────────┼─────────────┘
│
Agent Workflow
│
┌────────┴────────┐
│ │
Agent A Agent B
│ │
└───────A2A──────┘
│
▼
Validation
│
▼
Human Gate
│
▼
Production
The framework is only one layer of the architecture.
14. What Should You Actually Choose?
Use the following decision framework.
Choose LangGraph when:
State + control + branching
are the dominant requirements.
Choose CrewAI when:
Specialized agent collaboration
is the dominant requirement.
Choose Google ADK when:
Agent development + workflows +
evaluation + deployment + Google ecosystem
are important architectural requirements.
And remember:
These are not mutually exclusive architectural ideas.
A system can use an agent framework for orchestration while using MCP for tools and A2A for distributed agent communication.
15. The Architecture Matters More Than the Framework
A common mistake in agent engineering is starting with:
"Which framework should I use?"
A better approach is:
1. Define the business problem
↓
2. Identify deterministic operations
↓
3. Identify reasoning tasks
↓
4. Define state
↓
5. Define tool boundaries
↓
6. Define failure/retry behavior
↓
7. Define evaluation criteria
↓
8. Choose the orchestration framework
The framework should follow the architecture.
Not the other way around.
16. Final Takeaway
LangGraph, CrewAI, and Google ADK can all build production-grade agentic systems, but they encourage different ways of thinking about orchestration.
LangGraph emphasizes explicit graph-based control and stateful execution.
CrewAI emphasizes collaborative agents while also providing structured Flows for application orchestration.
Google ADK combines agents with workflow primitives and a broader development lifecycle around evaluation, deployment, and observability.
The real engineering decision is therefore not:
"Which framework wins?"
It is:
"Where should autonomy exist, and where should deterministic control remain?"
That is the question that matters in production AI.
The strongest agent architectures do not maximize autonomy.
They place autonomy exactly where reasoning creates value—and keep everything else as deterministic, observable, testable, and controllable as possible.
References
LangGraph Documentation — LangGraph overview and graph/state orchestration
CrewAI Documentation — Agents, Crews and Flows
Google Agent Development Kit Documentation — Agents and workflows
Google ADK Documentation — Multi-agent systems and workflow patterns
Model Context Protocol Documentation
Agent2Agent (A2A) Protocol Documentation
Enter fullscreen mode Exit fullscreen mode
답글 남기기