Agent Core & Orchestration

Multi-agent framework built on LlamaIndex for building production agentic pipelines. Implements a message-queue architecture with service discovery and a control plane for coordinating agents. Enables both local development and cloud deployment.

Lightweight, high-performance agent framework formerly known as Phidata. Agents are pure Python classes with built-in memory, knowledge, tools, and reasoning. Supports multimodal agents and ships with a monitoring UI out of the box.

Language Model Programming library treating prompts as first-class functions with automatic versioning and tracing. Tracks every prompt invocation and its output for full reproducibility. Aims to bring software engineering best practices to prompt development.

The fastest way to build MCP servers in Python. Exposes Python functions as MCP tools with a FastAPI-inspired decorator syntax. Used by thousands of developers to add MCP capabilities to existing Python services.

Web-based platform for running autonomous AI agents in the browser without any setup. Define a goal and watch the agent plan, search, and execute tasks in real time. Open-source and self-hostable, with 31,000+ GitHub stars.

Microsoft's language for controlling LLM generation using a mix of prompting and templating. Interleaves generation and control flow at the token level for maximum efficiency. Supports constrained generation with structured grammars and tool use.

The most widely-used framework for building LLM applications with chains, agents, and tools.

OpenAI's managed agent API providing persistent threads, file search, code interpreter, and function calling. No infrastructure to manage — OpenAI handles state and tool execution. The fastest path to deploying a production-ready GPT-4 powered agent with tool use.

Anthropic's direct API access to Claude models with tool use, vision, and extended context. 200K context window enables processing entire codebases or long document collections. Streaming, batching, and cache_control for prompt caching reduce costs in production agents.

Google's multimodal LLM API with function calling, code execution, and grounding with Google Search. 1M+ token context window and native multi-modal support (text, image, audio, video). Free tier available. Gemini 1.5 Pro leads many reasoning and long-context benchmarks.

European AI company providing open and proprietary LLM APIs with function calling and JSON mode. Mistral Large and Codestral models excel at code generation for agent tasks. Strong multilingual capabilities. GDPR-compliant EU hosting available for European agent deployments.

Enterprise-focused LLM API specializing in enterprise search and generation. Command models support tool use and RAG. Rerank API dramatically improves retrieval quality for agent knowledge bases. Strong multi-language support and on-premises deployment options for regulated industries.

Visual AI programming environment from Ironclad for building and running LLM chains in a node-graph UI. Supports debugging, testing, and deploying complex agent workflows with full observability.

Free compute environment with 4 CPU cores, 30GB RAM, and up to 30 GPU hours/week (T4 or P100). No weekly limits on CPU. Ideal for agent training experiments.

Free Jupyter Notebook environment with GPU access (T4/P100) for prototyping AI agents, fine-tuning models, and running experiments. No setup required.

Low-code interface to build, debug and evaluate multi-agent workflows powered by AutoGen. Provides a drag-and-drop UI for designing agent teams and testing their conversations. Ships with sample agents for coding, research, and data analysis.

Role-playing multi-agent framework where agents take on specialized roles (researcher, writer, engineer) and collaborate toward a shared goal. Supports both sequential and hierarchical process flows with human-in-the-loop checkpoints.

Fully dynamic agentic framework where agents create sub-agents on demand to complete any task. Agents communicate in a hierarchical tree structure and share a persistent memory. Features real-time terminal output and Docker-based code execution.

Stanford's LLM system for writing Wikipedia-like long-form articles by simulating multi-perspective research conversations. Decomposes the article task into expert agents that interview each other, then synthesizes a structured document. Demonstrates automated knowledge synthesis.

Microsoft Research's generalist multi-agent system that achieves top performance on agentic benchmarks including GAIA and WebArena. Uses an Orchestrator agent directing specialist subagents (WebSurfer, FileSurfer, Coder). A reference architecture for building capable multi-agent teams.

Microsoft's event-driven agentic framework for building conversational multi-agent pipelines. Agents can exchange messages, call tools, and hand off subtasks to specialized peers, making it ideal for code generation and enterprise automation.

Microsoft's open-source framework for building LLM applications using multiple conversational agents that can cooperate to solve complex tasks. Supports human-in-the-loop patterns, code execution, and tool use. Widely used in enterprise agentic deployments.

Role-based multi-agent framework where you define a crew of AI agents with specific roles, goals, and backstories. Agents collaborate autonomously on tasks and can use tools. Excellent developer experience with a growing ecosystem of integrations.

Communicative Agents for "Mind" Exploration — a research framework for studying emergent behaviors in multi-agent role-playing. Features built-in society simulation, tool use, and a large library of specialized agent archetypes.

Agent-to-Agent protocol by Google for standardized inter-agent communication.

Simulates a full software development company using LLM agents acting as CEO, CTO, programmer, reviewer, and tester. Generates complete software projects from a single natural-language prompt through communicative collaboration.

Graph-based orchestration library from LangChain for building stateful, multi-actor LLM applications. Nodes are agents or functions, edges are transitions. Supports cycles, branching, and persistence — making it ideal for long-running agent workflows.

Community fork of AutoGen with a more stable API and extended multi-agent capabilities. Designed for production use with better documentation, improved agent memory, and additional built-in tools. Maintained by a dedicated open-source team.

Communicative Agents for Mind Exploration of Large Language Model Society. Pioneered role-playing multi-agent frameworks where two agents play opposing roles (instructor and assistant) to complete tasks collaboratively. Includes extensive benchmarks.

Platform for deploying groups of agents in collaborative or competitive environments. Supports dynamic team formation, tool sharing, and plug-and-play agent modules for both research simulations and real-world task solving.

The minimalist task-driven autonomous agent script that sparked the modern agentic AI movement. Uses a simple task queue managed by an LLM to iteratively break down goals, execute tasks, and re-prioritize based on results.

Assigns different roles (Product Manager, Architect, Engineer) to LLMs to simulate a software company. Given a one-line requirement, produces PRDs, architecture diagrams, and complete code. Demonstrates structured multi-agent collaboration at scale.

Multi-agent platform from Alibaba's ModelScope for building distributed, fault-tolerant agent applications. Supports parallel execution, monitoring, and diverse communication patterns. First-class support for Chinese language models.

Drag-and-drop visual builder for multi-agent workflows built on top of LangChain. Lets non-engineers assemble agent pipelines without code. Supports sequential, parallel, and hierarchical agent topologies with a clean web UI.

Code-first agent framework from Microsoft Research for data analytics tasks. Converts user requests into Python code snippets, executes them in a sandboxed environment, and iterates based on results. Strong support for data manipulation and visualization agents.

Microsoft's enterprise SDK for integrating LLMs into .NET, Python, and Java applications. Provides plugins, planner, memory, and agent abstractions. Production-ready with extensive Azure integrations and strong enterprise support.

One of the original autonomous agent projects that sparked the agent revolution. Given a goal, it autonomously decomposes it into sub-tasks, uses tools to accomplish them, and iterates. The platform now includes a marketplace of agents and a cloud runtime.

Serverless platform for creating persistent AI agents with built-in memory, multi-step tasks, and tool integrations. Agents maintain context across sessions automatically. Provides a YAML-based DSL for defining complex agent workflows without infrastructure management.

Framework for building real-time multimodal AI agents with voice, video, and data capabilities. Built on top of LiveKit's WebRTC infrastructure. Supports STT, TTS, function calling, and voice activity detection out of the box.

Python framework for building agentic AI pipelines with explicit control flow by Prefect. Uses tasks and agents as first-class primitives with built-in observability. Designed to give developers full control over when and how AI makes decisions.

Letta multi-agent coordination layer that lets stateful agents hand off context and share persistent memory across agent boundaries. Useful for long-horizon tasks requiring memory continuity.

Minimal Go library for building message-passing agent systems with clean abstractions. Designed for developers who want full control over agent logic without opinionated orchestration overhead — ideal for embedding into existing Go services.

Agent framework from the Pydantic team with a strong emphasis on type safety and structured outputs. Uses Pydantic models for tool inputs and outputs, making agent behavior more predictable. Supports dependency injection, streamed responses, and testing.

Minimalist agent library from Hugging Face focusing on code agents that write and execute Python snippets as their actions. Exceptionally simple codebase (~1000 lines) making it easy to understand and extend. First-class support for Hugging Face models.

Lightweight experimental multi-agent orchestration framework from OpenAI. Uses handoffs and routines as core primitives, making it easy to build networks of specialized agents. Stateless by design — great for learning agent patterns.

Build stateful AI applications as directed action graphs. Burr tracks every state transition, supports human-in-the-loop interrupts, and includes a web UI for visualizing and debugging agent executions in real time.

Agent module within LlamaIndex providing ReAct, OpenAI function calling, and custom agents with deep integration into the LlamaIndex data and RAG ecosystem. Supports multi-step reasoning over complex document corpora with rich tool support.

The most widely-used agent primitives in the ecosystem. Supports ReAct, structured output, XML, JSON chat, and many other agent types. Integrates with hundreds of tools and providers. Battle-tested in thousands of production applications worldwide.

Self-correcting code-writing agent that iterates on a failing test suite until all tests pass. Wraps any LLM and uses a simple write-run-fix loop, making it a great foundation for AI-driven code generation pipelines.

Structured outputs library that patches LLM clients to return validated Pydantic models. Eliminates JSON parsing boilerplate in agents. Supports retry logic, streaming partial responses, and parallel extraction. Works with OpenAI, Anthropic, Gemini, and more.

Unified API interface standard for interacting with AI agents regardless of their underlying framework. Defines a common HTTP interface for task creation, step execution, and artifact retrieval — enabling agent interoperability across different systems.

AI engineering toolkit for building natural language interfaces with minimal code. Provides functions, classifiers, and extractors that work like regular Python functions but are backed by LLMs. Great for adding AI capabilities to existing codebases incrementally.

Google's Agent-to-Agent (A2A) protocol for standardized inter-agent communication. Provides a structured way for agents to discover capabilities, delegate tasks, and exchange artifacts — designed to work alongside MCP for a complete agentic interop stack.

Stanford framework for algorithmically optimizing LLM prompts and weights. Instead of writing prompts, you define a pipeline in Python and DSPy compiles it to optimized prompts. Enables systematic improvement of LLM program performance through automatic prompt engineering.

Pythonic library for building AI-powered applications with a focus on developer ergonomics. Uses decorators to turn regular functions into LLM calls. Supports structured extraction, streaming, async, and 10+ providers without abstraction overhead.

End-to-end NLP framework from deepset for building production-ready LLM applications and agents. Pipeline-based architecture for composing components (retrievers, generators, tools). Strong RAG support with 50+ integrations and an active community.

Structured text generation library that guarantees LLM outputs conform to a schema. Uses finite-state machines to constrain generation token by token. Essential for agents that need reliable JSON, regex-matched, or grammar-constrained outputs.

Observability and replay SDK built specifically for AI agents. Drop-in integration that records every LLM call, tool use, and agent decision. Provides session replay, cost tracking, and error diagnosis in a web dashboard with minimal code changes.

Modular agent framework built on Instructor and Pydantic. Breaks agent functionality into atomic, reusable components that can be composed. Emphasizes predictability and testability — each component has well-defined inputs and outputs.

Full-stack agent framework with built-in memory, knowledge, and tool abstractions. Provides pre-built agents for web search, financial data, and coding tasks. Ships with a playground UI for testing and debugging agents during development.

TypeScript toolkit for building AI-powered applications and agents in Next.js, Node.js, and edge runtimes. Provides useChat, useCompletion, and generativeUI hooks. Supports tool calling, multi-step agents, streaming, and 20+ model providers out of the box.

Anthropic's native tool calling interface for Claude models. Defines tools as JSON schemas and Claude decides when to call them. Supports parallel tool calls, streaming, and computer use. The foundation for building single-agent Claude-powered applications.

Durable execution platform for long-running, fault-tolerant workflows. Agents built on Temporal survive process crashes, network failures, and server restarts — state is automatically persisted and replayed, making it production-grade infrastructure for complex multi-step agents.

Durable execution engine for building resilient, serverless workflows and agents. Handles retries, state persistence, and long-running workflows natively. First-class support for building AI agent workflows with predictable recovery.

Background job and workflow platform with durable task execution for AI pipelines. Designed for long-running LLM tasks with built-in retries, fan-out, and event-driven triggers. Provides a React dashboard for monitoring workflow runs.

Durable execution platform for long-running, fault-tolerant workflows. Automatically retries failed activities, persists state across restarts, and provides full audit history. Increasingly adopted for agentic systems that must survive LLM API failures mid-execution.

Event-driven durable functions platform for AI pipelines. Write step functions in TypeScript with automatic retry, fan-out, and flow control. First-class AI features including step.ai for calling LLMs with built-in rate limiting and cost tracking.

Modern workflow orchestration with a Python-native API. Flows and tasks are observable, retryable, and schedulable. Growing support for agentic patterns with caching, concurrency control, and artifact tracking built in.

Data-aware orchestration platform for ML and AI pipelines. Asset-centric model tracks lineage of every data artifact. Excellent for agent systems that need to manage and version their data dependencies with full observability.

Battle-tested workflow orchestration platform for scheduling and monitoring complex pipelines. Widely used in enterprises for AI/ML data pipelines feeding agent systems. Extensive operator ecosystem and deep AWS/GCP/Azure integrations.

Open-source background jobs platform with first-class AI support. Run long AI tasks (minutes to hours) without timeouts. Provides real-time logging, retries, and a developer-friendly SDK that integrates naturally with existing Node.js applications.

Fast-booting virtual machines (250ms cold start) perfect for running isolated agent tasks. Each machine runs in its own VM with configurable CPU and memory. Great for executing untrusted agent-generated code in fully isolated environments.