AG2 vs CrewAI: The Complete Comparison (Including the AutoGen Rebrand Explained)

Here's what most AutoGen vs CrewAI articles won't tell you: the framework you know as AutoGen split into two separate projects in November 2024. One is now called AG2. The other is Microsoft's AutoGen 0.4, a full rewrite that isn't backward-compatible with existing code. Both halves have since moved again — Microsoft put AutoGen into maintenance mode behind a successor framework, and AG2 shipped a 1.0 release that broke compatibility with the very code the fork was created to preserve. If you're searching "autogen vs crewai" today, you need to know which AutoGen you're actually comparing before the comparison means anything.

AG2 (formerly AutoGen) is an open-source multi-agent framework originally developed by Microsoft researchers. In November 2024, the project's original creators forked the codebase and relaunched it as AG2 under the ag2ai GitHub organization. For most of its life AG2 was a drop-in continuation of AutoGen 0.2. That changed on 27 July 2026 with AG2 v1.0, which made a new protocol-driven ag2 package the headline framework and moved the familiar autogen.* classes into a separate project, AG2 Classic. Both lines are maintained. They are no longer the same thing.

CrewAI is a role-based multi-agent orchestration framework that launched in November 2023. It uses a "crew" metaphor where agents carry defined roles, goals, and backstories and collaborate through structured tasks. It is widely described as being built on top of LangChain; that is not the case today, and CrewAI's current release declares no LangChain dependency at all. It's grown to become the most-installed multi-agent framework available.

This comparison covers the architecture difference that actually matters for your workflow, developer experience benchmarks, a full pricing breakdown, the AutoGen Studio capability that every other comparison misses, enterprise readiness, and a decision framework with explicit criteria. We're a neutral index, not an affiliate site, so we'll state the tradeoffs and let you decide.

TL;DR: CrewAI receives roughly 23 million monthly PyPI downloads against AG2's 420,000, and holds 57,100 GitHub stars to the AG2 repository's 4,900 (pepy.tech and GitHub, August 2026). Both projects are permissively licensed and free to self-host — AG2 under Apache-2.0, CrewAI under MIT — and CrewAI no longer publishes a list price for its Enterprise tier. Choose CrewAI for structured, predefined workflows. Choose AG2 for dynamic problem-solving or secure code execution. If you have an existing AutoGen codebase, read the next section before you upgrade anything.

What happened to AutoGen and why was it rebranded to AG2?

AG2 was officially announced on November 11, 2024, when AutoGen's original creators forked the Microsoft-hosted repository and relaunched it under the ag2ai GitHub organization. For eighteen months the promise was continuity: AutoGen 0.2 code ran unmodified. That promise ended with AG2 v1.0, released on 27 July 2026, which AG2's own README states plainly: "AG2 v1.0 (pip install ag2) is not a drop-in upgrade from Classic. The agent model, orchestration, and imports all changed."

The November 2024 split, and the two releases that followed it, left four distinct paths developers must navigate today.

• AG2 v1.0 (pip install ag2): The current AG2. Multi-agent coordination runs through a Network — a Hub that owns the registry, write-ahead log and audit trail, with agents talking over typed channels. This replaces the classic GroupChat, swarm and nested-chat patterns.
• AG2 Classic (ag2ai/ag2-classic, documented at classic.docs.ag2.ai): The autogen.* namespace and the familiar classes — ConversableAgent, AssistantAgent, UserProxyAgent, GroupChat. Still maintained. This is where AutoGen 0.2 compatibility now lives.
• Microsoft AutoGen (github.com/microsoft/autogen): In maintenance mode. Its README carries the notice: "AutoGen is now in maintenance mode. It will not receive new features or enhancements and is community managed going forward."
• Microsoft Agent Framework (pip install agent-framework): Microsoft's successor, merging AutoGen with Semantic Kernel. Microsoft's own documentation calls it "the next generation of both Semantic Kernel and AutoGen" and publishes a migration guide from AutoGen.

Two installation details are worth pinning down, because both have changed and both will quietly hand you the wrong framework. pip install pyautogen no longer installs AG2: the current pyautogen release is version 0.10.0, described as a "proxy package for autogen-agentchat," and it depends on Microsoft's autogen-agentchat. And while AG2's README tells classic users to pip install ag2-classic, that distribution is not on PyPI yet — the package index returns nothing for it as of today. If you are on the classic line, stay pinned to what you already have rather than upgrading on the strength of the README.

Why does this matter for the comparison? The AutoGen that most community tutorials reference, most Stack Overflow answers describe, and most developers have actually built with is AutoGen 0.2. That code still runs, but the thing it runs on is now called AG2 Classic, and it is a sibling of AG2 v1.0 rather than an earlier version of it.

This split also has a licensing consequence, though not the one usually claimed. AG2 is Apache-2.0 licensed, not MIT, with no platform fees beyond LLM API costs. Microsoft's line carries deeper ties to the Azure and Semantic Kernel ecosystem, which introduces indirect cost and vendor dependencies that the original AutoGen community wanted to avoid. The fork was, in part, a decision about who controls the framework's direction and cost structure going forward.

One detail worth flagging for anyone leaning on an AI assistant or a secondary comparison to summarise this: the ground has moved twice since most of that writing was published, and much of what is still in circulation describes AutoGen as a single, actively-developed Microsoft framework. Both the maintenance-mode notice and the AG2 v1.0 split post-date it. That's the gap this article exists to fill, and it's why we cover the rebrand before anything else.

The practical conclusion: if you have an existing AutoGen 0.2 codebase, your continuity path is AG2 Classic, and it is a pin rather than an upgrade. If you're on Microsoft's AutoGen, the forward path is Microsoft Agent Framework, and there is an official migration guide for it. If you're evaluating from scratch, AG2 v1.0, AG2 Classic and Microsoft Agent Framework are three different products that happen to share ancestry.

How do AG2 and CrewAI approach multi-agent systems differently?

According to ZenML's engineering blog, "CrewAI is a role-based orchestration framework designed to make autonomous AI agents collaborate like a human team, while AutoGen promotes open-ended, conversational interactions where agents autonomously debate or solve problems." That single sentence captures the practical fork in the road for most teams, and the architectural difference runs deep enough to affect how you structure your projects from day one.

AG2's model is event-driven and emergent. In AG2 Classic, agents communicate via messages in a multi-turn conversation, and a GroupChat manager controls speaker selection using LLM reasoning, round-robin scheduling, or custom logic you define. AG2 v1.0 keeps the emergent spirit and changes the machinery: coordination runs through a Hub and typed channels — conversation for free-form exchanges between two parties, consulting for strict one-question-one-reply, discussion for round-robin across several agents, and workflow, a declarative TransitionGraph that is the closest analogue to a classic GroupChat. Either way, workflows emerge from agent interaction rather than being prescribed upfront.

The feature that competitors consistently miss: AG2 includes a native Docker-based code execution sandbox. Agents can write Python, execute it securely in a containerized environment, observe the output, and iterate. This isn't a plugin or an integration, it's built in — AG2's documentation has execution defaulting to a Docker container unless you explicitly opt out. One caveat: that documentation is written against the autogen namespace and ConversableAgent, which places it on the Classic line, and we could not establish from AG2's current docs how it carries into the v1.0 package. For code generation, debugging agents, and data analysis tasks that require running code, it still gives you something CrewAI doesn't have natively.

A layering distinction is worth getting right here, because it is routinely attributed to the wrong project. The Core API / AgentChat API split — low-level access to every message and agent behaviour underneath a higher-level abstraction closer to CrewAI's conceptual model — belongs to Microsoft's AutoGen, where it ships as the autogen-core and autogen-agentchat packages. It is not an AG2 feature. If that layering is what appealed to you, its living version is now Microsoft Agent Framework.

CrewAI's model is orchestrator-driven and deterministic. Every agent gets a Role (who they are), a Goal (what they optimize for), and a Backstory (context that shapes their reasoning and constraints). Tasks are discrete units of work with defined outputs, delegated top-down through two process types: Sequential, where each task completes before the next begins, and Hierarchical, where a manager agent delegates work to specialist workers. Context passes automatically between tasks, and CrewAI's own tools package provides broad integration out of the box.

The practical implication is predictability. CrewAI workflows are debuggable because you define the structure upfront and each agent's responsibility is explicit. AG2 workflows can handle problems you didn't anticipate because agents negotiate the solution path. Neither approach is inherently superior. The question is whether you know the answer path before you start building.

AutoGen vs CrewAI: video breakdown

What are the key feature differences between AG2 and CrewAI as of August 2026?

CrewAI receives roughly 23 million monthly PyPI downloads compared to AG2's 420,000 (pepy.tech, August 2026). On GitHub, CrewAI holds 57,058 stars against the ag2ai/ag2 repository's 4,856. Both figures now point the same way, which is a reversal of what this article previously reported on the star count.

That reversal is worth explaining, because the error is widespread. Comparisons that credit AG2 with 48,000-plus GitHub stars — including earlier versions of this one, and the ZenML figures it drew on — are reading microsoft/autogen's number, which today stands at 60,414. AG2 is a fork, and a fork's star count starts at zero. Its own repository has 4,856. The "AG2 leads on stars" framing does not survive checking the source. What remains true is that the two projects serve different audiences: production automation teams building predefined workflows have largely converged on CrewAI, while AG2's community is smaller, more research-weighted, and more experimental.

The download gap is the strongest available market signal: most teams building production automation workflows have voted with their package managers for CrewAI. Monthly download counts are noisier than they look — CI systems and mirrors inflate them for every package, and pepy.tech's default view includes that traffic rather than filtering it out — but a roughly 56x difference is not noise.

The performance benchmark deserves context. A 5-agent structured pipeline completes in approximately 62 seconds with CrewAI versus 78 seconds with AG2 (till-freitag.com). That's roughly a 20% speed advantage for CrewAI on structured workflows, likely because CrewAI's defined task flow eliminates the LLM reasoning overhead AG2 requires for GroupChat speaker selection. When the workflow is known upfront, removing that reasoning step matters at scale.

Two caveats on that benchmark. It tested structured pipelines where task sequences were defined upfront, which is the case CrewAI is built for. And it was run against the classic AG2 API; AG2 v1.0's Network model is different enough that we would not assume the numbers carry over unchanged. On lineage, AutoGen began inside Microsoft's FLAML project, whose repository was created in August 2020, and received its own repository in August 2023. An "origins trace to October 2019" claim circulates in several comparisons, including an earlier version of this one, and it matches neither repository's history.

Developer experience: which one gets you to working code faster?

Setting up a first working prototype takes approximately 20 minutes with CrewAI versus approximately 45 minutes with AG2, with a typical CrewAI implementation requiring around 40 lines of Python versus 60 lines for an equivalent AG2 workflow (till-freitag.com, measured against the classic AG2 API). That's 125% longer setup time and 50% more code for AG2. For teams under delivery pressure or developers new to multi-agent systems, those numbers represent real friction.

The reason for the gap is abstraction level. CrewAI's Agent class maps directly to intuitive concepts. You define a Role, a Goal, and a Backstory, and CrewAI handles the orchestration. The mental model maps to how humans think about teamwork, which is why non-engineers tend to pick it up faster than AG2.

AG2 requires more explicit configuration. You define agents, set system messages, configure conversation termination conditions, and specify how agents interact. The extra code buys you fine-grained control over agent behavior, but it's genuine overhead for anyone approaching multi-agent systems for the first time.

There's a counterpoint worth raising here, though it needs more care than it used to. The standard narrative assumes you're writing code. AutoGen Studio is a drag-and-drop visual interface that changes this calculation for non-coders and rapid prototypers — a product manager can prototype a multi-agent workflow in it without writing Python. It gets its own section below, both because every competitor article ignores it and because two things this article previously said about it are no longer true.

For experienced Python developers already familiar with agent frameworks, the gap narrows. Many AG2 practitioners report that once you internalize the classic ConversableAgent model, building complex multi-turn workflows is faster than working within CrewAI's orchestration constraints, particularly when the solution path requires agents to adapt mid-execution rather than follow a predefined task sequence.

How much does AG2 cost compared to CrewAI's pricing?

AG2 is Apache-2.0 licensed and free to use. Your only costs are the LLM API fees you pay directly to OpenAI, Anthropic, or whichever provider you use. There is no platform fee, no execution limit, and no managed service required.

CrewAI's published pricing has changed, and the change matters if you are budgeting from an older comparison. CrewAI's pricing page today lists two plans: a free Basic tier with 50 workflow executions per month, a visual editor and AI copilot, and GitHub integration; and an Enterprise tier priced as "Custom," listing governance features as SSO, RBAC, workload identity, PII redaction and policies, plus deployment flexibility. The $60,000-per-year Enterprise figure, the $120,000-per-year Ultra tier and the 10,000-executions-per-month allowance that this article previously quoted are no longer published anywhere on that page, and there is no Ultra tier on it at all. We could not establish a current list price from any primary source, and we are not going to guess at one. If you need a number, you will have to ask CrewAI for a quote.

AG2's open-source model still contrasts sharply with CrewAI's commercial platform structure.

The shape of the comparison survives the loss of the numbers, even if the arithmetic doesn't. AG2 has no platform fee at any execution volume; CrewAI's managed platform is a commercial product whose cost scales with how much you run through it. What nobody can currently tell you is where the crossover sits, because CrewAI stopped publishing it. Treat any specific dollar figure you find in a comparison article — including the ones this article used to carry — as unverified.

The pricing structure still signals a strategic difference between the two projects. CrewAI is building a managed platform business where the Enterprise tier bundles compliance infrastructure, managed scaling, and dedicated support. Teams without dedicated DevSecOps capacity may find that genuinely cheaper than the engineering time required to build equivalent infrastructure around AG2. Teams with strong internal infrastructure capacity get substantial financial value from AG2's zero platform cost.

One clarification: CrewAI's open-source core is MIT-licensed, so you can self-host CrewAI workflows without paying anything. The pricing structure applies to CrewAI's managed platform, now branded AMP. If you're comfortable managing your own infrastructure, both CrewAI and AG2 run free beyond LLM costs.

Why is AutoGen Studio the overlooked feature in most comparison articles?

AutoGen Studio is a low-code visual interface for building multi-agent workflows. It installs with a single command: pip install -U autogenstudio. Once running locally, it provides a drag-and-drop Build View where you compose agents, assign tools, and configure workflows without writing code, and a Playground/Session View where you test workflows interactively and observe agent conversations in real time.

Two corrections to how this article previously framed it. First, AutoGen Studio belongs to Microsoft's AutoGen, not to AG2 — it is documented in the microsoft/autogen README, and its current release is 0.4.2.2, tracking the AutoGen 0.4 line. Second, that line is in maintenance mode, so Studio is not receiving new features either. AG2's own equivalent is a hosted playground at playground.ag2.ai rather than a local install.

Here's the detail that still holds: almost no comparison article for "autogen vs crewai" mentions AutoGen Studio at all. It remains the largest information gap in the comparison landscape, even though the tool sits on the Microsoft side of the split rather than the AG2 side.

Why does it matter? The standard argument for CrewAI in developer experience comparisons rests on faster setup and lower code requirements, both of which are true when comparing Python to Python. But those numbers assume your team is writing code. AutoGen Studio gives product managers, data analysts, and non-technical stakeholders a visual prototyping environment where they can build and test multi-agent workflows without depending on engineering resources. Completed workflows can be exported as JSON configurations or Docker containers for Azure deployment, which means a prototype can move into an engineering-managed production pipeline without rebuilding from scratch.

CrewAI's visual tooling used to be the paid-tier comparison point here. That is no longer accurate either: CrewAI's free Basic plan now lists "Visual editor and AI copilot" among its included features. The genuine remaining difference is that AutoGen Studio runs entirely locally after a single pip install and works in air-gapped environments, which a hosted editor does not.

So if your team dismissed AG2 on the learning-curve argument, a GUI prototyping option does exist — but it sits on the Microsoft side of the split and it is frozen. That is a weaker counterargument than it was a year ago, and it is better said plainly than quietly dropped.

A primary comparison table consolidating the key decision dimensions appears below. The data draws on AG2's and CrewAI's GitHub repositories, CrewAI's official pricing page, pepy.tech download figures, and the till-freitag.com benchmark series.

Which platform is more ready for enterprise use in terms of compliance and security?

CrewAI Enterprise bundles governance features — SSO, RBAC, workload identity, PII redaction and policies — with deployment flexibility, priced on request. According to CrewAI's platform documentation, the managed platform targets teams that need to deploy, monitor and scale agent workloads centrally.

On compliance certifications specifically: CrewAI publishes its security posture and audit reports through a trust centre at trust.crewai.com. We were not able to read the current list of certifications from it directly, so if you need a specific report — SOC 2, HIPAA, or anything else — confirm it with CrewAI before procurement rather than relying on any comparison article's summary, this one included.

AG2 has no managed compliance infrastructure. Deploying it means you own the entire compliance configuration: HIPAA safeguards, access control systems, audit logging, and security scanning are all your responsibility. For organizations with mature DevSecOps practices, this is an advantage, not a gap. You control the entire stack and can configure it to exactly the security posture your compliance team requires, without a vendor's managed platform in the data path.

For Azure-native organizations, the Microsoft lineage still helps. The Docker container export from AutoGen Studio can move directly into Azure Container Instances or Azure Kubernetes Service, and the Azure deployment path for the Microsoft line is well-documented. Note that this is a property of Microsoft's AutoGen and its successor rather than of AG2, which is now an independent project.

The practical framing: if your organization needs certified compliance infrastructure and doesn't have the internal engineering resources to configure it in a self-hosted framework, CrewAI Enterprise is a serious option — but you will need to get a quote before you can compare it against the engineering cost of building equivalent security configuration around AG2. If your DevSecOps team can handle it, AG2's zero platform cost is a significant budget line item.

What do GitHub stars and PyPI installs reveal about the health of each community?

CrewAI has 57,058 GitHub stars against the ag2ai/ag2 repository's 4,856 (GitHub, August 2026). Stars generally reflect interest, goodwill, and prestige rather than deployment, and the name recognition that AutoGen built through Microsoft Research origins and coverage in publications from IBM Think mostly accrued to the microsoft/autogen repository, which stands at 60,414 stars today and is in maintenance mode. AG2 inherited the codebase and the maintainers, not the stars.

The PyPI data points the same direction. CrewAI receives approximately 23 million monthly downloads versus 420,000 for the ag2 package (pepy.tech, August 2026). Monthly downloads are a stronger signal of active use than stars because they reflect running codebases rather than bookmarks, though they are inflated for every package by CI systems and mirrors. Teams don't install packages they aren't deploying, but automated systems reinstall them constantly.

Taken together, the numbers describe a large production community around CrewAI and a smaller, more specialised one around AG2 — closer to what one observer described as "the PyTorch of agentic AI programming": powerful and flexible, worth the learning investment for the right project, widely studied but not always deployed in its full form.

On execution performance, benchmarks from till-freitag.com put a 5-agent structured pipeline at approximately 62 seconds with CrewAI versus 78 seconds with AG2. The 20% speed advantage for CrewAI on structured workflows likely reflects an architectural difference: CrewAI's defined task flow eliminates the LLM reasoning overhead that AG2's GroupChat speaker selection requires. When the solution path is known upfront, removing that deliberation step matters at scale.

Neither metric makes one framework objectively superior. They describe different tools with different strengths, used by different audiences for different purposes. Understanding which camp your use case falls into is the actual decision.

Which framework should you choose?

Helicone's comparison of the two frameworks puts the choice simply: pick CrewAI if you need "a structured framework for agents with predefined roles and workflows," and AutoGen if you want maximum flexibility and are comfortable writing and maintaining more code. That's a fair summary. But the full decision comes down to four questions, and being honest about your answers will tell you more than any benchmark table.

Do you know the solution path upfront? If yes, CrewAI's Sequential or Hierarchical process structure maps naturally to your workflow. Each task has a clear agent responsible for it, and output flows predictably to the next step. Content pipelines, customer support automation, marketing workflows, and data analysis pipelines all work well here. If the solution path is unknown or emergent, AG2's conversational model is better suited because agents can negotiate, backtrack, and adapt in ways a fixed task pipeline cannot.

Do you need code execution in a secure sandbox? AG2's native Docker-based code execution is a standout feature competitors consistently ignore. Agents can write Python, run it securely in a containerized environment, observe the output, and iterate. CrewAI has no native sandbox equivalent. If your use case involves code generation, automated debugging, or data analysis that requires actually running code, AG2 is the cleaner architectural choice — bearing in mind that this capability is documented on the Classic line.

Does your organization require compliance certifications? Healthcare teams, financial services firms, and regulated industries should evaluate CrewAI Enterprise seriously, because managed compliance infrastructure would require substantial internal engineering to replicate in a self-hosted AG2 deployment. The cost of that infrastructure is now quoted rather than published, so get a number before you plan around it.

What's your team's DevOps capacity? Teams with strong infrastructure capability get genuine financial value from AG2's zero platform cost. Teams that want a managed platform with built-in monitoring, scaling, and support will likely find CrewAI's pricing justified relative to the operational overhead it eliminates.

Frequently asked questions

What is the difference between CrewAI and AutoGen?

CrewAI uses structured role-based workflows where each agent has a defined Role, Goal, and Backstory, with tasks flowing top-down through Sequential or Hierarchical processes. AG2 (formerly AutoGen) uses conversational, emergent workflows where agents negotiate solutions through multi-turn dialogue — managed by a GroupChat controller in AG2 Classic, and by a Hub with typed channels in AG2 v1.0. Choose CrewAI for predictable business automation pipelines with a defined structure; choose AG2 for complex, dynamic problem-solving where the solution path isn't known upfront.

Is AutoGen being discontinued?

Microsoft's AutoGen is in maintenance mode as of 2026: its README states it "will not receive new features or enhancements and is community managed going forward," and Microsoft directs new users to Microsoft Agent Framework, which merges AutoGen with Semantic Kernel. It has not been deleted or archived, and existing code still runs. The community fork, AG2, remains actively developed and shipped version 1.0 on 27 July 2026. So AutoGen the name is winding down on the Microsoft side while the codebase continues under two other names.

What is better than AutoGen?

CrewAI is better than AG2 for structured multi-agent workflows, faster initial prototyping, and production reliability in business automation pipelines. AG2 is better for complex technical tasks, native code execution in a Docker sandbox, and dynamic problem-solving. Neither is universally better, though the adoption gap is wide: CrewAI has roughly 23 million monthly PyPI downloads and 57,058 GitHub stars, against AG2's 420,000 downloads and 4,856 stars. If you are on Microsoft's AutoGen specifically, Microsoft's own answer is Agent Framework.

Is AutoGen deprecated?

Microsoft's AutoGen is in maintenance mode rather than formally deprecated — bug fixes and community management continue, new features do not, and there is an official migration guide to Microsoft Agent Framework. AutoGen 0.2 compatibility now lives in AG2 Classic at github.com/ag2ai/ag2-classic, which remains maintained. Note that AG2 v1.0 is not a drop-in upgrade from Classic: AG2's own README states that "the agent model, orchestration, and imports all changed."

Which multi-agent framework should I use in 2026?

For most production teams: use CrewAI for structured business automation, fast prototyping, and managed cloud hosting, especially if compliance certifications matter. Use AG2 for research-intensive tasks, code execution workflows, and dynamic multi-agent negotiations, particularly when platform cost is a constraint — AG2 is Apache-2.0 licensed with zero platform fees beyond LLM API costs. If you are starting fresh inside a Microsoft and Azure environment, evaluate Microsoft Agent Framework alongside both.

Which platform should you choose for your multi-agent needs?

The AutoGen vs CrewAI comparison is really two separate questions: which framework fits your workflow type, and which fits your team's operational capacity. The AG2 rebrand story matters because it tells you the AutoGen ecosystem is actively maintained and evolving under community ownership — though it has now evolved far enough that "AutoGen compatibility" and "current AG2" are two different products.

For most production teams building automation pipelines in 2026, CrewAI's structured model, roughly 23 million monthly downloads, and managed platform make it the pragmatic default. The framework is fast to start with, produces predictable output, and has a managed enterprise option that handles compliance overhead you'd otherwise build yourself.

For research-oriented teams, advanced developers building code execution systems, or anyone who needs agents to reason their way to an unknown solution, AG2's emergent conversation model and zero platform cost are genuinely compelling. The GUI prototyping argument is weaker than it was, since AutoGen Studio belongs to the Microsoft line and that line is frozen.

Both frameworks have diverged more than converged since their concurrent launches in late 2023. CrewAI has consolidated around a managed platform; AG2 has rebuilt its orchestration model and split off its own history. Evaluate them against your actual workflow requirements rather than community sentiment — and against what their vendors publish today rather than what a comparison article said last year.

To explore these frameworks in the context of the broader ecosystem, see the Agent Frameworks category on AgentsIndex. If you're comparing CrewAI with LangGraph specifically, the CrewAI vs LangGraph comparison covers that head-to-head in detail. To see all documented options in this space, the best agent frameworks collection and AutoGen alternatives pages are useful starting points.