100 AI Agent Frameworks Mapped: Architecture, Governance & Selection Guide

Why an Agent Framework Map Is Needed

Over the past two years AI agent frameworks have expanded rapidly. Early projects focused on letting large models call tools; today the hard problems are managing state, context, and fault recovery in long tasks; coordinating multiple agents without unbounded cross-calls; adding human approval, permissions, auditing, and cost controls; integrating with existing enterprise data, identity, workflows, and legacy systems; and proving an agent is not just demonstrable but testable, observable, and maintainable. Choosing a framework now means selecting an execution model, governance approach, and engineering boundary.

This survey covers 100 distinctive projects (numbering is for readability only, not a ranking). The list includes general frameworks, SDKs, low-code platforms, and a few representative vertical agent systems. Most are open source; some also offer commercial cloud services.

1. General Agent Orchestration: From Tool Calling to Execution Management

LangGraph : Uses state graphs to express nodes, branches, loops, and human approval; supports checkpoints and fault recovery; suited for complex long-running processes.

LangChain : Vast ecosystem of models, tools, retrieval, and integrations; good for rapid agent prototyping; complex control can be delegated to LangGraph.

Microsoft Agent Framework : Merges AutoGen's agent abstractions with Semantic Kernel's enterprise capabilities; provides graph workflows, sessions, middleware, and MCP/A2A integration.

CrewAI : Describes multi-agent collaboration via roles, goals, tasks, and teams; intuitive concepts for research and business prototyping.

OpenAI Agents SDK : Builds applications with a few primitives—Agent, Handoff, Guardrail, Session—includes built-in tracing; production successor to Swarm.

Google ADK : Targets Gemini/Vertex AI; supports hierarchical agents, sequential and parallel workflows, and A2A; fits Google Cloud stacks.

Claude Agent SDK : Embeds Claude Code's file, command, tool, and sub-agent runtime into custom apps; suited for coding and long tasks.

Strands Agents : AWS model-driven SDK offering Graph, Swarm, Workflow, and other orchestration modes.

Pydantic AI : Brings type checking, structured output, dependency injection, and Pydantic validation into agents; for reliability-focused Python services.

Agno : Lightweight, quick start; natively considers multimodal, knowledge bases, memory, teams, and agent API runtime.

2. Multi-Agent Collaboration: Roles, Messaging, and Group Structures

AutoGen : Representative research framework for multi-agent conversation, group chat, and code execution; official repo archived; new projects should evaluate Microsoft Agent Framework first.

AG2 : Community fork by original AutoGen contributors preserving conversational multi-agent programming style.

Semantic Kernel : Strong plugins, functions, connectors, and enterprise app integration; fits existing C#/Python systems.

CAMEL : Centers on role-play and agent society cooperation; suitable for researching multi-agent communication, data generation, and social simulation.

MetaGPT : Encodes a software company's standard operating procedures into multi-agent flows; product, architecture, development, and testing roles collaborate to generate software.

ChatDev : Chat-driven virtual software company completing requirements, design, coding, and testing; high research and demo value.

AgentScope : Developer-oriented multi-agent framework emphasizing message passing, distributed execution, tool and state management.

AgentVerse : Covers both task solving and environment simulation; good for studying agent group collaboration, expert recruitment, and behavioral evolution.

Swarms : Provides sequential, concurrent, hierarchical, and hybrid swarm topologies; for experimenting with complex orchestration structures.

OpenAI Swarm : Demonstrates minimal multi-agent collaboration via Routine and Handoff; high educational value; production projects typically migrate to Agents SDK.

3. RAG, Data, and Lightweight Frameworks: Bringing Agents Closer to Real Knowledge

LlamaIndex Workflows : Event-driven workflows combined with data connectors, indexes, and agentic RAG; for knowledge-intensive agents.

Haystack : Modular pipelines and agents coexist; complete retrieval, evaluation, and production deployment system; fits enterprise search and QA.

smolagents : Hugging Face's minimal agent library; notably lets models generate and execute Python actions via Code Agent.

DSPy : Replaces extensive manual prompt tuning with programming and optimization; can optimize signatures, modules, and reasoning pipelines within agents.

Atomic Agents : Small atomic components based on Instructor and Pydantic; emphasizes I/O schemas, composability, and predictability.

Qwen-Agent : Built around Qwen's tool calling, planning, and memory; provides RAG, code interpreter, browser assistant, and MCP examples.

ModelScope-Agent : Tightly integrated with ModelScope model and tool ecosystem; supports tool calling, RAG, and multi-agent apps.

Lagent : InternLM ecosystem lightweight framework; supports ReAct, ReWOO, etc.; suitable for learning and secondary development.

XAgent : Emphasizes complex task decomposition, dual-loop planning, and tool execution; a representative project for researching autonomous agent architectures.

TaskWeaver : Microsoft's code-first data analysis agent; converts user requests into executable code that operates on data and plugins.

4. Language Ecosystems: Agents Beyond Python

Mastra : TypeScript-native; integrates Agent, Workflow, RAG, evaluation, and deployment; for Node.js full-stack teams.

Vercel AI SDK : Connects model calls, tools, structured output, and streaming UI; for Next.js and web agent products.

VoltAgent : TypeScript agent framework highlighting modularity, workflows, and built-in observability.

BeeAI Framework : Supports Python and TypeScript; stresses cross-framework agent interoperability.

LangChain4j : Brings model, tool, memory, and RAG abstractions to Java applications.

Spring AI : Integrates models, vector stores, tools, and MCP into the Spring programming model; for enterprise Java services.

Spring AI Alibaba : Enhances Spring AI with Alibaba Cloud models, agent orchestration, and graph workflows.

trpc-agent-go : Go-native agent framework covering graph workflows, tools, memory, MCP, A2A, and observability.

Rig : Rust-native, type-safe LLM/agent building library; for projects valuing performance and system integration.

Ax : Brings DSPy-style signatures, modules, and optimization to TypeScript; for structured LLM programs and agents.

5. Controllable Applications, Long-Term Memory & Dialogue: From Runnable to Constrained

Langroid : Core focus on messaging and multi-agent task collaboration; good support for local models, RAG, and tool use.

Griptape : Builds predictable agents with structures, tasks, tools, and rules; emphasizes enterprise workflows and security boundaries.

praxo-core : MIT-licensed embeddable agent kernel with Go reference implementation; combines policy control, tool authorization, HITL, session/checkpoint contracts, structured events, and cross-language consistency contracts; targets legacy systems and governed scenarios. It explicitly distinguishes framework capabilities from deployment responsibilities: providing a sandbox interface does not equal OS-level isolation; providing checkpoints does not guarantee external transactions or exactly-once; multiple language implementations do not imply full parity with the Go reference. Current docs list Go, Python, TypeScript, Java, Rust, R, and C as Agent-capable implementations; PHP, C, Fortran, COBOL as extended. This tiered classification is more engineering-meaningful than a vague "supports dozens of languages." praxo-core remains early; external production adoption and third-party verification are pending.

Marvin : Lightweight AI functions, tasks, and agent abstractions; for naturally embedding LLM capabilities into Python code.

ControlFlow : Builds controllable workflows with tasks, dependencies, and agents; balances programmatic control with autonomous decision-making.

Parlant : For customer-facing dialogue agents; constrains behavior via Guidelines and Journeys rather than relying solely on system prompts.

Letta : Derived from MemGPT; focuses on stateful agents, self-editing long-term memory, and long-running personalized assistants.

PraisonAI : Covers multi-agent, workflows, memory, self-reflection, and MCP integration; offers Python and JavaScript usage.

Rasa : Combines dialogue state, business rules, actions, and LLM capabilities; for self-hosted, controllable dialogue flows.

Botpress : Visual conversation and agent development platform; suits rapid channel integration, knowledge bases, tools, and human handoff.

6. Low-Code & Visual Platforms: Giving Agents to Broader Developers

Dify : Unifies prompts, RAG, agents, workflows, model management, and publishing; for rapid delivery of complete AI apps.

Langflow : Drag-and-drop agent flow building with Python component customization; balances prototyping and customization.

Flowise : TypeScript ecosystem visual LLM/agent builder; for quick RAG and multi-step flow assembly.

n8n : Places agent nodes into business automation integration ecosystem; for SaaS, database, and enterprise system linkage.

FastGPT : Tightly combines knowledge bases, data processing, and visual workflows; for Chinese knowledge QA and business agents.

RAGFlow : Based on deep document understanding and traceable RAG; also provides agent and workflow capabilities.

BISHENG : Enterprise-oriented visual LLM application platform; supports knowledge bases, process orchestration, and business integration.

Coze Studio : Visual agent, plugin, knowledge base, and workflow development platform; for building multi-channel intelligent agents.

Promptflow : Microsoft's LLM flow development tool; highlights flow visualization, batch runs, evaluation, and version management.

Rivet : Graphical AI programming environment; turns prompts, tools, and agent execution into inspectable flowcharts.

7. Autonomous Agents & Software Development: From Goals to Code Repositories

AutoGPT Platform : Evolved from early autonomous goal execution to a sustainable, orchestratable agent platform.

SuperAGI : Early developer-first autonomous agent framework with GUI, tools, and agent management; check maintenance status before adoption.

AgentGPT : Browser-based goal input; agent auto-plans and executes; for no-code autonomous agent experience.

BabyAGI : Minimal code demonstrating task creation–execution–priority adjustment loop; higher teaching than production value.

OpenHands : Software engineering agent platform; operates code, terminal, browser; provides sandbox and evaluation system.

SWE-agent : Takes GitHub issues, locates and modifies repository code; commonly used for SWE-bench and automatic repair research.

Aider : Terminal AI pair programming tool; tight Git repo integration; direct editing, committing, and model switching.

Cline : IDE-integrated coding agent; reads project, edits files, runs commands; human approval controls dangerous operations.

GPT Pilot : Emphasizes full app development flow from requirements, specs, task planning to coding and debugging.

Devika : Open-source agentic software engineer; includes task decomposition, web research, planning, and code generation.

8. Programming, Research & Data: Vertical Agents Forming Complete Loops

OpenCode : Terminal-first open-source coding agent; values model selection, sessions, and developer workflow.

Continue : Open-source IDE AI assistant; supports chat, edit, and agent modes; easy to plug different models and internal codebases.

Plandex : For large coding tasks; stresses planning, context management, diff review, and stepwise execution.

GPT Engineer : Generates code projects from natural language requirements; good for learning "requirements-to-codebase" agent flows.

RepoAgent : Focuses on repository-level code understanding and automatic documentation generation; for legacy project knowledge organization.

GPT Researcher : Automatically searches, filters, and synthesizes sources to produce cited research reports; a representative deep research agent.

STORM : Stanford's knowledge curation system; uses multi-perspective questioning and retrieval to generate cited long-form articles.

AI Scientist : Automatically proposes research ideas, runs experiments, and generates papers; explores full-loop automated scientific discovery.

AIDE : Uses tree search for automated ML experiment design, code generation, and metric optimization.

DB-GPT : Targets databases, data analysis, and private deployment; combines Text-to-SQL, RAG, and multi-agent data apps.

9. Browser, Computer & Phone: Agents Operating Real Interfaces

browser-use : Gives model a goal; agent autonomously observes and operates real browser; for open-ended web tasks.

Stagehand : Supplements deterministic browser code with AI primitives (Act, Extract, Observe); for maintainable automation flows.

Skyvern : Vision and LLM-driven web operations; targets forms, portals, business processes; close to AI RPA.

LaVague : Layers web understanding, planning, and action code generation; for researching Large Action Models and browser agents.

Nanobrowser : Runs browser agent as Chrome extension; leverages current browser environment; supports multi-agent collaboration.

Notte : Development and runtime layer for web agents; emphasizes browser sessions, structured interaction, and task execution.

AgentQL : Uses semantic queries to locate web elements and extract data; reduces reliance on traditional CSS selectors.

Agent-S : For general GUI operations; combines hierarchical planning, experiential memory, and cross-app action execution.

UFO : Microsoft's Windows desktop agent; perceives and operates different desktop apps via multi-agent.

Mobile-Agent : For phone GUI operations; combines visual perception, planning, and cross-app task execution.

10. Voice, Web3 & Other Vertical Scenarios

Pipecat : Real-time voice and multimodal dialogue framework; handles audio streams, interruptions, turn management, and voice tool calling.

LiveKit Agents : Combines real-time audio/video infrastructure with agents; for voice support, real-time assistants, multimodal interaction.

Vocode : Focuses on voice dialogue agents; encapsulates speech recognition, synthesis, streaming dialogue, and telephony integration.

Eliza : Emphasizes character personas, social channels, and plugin ecosystem; often used for social media, community, and Web3 agents.

Virtuals GAME : Modular agent decision engine; for games, virtual characters, and on-chain interaction agents.

Coinbase AgentKit : Provides wallets and on-chain operation tools for agents; for building agents that call contracts or execute on-chain actions.

uAgents : Fetch.ai's lightweight decentralized agent framework; focuses on identity, messaging, and agent networks.

Open Interpreter : Drives local code execution and computer operations via natural language; for local automation and personal assistant experiments.

Adala : For data labeling and processing; lets agents iterate based on real labels, feedback, and reflection.

Vision Agent : Lets agents select models and generate code for vision tasks; suits detection, segmentation, and image analysis automation.

Why praxo-core Made the Map

Among these 100 projects, praxo-core was included not for star count or model support breadth, but for its uncommon intersection of governed execution, cross-language contracts, and legacy system embedding. It positions itself as an embeddable agent execution kernel with Go as the reference implementation. Core features include policy hooks, tool authorization, human-in-the-loop, session/checkpoint contracts, structured events, and adaptation boundaries for models, tools, memory, retrieval, and sandboxes. It can be used independently without other AxisVela products. Its explicit capability boundaries—framework implementation ≠ user security controls; sandbox interface ≠ OS isolation; checkpoints ≠ external transaction guarantees; multiple language implementations ≠ full parity—are more engineering-meaningful than vague multi-language claims. The project remains early; external production adoption and independent verification are still accumulating.

How to Choose: Problem First, Framework Second

Technical selection can start from these requirement patterns:

Complex state, long flows, fault recovery, human approval : Evaluate LangGraph, Microsoft Agent Framework.

Rapid multi-agent team with role division : Evaluate CrewAI, CAMEL, MetaGPT.

Lightweight production apps primarily on OpenAI : Evaluate OpenAI Agents SDK.

Gemini/Google Cloud stack : Evaluate Google ADK.

AWS/Bedrock : Evaluate Strands Agents.

Type-safe Python services : Evaluate Pydantic AI, Atomic Agents.

TypeScript full-stack products : Evaluate Mastra, Vercel AI SDK, VoltAgent.

Java enterprise systems : Evaluate Spring AI, Spring AI Alibaba, LangChain4j.

RAG and enterprise knowledge bases : Evaluate LlamaIndex Workflows, Haystack, RAGFlow.

Low-code business applications : Evaluate Dify, n8n, Langflow, Flowise.

Automatic code repair : Evaluate OpenHands, SWE-agent.

Daily coding assistance : Evaluate Aider, Cline, OpenCode.

Browser automation : Evaluate browser-use, Stagehand, Skyvern.

Real-time voice agents : Evaluate Pipecat, LiveKit Agents.

Long-term memory and personalized assistants : Evaluate Letta.

Legacy systems, multi-language embedding, explicit governance boundaries : Evaluate praxo-core, Griptape, and native frameworks in the target language ecosystem.

Learning agent fundamentals : smolagents, BabyAGI, OpenAI Swarm reveal execution loops more clearly than large platforms.

Five Trends Behind the Map

Agent and Workflow convergence : Fully autonomous loops don't fit all tasks. Deterministic steps expressed as code, open steps delegated to agents, often more reliable than "everything to the model." Graph workflows, checkpoints, and human approval become infrastructure.

Tool calling is just the start; execution boundaries are the hard part : Real production issues include permissions, credentials, idempotency, timeouts, retries, cost, auditing, and fault recovery. A framework that clearly states "what we own, what you own" is more trustworthy than one with a long feature list but fuzzy boundaries.

MCP, A2A, and similar protocols reduce integration lock-in : Tool and agent interconnection is standardizing, but protocol compatibility ≠ automatic safety. Connecting untrusted tools, prompt injection, and cross-agent permission delegation still need independent governance design.

Multi-language focus is not quantity but verifiable consistency : Enterprise systems won't all rewrite to Python because agents are trendy. Java, Go, C#, COBOL, Fortran environments have real needs. The real difficulty in multi-language frameworks is contracts, behavioral coverage, test vectors, and upgrade compatibility—not generating a batch of same-named APIs.

Vertical agents are closing loops faster than general agents : Coding, research, browser ops, data analysis, and voice support have clearer inputs, tools, and evaluation standards. They often prove value more easily than "do-everything" general agents.

Conclusion

The value of agent frameworks lies not in repackaging the ReAct loop once more, but in helping developers handle state, tools, collaboration, governance, and evidence. These 100 projects have no unified ranking, and no single answer fits all scenarios. Mature projects deserve priority evaluation; new projects can enter watchlists through clear architectural differentiation. For praxo-core, multi-language and governance are just the starting point; what will determine whether it moves from "distinctive" to "adopted" are external users, independent reproduction, real workloads, and long-term maintenance. Final selection advice: if a regular program can reliably complete the task, don't use an agent just for the sake of using an agent.