🚀 Jumpstart 2027: Custom, Secure AI Workflows to Adopt Now. Reserve your spot →

Plotly

Plotly

November 20, 2026

7 AI Agent Frameworks and Platforms for Building AI Analyst Assistants in 2027

TL;DR

  • Choose Plotly when the goal is a working AI analyst experience with interactive, code-backed outputs, governed deployment, and a path for agents to use the same data and functions as the application.
  • Choose LangGraph when you need explicit state, branching, human checkpoints, and durable orchestration for a custom agent system.
  • Choose LlamaIndex when retrieval from documents and knowledge stores is the hardest part of the analyst workflow.
  • Choose OpenAI Agents SDK when you want a smaller set of agent, tool, handoff, and guardrail primitives.
  • Choose Google ADK when the assistant needs to fit closely into Google Cloud and its enterprise ecosystem.
  • MCP support is now common, so the more useful question is whether a product consumes MCP tools, exposes the finished application through MCP, or does both.
  • Resumable conversations, saved workflow state, and durable execution solve different problems. Test the exact failure and recovery behavior your production workflow requires.

An AI analyst assistant has to do more than answer a question convincingly. It needs to reach the right data, use the correct business logic, show how it produced the result, and recover safely when a tool call or long-running workflow fails.

That makes framework selection an architectural decision. A team building a research agent over thousands of filings needs different foundations from one turning forecasting code into an interactive application for finance users.

This comparison covers six open-source agent frameworks and one adjacent application platform, Plotly. Plotly is included deliberately. It represents the finished analyst experience many teams are trying to build with the other tools. It is not presented as though it were the same kind of product.

The products are not universally ranked from best to worst. Plotly leads this list for teams that want to move from AI-assisted analysis to a governed, interactive data application. The other entries remain stronger fits when the primary requirement is low-level orchestration, retrieval, provider-specific infrastructure, or typed agent development.

How we evaluated the shortlist

We selected products that can play a material role in an AI analyst architecture and have an active open-source or company-backed production path. We evaluated each option against the same six questions:

  1. What are you buying or adopting? A framework, an orchestration runtime, a retrieval system, or a finished analyst application platform.
  2. How does the agent coordinate work? Through a loop, graph, workflow, crew, handoff, or application session.
  3. How does it reach data and tools? Through Python integrations, retrieval pipelines, function tools, MCP, or application callbacks.
  4. What can be inspected and verified? State, traces, retrieved evidence, typed outputs, generated code, or the application logic itself.
  5. How does work recover? Conversation persistence, saved workflow context, checkpoints, or an external durable-execution system.
  6. What is the production path? Open-source self-management, managed cloud, private deployment, or a commercial enterprise platform.

We use MCP support precisely. Consuming an MCP server lets an agent call external tools. Exposing an application as an MCP server lets other agents use that application. Those are related but different capabilities.

AI agent frameworks and platforms compared

Product

Product type

Designed for

Orchestration model

MCP role

Recovery model

Production and commercial path

Plotly

AI analyst application platform and Python app ecosystem

Code-verifiable analysis delivered as an interactive application

Agentic Studio session plus Dash application logic and callbacks

Plotly Cloud connects to AI assistants; Dash apps can expose approved data and callbacks as MCP tools

Application sessions and platform operations; not a general durable workflow engine

Dash Open Source; Plotly Cloud; self-hosted Dash Enterprise

LangChain

General-purpose agent framework

Teams prioritizing a wide model, tool, and retrieval integration ecosystem

Agent loop built on the LangGraph runtime

First-party adapters consume MCP servers

LangGraph-backed persistence where configured

Open-source library plus LangSmith observability and deployment

LangGraph

Stateful orchestration framework

Long-running workflows with explicit branching, state, and human intervention

Directed state graph

Can use MCP-connected tools through the surrounding stack

Graph checkpoints and durable execution when a checkpointer is configured

Open source plus LangSmith deployment options

CrewAI

Multi-agent framework

Role-based agent teams and event-driven business workflows

Crews, processes, and Flows

MCP servers can be used as tools

Flow state persistence and resume; validate the boundaries of recovery for the chosen design

Open source plus CrewAI’s managed and enterprise platform

LlamaIndex

Data and retrieval framework

Agents that must reason over private documents, indexes, and knowledge sources

Event-driven workflows and agents

MCP tools are available through supported integrations

Workflow context can be serialized; recovery behavior depends on the workflow design and storage

Open source plus LlamaParse managed services

OpenAI Agents SDK

Lightweight agent SDK

Teams wanting a small set of agents, tools, handoffs, guardrails, sessions, and tracing

Agent loop with handoffs and agents-as-tools

Supports hosted and local MCP servers

Sessions preserve conversation history; run state can be serialized, but this is not automatic end-to-end workflow durability

Open-source SDK; model and hosted-tool usage are metered separately

Google ADK

Multi-language agent framework

Teams building around Gemini, Vertex AI, Google Cloud, or A2A interoperability

Agent hierarchy with sequential, parallel, loop, and custom agents

Built-in MCP tooling

Resumability can be configured; support and behavior vary by SDK and custom-agent design

Open source plus Google Cloud deployment services

1. Plotly

Plotly Dash app exploring coffee flavor data with interactive charts and filters.

Designed for: Teams that want an AI analyst to produce an interactive, inspectable application rather than stop at a chat response.

Plotly Studio uses natural-language instructions and data to generate code-backed analysis and Dash applications. That changes the deliverable. Instead of returning only prose or a static chart, the workflow can produce an application in which users filter data, adjust assumptions, inspect results, and continue the analysis.

Plotly is the clearest choice in this comparison when the assistant’s output needs to become a maintained analytical product.

What makes Plotly different

  • The output is inspectable Python. A team can review the calculations, transformations, and visualization logic instead of treating the final answer as an opaque model response.
  • The analyst experience and the production application share a stack. Teams can build with Dash Open Source, publish through Plotly Cloud, or operate applications inside their own infrastructure with Dash Enterprise.
  • MCP works at the application layer. With Dash MCP, a Dash app can expose selected data and callbacks as an MCP server. An AI client can then call the application’s governed functions rather than reconstructing its calculations from a screenshot or prompt.
  • Plotly supports builder-facing and viewer-facing AI. Plotly Studio helps create the application. Plotly Studio Embedded, in beta on Plotly Cloud, adds a conversational layer for authenticated app viewers to explore registered application data.
  • The enterprise route supports controlled infrastructure. Dash Enterprise is self-hosted on Kubernetes, supports internet-restricted and air-gapped installations, and can run Plotly Studio against an organization-selected LLM provider behind its firewall.

Where Plotly is the better choice

LangGraph, CrewAI, and the provider SDKs offer broader control over arbitrary agent workflows. If the requirement is to build a general agent system that coordinates tickets, emails, browser actions, and data tools, one of those frameworks is the more direct foundation.

If the requirement is an AI analyst application with Python calculations, interactive controls, custom visuals, governed deployment, and a result that people can continue using, Plotly is the better choice because those capabilities belong to the finished application rather than a separate interface the team still has to build.

Limitations and buying checks

Plotly is not a replacement for a document-ingestion and retrieval framework. Teams analyzing contracts, filings, or large unstructured corpora may pair it with LlamaIndex.

It is also not a general durable-execution engine. Long-running, cross-system agent workflows may still need LangGraph, Temporal, or another orchestrator behind the application.

Commercial path: Plotly offers a free Plotly Cloud plan, a paid Pro plan, and custom enterprise pricing. Check the current Plotly pricing page for app, viewer, credit, and deployment information.

2. LangChain

Designed for: Teams that want a large ecosystem of model, tool, retrieval, memory, and observability integrations.

LangChain remains the broadest entry point in this list. Its higher-level agent APIs reduce the amount of plumbing required to connect a model to tools, while the current agent runtime uses LangGraph underneath.

Why teams choose it

  • A wide integration ecosystem makes it easier to test models, vector stores, retrievers, and tools without designing every adapter from scratch.
  • First-party MCP adapters allow agents to use tools exposed by MCP servers.
  • LangSmith provides tracing, evaluation, observability, and deployment around the open-source framework.

Where it fits

Choose LangChain when ecosystem breadth and fast composition matter more than direct control over every transition. If the agent later requires explicit state machines, complex branches, or tightly controlled recovery, move down a layer to LangGraph rather than stacking more implicit chains.

Limitations and buying checks

Abstraction speeds up common work, but it can also make control flow harder to follow. Decide which layer owns state, retries, tool errors, and evaluation before production.

LangChain is not durable by default. Its agents can inherit LangGraph persistence when a checkpointer and storage are configured; the application still needs a deliberate recovery design.

Commercial path: The core libraries are open source. LangSmith adds paid observability and deployment services; review current usage and seat pricing directly with LangChain.

3. LangGraph

Designed for: Stateful agent workflows whose branches, interrupts, approvals, and recovery points need to be explicit.

LangGraph models a workflow as a graph of nodes and state transitions. That makes it a strong foundation when an analyst assistant must pause for approval, call several tools, revisit an earlier step, or resume a long-running task.

Why teams choose it

  • Explicit state makes complex agent behavior easier to inspect than an open-ended tool loop.
  • Checkpointers can save graph state so a workflow resumes from a recorded point.
  • Human-in-the-loop interrupts can be part of the graph rather than an afterthought in the interface.
  • It works closely with LangChain integrations without requiring the higher-level LangChain agent abstraction.

Where it fits

LangGraph is the strongest orchestration choice here for teams that need to design the full analyst workflow themselves and want state, branching, and recovery to be visible in code.

Plotly solves a different layer. LangGraph can orchestrate retrieval, validation, and approvals, while a Dash application presents the result and exposes governed analytical functions to users or agents.

Limitations and buying checks

A graph does not create the analyst-facing application. Teams still need to build authentication, interactive outputs, application state, deployment, and support around the workflow.

Durability also depends on configuration. Test the selected checkpointer, storage backend, idempotency rules, and side effects under real failure conditions.

Commercial path: LangGraph is open source. LangSmith provides managed deployment, observability, and enterprise options.

4. CrewAI

Designed for: Teams that find role-based agents and event-driven Flows a natural way to model collaborative work.

CrewAI separates the workers from the workflow. Crews define agents, roles, tasks, and collaboration patterns; Flows coordinate events, state, and control logic around them.

Why teams choose it

  • Role-based design maps cleanly to familiar responsibilities such as researcher, analyst, reviewer, and report writer.
  • Flows provide explicit start, listen, and route behavior for production workflows.
  • MCP servers can be connected as tools, reducing custom integration work.
  • The commercial platform adds deployment, monitoring, and management around the open-source framework.

Where it fits

CrewAI is a practical choice when subject-matter teams can describe the workflow as specialized roles and handoffs. It is especially useful for prototyping a multi-agent operating model before committing to a lower-level graph.

Limitations and buying checks

Roles and backstories can make a prototype intuitive without guaranteeing reliable execution. Put critical business rules in deterministic code and guardrails, not only in role prompts.

CrewAI documents persistent Flows and resumable workflows, but recovery depends on how the Flow, tasks, and external side effects are structured. Test failure in the middle of a tool call, not only between completed Flow steps.

Commercial path: The framework is open source. CrewAI also offers a managed automation platform and enterprise plans.

5. LlamaIndex

Designed for: Assistants whose hardest problem is retrieving the right evidence from private, heterogeneous data.

LlamaIndex began with data ingestion and retrieval, then expanded into agents and event-driven workflows. Its strongest reason to appear on an AI analyst shortlist is still the data layer: parsers, indexes, retrievers, query engines, and evaluation tools for grounding answers in enterprise information.

Why teams choose it

  • LlamaIndex offers strong document ingestion and retrieval primitives for RAG-heavy applications.
  • Workflows provide event-driven coordination around retrieval and tool use.
  • Workflow context can be serialized and restored when the application supplies the required storage and recovery logic.
  • LlamaParse, LlamaIndex’s hosted platform, adds managed parsing, extraction, indexing, and retrieval services.

Where it fits

Choose LlamaIndex when an analyst assistant must work across filings, policies, research, contracts, or other documents that require parsing and retrieval before analysis begins.

For a user-facing analytical application, LlamaIndex can supply evidence and context while Plotly renders interactive, code-backed outputs and provides the production experience.

Limitations and buying checks

Retrieval quality depends on document parsing, chunking, metadata, permissions, indexing, reranking, and evaluation. A large connector list does not remove that design work.

Serializable context should not be treated as automatic durable execution. Confirm when state is written, what happens to in-progress tool calls, and whether external writes are idempotent.

Commercial path: The framework is open source. LlamaParse provides paid managed services with usage-based and enterprise options.

6. OpenAI Agents SDK

Designed for: Teams that want a compact set of production agent primitives without adopting a larger orchestration framework.

The OpenAI Agents SDK centers on agents, tools, handoffs, guardrails, sessions, and tracing. It supports both hosted tools and external MCP servers while keeping the programming model relatively small.

Why teams choose it

  • Handoffs and agents-as-tools support specialist-agent patterns.
  • Guardrails can validate inputs and outputs around an agent run.
  • Built-in tracing helps teams inspect model calls, tool use, and handoffs.
  • The SDK supports several MCP transports and can reuse existing MCP servers.
  • Sessions and serialized run state support conversation continuity and selected resume patterns.

Where it fits

Choose the SDK when the team wants to build a custom assistant with clear primitives and already plans to own the surrounding application, persistence, and deployment architecture.

Limitations and buying checks

The SDK’s name can lead buyers to assume complete provider portability. It supports non-OpenAI models through compatible interfaces and custom clients, but capability parity, hosted tools, and tracing behavior can vary. Test the models and tools you intend to use.

Sessions store conversation history. Serialized run state can support resumption. Neither provides automatic, distributed, end-to-end durable execution across arbitrary side effects.

Commercial path: The SDK is open source. Teams pay for the models and hosted services they use.

7. Google Agent Development Kit

Designed for: Multi-agent systems that fit naturally into Google Cloud, Gemini, Vertex AI, and A2A-based architectures.

Google ADK supports Python, TypeScript, Go, Java, and Kotlin. It provides several agent types, including sequential, parallel, loop, LLM-driven, and custom agents, along with development, evaluation, and deployment tooling.

Why teams choose it

  • ADK aligns closely with Gemini and Google Cloud services.
  • Built-in MCP tooling connects agents to standardized external tools.
  • A2A support lets separately deployed agents communicate through a common protocol.
  • Resumability can be enabled for supported agent workflows.

Where it fits

Choose ADK when the organization already runs its data and AI workloads on Google Cloud or needs A2A interoperability between separately managed agents.

Limitations and buying checks

ADK offers more than persistent sessions. Conversation persistence and workflow resumption are separate capabilities. Resumability must be configured, and custom agents require additional implementation.

Support also varies across language SDKs. Check the exact SDK for session services, resume behavior, MCP, A2A, and deployment features before standardizing across a multilingual team.

Commercial path: ADK is open source. Production cost comes from the selected Gemini, Vertex AI, storage, compute, and deployment services.

How to choose an AI agent framework for an analyst assistant

Start with the final user experience

If users need a conversational research assistant, start with retrieval, citations, and orchestration. If they need to change assumptions, run scenarios, inspect charts, and reuse the result in a business workflow, start with the application.

That is where Plotly changes the shortlist. A framework can coordinate the agent, but it does not automatically give the team an interactive analytical application with governed sharing and deployment.

Separate three kinds of recovery

Ask vendors and engineering teams to demonstrate all three:

  • Conversation continuity: Can the assistant remember the thread after a user returns?
  • Workflow resume: Can a paused or interrupted run continue from a saved state?
  • Durable execution: After a process or worker fails, can the system recover without repeating completed side effects?

A product can support one without supporting the others.

Test MCP in both directions

Most agent frameworks can now consume MCP tools. That no longer settles the decision.

For analyst applications, ask whether the finished system can also expose governed functions and data to other agents. Dash supports this application-side model: teams can decide which callbacks and data the MCP server makes available, and Plotly Cloud can apply the app’s existing access model to connected clients.

Make verification concrete

Observability can mean a trace of model calls, a graph checkpoint, retrieved citations, a validated schema, or executable application code. Decide which evidence a skeptical reviewer needs.

For a numerical answer, a trace of prompts is rarely sufficient. The reviewer may need the source data, transformation, calculation, code version, and application state that produced the number.

Price the operating model, not only the framework

Open-source licensing does not make the production system free. Include model tokens, retrieval and embedding, storage, tracing, evaluation, deployment, secrets, identity, infrastructure, support, and the engineering work required to build the interface.

Plotly carries a commercial platform cost on the Cloud or Enterprise path, but it can replace work the team would otherwise do to build, secure, deploy, and operate the analyst-facing application around a framework.

Recommended architectures by requirement

Requirement

Start with

Add when needed

Interactive AI analyst app with custom Python logic

Plotly Studio, Dash, and Plotly Cloud or Dash Enterprise

LangGraph or another orchestrator for long-running cross-system workflows

Durable, stateful agent workflow

LangGraph

Plotly for an analyst-facing application; LlamaIndex for retrieval

Role-based multi-agent process

CrewAI

Plotly for interactive analytical delivery

Document-heavy research assistant

LlamaIndex

Plotly for interactive evidence review and quantitative analysis

Lightweight custom agent

OpenAI Agents SDK

An external durable runtime if workflows become long running

Google Cloud-centered agent system

Google ADK

Plotly when results need custom interactive data applications

Final recommendation

Choose the framework according to the hardest part of the system.

If that is orchestration, LangGraph provides the clearest control over state and branching. If it is retrieval, LlamaIndex deserves the first technical evaluation. If it is integration with Google Cloud, Google ADK provides the strongest ecosystem fit.

Choose Plotly when the difficult part is delivering a trustworthy AI analyst experience that people can keep using: an interactive application backed by reviewable Python, connected to governed data and functions, and deployable through a managed cloud or inside the organization’s infrastructure.

That recommendation comes with a real tradeoff. Plotly gives the team a broader application and deployment path because it is more than an orchestration library. For general-purpose agents, it will often sit alongside one of the frameworks in this list rather than replace it.

Before committing, run one representative analyst task through the proposed stack. Interrupt it during a tool call, change a metric definition, ask a second user to verify the answer, and trace the result back to its source data and code. The framework that survives that test is more valuable than the one with the longest feature list.

For teams ready to move from an AI prototype to a governed analytical application, explore Plotly Studio or request a Dash Enterprise demo.

Frequently asked questions

bluesly
x
instagram
youtube
medium
fcaebook

Product

© 2026
Plotly. All rights reserved.
Cookie Preferences
aicpa/soc2