AI Agent Frameworks & Platforms Compared: LangChain, Microsoft, AWS, and Google's Strategy and Strengths
Hi, I’m Lena Nadir.
The landscape of AI agent frameworks has exploded over the past year or two. LangChain, Microsoft, AWS, and Google have each built out their own agent development ecosystem with a distinct strategy, and it’s become genuinely hard to tell which one you should pick.
As for me, I started learning AI agent frameworks with LangChain & LangGraph, then moved from Azure OpenAI Studio to Microsoft Foundry and ended up making Foundry my main tool. Prototyping experimentally in the Foundry Portal’s Playground was just easy, and honestly, my work environment is so thoroughly locked into Microsoft services 😂 that I never really needed to reach for another framework.
In this post, I’ll organize the four major frameworks by provider/license, strengths, state management and control approach, and LLM compatibility. This isn’t meant to push any particular framework — I hope it’s useful as a reference when you’re weighing your options.
First, take a look at the genealogy chart below for the big picture — it maps out how each company’s frameworks have evolved over time. The top row is the “Agent Framework/SDK layer,” and the bottom row is the “Platform/Runtime layer” that runs it in production. Late 2022 through 2023 was the dawn of agent frameworks, and over roughly three years they’ve evolved into full-fledged platforms for production AI agent infrastructure.
A genealogy chart showing how each company’s frameworks have evolved over time. The top row is the code-level Framework/SDK layer; the bottom row is the Platform/Runtime layer that handles production operation. Arrows indicate only “the same product evolved or was renamed” — unrelated items on different layers (such as Bedrock Agents and Amazon Bedrock AgentCore) are placed independently without arrows.
Comparing the Major AI Agent Frameworks and Platforms
Next, the two tables below compare the major AI agent frameworks and platforms. Note that the LangChain and Microsoft Agent Framework entries are based on my own hands-on experience, while the rest are compiled from documentation and other written sources.
One interesting thing is that every vendor has converged on this same two-layer structure. Microsoft, for example, ships “Microsoft Agent Framework” (the code-level framework) and “Microsoft Foundry Agent Service” (the hosting platform) as two separate products. AWS follows the same pattern: “Strands Agents” (where you write the code) and “Amazon Bedrock AgentCore” (which provides the runtime, memory, and so on) are separate layers.
This structure reminds me of the relationship between a container “image” and its “runtime.” Given how fast the technology is moving — AutoGen/Semantic Kernel converging into Microsoft Agent Framework, Assistants API/Swarm converging into Agents SDK + Responses API — I’d expect the framework layer to keep getting rewritten every few years. Keeping the platform layer separate (the part enterprises actually depend on — scaling, identity, observability) protects it from the risk of the framework layer becoming obsolete.
At the same time, you can see the business logic behind it too. Every vendor releases its Framework/SDK layer as open source — a free layer designed to draw developers in. The Platform/Runtime layer, on the other hand, is where the actual revenue comes from (from the user’s side, it shows up as ongoing infrastructure cost), and it’s the layer that’s hard to walk away from once you’re integrated — identity, compliance, existing cloud contracts, and so on. It reads like a strategy of keeping the framework open while locking customers in at the platform layer.
Four independent companies converging on the same structure without any coordination is probably no coincidence — it’s likely driven by both technical and strategic logic working together.
The Agent Development Framework Layer
| Framework | Provider / License | Key Features & Strengths | State Management & Control |
|---|---|---|---|
| LangChain / LangGraph | LangChain Inc. / MIT | LangChain is a high-level agent framework for working with LLMs, models, tools, and data sources. LangGraph is a lower-level agent orchestration/runtime that can be used independently of LangChain, with a focus on long-running execution, persistence, human-in-the-loop, and streaming. Easy to keep cloud- and LLM-agnostic | State + Graph. Uses a graph structure where state is passed between nodes. Checkpointers persist state, enabling resumption mid-run and access to past states. Also supports human-in-the-loop via interrupts |
| Microsoft Agent Framework | Microsoft / MIT | An OSS framework that combines AutoGen’s agent/multi-agent abstractions with Semantic Kernel’s session-based state management, type safety, filters, and telemetry. Works with multiple models/providers beyond Microsoft Foundry, including Azure OpenAI, OpenAI, Anthropic, and Ollama | Agent + Workflow. Provides session-based state management plus workflow orchestration patterns — sequential, concurrent, handoff, group chat, and Magentic. Workflow checkpointing also supports pausing and resuming long-running processes |
| Strands Agents | Amazon Web Services / Apache 2.0 | A lightweight, model-driven OSS SDK. Provides a simple abstraction over the agent loop, model calls, and tool calls, and works with multiple model providers and MCP. Supports Python and TypeScript, and can use model providers beyond Amazon Bedrock (not personally verified) | Agent Loop + State / Session / Memory. The framework itself provides agent state and session persistence. A MemoryManager also handles long-term memory across sessions, and can be combined with external memory services |
| Agent Development Kit (ADK) | Google / Apache 2.0 | An open agent development framework. Integrates with Gemini/Google Cloud while also supporting multiple model providers and external tools. Available in Python, TypeScript, Go, Java, and Kotlin. Covers not just agent development but also evaluation, debugging, and deployment (not personally verified) | Agent + Workflow. Manages session, state, and memory as separate concerns. Workflow agents let you build predictable sequential/parallel/loop execution flows, which can be combined with LLM-agent-driven dynamic routing and multi-agent setups |
The Agent Platform Layer (Managed Infrastructure for Production)
| Platform | Provider | Role | Supported Frameworks |
|---|---|---|---|
| LangSmith Deployment | LangChain Inc. | A managed execution platform for agents. Provides durable execution, streaming, horizontal scaling, persistence, human-in-the-loop, and observability. Integrates with LangSmith’s evaluation/observability features, and can run self-hosted or as a standalone server, not just in the cloud | Deepest integration with LangGraph/LangChain, but framework-agnostic. Also supports Strands, CrewAI, AutoGen, Google ADK, and more via the Functional API and similar mechanisms |
| Microsoft Foundry Agent Service | Microsoft | A managed platform providing AI agent hosting, scaling, identity, security, observability, session management, and more. Supports both prompt agents and code-based hosted agents | Supports Microsoft Agent Framework, LangGraph, OpenAI Agents SDK, Anthropic Agent SDK, GitHub Copilot SDK, and more. You can also deploy hosted agents built with your own custom code |
| Amazon Bedrock AgentCore | Amazon Web Services | A framework- and model-agnostic agent operations platform that offers Runtime, Identity, Memory, Gateway, Browser, Code Interpreter, Observability, and more as individual services (not personally verified) | Supports Strands Agents, LangGraph, CrewAI, LlamaIndex, Google ADK, OpenAI Agents SDK, and more. The Runtime service in particular supports a wide range of frameworks, though coverage varies by service |
| Vertex AI Agent Engine | A managed runtime providing agent deployment and execution, scaling, session management, observability, IAM, and more. Integrated with Google Cloud’s agent development and operations stack (not personally verified) | Full integration with ADK, LangChain, and LangGraph. AG2 and LlamaIndex integrate via the Vertex AI SDK, while CrewAI and others deploy via custom templates |
Each Vendor’s Direction, Strengths, and LLM Compatibility
From here, let’s take a closer look at each vendor/community’s direction, strengths, and LLM compatibility. In the end, I’d suggest making your final choice around whatever cloud environment you’re already using, weighing in the cost-effectiveness and operational overhead of going multi-cloud.
LangChain: From Agent Development to an Agent Engineering Platform
- Direction: On top of LangChain’s model/tool/data-source integrations, LangChain has combined stateful agent orchestration via LangGraph with observability, evaluation, and deployment via LangSmith, expanding into a platform that covers everything from agent development to production. In October 2025, what used to be “LangGraph Platform” was renamed “LangSmith Deployment.” LangGraph itself remains usable independently as an OSS agent orchestration framework.
- Strengths: Rich integrations with external models, tools, and data sources, plus a deep feature set for developing, debugging, and operating complex agent workflows — human-in-the-loop, persistence, long-running execution, and access to past states. LangSmith Deployment itself is now framework-agnostic and supports agent frameworks beyond LangGraph.
Microsoft: An Enterprise Agent Platform Built Around Microsoft Foundry Integration
- Direction: Microsoft has consolidated Semantic Kernel, proven in enterprise agent development, and AutoGen, strong in multi-agent systems, into Microsoft Agent Framework. Within Microsoft Foundry, Agent Framework is positioned as the recommended framework for code-based hosted agents and multi-agent development, while the platform still accepts other frameworks such as LangGraph, OpenAI Agents SDK, and Anthropic Agent SDK.
- Strengths: Easy integration with Microsoft Foundry’s tool set — Search, Web Search, Code Interpreter, Memory, MCP — as well as enterprise infrastructure like Microsoft Entra ID, RBAC, network isolation, and observability. This really shines when you’re embedding agents into an existing Azure/Microsoft environment.
AWS: A Framework-Agnostic Agent Ecosystem
- Direction: AWS offers multiple options: the established managed agent service “Amazon Bedrock Agents,” the OSS framework for writing agent logic in code “Strands Agents,” and “Amazon Bedrock AgentCore,” which provides runtime, memory, identity, gateway, observability, and more. AgentCore in particular is designed to be framework- and model-agnostic, and can be used not only from Strands Agents but also from LangGraph, CrewAI, LlamaIndex, Google ADK, OpenAI Agents SDK, and others.
- Strengths: Easy to build IAM-based access control, AWS’s network and security infrastructure, and integrations with various AWS services directly into your agent’s production operations. AgentCore also lets you adopt AWS’s managed operations infrastructure without major changes to your existing agent framework or models.
Google: Open Agent Development Meets Google Cloud Integration
- Direction: Google’s agent development environment centers on Agent Development Kit (ADK), an Apache 2.0 open-source project that supports multiple languages, models, and agent configurations. At the same time, it integrates deeply with Gemini and various Google Cloud services, letting you combine an open agent framework with Google Cloud’s managed infrastructure.
- Strengths: Beyond dynamic, LLM-driven agent execution, you can combine sequential/parallel/loop workflows to build predictable execution flows. It also supports agent-to-agent collaboration via protocols like A2A, letting you build multi-agent systems.
Platform and LLM Compatibility
| Platform | Model Relationship | Integration with In-House Models | Notes |
|---|---|---|---|
| LangSmith Deployment | Model-agnostic | Designed to avoid lock-in to any particular vendor | Can be combined with multiple agent frameworks, centered on LangGraph/LangChain. The emphasis is less on the LLM itself and more on agent orchestration, deployment, and observability |
| Microsoft Foundry Agent Service | Multi-LLM | Deep integration with the Microsoft Foundry model catalog | Supports a wide range of models beyond the GPT family, including Llama, DeepSeek, and Claude. Also integrates with Microsoft Entra ID and Foundry’s tool set |
| Amazon Bedrock AgentCore | Model-agnostic | Deep integration with Amazon Bedrock | Supports external models like OpenAI, Gemini, and Claude in addition to models available on Bedrock. AgentCore Runtime explicitly positions itself as framework- and model-agnostic |
| Vertex AI Agent Engine | Multi-LLM | Deep integration with Gemini/Google Cloud | Centered on Gemini, but supports multiple agent frameworks and models. Integrates with Google Cloud’s IAM, observability, and agent operations infrastructure |
* Which LLM is the “best fit” depends on factors like model performance, cost, tool-use capability, and context length, so this table doesn’t label any specific model as “optimal.” Every platform is moving toward supporting third-party models while keeping tight integration with its own.
Summary: How to Think About Your Choice
- If you prioritize state management for complex agent workflows, human-in-the-loop, and debugging/evaluation: LangGraph / LangSmith is a strong candidate
- If you have an existing Azure/Microsoft environment and prioritize enterprise identity, security, and governance: Microsoft Agent Framework / Microsoft Foundry is a strong candidate
- If you want to leverage AWS’s IAM, network, and monitoring infrastructure while keeping your options open on agent frameworks and LLMs: Strands Agents / Amazon Bedrock AgentCore is a strong candidate
- If you also want to leverage Google Cloud/Gemini integration: Google ADK / Vertex AI Agent Engine is a strong candidate
That said, every major platform today is moving away from “our framework only” and toward multi-framework, multi-model support. So when choosing, it’s important to look beyond “which frameworks can I use” and consider how much weight you want to put on your existing cloud infrastructure, identity/security, observability, evaluation, data infrastructure, and freedom of model choice.
Also, given how fast AI agent frameworks and platforms are evolving, this article is based on information as of August 2026. Before adopting any of these in practice, please check each vendor’s latest documentation and release notes.
Overall Impressions
What struck me most while putting this comparison together is that these four companies aren’t simply competing on “agent framework features.”
Every vendor has:
- a development framework layer for implementing agent logic, and
- a platform layer for running, monitoring, and managing agents in production
and has built an ecosystem that combines the two.
And the competitive landscape seems to be shifting from “our framework vs. open frameworks” toward competition that assumes multi-framework, multi-model support as a baseline.
At the same time, tight integration between a vendor’s own framework and its own platform still remains strong:
- LangGraph ↔ LangSmith
- Microsoft Agent Framework ↔ Microsoft Foundry
- Strands Agents ↔ AgentCore
- Google ADK ↔ Vertex AI
So when choosing your agent infrastructure, I think it’s important to judge not just the framework’s standalone features, but also your existing cloud infrastructure, security/identity, observability, LLM options, and how easy it will be to migrate down the road.
It seems to me that competition in AI agents has broadened — from a contest between individual LLMs or frameworks into a contest between entire ecosystems for continuously developing, evaluating, and operating agents.
References
Official Documentation
Microsoft
- Microsoft Agent Framework Overview (Microsoft Learn)
- Microsoft Foundry Agent Service — Overview (Microsoft Learn) — Covers Agent Service’s role as a managed platform, hosted agents, supported frameworks, and identity/security/observability.
AWS (Strands Agents / AgentCore)
- Strands Agents — Session Management — Confirms that Strands itself can persist agent state, conversation history, and multi-agent state, backing up this article’s point about state management being delegated to AgentCore.
- Strands Agents — Memory — Explains the difference between session management and long-term memory, and how MemoryManager retains memory across sessions.
- Amazon Bedrock AgentCore — Developer Guide — A central resource for understanding AgentCore’s overall architecture (Runtime, Memory, Identity, Gateway, Observability) and its framework-/foundation-model-agnostic positioning.
- Amazon Bedrock AgentCore — Supported interfaces / frameworks — Covers the AgentCore SDK/CLI and how to use it with multiple frameworks such as Strands Agents and LangGraph.
- Amazon Bedrock Agents vs AgentCore + Strands (Cipher Projects)
Google (ADK / Vertex AI Agent Engine)
- Agent Development Kit — Technical Overview — Covers ADK’s core concepts: LlmAgent, workflow agents (Sequential/Parallel/Loop), tools, and callbacks.
- Agent Development Kit — Get Started — Lists quickstarts for Python, TypeScript, Go, Java, and Kotlin, useful as a reference for supported languages.
- Vertex AI Agent Engine — Overview — Covers production deployment, management, and scaling for Agent Engine, and the different integration levels with ADK/LangChain/LangGraph — notably the distinction between “full integration,” “Vertex AI SDK integration,” and “custom template.”