This wiki already compares CrewAI against Strands Agents and against LangGraph — both are about role-based crews versus something else. This page is a different three-way: Pydantic AI, Strands Agents, and LangGraph are the three frameworks a team reaches for when the priority is a typed, production-grade single- or multi-step agent rather than a “team of role-played personas” model. None of the three is a CrewAI-style crew abstraction, and none of them competes primarily on how many pre-built personas or tools ship in the box. They compete on a narrower and more consequential question: who controls the execution flow — the model, an explicit graph you author, or nobody by design — and whose roadmap you’re now downstream of. See CrewAI vs LangGraph and CrewAI vs Strands for the role-based-crew ground; this page does not restate it.

What each one actually is

Pydantic AI is a Python agent framework published by Pydantic Services Inc., the company behind the Pydantic validation library, under the MIT license.[^1] It defines an Agent around Pydantic models for tool inputs, tool outputs, and final results, validating everything at runtime and retrying automatically on schema failure. Under the hood, every Agent compiles to a small finite-state machine implemented in pydantic-graph — a separate, standalone graph/FSM library that ships as a dependency but has no dependency on Pydantic AI itself and can be used on its own for workflows that have nothing to do with LLMs.[^2] The framework’s own documentation describes the goal as bringing “the FastAPI feeling” to agent development: type hints drive validation and developer ergonomics the way they do in a FastAPI route.[^3] It is worth being precise about that lineage: FastAPI itself was created independently by Sebastián Ramírez and merely depends on Pydantic for validation — the Pydantic team did not build FastAPI, and the “FastAPI-like” claim is Pydantic AI’s own positioning, not a shared-authorship fact.[^4]

Strands Agents is an open-source SDK maintained directly by AWS (author of record: Amazon, opensource@amazon.com) under the Apache-2.0 license, with Python and TypeScript SDKs living in a single monorepo.[^5] Its stated design principle is a model-driven loop: you give the model a system prompt and a list of @tool-decorated functions, call agent(message), and the model itself decides at each turn whether to call a tool or return a final answer — there is no state schema or graph topology to author up front.[^6] Since Strands 1.0 (July 2025) it also ships explicit primitives — Agents-as-tools, Swarms, Graphs, and Handoffs — for when a team wants deterministic routing instead of letting the model decide, so the model-driven loop is the default posture, not the only one available.[^7]

LangGraph is a graph/state-machine library published by LangChain Inc. under the MIT license.[^8] You define a typed State, Node functions that read and update it, and Edges (including conditional edges) that determine what runs next; execution follows the graph topology you wrote, with built-in checkpointing for pause/resume and human-in-the-loop review at any node boundary. LangGraph reached its 1.0 general-availability release on October 22, 2025, committing to no breaking changes until 2.0, after more than a year of production use at companies including Uber, LinkedIn, and Klarna.[^9]

Constraints that actually decide this, before any feature row

Vendor affiliation and who controls the roadmap. This is the load-bearing constraint for this trio, and it is not the simple “AWS vs. independent vs. LangChain” split the framing invites at first glance. Strands is a direct AWS product — Amazon is the named author, the repository lives under the strands-agents GitHub org, and its natural deployment path is Amazon Bedrock AgentCore, GA since October 13, 2025.[^10] LangGraph is published by LangChain Inc., a venture-backed company that closed a $125M Series B led by IVP in October 2025 at a $1.25B valuation (roughly $260M raised across rounds), monetizing through LangSmith (tracing/eval) and LangSmith Deployment — the hosted deployment product formerly branded “LangGraph Platform” until its October 2025 rename.[^11] Pydantic AI is often framed as the “neutral” third option because it is not tied to a hyperscaler or a single model vendor — and on model-agnosticism that framing holds: it supports OpenAI, Anthropic, Google, Bedrock, Azure AI Foundry, Groq, Mistral, xAI, and Ollama, swappable by changing a string.[^12] But it is not independent of commercial pressure — Pydantic Services Inc. is itself venture-backed, having raised a $4.7M seed round in February 2023 and a $12.5M Series A in October 2024, both led by Sequoia Capital, with the Series A launched alongside its commercial observability product, Logfire.[^13] All three frameworks are open source and free; none of the three companies behind them is a nonprofit foundation. The difference is which commercial entity you become downstream of, not whether one of the three avoids that entirely.

Internal capability required — the control-flow fit. LangGraph requires a team comfortable designing a typed state schema and a graph topology before writing agent logic; that is real, non-optional upfront work, and it is the same tradeoff CrewAI vs LangGraph already covers for the role-based-crew comparison. Strands asks a team to trust the model’s own judgment about what to do next, which is less design work but requires confidence that model-driven exploration converges reliably for the task at hand. Pydantic AI asks the most of a team in a different way: it makes no structural decision for you at all, so multi-step orchestration is something you build yourself, either as plain Python calling multiple typed Agents in sequence or by reaching for pydantic-graph directly. This is the same category constraint-driven comparisons calls “internal capability and knowledge retention” — the deciding factor is not which framework is objectively more capable, but which control-flow philosophy your team already has the muscle for.

Cost structure. All three core frameworks are free and open source; the real cost is compute plus whichever optional commercial layer you turn on. LangSmith’s free Developer tier covers 5,000 base traces/month on one seat, and Plus is $39/seat/month with 10,000 base traces included; hosted deployment (LangSmith Deployment, the product renamed from “LangGraph Platform” in October 2025) is metered separately by compute and storage rather than a flat per-execution rate — LangChain Compute Units at $1.50 each (covering runtime vCPU-hours and memory-hours) plus LangChain Storage Units for traces and deployments, per LangChain’s own current pricing page; treat any “$X per node execution” figure from third-party writeups as the superseded pricing model.[^14] Logfire’s cloud pricing is usage-based with an Enterprise tier for custom SLAs; Logfire is also available fully self-hosted via an open-source Helm chart.[^15] Strands has no separate framework-level commercial tier — its natural billed layer is AWS itself: Bedrock inference cost, plus AgentCore Runtime and AgentCore Observability consumption, which shows up on an existing AWS invoice rather than a new vendor contract.

Resilience and ecosystem maturity signal. GitHub star counts are a weak proxy but a real one: LangGraph sits at roughly 41,000 stars, Pydantic AI at roughly 19,700, and Strands’ SDK repository at roughly 7,100, as of this writing.[^16] That ordering roughly tracks each project’s head start — LangChain’s ecosystem predates the others by years — more than it tracks technical merit, but a smaller community does mean fewer Stack Overflow answers, fewer third-party integrations, and a thinner bench of engineers who already know the framework when you need to hire.

Trust and data flow for the optional observability layer. By default, none of the three frameworks routes prompts or completions anywhere except the model provider you configured — the framework itself is not a data processor. That changes once you turn on the vendor’s own tracing product: LangSmith’s managed cloud sends trace data to LangChain Inc.’s infrastructure unless you use its Enterprise self-hosted or BYOC options (self-host inside your own AWS/GCP/Azure Kubernetes cluster, with multi-geo deployments for data-residency needs).[^17] Logfire has the same split: managed cloud, or a self-hosted Enterprise edition via an open-source Helm chart.[^18] Strands emits OpenTelemetry-native spans routable to CloudWatch/X-Ray via AgentCore Observability, or to any other OTel backend such as Jaeger.[^19] “Does telemetry leave our boundary” is answerable for all three — but the default differs, and is worth checking rather than assuming.

Gates vs. tradeoffs

Gates — these rule an option out categorically for a reader who has the stated constraint, independent of any other row in a feature table:

  • An organization that must procure and bill every production AI dependency through a single existing AWS contract, with no realistic path to add a new SaaS vendor for something as small as an observability subscription, has effectively one option here whose entire stack — SDK, model backend, managed runtime, telemetry sink — is procurable as AWS line items: Strands on Bedrock/AgentCore. LangGraph and Pydantic AI both run fine on AWS, but their natural commercial add-ons (LangSmith, Logfire) are separate vendor contracts.
  • Conversely, an explicit policy against depending on a single hyperscaler’s managed agent runtime for production workloads gates out Strands’ natural deployment path (AgentCore) specifically — though the SDK itself still runs on Lambda, ECS, EKS, or plain Docker without AgentCore, so a reader in this position should rule out the runtime, not the SDK.
  • A team with no capacity to design and maintain a graph topology, on a workflow complex enough to need real multi-step control, is gated out of a productive LangGraph adoption in the near term — not because LangGraph is worse, but because the upfront design cost is real, the same conclusion CrewAI vs LangGraph reaches for the crew-based comparison.

Tradeoffs — genuinely worth weighing, not gates:

  • Verbosity versus control: LangGraph’s explicit graph is more code upfront in exchange for a fully inspectable, checkpointable execution path at every node boundary; Strands’ implicit loop is less code in exchange for less visibility into why the model chose a particular path on a given run; Pydantic AI defers the decision entirely, which is faster to start and slower to standardize across a team without an agreed convention.
  • Ecosystem size versus vendor concentration: LangGraph’s larger community and tool ecosystem is a real advantage in hiring and troubleshooting, purchased at the cost of depending more heavily on one company’s roadmap and pricing decisions for the tooling around the framework.
  • Pricing model shape: LangSmith’s per-seat-plus-compute/storage-metered pricing, Logfire’s usage-based-plus-Enterprise pricing, and AWS’s consumption-based pricing for Bedrock/AgentCore scale differently against team size versus request volume — worth modeling against your actual traffic pattern rather than assuming one is cheaper in the abstract.

The control-flow philosophy, concretely

Take a task with an unclear number of steps: “look something up, decide if the result is good enough, and either answer or look again.” In LangGraph, this is a cycle you draw explicitly — a node that calls a tool, a conditional edge that inspects the state and routes either back to the search node or forward to a final-answer node — and every hop through that cycle is a state transition you can log, checkpoint, and resume from. In Strands, the same task is one agent() call with a search tool attached; the model decides, turn by turn, whether the result is sufficient, and the loop terminates when the model itself signals it is done — there is no external topology deciding that for it, though Strands’ opt-in Graph and Swarm primitives exist for exactly the cases where a team decides it wants that determinism back. In Pydantic AI, the same task is whatever you write: a single Agent with a tool and a validated output_type can approximate the Strands pattern, or you can drop into pydantic-graph directly and get something closer to LangGraph’s explicit topology — the framework does not push you toward either, which is precisely its stated positioning and precisely the thing a team has to supply structure for on its own.

What this comparison cannot resolve

Whether your organization’s procurement process genuinely treats “AWS-billed” as materially easier than “one more SaaS contract” is specific to that organization, not a general fact about any of these three tools. Whether your team’s actual comfort with graph-based state modeling versus trusting a model-driven loop is what your engineers report versus what a code review three months in actually shows is something only that team’s own retrospectives can answer. And the commercial terms cited here — LangSmith and LangGraph Platform pricing, Logfire’s Enterprise tier, AWS’s Bedrock/AgentCore consumption rates — change on each vendor’s own schedule; verify current pricing against each vendor’s own pricing page before a procurement decision rather than this article’s snapshot.

Further reading

Sources

  1. Pydantic AI, LICENSE file (MIT): https://github.com/pydantic/pydantic-ai/blob/main/LICENSE
  2. Pydantic AI, pydantic_graph package and docs — a standalone graph/FSM library with no dependency on Pydantic AI: https://ai.pydantic.dev/graph/ and https://pypi.org/project/pydantic-graph/
  3. Pydantic AI documentation, overview page (“bring that FastAPI feeling to GenAI app and agent development”): https://pydantic.dev/docs/ai/overview/
  4. Sebastián Ramírez (tiangolo), FastAPI creator profile and project pages, confirming independent authorship of FastAPI: https://github.com/tiangolo and https://en.wikipedia.org/wiki/FastAPI
  5. Strands Agents, PyPI package page (Apache-2.0, author AWS) and GitHub monorepo: https://pypi.org/project/strands-agents/ and https://github.com/strands-agents/harness-sdk
  6. Strands Agents documentation, “Model Providers” and core concepts on the model-driven approach: https://strandsagents.com/docs/user-guide/concepts/model-providers/
  7. AWS Open Source Blog, “Introducing Strands Agents 1.0: production-ready multi-agent orchestration made simple”: https://aws.amazon.com/blogs/opensource/introducing-strands-agents-1-0-production-ready-multi-agent-orchestration-made-simple/
  8. LangGraph, PyPI package page (MIT, maintained by LangChain): https://pypi.org/project/langgraph/
  9. LangChain, “LangGraph 1.0 is now generally available” (October 22, 2025): https://changelog.langchain.com/announcements/langgraph-1-0-is-now-generally-available
  10. AWS, “Amazon Bedrock AgentCore is now generally available” (October 13, 2025): https://aws.amazon.com/about-aws/whats-new/2025/10/amazon-bedrock-agentcore-available
  11. SiliconANGLE, “AI agent tooling provider LangChain raises $125M at $1.25B valuation” (October 20, 2025): https://siliconangle.com/2025/10/20/ai-agent-tooling-provider-langchain-raises-125m-1-25b-valuation/
  12. Pydantic AI documentation, overview page, model provider list: https://pydantic.dev/docs/ai/overview/
  13. Pydantic, “Announcement: Pydantic Logfire launch & Series A Funding”: https://pydantic.dev/articles/logfire-announcement ; Yahoo Finance, “Sequoia backs Pydantic to expand beyond its open source roots”: https://finance.yahoo.com/news/sequoia-backs-pydantic-expand-beyond-090000437.html
  14. LangChain, official pricing page (LangSmith tiers, and current LCU/LSU-based deployment metering that superseded per-node pricing after the October 2025 LangGraph Platform → LangSmith Deployment rename): https://www.langchain.com/pricing ; see also LangChain, “LangSmith Deployment” product page confirming the rename: https://www.langchain.com/langsmith/deployment
  15. Pydantic, “Pricing and Plans for Pydantic Logfire” and “Self-Hosted Logfire Architecture”: https://pydantic.dev/pricing and https://pydantic.dev/docs/logfire/deploy/self-hosted-deployment/architecture/
  16. GitHub repository pages, star counts as of September 2026: https://github.com/pydantic/pydantic-ai , https://github.com/langchain-ai/langgraph , https://github.com/strands-agents/harness-sdk
  17. LangChain, “Self-hosted LangSmith” docs and “Multi-Geo Data Residency for Self-Hosted LangSmith”: https://docs.langchain.com/langsmith/self-hosted
  18. Pydantic, “Self-Hosted Logfire Architecture”: https://pydantic.dev/docs/logfire/deploy/self-hosted-deployment/architecture/
  19. AWS Machine Learning Blog, “Strands Agents SDK: a technical deep dive into agent architectures and observability”: https://aws.amazon.com/blogs/machine-learning/strands-agents-sdk-a-technical-deep-dive-into-agent-architectures-and-observability/