Choosing an AI Agent Framework: LangGraph, Strands, Bedrock AgentCore, Azure AI Foundry, Vertex AI, and Vercel AI SDK

The AI agent space has matured rapidly. A year ago, you could get away with a while loop and a model API call. Today, production agents need durable state, observability, secure tool execution, and a deployment story that doesn't require rebuilding infrastructure from scratch every time a model provider ships a breaking change.

I've been evaluating six platforms that sit at different points on the spectrum from "low-level SDK you run anywhere" to "fully managed agent runtime." This post is a practical walkthrough of where each one shines and where it falls short.

The landscape at a glance

Before diving into details, here's the high-level positioning of each platform:

LangGraph: the graph-based orchestration layer

LangGraph is the agent runtime built on top of LangChain. Where LangChain provides the primitives (model wrappers, prompts, tools), LangGraph adds the ability to define cyclic graphs with explicit state management and control flow ^[1].

Why you'd pick it: You need fine-grained control over multi-step agent workflows with conditional branching, human-in-the-loop checkpoints, and durable execution. LangGraph is used in production by companies including LinkedIn, Uber, Klarna, and Elastic ^[2].

Integration and model support: Compatible with any model accessible through LangChain's provider ecosystem: OpenAI, Anthropic, Google, Amazon Bedrock, Mistral, and many others. The LangSmith platform provides debugging, evaluation, and monitoring ^[3].

Observability: LangSmith integration gives you trace-level visibility into each graph node execution, tool call, and state transition. You can replay failed runs and evaluate agent outputs against datasets.

Trade-offs: The learning curve is steeper than simpler SDKs. The graph abstraction is powerful but requires you to think carefully about state schemas and node design upfront. Async support in v0.5 still has limitations, and chat-as-control-flow patterns can get unwieldy beyond five or so agents with heavy conditional logic.

Pricing: LangGraph itself is open source (MIT). LangSmith (the observability/evaluation platform) has a free tier and paid plans for teams. Self-hosting is an option for the runtime.

Strands Agents: model-driven simplicity

Strands Agents is an open-source Python SDK from AWS that takes a deliberately minimalist, model-driven approach. The core idea: modern models are good enough at planning and tool selection that you don't need a complex orchestration graph. Define a prompt, give the agent some tools, and let the model drive ^[4].

Why you'd pick it: You want to go from prototype to production fast without writing orchestration logic. Multiple teams at AWS use Strands in production, including Amazon Q Developer, AWS Glue, and VPC Reachability Analyzer. Where it used to take months to ship an agent, the Q Developer team now ships new agents in days and weeks.

Integration and model support: Works with Amazon Bedrock, Anthropic API, Llama API, Ollama (for local dev), and any provider via LiteLLM. Tool support includes MCP servers, 20+ pre-built tools, and any Python function decorated with @tool.

Observability: Uses OpenTelemetry for distributed tracing, so you can pipe telemetry to any OTEL-compatible backend. Strands supports tracking agent trajectories and metrics across distributed architectures.

Trade-offs: The model-driven approach means the model's reasoning quality is your ceiling. For workflows that need deterministic control flow (like approval chains or strict step ordering), you'll end up fighting the abstraction. Strands is Python-only, so TypeScript teams are out of luck.

Pricing: Fully open source under Apache 2.0. You pay for the model API calls and whatever infrastructure you deploy on (Lambda, Fargate, EC2, etc.).

Bedrock AgentCore: managed agent infrastructure

Amazon Bedrock AgentCore is an agentic platform for deploying and operating agents at scale without managing infrastructure. It's not an SDK for building agent logic—it's the layer that handles runtime, identity, memory, tool gateway, observability, and policy enforcement ^[5].

Why you'd pick it: You've built an agent with Strands, LangGraph, CrewAI, or any other framework, and now you need to deploy it with enterprise-grade security, session isolation, and monitoring without rolling your own infrastructure.

Key capabilities:

• Runtime: Serverless deployment with complete session isolation, support for workloads running up to 8 hours, and billing based on actual CPU/memory consumption per second
• Gateway: Converts APIs and Lambda functions into agent-compatible tools, with MCP server support and semantic tool discovery
• Memory: Persistent short-term and long-term memory that maintains context across interactions
• Identity: Native integration with corporate identity providers for automated authentication and permission delegation
• Observability: Powered by Amazon CloudWatch and OpenTelemetry, with tracing, dashboards, and evaluation scoring
• Policy: Fine-grained control over agent actions using Cedar-based policies with real-time enforcement

Trade-offs: You're locked into AWS. The platform is new (GA in 2025), so the ecosystem of examples, community patterns, and third-party integrations is still growing. Pricing is consumption-based with no upfront commitments, but costs can be opaque until you instrument properly.

Azure AI Foundry: the Microsoft full-stack play

Azure AI Foundry (recently rebranded from Azure AI Studio) is Microsoft's end-to-end platform for building, deploying, and governing AI applications and agents. It supports over 70,000 customers and processes 100 trillion tokens per quarter ^[6].

Why you'd pick it: Your organization is already invested in the Microsoft ecosystem (Entra ID, Microsoft 365, Azure DevOps), and you want agents that integrate natively with Teams, SharePoint, Microsoft Fabric, and 1,400+ enterprise data connectors.

Integration and model support: The model catalog includes OpenAI models, 10,000+ open-source models from Hugging Face, and models from xAI, Meta, Mistral, DeepSeek, and others. The new model router automatically selects the optimal Azure OpenAI model per prompt.

Agent capabilities: The Foundry Agent Service (now GA) handles multi-agent orchestration with stateful context management, error handling, and long-running processes. It supports A2A (Agent-to-Agent) and MCP protocols for cross-framework agent communication. Agents can be deployed directly into Microsoft Teams and Office apps.

Observability: Foundry Observability provides end-to-end monitoring with latency, throughput, usage, and quality metrics, plus detailed trace logs of reasoning steps and tool calls. Integrates with Azure Monitor for production dashboards and alerting.

Governance: Microsoft Entra Agent ID gives every agent a first-class identity in your directory, with Conditional Access policies, MFA, and least-privilege roles. Content filtering includes "Spotlighting" for prompt injection detection, and there's built-in integration with Microsoft Defender for Cloud.

Trade-offs: The platform's breadth is also its complexity. If you're not already in the Microsoft ecosystem, onboarding overhead is significant. Pricing is usage-based across multiple dimensions (model tokens, tool invocations, search queries, storage), which can be difficult to predict.

Google Vertex AI Agent Builder: the Google Cloud-native option

Google's agent story centers on Vertex AI Agent Builder, which includes the Agent Development Kit (ADK) for building agents and Agent Engine for deploying and running them ^[7]. This is distinct from Vertex AI's broader ML platform (training, prediction serving, AutoML), though they share the same console.

Why you'd pick it: You're already on Google Cloud, you want tight integration with Google's model ecosystem (Gemini, plus third-party models like Claude on Vertex), and you value the Agent2Agent (A2A) open protocol for cross-framework agent interoperability.

Key capabilities:

• Agent Engine: Managed runtime with sessions, memory, code execution in sandboxed environments, and observability via Cloud Trace, Monitoring, and Logging ^[8]
• Agent Designer: Low-code visual designer for building and testing agents in the console
• Integration: 100+ pre-built connectors, MCP support, Apigee integration for enterprise APIs
• Model support: Gemini models, Claude (Opus/Sonnet) via Vertex, and a broad catalog of open models

Observability: Built on Google Cloud's native monitoring stack (Cloud Trace, Logging, Monitoring). Agent Engine provides session-level observability and evaluation capabilities.

Trade-offs: The agent platform is newer than some competitors, and the ecosystem of community examples is still developing. ADK is Python-first with expanding Java/Go support. If you need TypeScript-native agent development, this isn't the platform.

Pricing: Usage-based across Vertex AI services (model predictions, search, storage, compute). The pricing model involves multiple dimensions and can require careful estimation.

Vercel AI SDK: the TypeScript-first web SDK

The Vercel AI SDK is a different beast from the other entries on this list. It's an open-source TypeScript toolkit focused on building AI-powered features in web applications. With over 20 million monthly downloads, it's the de facto standard for AI in the JavaScript ecosystem ^[9].

Why you'd pick it: You're building AI features in a web application with Next.js, React, Svelte, Vue, or Node.js, and you want a unified API that works across providers without locking you into one model vendor.

What changed in v6: AI SDK 6 (released December 2025) introduced the Agent abstraction—reusable agents with built-in model, instructions, and tools that integrate across your application. Other additions include full MCP support, DevTools, reranking, image editing, and tool calling with structured outputs.

Integration and model support: The SDK provides a unified API across OpenAI, Anthropic, Google, Mistral, Amazon Bedrock, and many more providers. Switching providers is a one-line change. The LangChain adapter was rewritten in v6 for better interop.

Observability: AI SDK 6 includes built-in DevTools for development. For production, it integrates with observability platforms. The AI Gateway on Vercel provides caching, rate limiting, and usage tracking.

Trade-offs: The AI SDK excels at the web layer—streaming UI, chat interfaces, tool-calling UIs. It's less suited for heavy backend agent orchestration (long-running workflows, durable state, multi-agent coordination). For that, you'd pair it with LangGraph, Strands, or a managed platform.

Pricing: The SDK itself is open source and free. You pay for model API calls directly to providers. If deploying on Vercel, standard Vercel pricing applies. The AI SDK works equally well on any Node.js hosting.

Comparison table

How to choose

The right platform depends on three things: your cloud provider, your team's language preferences, and the complexity of your agent workflows.

If you're all-in on AWS and need managed infrastructure: start with Strands Agents for building agent logic, and deploy on Bedrock AgentCore when you need production-grade hosting with identity, memory, and policy enforcement.

If you're in the Microsoft ecosystem: Azure AI Foundry gives you the most seamless integration with Entra, Teams, SharePoint, and the broader Microsoft stack. The Agent Service handles multi-agent orchestration natively.

If you're on Google Cloud: Vertex AI Agent Builder with Agent Engine provides a managed runtime that integrates with Google's model catalog and Cloud monitoring. The A2A protocol is a differentiator for cross-framework agent interop.

If you're building a web application with AI features: The Vercel AI SDK is the best starting point for the frontend layer. Pair it with a backend orchestration framework for complex agent logic.

If you need maximum control over agent behavior: LangGraph gives you the most explicit, inspectable agent architecture. You'll write more code, but you'll understand exactly what your agent is doing at every step.

If you want to ship fast with minimal orchestration code: Strands Agents lets you lean on model capabilities directly. Define tools and a prompt, and let the model figure out the plan.

Need help shipping?

If you want a partner to design, build, or harden production AI features—agents, streaming UIs, or full-stack integration—see Services, especially AI Product Engineering. Get in touch with your stack and timeline.