Agentic Frameworks Deep Dive: pi-agent-core vs Google ADK vs AWS Strands vs CrewAI vs LangGraph vs Pydantic AI

Executive Summary

#

Protocol Support: The New Standard

#

Protocol Landscape

#

Framework Protocol Support Matrix

#

Protocol Spotlights

#

Beyond the matrix, here’s what each protocol actually enables:

MCP (Model Context Protocol) — The “USB-C for AI tools.” Standardizes how LLMs discover and call tools, access resources, and get structured prompts. Anthropic’s protocol, now adopted by Google, OpenAI, and the ecosystem.

UCP (Universal Commerce Protocol) — Google’s protocol for agentic commerce. Agents discover merchants via .well-known/ucp, negotiate offers, and complete checkout flows. Think of it as “Stripe for AI agents” — but a protocol, not a company.

🎬 Want visual explainers for each protocol? See AI Agent Protocols in 60 Seconds.

Google ADK Protocol Excellence

#

Google ADK provides first-class support for the protocols they helped create:

# A2A - Exposing an agent
from google.adk.a2a import A2AServer

server = A2AServer(agent=my_agent)
server.expose(port=8080)

# A2A - Consuming another agent
from google.adk.a2a import A2AClient

remote_agent = A2AClient("https://other-agent.example.com")
result = await remote_agent.invoke("analyze this data")

ADK Protocol Features:

• ✅ MCP tools integration
• ✅ A2A server/client (exposing & consuming)
• ✅ AG-UI (Agentic UI) support
• ✅ Bidi-streaming for real-time
• ✅ Multi-language (Python, Go, Java, TypeScript)

The Frameworks at a Glance

#

flowchart TB
    subgraph PROTOCOLS["Protocol-First"]
        ADK[Google ADK
MCP + A2A + AG-UI + UCP]
        STR[AWS Strands
MCP + A2A + AG-UI]
    end
    
    subgraph CHANNELS["Channel-First"]
        OC[pi-agent-core/OpenClaw
WhatsApp, Telegram, etc.]
    end
    
    subgraph WORKFLOW["Workflow-First"]
        LG[LangGraph
Graph-based orchestration]
        CR[CrewAI
Multi-agent teams]
    end
    
    subgraph SIMPLE["Simplicity-First"]
        PYD[Pydantic AI
Type-safe agents]
    end

1. Session Management

#

Google ADK

#

Clean separation of Session, State, and Memory with session rewind capability:

# ADK Session concepts
Session    → Single conversation thread (contains Events)
State      → Data within current conversation (session.state)
Memory     → Cross-session searchable knowledge store

# Services
SessionService → CRUD for sessions, append events, modify state
MemoryService  → Ingest from completed sessions, search knowledge

Features:

• ✅ SessionService for lifecycle management
• ✅ State persistence within sessions
• ✅ Session rewind — travel back to previous states
• ✅ Session migration between backends
• ✅ In-memory (testing) and cloud (production) backends
• ✅ Multi-language support (Python, Go, Java, TypeScript)

pi-agent-core (OpenClaw)

#

Sophisticated session system with structured keys and comprehensive lifecycle:

Session Keys:
agent:main:main                    → Primary DM
agent:main:whatsapp:group:123      → Channel-specific groups
agent:main:telegram:dm:456         → Per-channel DMs
cron:daily-report                  → Scheduled tasks

Features:

• ✅ Structured session keys with channel/peer isolation
• ✅ Daily resets (configurable hour, default 4 AM)
• ✅ Idle timeouts for inactive sessions
• ✅ JSONL transcript persistence
• ✅ Per-session queuing (serialized runs)
• ✅ Session write locks for consistency

AWS Strands

#

Enterprise-grade session management with multiple backends:

# Strands Session Managers
FileSessionManager        → Local file storage
S3SessionManager          → AWS S3 backend
RepositorySessionManager  → Custom repository pattern
AgentCore Memory          → Native AWS AgentCore integration
Valkey/Redis              → Distributed cache

Features:

• ✅ Multiple storage backends
• ✅ Conversation Manager options (Sliding Window, Summarizing)
• ✅ Native AgentCore Runtime integration
• ✅ State management across interactions

LangGraph

#

Checkpointing-based persistence with maximum flexibility:

from langgraph.checkpoint.sqlite import SqliteSaver

memory = SqliteSaver.from_conn_string(":memory:")
graph = workflow.compile(checkpointer=memory)

# Resume from checkpoint
config = {"configurable": {"thread_id": "user-123"}}
graph.invoke(state, config)

Features:

• ✅ Thread-based state management
• ✅ Checkpoint/restore at any point
• ✅ Custom checkpointer implementations
• ✅ Time-travel debugging

CrewAI

#

Implicit session management focused on crew executions:

crew = Crew(
    agents=[...],
    tasks=[...],
    memory=True,  # Enables memory system
)

Features:

• ✅ Automatic storage location handling
• ✅ Project-scoped isolation
• ⚠️ Less explicit session control (crew-centric)

Pydantic AI

#

Manual message history management:

result = agent.run_sync("Hello", message_history=previous_messages)
all_messages = result.all_messages()

Features:

• ✅ Type-safe message handling
• ⚠️ No built-in persistence (manual tracking)

2. Memory Systems

#

Google ADK Memory

#

Service-based architecture with MemoryService:

# MemoryService handles:
# - Ingesting from completed sessions
# - Cross-session search
# - Knowledge base management

memory_service = MemoryService()

# Ingest session into long-term memory
memory_service.ingest(completed_session)

# Search across all memory
results = memory_service.search(query="previous decisions about X")

Features:

• ✅ Session → Memory ingestion pipeline
• ✅ Cross-session search
• ✅ Context caching
• ✅ Context compression

pi-agent-core Memory

#

Workspace-based plain Markdown files:

~/.openclaw/workspace/
├── SOUL.md          # Agent personality (always loaded)
├── USER.md          # Human context (always loaded)
├── MEMORY.md        # Long-term (main session only)
└── memory/
    └── YYYY-MM-DD.md  # Daily notes

Features:

• ✅ Vector search with embeddings (OpenAI, Gemini, local)
• ✅ Hybrid search (BM25 + vector)
• ✅ Pre-compaction memory flush
• ✅ memory_search and memory_get tools

CrewAI Memory

#

Four-layer memory architecture:

3. Agent Loop Comparison

#

All frameworks implement variations of the ReAct pattern (Reason + Act):

flowchart LR
    subgraph LOOP["Universal Agent Loop"]
        A[Receive Input] --> B[Build Context]
        B --> C[LLM Inference]
        C --> D{Tool Call?}
        D -->|Yes| E[Execute Tool]
        E --> F[Add Result]
        F --> C
        D -->|No| G[Return Response]
    end

Loop Implementation Comparison

#

Google ADK Bidi-Streaming & AG-UI

#

Bidi-streaming enables real-time voice/video agents. AG-UI (or A2UI — Agent-to-User Interface) is the emerging standard for streaming UI state from agents to users. Both are built for latency-sensitive, interactive experiences.

Google ADK has first-class bidi-streaming support:

# ADK Bidi-streaming models
- Nova Sonic (AWS)
- Gemini Live (Google)
- OpenAI Realtime

# Supports real-time:
- Audio input/output
- Video input
- Interruptions
- Session management

4. Webhooks & External Integration

#

Google ADK

#

Most comprehensive protocol and deployment support:

Third-party integrations: Asana, Atlassian, GitHub, GitLab, MongoDB, Notion, Stripe, and more.

pi-agent-core (OpenClaw)

#

Most comprehensive messaging channel support:

AWS Strands

#

AWS-native + community integrations:

• AG-UI protocol support
• A2A protocol support
• Telegram (community)
• Teams (community)
• UTCP tool protocol

5. Session Replay & Debugging

#

Google ADK

#

Session rewind is a standout feature:

# Rewind to previous session state
session_service.rewind(session_id, to_event_index=5)

# Full observability stack
- Cloud Trace integration
- BigQuery Agent Analytics
- AgentOps / Arize / MLflow / Phoenix support

LangGraph

#

Best-in-class time-travel debugging:

# Time-travel debugging
for state in graph.get_state_history(config):
    print(state.values, state.next)

# Replay from any checkpoint
graph.update_state(config, new_values)

pi-agent-core

#

JSONL transcripts enable full replay:

# Session transcripts
~/.openclaw/agents/<agentId>/sessions/<sessionId>.jsonl

# Full conversation replay possible
# Compaction summaries preserved

AWS Strands

#

Comprehensive observability:

• OpenTelemetry traces
• Strands Evals SDK
• Trajectory evaluation
• Goal success rate tracking

6. Commonalities Across Frameworks

#

Shared Concepts

#

Multi-Agent Patterns

#

7. Framework Selection Guide

#

flowchart TB
    START[Need an Agent Framework?] --> Q1{Need full
protocol support?}
    Q1 -->|Yes, A2A/MCP/AG-UI| ADK[Google ADK]
    Q1 -->|No| Q2{Multi-channel
messaging?}
    Q2 -->|Yes| OC[pi-agent-core/OpenClaw]
    Q2 -->|No| Q3{AWS native?}
    Q3 -->|Yes| STR[AWS Strands]
    Q3 -->|No| Q4{Complex workflows?}
    Q4 -->|Yes| LG[LangGraph]
    Q4 -->|No| Q5{Multi-agent teams?}
    Q5 -->|Yes| CR[CrewAI]
    Q5 -->|No| PYD[Pydantic AI]

Recommendations

#

Conclusion

#

The agentic framework landscape is maturing rapidly, with clear differentiation emerging:

1. Protocol Leadership — Google ADK leads with comprehensive support for A2A, MCP, AG-UI, and UCP (protocols they helped create)
2. Channel Coverage — pi-agent-core/OpenClaw excels at multi-channel messaging (WhatsApp, Telegram, Discord, etc.)
3. Cloud Integration — AWS Strands for AWS, Google ADK for GCP
4. Workflow Flexibility — LangGraph offers the most control over agent behavior
5. Memory Sophistication — All major frameworks now offer robust session and memory systems

The right choice depends on your priorities:

• Need full protocol interoperability? → Google ADK
• Need to reach users on WhatsApp/Telegram? → pi-agent-core
• Deep in AWS ecosystem? → Strands
• Want maximum control? → LangGraph

This comparison reflects the state of these frameworks as of February 2026. The agentic AI space evolves rapidly — always check the latest docs.