In this article, we compare CrewAI, AutoGen, Vertex AI, and LangGraph, four modern multi-agent frameworks, in the context of enabling natural-language (NL) querying and self-service analytics on data platforms.
We explore each in terms of key dimensions (NL-to-SQL querying, BI integration, orchestration, semantic-layer support, dev experience, deployment, and target users) and provide small proof of concept (POC) examples.
All claims are backed by current documentation and real-world use cases as of mid-2025.
The information in this article is subject to change in the next several of months, or next year.
POCs are focusing on multi-agent capabilities (2-3 agent nodes maximum).
AutoGen overview
AutoGen (by Microsoft) is an open-source, multi-agent conversation framework that emphasises multi-agent collaboration. It provides high-level abstractions for agents to chat, plan, and work together, even with human participation.
The authors describe it as “an open-source programming framework for agentic AI” and it has a large community of ~45.7k GitHub stars.
AutoGen is very flexible, allowing you to wire agents together (e.g. AssistantAgent), share memory, and call tools.
Query data warehouse
AutoGen itself does not include built-in connectors to Snowflake or BigQuery. Instead, it allows agents to use custom tools (Python functions or MCP servable tools). In practice, one can integrate database connectors manually.
For example, Nexla built the Nexla Orchestrated Versatile Agents (NOVA) on AutoGen. It executes SQL transformation, being able to run code or SQL on Snowflake or BigQuery as needed.
NOVA lets developers define a Python tool that uses the BigQuery or Snowflake client library and give it to the agent. Then, AutoGen’s AssistantAgent can call that function when appropriate. The framework even auto-wraps Python functions into tools.
Thus, while not automatic, NL2SQL is fully possible by integrating an external tool or by prompting the model and running the result.
BI integration
AutoGen does not provide specific BI / dashboard connectors out of the box. However, since tools can be arbitrary code, you can have an agent use a charting library or call a BI API (like Looker or PowerBI) as a tool. The framework’s focus is more on conversational workflows than end-user BI.
In essence, integrating with dashboards would be a custom integration; e.g. an agent gathers insights and then pushes data via an API to a dashboard or returns results that a developer can visualise.
Orchestration and tools
AutoGen’s core strength is agent orchestration. It supports multi-agent teams where agents can specialise and pass messages. Agents can call each other and coordinate.
It is important to mention that tools can be any Python function or class; AutoGen automatically converts them to callable tools for the agent.
We learn from the documentation that you can simply pass a Python function into AssistantAgent(name=..., tools=[func], ...).
Agents also support human-in-the-loop by stopping for human feedback if configured. Overall, AutoGen is highly customisable and supports complex topologies, making it ideal for bespoke agentic workflows.
Semantic layers
There is no built-in semantic-layer feature in AutoGen. However, like Snowflake tools, one can query any semantic layer via a custom tool. For example, a Python tool could call the dbt Semantic Layer (MCP server) or Snowflake’s Cortex API and return metrics.
AutoGen’s flexibility allows it to interact with such layers if the integration is coded.
Developer experience and community
AutoGen is a mature open-source project with extensive docs and a big GitHub repo. The documentation includes examples for multi-agent teams, customising agents, and workflow patterns. It has Discord and community channels.
Since it is lower-level, developers need to write Python code for workflows, but that also means full flexibility. Tools and agent behaviour can be inspected, as the framework shows tool calls and reasoning steps in detail.
The code examples, such as defining an AssistantAgent with a web_search function, show that get an agent working is perfectly straightforward.
In short, AutoGen is well-documented, comes with a wide set of examples, and has an active community that makes it easy to find support.
Deployment
AutoGen is open-source only. There is no managed cloud service; you run it as a Python library. It supports running on your own infrastructure (e.g. local, server, Kubernetes). This means you get full control but more operational responsibility.
Some startups and consulting products have packaged AutoGen into services, but the core is a code library.
Suitability and segments
AutoGen is aimed at technical teams that need custom multi-agent systems. Its learning curve is steeper, so it works best for organisations with strong engineering resources.
Consulting firms can leverage AutoGen’s flexibility for complex agentic solutions, such as data transformation pipelines. For startups or SMEs, AutoGen is a good choice if they need highly-custom automation (e.g. a team of agents orchestrating ETL) and have the development resources.
Non-technical users would typically not use AutoGen directly; instead, data engineers or AI engineers would build AutoGen-based tools for them.
In summary, AutoGen is favoured by large enterprises or technical teams that need bespoke agent workflows, rather than turnkey BI products.
Example POC
Here is a minimal AutoGen multi-agents solution that uses custom tool functions (query_mock_database, format_report). You can see how to create two AssistantAgent(s) with a function tool specialised for each, and how they coordinate in a RoundRobinGroupChat:
🔗 View complete POC code on GitHub.
CrewAI overview
CrewAI is an open-source multi-agent framework focused on role-based crews of AI agents. It provides high-level abstractions (agents, crews, flows) for automating complex tasks.
CrewAI emphasises simplicity and quick start; its documentation describes it as a "lean, lightning-fast Python framework built entirely from scratch, completely independent of LangChain or other agent frameworks".
It has strong community adoption, with 32.7k GitHub stars and a commercial CrewAI Enterprise offering for production features.
Query data warehouse
CrewAI includes a Snowflake tool that lets agents execute SQL against Snowflake warehouses. For example, one can configure a SnowflakeSearchTool with credentials, then define an agent using this tool to answer NL tasks, such as “Query the sales data for the last quarter”. There is also an NL2SQL tool to translate NL to SQL.
CrewAI does not include a built-in BigQuery connector by default, but users can add a generic SQL or custom tool (e.g. via Python) to query BigQuery.
BI integration
CrewAI advertises use cases in business intelligence and dashboards. Its website explicitly lists “Business Intelligence Dashboards: Implement AI for real-time BI, transforming data into actionable insights”.
In practice, agents can use CrewAI’s SQL tools to feed results into visualisation libraries or BI APIs. For example, there is a community tutorial for building a simple AI-driven BI report using CrewAI and OpenAI.
CrewAI also has connectors for common enterprise apps and exposes APIs, making it possible to push or fetch data from BI platforms.
Orchestration and tools
CrewAI provides built-in orchestration, with agents operating in crews with defined tasks, supporting human feedback during execution. It includes pre-built tools like database connectors, vector search, web APIs that agents can invoke.
The Crew Control Plane (enterprise) offers a UI to manage agents and monitoring. CrewAI’s programming model handles retries, async execution, caching, and provides a simple verbose mode for tracing.
The framework is opinionated, abstracting away much of the orchestration, but allows low-level control via custom flows and event listeners.
Semantic layers
CrewAI does not natively implement semantic layers (like dbt or Snowflake semantic views), but it can query any SQL-accessible object. In principle, an agent could query a dbt metrics layer or Snowflake semantic views by treating them as tables.
CrewAI also supports connecting to Model Context Protocol (MCP) servers as tools via its MCP Servers as Tools Guide, which means it could plug into a dbt or Snowflake semantic service if exposed via MCP.
Developer experience and community
CrewAI’s documentation is extensive, with quick starts and dozens of pre-built tools. The core library is MIT-licensed on GitHub, and there is a growing community forum.
In terms of learning resources, there are tutorials on CrewAI’s blog as well as on third-party blogs. A free online course, CrewAI University, has certified 100,000+ developers.
In short, being newer, CrewAI has fewer third-party tutorials than LangChain ecosystems. However, it is well-documented and widely used.
Deployment
CrewAI supports open-source self-hosting and a managed cloud offering. The website states it works in the cloud, self-hosted or locally.
The Enterprise Suite adds features for security and observability. Organisations can deploy CrewAI on-premises or in any cloud, giving full control over data and LLM APIs.
Suitability and segments
CrewAI’s ease-of-use makes it attractive to teams that want to quickly prototype NL agents without heavy infrastructure work.
Its adoption by ~60% of Fortune 500 (per website) suggests it scales to large enterprises. Consulting firms can leverage CrewAI to build custom data bots for clients, as it simplifies agent development. For startups and SMEs, CrewAI’s open-source, low-code nature is appealing; technical teams (data engineers, ML engineers) would find it straightforward to integrate with Snowflake.
Non-technical users would rely on developers, since agent definitions require coding both the tasks and the tools.
Example POC
This multi-agent data analytics demo features two specialised agents: a data analyst that converts natural language to SQL queries using a MockSQLTool, and a report writer that formats results into business-friendly reports.
Built on CrewAI's role-based framework, it demonstrates orchestrated agent collaboration through sequential tasks within a Crew:
🔗 View complete POC code on GitHub.
Vertex AI overview
Vertex AI is Google Cloud’s managed framework for building production agents. It provides an Agent Development Kit (ADK) in Python, multi-agent orchestration, and a hosting environment. Google markets it as “build production-ready agents in under 100 lines of code”.
The platform includes managed runtimes (Agent Engine), memory, RAG (Vertex AI Search), and connectors to Google tools. It is vendor-specific, as it requires Google Cloud, but integrates deeply with Google’s data stack.
Query data warehouse
Vertex AI naturally integrates with Google data services. For BigQuery, Google provides examples and connectors to let agents query BigQuery.
For example, a Vertex AI conversation agent can use a Cloud Run hosted function to run BigQuery SQL. The POC blog shows a chat agent that sends NL to a Vertex conversational agent, which uses a BigQuery tool to retrieve data.
Snowflake is not a first-party service in Google Cloud; querying Snowflake would require a custom connector, such as. an Apigee proxy or MCP server, since Vertex does not natively provide a Snowflake tool.
In contrast, BigQuery and Google SQL are first-class: ADK supports an underlying Vertex AI search retriever for BigQuery metadata, whose sample repo is available here.
BI integration
Vertex integrates with Google’s BI tools. Notably, Google has announced that BI platform Looker now supports conversational analytics via Gemini on Vertex AI with the same semantic model. This means that Vertex agents can interact with a governed data model through Looker. Practically, you could deploy an agent that queries Looker dashboards or uses Looker’s APIs.
Moreover, since Vertex runs on Google Cloud, it can push results to Data Studio or Looker automatically.
The Agent Builder includes Vertex AI Search for RAG and a variety of data connectors (see below), making it easy to retrieve data from enterprise BI sources.
Orchestration and tools
Vertex’s ADK supports multi-agent workflows and includes a suite of built-in capabilities. You write Python code using their ADK library to define agents and a workflow. ADK supports the MCP, practically letting agents tap into any MCP-compatible data source.
There are 100+ pre-built connectors for Google and 3rd-party services, and Vertex agents can use Google Search, Code Execution, Vertex AI Search (a RAG tool), or custom tools.
The platform provides the Agent Engine, a fully-managed runtime that handles scaling, memory (short- and long-term), retries, and monitoring.
Inter-agent communication follows Google’s Agent-to-Agent protocol (A2A). Essentially, Vertex offers a cloud-managed orchestration layer, meaning you do not need to build any agent infrastructure yourself.
Semantic layers
Vertex AI is designed to work with enterprise semantic models. Looker, for example, shows a trusted semantic model is used for conversation.
In fact, Vertex specifically mentions MCP support, noting that “agents connect to the vast and diverse data sources [...], leveraging MCP-compatible tools”. This means a Vertex agent can query a dbt semantic layer by pointing to the dbt MCP server.
For Snowflake semantic views, Vertex could integrate via Apigee or by using Snowflake’s Cortex APIs if exposed. But mainly, Vertex is built around Google’s own semantic tooling (BigQuery LookML, Vertex AI Search, etc.).
Developer experience and community
As a Google product, Vertex AI has extensive documentation, codelabs, and sample code. The ADK library is relatively new, but there are official guides and community blog posts on common use cases like. SQL query agents.
Since this is a managed cloud service, the experience here is different from an open-source library; it requires a GCP account, and much of the behaviour is specified in cloud resources rather than pure code.
The community is smaller than open-source (no GitHub stars to cite), but many Google Cloud customers and partners are adopting it, and Google shares success stories.
Tools like Vertex AI Search and Agentspace, the enterprise agent catalogue, are unique to Google’s ecosystem.
Deployment
Vertex AI Agent Builder is fully managed on Google Cloud; you do not self-host it. Agents run in Google’s infrastructure, i.e. Agent Engine.
That means you trade flexibility for convenience: you get auto-scaling and a UI, integrated security, but you are locked into Google’s environment.
There is no open-source variant of Agent Builder. Vertex has an Agent Garden with pre-built agents and connectors. Essentially, deployment is cloud-only, though you can connect it to external systems via MCP, Apigee, etc.
Suitability and segments
Vertex is best suited for enterprises already on Google Cloud that have complex data platforms and are looking for a turnkey solution.
Consulting firms building on GCP could use Agent Builder for clients, especially if the latter have Google services like BigQuery, Looker, Google SQL at the core of their systems. For startups/SMBs, Vertex may be less relevant unless they use GCP because of the usage cost and the vendor lock-in.
Vertex lowers the barrier for non-experts to build agents (aka the low-code pitch), so it can serve teams without deep ML ops skills. Technical teams get the advantage of integrated scaling and Google’s AI tech; non-technical business users can interact via conversational UI or dashboards powered by the agents.
Example POC
Let’s explore a multi-agent workflow on Google' ADK with two specialised agents: a sql_query_agent that converts NL to SQL and executes queries via execute_sql_query(), and a data_analysis_agent that processes results and generates business insights via analyze_data().
Built on SequentialAgent orchestration, this solution demonstrates a Google Cloud native integration with Gemini-2.0-flash model with the fancy built-in Chatbot web UI.
🔗 View complete POC code on GitHub.
LangGraph overview
LangGraph (by LangChain Inc.) is a stateful, graph-based orchestration framework for building complex multi-agent applications.
Unlike CrewAI’s high-level roles or AutoGen’s multi-chat style, LangGraph models agent workflows as directed graphs of nodes of agents, tools, and memory. It provides fine-grained control and built-in support for streaming outputs, memory, and monitoring.
LangGraph is open-source (13.9k GitHub stars) but also offered as a managed platform, namely LangGraph Platform, for easy deployment.
The vendor touts LangGraph as enabling “reliable, production-ready agents” with full observability.
Query data warehouse
LangGraph itself is agnostic to data sources. It can integrate with LangChain tools or any custom tool. For example, the LangChain ecosystem provides a Snowflake connector for vectors, and you can use LangChain’s SQL toolkit for databases. In fact, community examples (mentioned in Vertex AI POC section) show LangGraph is used to build agents that query BigQuery, such as an agent pipeline (LangGraph + Vertex Agent Builder + LangChain) that retrieves BigQuery schema, generates SQL, executes it, and returns charts.
Similarly, LangGraph can incorporate Snowflake queries by using a tool node that wraps the Snowflake connector (as CrewAI does). In short, like AutoGen, LangGraph relies on custom tools/chain components to query Snowflake or BigQuery.
BI integration
LangGraph is primarily a backend framework, so it does not directly automate dashboards. However, it can generate insights to be then visualised by a frontend. In a BigQuery / BI agent example, after LangGraph generated SQL and executed it, the solution “generate[d] insightful visualisations to support decision-making”. This suggests that LangGraph workflows can include steps that call charting libraries or BI APIs.
LangGraph also has memory and streaming support, which could drive real-time dashboards or streaming reports. There is no out-of-the-box BI integration, but flexible enough to push results to any BI tool.
Orchestration and tools
LangGraph is designed for explicit orchestration. You define a stateful graph where each node is an agent or tool. The flow of information is explicit via edges. The official site emphasises features like token-by-token streaming (to show intermediate reasoning), “long-term memory to recall information across sessions,” and fault-tolerant scaling with task queues. In practice, developers use the LangGraph Python API to build these graphs.
LangGraph comes with built-in notions of memory, replay, check-pointing, and even visual tools for debugging. It is less opinionated than CrewAI, and you need to manage states and transitions yourself.
It is also worth noting that it offers the most granular control. LangGraph Platform (the SaaS) provides 1-click deployment and monitoring (LangSmith).
Semantic layers
LangGraph does not specifically target semantic layers, but as with others, it can query them if given the proper tools. A Snowflake agent blog article shows how you can use LangGraph with Snowflake Cortex tools like Cortex Search or Analyst to interpret NL queries.
A LangGraph workflow could branch like so:
- One path sending user input to Snowflake Cortex Analyst, which returns SQL;
- Another path using Cortex Search vector search).
So LangGraph can work as the glue between NL and semantic-layer services.
Similarly, for dbt, you can connect a LangGraph agent to a dbt MCP server if exposed as a service. There is no built-in support, but the framework’s flexibility allows it.
Developer experience & community
LangGraph is part of the LangChain ecosystem, which is widely used. It has official documentation, and is deeply integrated with LangSmith for logging and monitoring. The open-source library is mature.
LangChain’s strong community means a lot of shared templates and examples. Developers who need complex multi-step logic and safety checks find LangGraph powerful.
Onboarding is steeper (graph vs. simple agents), but it offers debugging tools and a visual builder in the platform.
Deployment
You can use LangGraph as an open-source framework or via the LangGraph Platform. The framework itself is MIT-licensed, so you can self-host and integrate with any LLM.
The platform is SaaS (currently beta free) or you can opt for self-hosting; it provides built-in APIs, UI, and scaling.
In short, you can either run LangGraph code on your own servers or deploy on LangGraph’s managed infrastructure. This hybrid option makes it versatile: small projects can use open-source mode, while enterprises can pay for the managed offering with SLA.
Suitability and segments
LangGraph is ideal for technical users and large enterprises tackling complex workflows. Its power comes at the cost of complexity. A consulting firm with a need for sophisticated LLM-based products, such as generative research assistants, multi-step data pipelines, may benefit from LangGraph for its control.
Startups or small companies might find it an overkill unless they have significant engineering resources.
That said, LangGraph’s flexibility means it can easily scale from prototyping to production. It might be a good option for data platform teams that want a robust, debuggable agent architecture. Non-technical analysts likely would not use it directly, but they could interact with LangGraph-based apps built by developers.
Example POCs
Example 1: Graph-based workflow for data analytics
A stateful, graph-based workflow for data analytics with four sequential nodes:
- Query understanding (parses natural language intent);
- SQL generation (creates SQL from intent);
- Execution (runs queries on mock data);
- Formatting (creates business reports).
Built on StateGraph architecture, this solution demonstrates visual workflow representation, state management across nodes, error handling at each step, and provides real-time execution tracking with step history.
🔗 View full POC code on GitHub.
Example 2: LangGraph + CrewAI Agents
Combining LangGraph with CrewAI Agents that connects to dbt's semantic layer for natural language data queries regardless of data warehouse providers.
Example 3: LangGraph + Vertex AI
In another POC that combines LangGraph + Vertex AI, a chat agent receives a NL question (e.g. “How much is the total volume by sales?”) and then calls a Cloud Run function to execute the BigQuery SQL, returning the result.
The sequence is: User ➔ Vertex Conversation Agent ➔ BigQuery tool ➔ Answer.
In this hypothetical code, run_bigquery is a cloud function (hosted separately) that takes a query string and returns the BigQuery result. Google’s official example uses exactly this pattern: the agent invokes a tool backed by a cloud function to get BigQuery data.
A snippet illustrating this might look like:
AI frameworks comparison demo
Let’s run the POC examples to see how they run in action.
CrewAI, AutoGen, Vertex AI, and LangGraph feature comparison
Recommendations and use cases matrix
We have found that many use cases combine LangGraph with other frameworks. However, if we would like to use a single framework alone, below are the recommendations based on the framework strengths for certain scenarios.
When should you use CrewAI
We recommend CrewAI for teams that aim to strike a balance between ease-of-use and power. The Snowflake integration and pre-built tools make it ideal for data teams that need to spin up NL query bots quickly, e.g. turn Snowflake / SQL into conversational BI.
The availability of a cloud-hosted enterprise option appeals to consulting firms and large companies requiring security and monitoring. It works well for both startups and enterprises, as long as a technical person codes the agents. Non-coders can still use the CrewAI UI to manage agents and review outputs.
When should you use AutoGen
AutoGen is your go-to choice when you need custom multi-agent collaboration. If your use case involves a complex workflow like data transformations, multi-step analysis, automated dashboard generation with human review, AutoGen gives maximum flexibility.
It has no managed hosting, so it suits organisations with strong engineering or consultants building custom solutions. For example, a data platform team at an enterprise could use AutoGen to implement a conversational “data engineer” that designs ELT pipelines in BigQuery or Snowflake.
However, AutoGen is less suited for quick BI queries, as it requires building the underlying tools.
When should you use Vertex AI
Vortex AI is great for companies already invested in Google Cloud. If your data lives in BigQuery or Looker, Vertex offers the most frictionless path to NL analytics (just consider the Gemini-powered Looker chats).
It is also a good option for teams that lack heavy ML engineering resources, since Google provides much of the infrastructure.
However, it is a closed ecosystem; use it if you can and want to be on GCP. Ideal segments include large enterprises or digital-native firms leveraging Google’s analytics stack. It is less appealing if you require Snowflake-first architecture or pure open-source solutions.
When should you use LangGraph
LangGraph is designed for advanced users. If you need a stateful, complex agent application beyond simple query answering, LangGraph is a strong choice. Its deployment flexibility (SaaS or self-host) suits teams that may later scale up.
For example, a consulting group building a custom financial planning assistant might use LangGraph to manage a long, branching conversation with recall of past data.
It is great for technically sophisticated teams, and for projects where fine control and reliability are paramount. It is generally an overkill for simple Q&A or dashboards.
CrewAI, AutoGen, Vertex AI, and LangGraph suitability by organisation
If you have an enterprise AI use case, and you are ready to start exploring implementations, reach out.
We will analyse your case and help you build a POC around it.
Meanwhile, you might want to check out these articles on the Infinite Lambda Blog:
- How to Build Reliable GenAI for Enterprise: Scalable, Interoperable & Programmable
- Customer Reviews Analytics with Snowflake Cortex: Practical Guide
- How to Implement Model Context Protocol Server with the mcp-fivetran Package
- How to Automate Invoice Classification with GenAI: A Multi-Stage Approach on Snowflake
- DSPy Prompt Automation, Evaluation, and Optimisation: Building a Financial Adviser
- MCP vs Workflow Automation vs LLM-specific function calling for Enterprise
References
- CrewAI Official Documentation (Introduction)
- CrewAI Snowflake Search Tool Documentation
- CrewAI NL2SQL Tool Documentation
- crewAIInc/crewAI GitHub Repository
- AutoGen Documentation (Overview)
- AutoGen AgentChat Documentation
- microsoft/autogen GitHub Repository
- Vertex AI Agent Development Kit (ADK) Documentation
- Building AI Agents with Vertex AI Agent Builder (Google Codelab)
- From Prototypes to Agents with ADK (Google Codelab)
- Vertex AI Search Introduction (Google Cloud Docs)
- google/adk-python GitHub Repository
- google/adk-java GitHub Repository
- LangGraph Official Documentation (LangChain)
- langchain-ai/langgraph GitHub Repository