Whenever the term “AI agents” is used in the context of generative AI applications, people tend to imagine systems where large language models (LLMs) autonomously perform complex tasks from start to finish. In practice, however, most production applications sit somewhere along a spectrum between simple prompting and full autonomy.
We use the term “agentic systems” to cover that full range: systems where LLMs influence or decide execution flow with varying degrees of autonomy. The system’s degree of “agenticity” depends on how much decision-making authority is delegated to the LLM — from tightly controlled flows to multi-agent teams that coordinate complex, open-ended work.
Below are seven practical design patterns we use with customers. For each pattern you’ll find a short explanation, when to use it, and concrete use cases.
- [Controlled flows](#controlled-flows)
- [LLM as a router](#llm-as-a-router)
- [Parallelization](#parallelization)
- [Reflect & critique](#reflect-and-critique)
- [Human-in-the-loop](#human-in-the-loop)
- [Agents (single-agent)](#agents-single-agent)
- [Multi-agent](#multi-agent)
- [Single-agent](#single-agent)
- [Multi-agent](#multi-agent)
---
## Controlled flows
Controlled flows are a low-risk way to leverage LLM capabilities inside a well-defined pipeline. The sequence of steps — and the rules for moving between them — are fixed. LLMs are free to operate inside each step (generate, analyze, summarize), but they cannot choose the next step.
- Tasks that decompose into a deterministic sequence of subtasks.
- You need predictable, auditable outputs while still benefiting from LLM flexibility.
Use cases
- Content review: LLMs fix grammar, check style, and flag factual claims, then pass artifacts to human reviewers.
- Natural-language-to-query: LLMs extract query parameters and data sources in a fixed query pipeline, producing reproducible queries.
---
## LLM as a router
Use an LLM to inspect incoming requests and route them to specialized workflows, models, or microservices. The router’s job is classification and dispatch — not open-ended decision-making.
When to use
- Requests are heterogeneous and can be handled by different subsystems.
- You want to optimize for cost or accuracy by sending requests to the right model or workflow.
Use cases
- Customer support triage: route tickets to billing, technical, or legal handlers.
- Cost-aware routing: send simple queries to smaller models and complex reasoning to larger ones.
---
## Parallelization
Split a complex task into independent subtasks and run them concurrently across LLMs or prompt variants. Aggregate and reconcile outputs afterwards.
- The problem can be partitioned into largely independent pieces.
- You want lower latency or increased reliability through ensemble-style checks.
Use cases
- LLM-as-judge: multiple evaluations run in parallel (or repeated prompts to the same model) and an aggregator picks the best result.
- Code generation: run different models to generate implementations, execute tests, and select the most efficient/robust output.
---
## Reflect & critique
This pattern separates generation and evaluation into different LLM roles: a generator produces an output, and an evaluator inspects, critiques, and requests refinements. Iterate until the evaluation criteria are satisfied.
When to use
- You need iterative refinement where quality improves through critique and correction.
- Evaluation criteria can be expressed clearly so the evaluator LLM applies them consistently.
Use cases
- Report generation: the evaluator checks for required sections, tone, and factual consistency and asks the generator to improve where needed.
- Code refinement: the evaluator suggests optimizations and security hardening after running tests.
---
## Human-in-the-loop
Embed human reviewers at critical decision points. LLMs can ask for clarifications, offer suggestions, or hand off uncertain cases for human approval — preserving speed while keeping final authority where it matters.
When to use
- Tasks where errors are costly, regulated, or high-impact.
- The system needs occasional human judgment (authentication steps, legal approvals, medical reviews).
Use cases
- Computer use: LLMs automate flows but prompt humans for authentication, 2FA, or CAPTCHAs.
- Claims processing: LLMs provide a recommended decision and rationale; human adjusters make the final call.
---
## Agents (single-agent)
When people say “AI agents” they often mean a single LLM that reasons about next steps, calls tools, and uses results to decide what to do next. The agent is flexible and can handle tasks without a fixed script.
When to use
- Tasks that lack a predictable workflow and benefit from exploratory, stepwise reasoning.
- You can tolerate non-deterministic outputs and higher latency.
Use cases
- Adaptive tutoring: the agent personalizes lessons by deciding what to teach next.
- End-to-end app building: generate, test, debug, and iterate on code with tool access.
NOTE: Combine single-agent systems with reflect-and-critique or human-in-the-loop to increase reliability.
---
## Multi-agent
Multiple agents coordinate to solve larger problems. Architectures vary: a supervisor agent may orchestrate specialists, agents may form a fully connected network, or you can custom-define interactions.
- Open-ended or highly exploratory tasks where diverse expertise and parallel experimentation add value.
- You accept the higher complexity, cost, and difficulty of debugging multi-agent workflows.
Use cases
- Scientific discovery: teams of agents review literature, propose experiments, and evaluate results.
- Multimedia storytelling: creative agents specialize in narrative, visual art, and music and collaborate to produce a unified piece.
---
## Practical guidance and trade-offs
- Start simple: prefer controlled flows and LLM routing before moving to agents or multi-agent systems.
- Measure per-step: add observability at each handoff so you can diagnose where mistakes occur.
- Combine patterns: human-in-the-loop + reflect-and-critique + agent routing often gives the best reliability/cost balance.
- Cost vs. autonomy: higher autonomy usually means higher compute costs and latency — budget accordingly.
- Fail open vs. fail closed: choose conservative failure modes for risky domains (block or human-review) and more permissive modes for low-risk features.
---
## Conclusion
Agentic systems are not a binary choice; they’re design decisions along a spectrum of autonomy. Use the seven patterns above as a cookbook: start with low-risk patterns, instrument heavily, and only increase agenticity when you can measure gains and control failure modes.
*The most comprehensive, structured guide to AI agent frameworks, tools, and resources.*
*Updated weekly. Compared side-by-side. Built for developers who ship.*
**[Explore the Stack](#contents) • Read the docs in CONTRIBUTING.md • [Submit a Tool](https://github.com/ARUNAGIRINATHAN-K/awesome-ai-agents-2026/issues)**
- [Open-Source Models for Agents](#open-source-models-for-agents)
- [Market Stats and Benchmarks 2026](#market-stats-and-benchmarks-2026)
- [Local and Self-Hosted AI](#local-and-self-hosted-ai)
- [AI Governance and Compliance](#ai-governance-and-compliance)
- [Cybersecurity Agents](#cybersecurity-agents)
- [Healthcare and Therapy Agents](#healthcare-and-therapy-agents)
- [Newsletters and Communities](#newsletters-and-communities)
- [Changelog](#changelog)
- [Star History](#star-history)
## Orchestration Frameworks
- [Agency Swarm](https://github.com/VRSEN/agency-swarm) `🚀``[Python]``[Multi-Agent]` - Orchestrates multi-agent systems built on the OpenAI Assistants API with role-based collaboration.
- [AgentScope](https://github.com/agentscope-ai/agentscope) `🚀``[Python]``[Multi-Agent]` - Alibaba multi-agent framework with distributed deployment and fault tolerance for production use.
- [Agno](https://github.com/agno-agi/agno) `🌱``[Python]``[Multi-Agent]` - Multi-agent framework with a runtime and control plane for managing agent deployments at scale.
- [Anthropic SDK](https://github.com/anthropics/anthropic-sdk-python) `🚀``[Python]``[Anthropic]` - Official Claude SDK with tool use, computer control, and streaming for building Claude-native agents.
- [AutoGen](https://github.com/microsoft/autogen) `🚀``[Python]``[Multi-Agent]` - Event-driven multi-agent framework merged with Semantic Kernel for production workflows.
- [AWS Bedrock Agents](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html) `🚀``[Python]``[Compliance]` - Managed AWS infrastructure for agents with Bedrock models, enterprise compliance, and auto-scaling deployment.
- [CAMEL](https://github.com/camel-ai/camel) `🌱``[Python]``[Multi-Agent]` - Role-based multi-agent simulation framework for collaborative reasoning and task completion.
- [CopilotKit](https://github.com/CopilotKit/CopilotKit) `🌱``[TypeScript]``[Multi-Agent]` - Open-source platform for embedding custom AI copilots into React applications.
- [CrewAI](https://github.com/crewAIInc/crewAI) `🚀``[Python]``[Multi-Agent]` - Production multi-agent framework with 5K+ GitHub stars, role-based collaboration, async execution, and 1500+ company adoptions.
- [DSPy](https://github.com/stanfordnlp/dspy) `🌱``[Python]``[Research]` - Stanford framework that programmatically optimizes LLM prompts using machine learning.
- [Ontheia](https://github.com/Ontheia/ontheia) `🌱``[TypeScript]``[MCP]` - Self-hosted MCP-native agent platform with visual workflow automation and multi-provider support.
- [Google ADK](https://github.com/google/adk-python) `🌱``[Python]``[Multi-Agent]` - Modular agent dev kit with native Gemini and Vertex AI integration.
- [Haystack](https://github.com/deepset-ai/haystack) `🚀``[Python]``[RAG]` - Production-ready AI orchestration framework focused on building customizable LLM applications and RAG pipelines.
- [Letta](https://github.com/letta-ai/letta) `🌱``[Python]``[Memory]` - Stateful agents with built-in long-term memory and a REST API server.
- [LightAgent](https://github.com/wanxingai/LightAgent) `🌱``[Python]``[MCP]` - Lightweight agent framework with memory, MCP/SSE, Tree-of-Thought planning, and LightSwarm collaboration.
- [LlamaIndex](https://github.com/run-llama/llama_index) `🌱``[Python]``[RAG]` - The framework for connecting LLMs to your data, with indexing and retrieval capabilities.
- [LangSmith Fleet](https://smith.langchain.com/hub/fleet) `🚀``[Cloud]``[LangChain]` - No-code agent orchestration platform with visual workflow builder and enterprise deployment.
- [Mastra](https://github.com/mastra-ai/mastra) `🌱``[TypeScript]``[MCP]` - Opinionated TypeScript framework with RAG, observability, and MCP support built in.
- [MicroAgent](https://github.com/BuilderIO/micro-agent) `🌱``[TypeScript]``[Multi-Agent]` - Lightweight agent framework with self-editing prompts and code for minimal-overhead agent loops.
- [Modus](https://github.com/hypermodeinc/modus) `🔬``[WebAssembly]``[Serverless]` - Serverless framework for high-throughput agent workloads with minimal cold starts.
- [Open-AutoGLM](https://github.com/zai-org/Open-AutoGLM) `🔬``[Python]``[Mobile]` - Open-source phone agent framework for building mobile device automation agents.
- [OpenAI Agents SDK](https://github.com/openai/openai-agents-python) `🚀``[Python]``[Multi-Agent]` - Lightweight multi-agent SDK with tracing and guardrails from OpenAI.
- [PraisonAI](https://github.com/MervinPraison/PraisonAI) `🚀``[Python]``[MCP]` - Production multi-agent framework with self-reflection, MCP integration, and workflow automation.
- [PydanticAI](https://github.com/pydantic/pydantic-ai) `🌱``[Python]``[Pydantic]` - Type-safe agent framework from the Pydantic team with a FastAPI-style developer experience.
- [Semantic Kernel](https://github.com/microsoft/semantic-kernel) `🚀``[C#]``[Microsoft]` - Microsoft enterprise SDK for Python, C#, and Java with modular plugins, memory, and goal planning.
- [Smolagents](https://github.com/huggingface/smolagents) `🌱``[Python]``[Research]` - Hugging Face code-first framework where agents write and execute Python instead of JSON tool calls.
- [Upsonic](https://github.com/Upsonic/Upsonic) `🌱``[Python]``[MCP]` - Minimalist agent framework with MCP support and rapid setup for quick prototyping.
## Coding Agents
- [Aider](https://github.com/Aider-AI/aider) `🌱``[Python]``[CLI]` - Terminal-first pair programmer that edits code in local repos, preserves Git history, and supports multi-file changes.
- [Amazon Q Developer](https://aws.amazon.com/q/developer/) `🚀``[Python]``[IDE]` - AWS-native AI coding assistant with Lambda, CloudWatch, infrastructure support, and security scanning.
- [AutoGPT](https://github.com/Significant-Gravitas/AutoGPT) `🌱``[Python]``[CLI]` - Mature autonomous agent platform with Forge framework and public benchmarks for evaluating agent capabilities.
- [Claude Code](https://github.com/anthropics/claude-code) `🚀``[TypeScript]``[Anthropic]` - Terminal-first agentic coding from Anthropic with Computer Use integration, multi-file edits, persistent shell sessions, Git operations, and fine-tuning support.
- [Cline](https://github.com/cline/cline) `🌱``[TypeScript]``[VS Code]` - Autonomous coding agent in your IDE that creates/edits files, runs commands, and uses the browser with permission-gated steps.
- [CodeRabbit](https://www.coderabbit.ai) `🚀``[Cloud]``[GitHub]` - AI-powered PR reviewer with inline suggestions, security scanning, and automatic code quality checks.
- [Codex CLI](https://github.com/openai/codex) `🚀``[Python]``[OpenAI]` - OpenAI's lightweight, open-source terminal coding agent with fast execution and strong benchmark scores.
- [Codex-CLI](https://github.com/microsoft/Codex-CLI) `🌱``[C#]``[CLI]` - CLI tool that turns natural language commands into Bash, ZShell, and PowerShell equivalents.
- [Continue](https://github.com/continuedev/continue) `🌱``[TypeScript]``[VS Code]` - Source-controlled AI checks enforceable in CI, powered by the open-source Continue CLI.
- [Cursor](https://cursor.com) `🚀``[TypeScript]``[IDE]` - AI-native IDE with parallel Cloud Agents and 100K+ enterprise users.
- [Devika](https://github.com/stitionai/devika) `🌱``[Python]``[Docker]` - Open-source AI software engineer that understands high-level instructions and writes full-featured code autonomously.
- [Devin](https://devin.ai) `🚀``[Cloud]``[GitHub]` - Fully autonomous AI software engineer showing 8-12x efficiency gains in production (Nubank case study), cloud sandbox with persistent state, GitHub integration, and enterprise adoption growing 40% MoM.
- [gemini-cli](https://github.com/google-gemini/gemini-cli) `🌱``[Go]``[CLI]` - Open-source CLI agent bringing Gemini AI directly into your terminal.
- [GitHub Copilot](https://github.com/features/copilot) `🌱``[TypeScript]``[VS Code]` - Agent Mode in VS Code with Copilot Workspace for issue-to-PR workflows across Claude, GPT, and Gemini.
- [Goose](https://github.com/aaif-goose/goose) `🌱``[Rust]``[CLI]` - Extensible open-source CLI agent that installs, executes, edits, and tests with any LLM.
- [JetBrains AI](https://www.jetbrains.com/ai/) `🌱``[Kotlin]``[JetBrains]` - Deep AI integration across all JetBrains IDEs with context-aware completions and refactoring.
- [Kiro](https://kiro.dev) `🚀``[Cloud]``[IDE]` - Spec-driven development agent that writes specs, auto-generates tasks, implements code, and automates DevOps workflows.
- [Open Interpreter](https://github.com/openinterpreter/open-interpreter) `🌱``[Python]``[CLI]` - Execute code locally via natural-language model instructions with a ChatGPT-like interface.
- [opencode](https://github.com/anomalyco/opencode) `🌱``[TypeScript]``[Desktop]` - Open-source coding agent available as a desktop app with a visual interface.
- [OpenHands](https://github.com/OpenHands/OpenHands) `🌱``[Python]``[Docker]` - AI-driven development platform that writes, tests, and deploys code autonomously.
- [PR-Agent](https://github.com/The-PR-Agent/pr-agent) `🚀``[Python]``[GitHub]` - Open-source AI PR reviewer that auto-describes, reviews, and improves pull requests.
- [Qodo](https://www.qodo.ai) `🚀``[Cloud]``[Security]` - AI code review platform with context-aware PR validation and security analysis.
- [RooCode](https://github.com/RooCodeInc/Roo-Code) `🌱``[TypeScript]``[VS Code]` - Cline fork with structured modes and reduced hallucinations for more reliable code generation.
- [Snyk Code](https://snyk.io/product/snyk-code/) `🌱``[Cloud]``[Security]` - AI-powered security scanner with real-time vulnerability detection in agent-generated code.
- [Sourcegraph Cody](https://sourcegraph.com/docs/cody) `🚀``[TypeScript]``[IDE]` - AI coding assistant that excels at large codebases with an enterprise context engine.
- [SWE-agent](https://github.com/SWE-agent/SWE-agent) `🚀``[Python]``[GitHub]` - Takes a GitHub issue and tries to automatically fix it.
- [Tabnine](https://www.tabnine.com) `🚀``[TypeScript]``[IDE]` - Privacy-first AI code completion with on-premise deployment and codebase fine-tuning options.
- [TaskWeaver](https://github.com/microsoft/TaskWeaver) `🚀``[Python]``[Microsoft]` - A code-first agent framework from Microsoft for planning and executing data analytics tasks.
- [Windsurf](https://devin.ai/desktop) `🌱``[TypeScript]``[IDE]` - AI-native IDE with Cascade agent for multi-step autonomous tasks and team workflows.
## Memory and Context
- [Acontext](https://github.com/memodb-io/Acontext) `🌱``[Python]``[Local]` - Manages agent skills and long-term memory as a layered data structure for persistent context.
- [Agentage Memory](https://agentage.io) `🌱``[Cloud]``[MCP]` - Cross-vendor shared memory layer exposed as a remote MCP server at `memory.agentage.io/mcp` (Streamable HTTP, OAuth 2.1 + PKCE + DCR) that Claude, Cursor, and ChatGPT read and write as plain markdown you own.
- [Chroma](https://github.com/chroma-core/chroma) `🌱``[Python]``[Vector DB]` - Lightweight, embeddable vector store for building memory-augmented AI agents with fast semantic retrieval.
- [cognee](https://github.com/topoteretes/cognee) `🌱``[Python]``[Graph-Based]` - Knowledge engine for AI agent memory, set up in 6 lines of code with graph-based knowledge extraction.
- [Cortex Memory](https://github.com/prem-research/cortex) `🌱``[Python]``[Vector DB]` - Full-stack solution for agent memory covering extraction, vector search, and optimization.
- [graphiti](https://github.com/getzep/graphiti) `🌱``[Python]``[Multi-Agent]` - Build real-time knowledge graphs for AI agents with automatic entity extraction and linking.
- [Kage](https://github.com/kage-core/Kage) `🌱``[TypeScript]``[MCP]` - Git-native memory for coding agents that stores decisions and fixes as repo files and verifies them against the codebase, withholding stale knowledge.
- [LanceDB](https://github.com/lancedb/lancedb) `🌱``[Rust]``[Vector DB]` - Serverless vector search database embedded directly in the agent process with no infrastructure needed.
- [Langmem](https://github.com/langchain-ai/langmem) `🌱``[Python]``[LangChain]` - Helps agents learn and adapt from their interactions over time with persistent memory.
- [Mem0](https://github.com/mem0ai/mem0) `🌱``[Python]``[Vector DB]` - Memory layer for AI applications with long-term, short-term, and semantic memory extraction.
- [Remio](https://remio.ai/) `🔬``[Desktop]``[Memory]` - Local-first AI memory desktop app that parses files into searchable vector indexes.
- [Memoir](https://github.com/zhangfengcdt/memoir) `🔬``[Python]``[Memory]` - Git-like versioned semantic memory for AI agents with branching and commits.
- [Memvid](https://github.com/memvid/memvid) `🌱``[Python]``[RAG]` - Replace complex RAG pipelines with a serverless, single-file memory layer for instant retrieval.
- [Milvus](https://github.com/milvus-io/milvus) `🌱``[Go]``[Vector DB]` - Scales vector search to billions of embeddings for large-scale agent knowledge bases.
- [Mori (森)](https://github.com/fjwood69/mori) `🌱``[Python]``[MCP]` - Sovereign shared memory layer for AI coding agents with zero-instrumentation capture via lifecycle hooks, a dream pipeline that distills sessions into curated governed memories, and support for Claude Code, Cursor, Codex, and Antigravity.
- [Motorhead](https://github.com/getmetal/motorhead) `🌱``[Rust]``[Multi-Agent]` - Manages conversation context windows for agents with automatic background summarization.
- [Pathway](https://github.com/pathwaycom/pathway) `🌱``[Python]``[RAG]` - Live data RAG engine with real-time streaming for agents that need up-to-the-second knowledge.
- [Pinecone](https://www.pinecone.io) `🚀``[Cloud]``[Vector DB]` - Managed vector database with agent namespaces for multi-tenant isolation, hybrid search (vector + keyword), serverless auto-scaling, and $11B valuation.
- [Qdrant](https://github.com/qdrant/qdrant) `🌱``[Rust]``[Vector DB]` - High-performance vector similarity search engine with rich payload filtering for agent memory.
- [RAGFlow](https://github.com/infiniflow/ragflow) `🌱``[Python]``[RAG]` - Open-source RAG engine with agent capabilities and deep document understanding for knowledge bases.
- [SimpleMem](https://github.com/aiming-lab/SimpleMem) `🌱``[Python]``[Multimodal]` - Efficient lifelong memory for LLM agents supporting both text and multimodal inputs.
- [Supermemory](https://github.com/supermemoryai/supermemory) `🌱``[TypeScript]``[Vector DB]` - Extremely fast and scalable memory engine and API designed for the AI era.
- [Weaviate](https://github.com/weaviate/weaviate) `🌱``[Go]``[Vector DB]` - Stores and searches vector embeddings with hybrid keyword and semantic retrieval for agent knowledge.
- [Zep](https://github.com/getzep/zep) `🌱``[Python]``[Multi-Agent]` - Enriches agent long-term memory with automatic summarization, entity extraction, and search.
## Multi-Agent Systems
- [AgentVerse](https://github.com/OpenBMB/AgentVerse) `🌱``[Python]``[Multi-Agent]` - Framework for building custom multi-agent environments to accomplish collaborative tasks.
- [EvoAgentX](https://github.com/EvoAgentX/EvoAgentX) `🌱``[Python]``[Multi-Agent]` - Evaluates and evolves agentic workflows over time using automatic optimization.
- [Hivemoot](https://github.com/hivemoot/hivemoot) `🚀``[Python]``[GitHub]` - Autonomous agent teams that collaboratively build software on GitHub.
- [MetaGPT](https://github.com/FoundationAgents/MetaGPT) `🌱``[Python]``[Multi-Agent]` - Simulates a full software company workflow from requirements to PRs using role-playing agents.
- [NarraNexus](https://github.com/NetMindAI-Open/NarraNexus) `🌱``[Python]``[Multi-Agent]` - Ready-to-run AI agent team workspace by NetMind.AI whose agents remember, collaborate, and use tools from day one.
- [P2PCLAW](https://github.com/Agnuxo1/OpenCLAW-P2P) `🌱``[Python]``[RAG]` - Decentralized scientific research network with 14+ autonomous agents featuring P2P mesh, IPFS storage, and Lean 4 formal verification, self-hosted with Docker Compose.
- [Swarm](https://github.com/openai/swarm) `🚀``[Python]``[OpenAI]` - Lightweight framework for agent handoffs, context variables, and function calling patterns from OpenAI.
- [Swarms Framework](https://github.com/kyegomez/swarms) `🚀``[Python]``[Multi-Agent]` - Multi-agent orchestration for production use cases with scalability and reliability at its core.
- [Yao Agents](https://yaoagents.com) `🌱``[Go]``[MCP]` - Complete local AI execution platform with 30+ Experts, autonomous Robot orchestration via 5-stage Pipeline, API-based Robot-to-Robot calling, MCP support, and multi-channel messaging.
## Agent Communication Protocols
The protocol layer that enables agents to discover tools, communicate with each other, and interoperate across ecosystems.
- [A2A Protocol](https://github.com/a2aproject/A2A) `🚀``[Python]``[Multi-Agent]` - Google's open protocol enabling AI agents to communicate, collaborate, and delegate tasks across frameworks.
- [Arcade AI](https://github.com/ArcadeAI/arcade-mcp) `🌱``[Python]``[Multi-Agent]` - Tool-use platform with authentication, authorization, and logging for agent-tool interactions.
- [Composio](https://github.com/ComposioHQ/composio) `🌱``[TypeScript]``[Multi-Agent]` - Integration platform with 250+ pre-built tool connectors for AI agents and LLMs.
- [Docker MCP](https://github.com/docker/mcp-gateway) `🌱``[Go]``[MCP]` - Docker's MCP gateway CLI plugin for running MCP servers in isolated containers.
- [HCS Agent Protocol](https://github.com/hashgraph/hedera-agent-kit-js) `🌱``[TypeScript]``[IDE]` - Hedera open standards for agent identity with trustless P2P communication and 187K+ verified agents.
- [HIG Doctor](https://github.com/raintree-technology/hig-doctor) `🌱``[TypeScript]``[MCP]` - Apple HIG audit CLI and MCP server exposing design-guideline lookup and project audits for coding agents across SwiftUI, UIKit, React, Next.js, Flutter, Compose, HTML, and CSS.
- [Hyper](https://github.com/hyperfx-ai/marketing-skills) `🌱``[Cloud]``[MCP]` - Open-source Agent Skills and a hosted MCP connecting agents to 200+ marketing integrations across paid ads, SEO, analytics, social, and image and video generation, with a human-approval gate on every action.
- [MCP Registry](https://github.com/modelcontextprotocol) `🌱``[Python]``[Multi-Agent]` - Official Model Context Protocol specification and server implementations for standardized tool access.
- [mcp-nest](https://github.com/CharanBharathula/mcp-nest) `🌱``[Python]``[MCP]` - Unified Model Context Protocol (MCP) server for executing code and managing files.
- [NotFair](https://notfair.co) `🚀``[Cloud]``[MCP]` - Hosted Google Ads MCP server for diagnosing, optimizing, and executing campaign changes via the Google Ads API with a human-approval gate.
- [NotFair Skills](https://github.com/nowork-studio/NotFair) `🚀``[TypeScript]``[MCP]` - Open-source Claude Code skills for SEO, GEO, Google Ads, and Meta Ads, connecting to live data through Google Ads MCP, Meta Ads MCP, Google Search Console MCP, and Google Analytics (GA4) MCP.
- [Toolhouse](https://toolhouse.ai) `🌱``[Python]``[Multi-Agent]` - Cloud-hosted tool infrastructure for agents with optimized execution and low-latency access.
- [Zapier MCP Server](https://zapier.com/mcp) `🌱``[Cloud]``[MCP]` - Connect agents to 7,000+ app integrations via MCP, powered by Zapier's automation platform.
- [zero-api-key-web-search](https://github.com/wd041216-bit/zero-api-key-web-search) `🌱``[Python]``[MCP]` - Free web search toolkit for AI agents with no API keys, MCP server support.
## Browser and Computer Use Agents
- [Agent S2](https://github.com/simular-ai/Agent-S) `🌱``[Python]``[Vision]` - Open-source GUI automation framework for building desktop and browser agents with vision.
- [AgentQL](https://github.com/tinyfish-io/agentql) `🌱``[Python]``[Multi-Agent]` - AI-powered web scraping and automation with a semantic query language for page elements.
- [Airtop](https://www.airtop.ai) `🚀``[Cloud]``[Multi-Agent]` - Enterprise-grade cloud browser infrastructure for AI agent automation at scale.
- [Browser Use](https://github.com/browser-use/browser-use) `🌱``[Python]``[Multi-Agent]` - Open-source framework to let LLMs navigate and interact with any website programmatically.
- [Browserbase](https://www.browserbase.com) `🚀``[Cloud]``[Multi-Agent]` - Scalable headless browser infrastructure purpose-built for running AI agents in production.
- [Dia Browser](https://www.diabrowser.com) `🌱``[Cloud]``[Multi-Agent]` - AI-native browser from Atlassian and the Browser Company with built-in agent workflows.
- [Fellou](https://fellou.ai) `🌱``[Cloud]``[Multi-Agent]` - Transparent agentic browser with visual workflow editing and persistent agentic memory.
- [Genspark](https://www.genspark.ai) `🌱``[Cloud]``[Local]` - On-device AI browser with 169+ local models that runs without internet connection.
- [Grok Computer](https://x.ai) `🌱``[Cloud]``[Multi-Agent]` - Upcoming xAI desktop agent with mouse control and application automation capabilities.
- [LaVague](https://github.com/lavague-ai/LaVague) `🌱``[Python]``[Multi-Agent]` - Large Action Model framework to turn natural language instructions into browser automation.
- [Manus](https://manus.im) `🚀``[Cloud]``[Multi-Agent]` - Autonomous digital employee with Browser Operator extension acquired by Meta for web-based task execution.
- [MultiOn](https://www.theagi.company/) `🚀``[Cloud]``[Multi-Agent]` - Reliable web automation API with CAPTCHA handling for building production browser agents.
- [OpenAI Operator](https://openai.com/index/computer-using-agent/) `🚀``[Cloud]``[OpenAI]` - ChatGPT autonomous web agent with human checkpoints using Computer Use Agent technology.
- [Playwright MCP](https://github.com/microsoft/playwright-mcp) `🌱``[TypeScript]``[MCP]` - MCP server wrapping Playwright for seamless browser automation integration with LLM agents.
- [Skyvern](https://github.com/Skyvern-AI/skyvern) `🚀``[Python]``[GitHub]` - Production browser automation with 21.5K GitHub stars, 10M+ executed workflows, vision-first automation, and sub-300ms response times.
- [Stagehand](https://github.com/browserbase/stagehand) `🌱``[TypeScript]``[Multi-Agent]` - AI web browsing framework built on Playwright with natural-language selectors and actions.
## Agent Tooling and Infrastructure
Sandboxes, web scrapers, browser automation, and networking layers that agents depend on.
- [AgentDock](https://github.com/agentdock/agentdock) `🚀``[Python]``[Docker]` - Framework for building and deploying production-ready AI agents with composable node architecture.
- [Agent Starter](https://github.com/raintree-technology/agent-starter) `🌱``[TypeScript]``[MCP]` - Project-local config manager that syncs one `agent.json` manifest into Claude Code, Codex, Cursor, and MCP setup while preserving manual edits and detecting drift.
- [codex-profiles](https://github.com/Ducksss/codex-profiles) `🚀``[Python]``[OpenAI]` - Bash CLI for switching OpenAI Codex CLI and Desktop profiles with isolated CODEX_HOME directories.
- [Crawl4AI](https://github.com/unclecode/crawl4ai) `🌱``[Python]``[Multi-Agent]` - Extracts structured data from web pages using LLM-friendly output formats optimized for agent ingestion.
- [Docling](https://github.com/docling-project/docling) `🌱``[Python]``[IDE]` - Parses PDFs, DOCX, and slides into structured text with deep layout understanding for document agents.
- [E2B](https://github.com/e2b-dev/e2b) `🌱``[TypeScript]``[Multi-Agent]` - Cloud sandboxes for AI agents to run code securely in isolated environments.
- [Engram](https://github.com/kwstx/translator) `🌱``[Python]``[Multi-Agent]` - Universal bridge for multi-protocol AI agent systems with automated semantic mapping.
- [Firecrawl](https://github.com/firecrawl/firecrawl) `🌱``[TypeScript]``[Multi-Agent]` - Web scraping API built for LLMs that converts websites to clean, structured markdown.
- [Jina Reader](https://github.com/jina-ai/reader) `🌱``[TypeScript]``[Multi-Agent]` - Converts any URL to LLM-ready clean text via a simple API prefix for agent ingestion.
- [LlamaParse](https://github.com/run-llama/llama_cloud_services) `🌱``[Python]``[RAG]` - GenAI-native document parser designed to extract complex tables and layouts for RAG pipelines.
- [Marker](https://github.com/datalab-to/marker) `🌱``[Python]``[CLI]` - Converts PDF documents to markdown with high accuracy for tables, equations, and figures.
- [Notte](https://github.com/nottelabs/notte) `🚀``[Python]``[Pipeline]` - Browser automation engine optimized for production AI pipelines.
- [Pilot Protocol](https://github.com/TeoSlayer/pilotprotocol) `🌱``[Go]``[Multi-Agent]` - Networking stack for distributed agent systems with encrypted tunnels.
- [Playwright](https://github.com/microsoft/playwright) `🌱``[TypeScript]``[Testing]` - Automates Chromium, Firefox, and WebKit browsers with a single cross-language API for agent-driven testing.
- [ScrapeGraphAI](https://github.com/ScrapeGraphAI/Scrapegraph-ai) `🌱``[Python]``[LangChain]` - Python web-scraping library that uses LLMs to build intelligent scraping pipelines from natural-language instructions.
- [Surya](https://github.com/datalab-to/surya) `🌱``[Python]``[CLI]` - Runs OCR and layout detection on documents in 90+ languages for multilingual document agents.
- [Tavily](https://github.com/tavily-ai/tavily-python) `🌱``[Python]``[Multi-Agent]` - Search API purpose-built for LLM agents providing real-time, accurate web data with source citations.
- [traceAI](https://github.com/future-agi/traceAI) `🌱``[Python]``[Observability]` - OpenTelemetry-native tracing for LLM and agent apps with 50+ framework integrations.
- [Unstructured](https://github.com/Unstructured-IO/unstructured) `🌱``[Python]``[Pipeline]` - Ingests and preprocesses documents across 25+ file types for downstream LLM and agent pipelines.
## Low and No-Code Builders
- [Activepieces](https://github.com/activepieces/activepieces) `🌱``[TypeScript]``[Docker]` - Open-source Zapier alternative with AI-powered automation nodes and visual workflow builder.
- [AgentGPT](https://github.com/reworkd/AgentGPT) `🌱``[TypeScript]``[Local]` - Deploy AI agents in the browser with zero local setup required.
- [Dify](https://github.com/langgenius/dify) `🌱``[Python]``[RAG]` - Open-source LLM app development platform with visual workflow builder and RAG orchestration.
- [FastAgency](https://github.com/ag2ai/fastagency) `🚀``[Python]``[Multi-Agent]` - Deploys multi-agent workflows as production APIs with minimal configuration and setup.
- [Flowise](https://github.com/FlowiseAI/Flowise) `🌱``[TypeScript]``[RAG]` - Open-source drag-and-drop UI to build customized LLM flows, RAG pipelines, and agent systems.
- [Langflow](https://github.com/langflow-ai/langflow) `🌱``[Python]``[RAG]` - Visual drag-and-drop builder for LLM workflows, RAG agents, and multi-step pipelines.
- [Lindy](https://www.lindy.ai) `🌱``[Cloud]``[No-Code]` - No-code AI agent platform with 3000+ app integrations for business workflow automation.
- [Make](https://www.make.com/en) `🌱``[Cloud]``[RAG]` - Visual workflow automation platform with AI capabilities and drag-and-drop scenario builder.
- [n8n](https://github.com/n8n-io/n8n) `🌱``[TypeScript]``[Docker]` - Open-source workflow automation with AI agent nodes combining visual and code-based orchestration.
- [Relevance AI](https://relevanceai.com) `🌱``[Cloud]``[No-Code]` - No-code AI agent builder for sales, support, and research use cases with team collaboration.
- [Rivet](https://github.com/Ironclad/rivet) `🌱``[TypeScript]``[RAG]` - Visual AI workflow builder with drag-and-drop interface for designing agent pipelines.
- [Temporal](https://github.com/temporalio/temporal) `🚀``[Go]``[Multi-Agent]` - Durable execution platform for long-running agent workflows with automatic retry and state persistence.
- [Wordware](https://www.wordware.ai) `🌱``[TypeScript]``[IDE]` - Web-hosted IDE where domain experts collaborate with AI engineers to build agent workflows.
- [Zapier AI](https://zapier.com) `🌱``[Cloud]``[No-Code]` - Connects 7000+ apps with natural language workflow creation for no-code agent automation.
## Voice and Multimodal Agents
- [Agentset](https://github.com/agentset-ai/agentset) `🚀``[Python]``[RAG]` - Production RAG platform with reasoning, hybrid search, and full multimodal support.
- [LiveKit Agents](https://github.com/livekit/agents) `🌱``[Python]``[IDE]` - Framework for building real-time, multimodal AI agents with voice, video, and data channels.
- [Nuance AI](https://dragon.nuance.com/en-us/home) `🚀``[Cloud]``[CLI]` - Enterprise speech and conversational AI platform for clinical and contact-center workflows with HIPAA-capable deployments.
- [Google Cloud Speech-to-Text v2](https://cloud.google.com/speech-to-text) `🚀``[Cloud]``[Pipeline]` - Google Cloud streaming and batch speech recognition API v2 with improved accuracy, streaming, and noise suppression for real-time agent pipelines.
- [Pipecat](https://github.com/pipecat-ai/pipecat) `🚀``[Python]``[Streaming]` - Production-grade voice AI framework with sub-250ms latency, WebRTC support, multimodal (voice+vision+text), real-time streaming, and 70+ language support.
- [Rasa](https://github.com/RasaHQ/rasa) `🌱``[Python]``[Self-Hosted]` - Open-source conversational AI framework with self-hosted NLU training and dialogue management.
- [simulate-sdk](https://github.com/future-agi/simulate-sdk) `🌱``[Python]``[Voice]` - Persona- and scenario-driven SDK for simulating voice and text AI agents.
- [Vapi](https://github.com/VapiAI/server-sdk-python) `🌱``[Python]``[Voice]` - Platform for building voice AI agents with low-latency speech-to-speech capabilities.
- [Vocode](https://github.com/vocodedev/vocode-core) `🌱``[Python]``[Streaming]` - Open-source framework for building voice-based LLM agent applications with streaming support.
- [Wispr Flow](https://wisprflow.ai/) `🚀``[Cloud]``[Voice]` - Voice orchestration platform for multimodal AI agents with 50+ language support, workflow building, and enterprise integrations.
## Safety Guardrails and Observability
- [Agent OS](https://github.com/buildermethods/agent-os) `🌱``[Python]``[Multi-Agent]` - Kernel architecture for governing autonomous AI agents with policy enforcement.
- [AgentDoG](https://github.com/AI45Lab/AgentDoG) `🌱``[Python]``[Multi-Agent]` - Diagnostic guardrails that analyze full agent execution trajectories to detect instruction hijacking and tool misuse.
- [AgentGuard](https://github.com/cyberark/agent-guard) `🌱``[Python]``[Observability]` - Runtime observability and guardrails for AI agents with loop detection and anomaly alerts.
- [agenttrace](https://github.com/luoyuctl/agenttrace) `🌱``[Go]``[CLI]` - Local-first TUI for AI coding agent session observability with tokens, cost, latency, tool failures, anomalies, reports, diffs, and CI health gates.
- [APort Agent Guardrails](https://github.com/aporthq/aport-agent-guardrails) `🌱``[Python]``[Multi-Agent]` - Pre-action authorization plugin for agent frameworks with policy-based access control.
- [Patronus AI LYNX](https://patronus.ai/) `🌱``[Cloud]``[Testing]` - Hallucination detection system beating GPT-4 baselines, with specialized testing for agent outputs and LLM-generated content quality.
- [Arize Phoenix](https://github.com/Arize-ai/phoenix) `🌱``[Python]``[Observability]` - Open-source observability platform built on OpenTelemetry for tracing, evaluating, and debugging AI agents.
- [Braintrust](https://www.braintrust.dev) `🌱``[TypeScript]``[Evaluation]` - Eval-driven development platform with experiment tracking and prompt optimization for agent quality.
- [ElevenAgents](https://elevenlabs.io/agents) `🚀``[Cloud]``[Voice]` - Voice agent platform from ElevenLabs for customer support automation with HIPAA compliance and multi-language support.
- [DriftGuard](https://github.com/sujal-maheshwari2004/DriftGuard) `🌱``[Python]``[Multi-Agent]` - Semantic memory guardrails using causal graphs to prevent agents from repeating past failures.
- [Guardrails AI](https://github.com/guardrails-ai/guardrails) `🌱``[Python]``[Multi-Agent]` - Adds structural, type, and quality guarantees to LLM outputs for reliable agent responses.
- [Helicone](https://github.com/Helicone/helicone) `🌱``[TypeScript]``[Observability]` - Open-source LLM observability with one-line integration for cost tracking and prompt analytics.
- [Lakera Guard](https://www.lakera.ai) `🌱``[Cloud]``[Security]` - Real-time protection against prompt injection, data leakage, and toxicity in agent interactions.
- [Laminar](https://github.com/lmnr-ai/lmnr) `🌱``[Rust]``[Observability]` - Open-source observability and analytics platform purpose-built for the full lifecycle of AI agents.
- [Langfuse](https://github.com/langfuse/langfuse) `🌱``[TypeScript]``[Observability]` - Open-source LLM observability platform for tracing, prompt versioning, and LLM-as-a-judge evaluations.
- [LangSmith](https://smith.langchain.com) `🚀``[Cloud]``[LangChain]` - LangChain platform for tracing, testing, and evaluating agent performance with production monitoring.
- [LLM Guard](https://github.com/protectai/llm-guard) `🌱``[Python]``[Security]` - Security toolkit for scanning LLM inputs and outputs to prevent prompt injection and data leaks.
- [Logfire](https://github.com/pydantic/logfire) `🌱``[Python]``[Pydantic]` - Python-native observability from the Pydantic team with deep integration for high-performance agent monitoring.
- [NeMo Guardrails](https://github.com/NVIDIA-NeMo/Guardrails) `🌱``[Python]``[Multi-Agent]` - NVIDIA programmable guardrails toolkit for controlling and securing LLM-powered agent conversations.
- [Orchard Kit](https://github.com/OrchardHarmonics/orchard-kit) `🌱``[Python]``[Security]` - Modules for agent runtime security, self-audit trails, and collective cognition patterns.
- [OWASP Top 10 for Agentic Apps](https://owasp.org/www-project-top-10-for-large-language-model-applications/) `🌱``[Python]``[Security]` - Security framework covering goal hijacking, tool misuse, and cascading failure mitigations for agents.
- [Rebuff](https://github.com/protectai/rebuff) `🌱``[Python]``[Security]` - Self-hardening prompt injection detection system for securing agent inputs against adversarial attacks.
- [ai-evaluation](https://github.com/future-agi/ai-evaluation) `🌱``[Python]``[Evaluation]` - LLM evaluation framework with 50+ metrics, LLM-as-Judge, and guardrail scanners (jailbreak, PII, injection).
- [Future AGI](https://github.com/future-agi/future-agi) `🌱``[Python]``[Self-Hosted]` - Self-hostable end-to-end agent engineering platform with tracing, evals, guardrails, and gateway.
## Agent Interfaces and UIs
Frontend workspaces and chat interfaces with built-in agent plugins and tool-use capabilities.
- [AnythingLLM](https://github.com/Mintplex-Labs/anything-llm) `🌱``[TypeScript]``[RAG]` - All-in-one AI application with RAG, agents, and multi-model support for desktop and Docker.
- [DB-GPT](https://github.com/eosphoros-ai/DB-GPT) `🌱``[Python]``[Database]` - Data interaction platform with local LLM support for 100% private database and analytics agents.
- [LibreChat](https://github.com/danny-avila/LibreChat) `🌱``[TypeScript]``[IDE]` - Self-hosted multi-model chat interface supporting all major AI providers with access control.
- [LobeHub](https://lobehub.com/) `🌱``[TypeScript]``[Multi-Agent]` - Modern platform for hybrid work and AI-driven collaboration with extensible agent teams and rapid integration.
- [LobeChat](https://github.com/lobehub/lobehub) `🌱``[TypeScript]``[Multi-Agent]` - Modern, open-source AI chat framework with a massive plugin ecosystem for autonomous agent capabilities.
- [OpenWebUI](https://github.com/open-webui/open-webui) `🌱``[TypeScript]``[RAG]` - Extensible local AI interface with built-in RAG, tool use, and support for multi-agent workflows.
## Agent Deployment and Hosting
- [AWS Bedrock AgentCore](https://github.com/awslabs/agentcore-samples) `🚀``[TypeScript]``[Compliance]` - Managed AWS infrastructure for Bedrock-based agents with compliance, scaling, and monitoring built in.
- [Cerebras Inference](https://www.cerebras.ai) `🌱``[Cloud]``[Multi-Agent]` - Fastest LLM inference delivering 1000+ tokens per second on Llama 3.3 70B with a free tier.
- [Fireworks AI](https://fireworks.ai) `🌱``[Cloud]``[RAG]` - Serverless LLM inference with fine-tuning, RAG support, and free credits for rapid prototyping.
- [Groq Cloud](https://groq.com) `🌱``[Cloud]``[Multi-Agent]` - Ultra-fast LPU-based LLM inference for Mixtral, Llama, and Gemma with a free API tier.
- [Modal](https://github.com/modal-labs/modal-client) `🌱``[Python]``[Serverless]` - Serverless GPU compute purpose-built for AI workloads with fast cold starts and Python-native deployment.
- [Northflank](https://northflank.com/) `🌱``[Cloud]``[Kubernetes]` - Full-stack platform with GPU orchestration, Git-based CI/CD, and bring-your-own-cloud support.
- [Railway](https://railway.com/) `🚀``[Cloud]``[Stateful]` - One-click deploy from GitHub with persistent volumes and databases for stateful agent deployments.
- [Together AI](https://www.together.ai) `🌱``[Cloud]``[Multi-Agent]` - Inference API hosting 200+ open models with fast generation and a free tier for developers.
- [Trigger.dev](https://github.com/triggerdotdev/trigger.dev) `🌱``[TypeScript]``[Serverless]` - Background job platform with cron, webhook, and event triggers purpose-built for long-running agent tasks.
## Agent Evaluation and Benchmarks
- [AgentBench](https://github.com/THUDM/AgentBench) `🌱``[Python]``[Benchmark]` - Comprehensive benchmark for evaluating LLMs as agents across 8 distinct environments.
- [ARC-AGI-2](https://arcprize.org) `🌱``[Python]``[Benchmark]` - Frontier benchmark for measuring general intelligence capabilities in AI agents beyond pattern matching.
- [GAIA Benchmark](https://huggingface.co/papers/2311.12983) `🌱``[Python]``[Benchmark]` - Benchmark for General AI Assistants measuring real-world reasoning and tool use.
- [Inspect AI](https://github.com/UKGovernmentBEIS/inspect_ai) `🌱``[Python]``[Evaluation]` - Framework for evaluating large language models with composable tasks and scoring.
- [SWE-bench](https://github.com/SWE-bench/SWE-bench) `🚀``[Python]``[GitHub]` - Benchmark for evaluating LLMs on real-world software engineering tasks from GitHub issues.
- [WebArena](https://github.com/web-arena-x/webarena) `🌱``[Python]``[Evaluation]` - Benchmark for web agent evaluation using real websites with realistic task completion metrics.
## Agent Testing & Debugging
**Tools and frameworks focused on testing, debugging and evaluating agent workflows in production.**
| agenttrace | Advanced | Basic | ✓ | Local | Session observability, tokens/cost/latency (see Safety Guardrails) |
| Inspect AI | ✗ | ✓ | ✓ | API | Composable evaluation framework (see Agent Evaluation) |
| Patronus AI LYNX | ✓ | ✓ | ✓ | Cloud | Hallucination detection for agent outputs |
| Braintrust Evals | Basic | ✓ | ✓ | Cloud | Eval-driven development and experiment tracking |
| pytest-Agents | ✗ | ✓ | ✗ | Local | Pytest fixtures and runners for agent unit tests |
| Agent Mutation Testing | ✗ | ✓ | ✗ | Local | Generates adversarial mutations to test agent robustness |
| Cortex Debugger | ✓ | ✗ | ✗ | Local | Step-through debugging primitives for agent workflows |
| Agent Coverage Tools | ✗ | ✓ | ✗ | Local | Coverage analysis for agent branches and tool calls |
Notes: Several of these projects already appear elsewhere in this document (agenttrace, Inspect AI, Patronus). New local docs link to conceptual testing tools not yet listed elsewhere.
## Industry-Specific Agents
Curated list of vertical agent solutions for finance, healthcare, legal, manufacturing, and government.
### Finance
- [Anthropic Finance Agents](https://www.anthropic.com) `🚀``[Cloud]``[Multi-Agent]` - Domain-specialized agents for earnings analysis and portfolio insight.
- [JPMorgan AlphaBlue](https://www.jpmorgan.com/global) `🚀``[Cloud]``[Multi-Agent]` - Trading and market analysis agent integrations for institutional workflows.
- [Goldman Sachs Marquee AI](https://www.goldmansachs.com) `🚀``[Cloud]``[Multi-Agent]` - Market data and analytics agents built on Marquee platform.
- [Morgan Stanley AdvisorBot](https://www.morganstanley.com) `🚀``[Cloud]``[CLI]` - Financial advisory assistant for advisors and retail clients.
### Healthcare
- Epic AI Assistant (https://www.epic.com) - Clinical documentation and workflow agents integrated with Epic HER (🏷️ `Cloud``Healthcare``Enterprise`).
- [Nuance Healthcare AI](https://www.microsoft.com/en-us/health-solutions) `🚀``[Cloud]``[CLI]` - Speech and clinical AI solutions for documentation and radiology.
- [Tempus AI](https://www.tempus.com) `🌱``[Cloud]``[CLI]` - Oncology research and clinical decision support agents.
### Legal
- [LexisNexis AI](https://www.lexisnexis.com/en-us/gateway.page) `🚀``[Cloud]``[Research]` - Document review and legal research agents.
- [Westlaw AI-Assisted Research](https://legal.thomsonreuters.com/en/westlaw) `🚀``[Cloud]``[Multi-Agent]` - Case law analysis and brief drafting agents.
- [ROSS Intelligence](https://blog.rossintelligence.com/) `🌱``[Cloud]``[Research]` - Contract analysis and legal research agents.
### Manufacturing & Industrial
- [Siemens AI Ops](https://www.siemens.com/en-us/) `🚀``[Cloud]``[Multi-Agent]` - Factory-floor optimization and predictive maintenance agents.
- [GE Predix Agents](https://www.ge.com/) `🚀``[Cloud]``[IDE]` - Equipment monitoring and incident prediction agents for industrial fleets.
### Government & Compliance
- Anthropic Government Agents - Policy analysis and public sector agents for regulated workflows (🏷️ `Cloud``Government``Enterprise`).
- Tax & Insurance Agent Platforms - Generic category placeholder for compliance-focused tax and underwriting agents (🏷️ `Cloud``Compliance``Enterprise`).
## Learning Resources
- [AgentBench: Evaluating LLMs as Agents](https://arxiv.org/abs/2309.07864) `🌱``[Python]``[Benchmark]` - The benchmark paper for evaluating LLMs as agents across diverse environments.
- [AI Agents in LangGraph](https://www.deeplearning.ai/courses/ai-agents-in-langgraph) `🚀``[Python]``[Multi-Agent]` - Short course on building production agents with LangGraph by Andrew Ng's platform.
- [AI Engineering by Chip Huyen](https://www.oreilly.com/library/view/ai-engineering/9781098166298/) `🌱``[Python]``[IDE]` - Comprehensive guide on AI systems design and deployment covering agent architecture patterns.
- [Anthropic Cookbook](https://github.com/anthropics/claude-cookbooks) `🚀``[Python]``[Anthropic]` - Collection of Claude agent recipes and integration patterns from Anthropic.
- [Building Effective Agents](https://www.anthropic.com/engineering/building-effective-agents) `🚀``[Python]``[Anthropic]` - Anthropic's guide on agent design patterns, evaluation strategies, and production best practices.
- [Hugging Face Agents Course](https://huggingface.co/learn/agents-course/unit0/introduction) `🚀``[Python]``[Multi-Agent]` - Open-source course on building AI agents using Hugging Face tools and models.
- [Implicit Behavioral Alignment of Language Agents in High-Stakes Crowd Simulations](https://arxiv.org/abs/2509.16457) `🌱``[Python]``[Benchmark]` - EMNLP 2025 paper introducing PersonaEvolve, an LLM-based optimizer that refines agent personas so crowds of LLM agents behave realistically against expert benchmarks.
- [LATS: Language Agent Tree Search](https://github.com/lapisrocks/LanguageAgentTreeSearch) `🌱``[Python]``[Paper]` - Combines Monte Carlo tree search with LLM reasoning for complex multi-step planning tasks.
- [LLM Powered Autonomous Agents](https://lilianweng.github.io/posts/2023-06-23-agent/) `🌱``[Python]``[Multi-Agent]` - Deep breakdown of LLM-powered agent components: planning, memory, and tool use.
- [Microsoft GenAI for Beginners](https://github.com/microsoft/generative-ai-for-beginners) `🚀``[Python]``[Microsoft]` - 21-lesson course on generative AI concepts and agent development from Microsoft.
- [OpenAI Cookbook](https://github.com/openai/openai-cookbook) `🚀``[Python]``[OpenAI]` - Practical guides and recipes for building with OpenAI APIs including agent patterns.
- [ReAct: Synergizing Reasoning and Acting in Language Models](https://arxiv.org/abs/2210.03629) `🌱``[Python]``[Paper]` - The foundational paper behind the ReAct prompting pattern used in most agent frameworks.
- [Reflexion](https://github.com/noahshinn/reflexion) `🌱``[Python]``[Paper]` - Research framework letting agents learn from past mistakes via iterative verbal self-reflection loops.
- [Tree of Thoughts](https://github.com/princeton-nlp/tree-of-thought-llm) `🌱``[Python]``[Paper]` - Explores multiple parallel reasoning paths before committing to a final answer for complex problems.
## Agent Communication
Capabilities that let agents send messages, notifications, and reports across channels.
- [Apprise](https://github.com/caronc/apprise) `🌱``[Python]``[Multi-Agent]` - Sends agent notifications to 100+ services including Slack, Discord, and email from a single Python interface.
- [Discord.py](https://github.com/Rapptz/discord.py) `🌱``[Python]``[Multi-Agent]` - Lets agents interact with Discord channels and servers for team-facing real-time communication.
- [FastAPI-Mail](https://github.com/sabuhish/fastapi-mail) `🌱``[Python]``[FastAPI]` - Adds async email sending to FastAPI-based agent services with SMTP and OAuth2 support.
- [Novu](https://github.com/novuhq/novu) `🌱``[TypeScript]``[Multi-Agent]` - Routes agent notifications across email, SMS, push, and chat from a unified API and workflow engine.
- [Ntfy](https://github.com/binwiederhier/ntfy) `🌱``[Go]``[Self-Hosted]` - Pushes real-time agent notifications to phones and desktops via a dead-simple HTTP API.
- [Resend](https://github.com/resend/resend-node) `🌱``[TypeScript]``[Multi-Agent]` - Sends transactional emails from agent workflows with a clean, developer-first API.
- [Slack Bolt](https://github.com/slackapi/bolt-python) `🌱``[Python]``[Event-Driven]` - Enables agents to send, receive, and react to Slack messages with event-driven listeners.
- [The Colony](https://thecolony.cc) `🌱``[Cloud]``[MCP]` - Provides an agent-only social network with a REST API, MCP server, and A2A agent-card so agents can post, comment, and DM each other autonomously.
- [Twilio](https://github.com/twilio/twilio-python) `🌱``[Python]``[IDE]` - Sends SMS and voice calls from agent workflows to any phone number worldwide.
## Data Pipeline and Workflow
Frameworks for orchestrating data transformations and long-running agent-driven workflows.
- [AI for Database](https://www.aifordatabase.com) `🌱``[Cloud]``[Database]` - Connects to any database for plain English queries with self-refreshing dashboards and automated workflows.
- [Burr](https://github.com/apache/burr) `🌱``[Python]``[Observability]` - Tracks and manages multi-step agent state machines with built-in observability and persistence.
- [Dagster](https://github.com/dagster-io/dagster) `🌱``[Python]``[Pipeline]` - Manages data assets and pipelines with built-in lineage tracking for data-intensive agent systems.
- [GPT Researcher](https://github.com/assafelovic/gpt-researcher) `🌱``[Python]``[LangChain]` - Conducts multi-source autonomous web research and produces cited, structured long-form reports.
- [Hamilton](https://github.com/apache/hamilton) `🌱``[Python]``[Pipeline]` - Defines modular data transformations as Python functions wired automatically into a DAG for agent pipelines.
- [Hex AI](https://hex.tech) `🌱``[Cloud]``[Multi-Agent]` - Collaborative data platform with AI-powered analysis and notebook-based data exploration for teams.
- [Julius AI](https://julius.ai) `🌱``[Cloud]``[Multi-Agent]` - Upload CSV or Excel files and analyze data using natural language questions for instant insights.
- [PandasAI](https://github.com/sinaptik-ai/pandas-ai) `🌱``[Python]``[Multi-Agent]` - Chat with your data using natural language queries that convert to Pandas and SQL operations.
- [Prefect](https://github.com/PrefectHQ/prefect) `🌱``[Python]``[Pipeline]` - Orchestrates agent workflows and data pipelines with retries, caching, and built-in observability.
- [Signals CLI](https://signals.dev) `🌱``[Cloud]``[CLI]` - Intent signal CLI detecting LinkedIn engagers, keyword posters, and funding events with JSON output for agent pipelines.
- [STORM](https://github.com/stanford-oval/storm) `🌱``[Python]``[Research]` - Generates Wikipedia-style long-form articles by autonomously researching and synthesizing multiple sources.
## Secure Execution Environments
Infrastructure for running agent-generated code safely in isolated, sandboxed, or serverless environments.
> 💡 **Quick Decision Guide:**
> - **Fastest hosted sandbox:** E2B, Daytona
> - **Self-hosted VM isolation:** Firecracker, Kata Containers, gVisor
> - **Container-based:** Docker, Podman, Sysbox
> - **Serverless:** AWS Lambda, Google Cloud Run, Cloudflare Workers
- agentbox - Docker for AI Agents — package, test, version, and govern AI agents across every framework (🏷️ `Python``Docker``CLI`).
- [agentnotary](https://github.com/CharanBharathula/agentnotary) `🌱``[Python]``[CLI]` - Notarize, govern, and audit AI agents — cryptographic seal, runtime guard, EU AI Act docs, and adversarial fuzzer.
- [AWS Lambda](https://github.com/aws/aws-lambda-python-runtime-interface-client) `🚀``[Python]``[Serverless]` - Serverless function runtime with Firecracker isolation for executing short-lived agent tasks at scale.
- [Cloudflare Workers](https://github.com/cloudflare/workers-sdk) `🌱``[TypeScript]``[Serverless]` - Ultra-low-latency V8-isolate serverless runtime at the edge for lightweight agent task execution.
- [Daytona](https://github.com/daytonaio/daytona) `🌱``[Python]``[Vision]` - Self-hostable git-based developer environment manager for sandboxed agent code execution with fast provisioning.
- [Docker](https://github.com/moby/moby) `🌱``[Go]``[Docker]` - Standard container runtime providing namespace and cgroup isolation for packaging and running agent workloads.
- [Firecracker](https://github.com/firecracker-microvm/firecracker) `🚀``[Rust]``[AWS]` - Lightweight microVM technology with 125ms boot time used by AWS Lambda and E2B under the hood.
- [Google Cloud Run](https://github.com/GoogleCloudPlatform/cloud-run-samples) `🌱``[Python]``[Serverless]` - Fully managed serverless platform with gVisor isolation for running stateless agent containers at scale.
- [gVisor](https://github.com/google/gvisor) `🚀``[Go]``[IDE]` - User-space kernel that intercepts syscalls to provide VM-level security with container-level overhead.
- [Kata Containers](https://github.com/kata-containers/kata-containers) `🌱``[Go]``[Security]` - Combines VM-level security with the developer experience of containers using lightweight VMs.
| Stable Diffusion | Full control | Yes | Free (OSS) |
| Ideogram v3 | Text rendering | No | Free / $7+/mo |
| Google Imagen 4 | Highest fidelity | No | API |
| Seedream AI Studio | Multi-model (5.0/4.5/4.0) | No | Free / Paid |
- [Adobe Firefly 3](https://firefly.adobe.com) `🌱``[Cloud]``[Multi-Agent]` - Generates commercially safe images from text prompts using a model trained exclusively on licensed data.
- [DALL-E 3.5](https://openai.com/dall-e-3) `🚀``[Cloud]``[OpenAI]` - Generates detailed images from text prompts with 95% text accuracy integrated directly into ChatGPT.
- [FLUX 2](https://bfl.ai) `🌱``[Python]``[Multi-Agent]` - Open-weight photorealism model producing 4K output at 6x faster generation speed than its predecessor.
- [Google Imagen 4](https://deepmind.google/models/imagen/) `🚀``[Cloud]``[Multi-Agent]` - Produces photorealistic images from text via Google DeepMind accessible through AI Studio.
- [Ideogram v3](https://ideogram.ai) `🌱``[Cloud]``[IDE]` - Renders readable text inside generated images with near-zero spelling errors for logos and marketing.
- [Leonardo AI](https://leonardo.ai) `🌱``[Cloud]``[Multi-Agent]` - Multi-model image platform with Realtime Canvas and 3D gaming asset generation now owned by Canva.
- [Midjourney v7](https://midjourney.com) `🌱``[Cloud]``[Multi-Agent]` - Produces the highest artistic quality images with unmatched aesthetics via Discord and web interface.
- [Recraft](https://www.recraft.ai) `🌱``[Cloud]``[Vector DB]` - Design-first image generator with native vector art output and brand consistency tools for designers.
- [Seedream AI Studio](https://seedream4.video/) `🚀``[Cloud]``[CLI]` - Multi-model AI image generation platform by ByteDance using Seedream 5.0/4.5/4.0 models with one-click image-to-video animation via Kling 2.1.
- [Stable Diffusion 3.5](https://stability.ai) `🌱``[Python]``[Pipeline]` - Open-source foundation model with full ControlNet, LoRA, and ComfyUI ecosystem for custom pipelines.
### Video Generation
| Generator | Max Length | Resolution | Open Source |
- [Google Veo 3.1](https://deepmind.google/models/veo/) `🚀``[Cloud]``[IDE]` - Generates the highest cinematic quality video with native audio from text prompts via Google DeepMind.
- [HaiLuo AI](https://hailuoai.video) `🌱``[Cloud]``[IDE]` - Budget video generation platform offering 10 free videos per day with HD output quality.
- [HunyuanVideo](https://github.com/Tencent-Hunyuan/HunyuanVideo) `🌱``[Python]``[IDE]` - Open-source video generation model from Tencent that runs on consumer-grade GPUs.
- [Kling 3.0](https://kling.ai) `🌱``[Cloud]``[IDE]` - Generates 4K video up to 2 minutes long with native audio at the most competitive pricing available.
- [LTX Video](https://github.com/Lightricks/LTX-Video) `🌱``[Python]``[IDE]` - Commercially safe open-source video generation model trained on fully licensed data.
- [Luma Dream Machine](https://lumalabs.ai/app) `🌱``[Cloud]``[IDE]` - Creates physics-accurate 4K HDR video scenes with 3D-style output for cinematic quality.
- [Pika 2.5](https://pika.art/login) `🌱``[Cloud]``[IDE]` - Beginner-friendly video generation tool with fast turnaround and intuitive editing controls.
- [Runway Gen-4.5](https://runwayml.com) `🌱``[Cloud]``[IDE]` - Professional video generation with Motion Brush and the highest benchmark scores for visual quality.
- [Seedance 2.0](https://seed.bytedance.com/en/seedance) `🌱``[Cloud]``[IDE]` - Quad-modal input video generator with built-in lip-sync and 2K resolution output.
- [Sora 2](https://sora.com) `🚀``[Cloud]``[OpenAI]` - Generates 25-second cinematic video clips with strong narrative coherence from text prompts by OpenAI.
- [Wan 2.1](https://github.com/Wan-Video/Wan2.1) `🌱``[Python]``[IDE]` - Open-source self-hosted video generation model with unlimited length and no per-video costs.
### Music and Audio Generation
- [ElevenLabs Music](https://elevenlabs.io/music) `🚀``[Cloud]``[Multi-Agent]` - Generates vocals and instrumentals with stem separation and per-section editing for audio production.
- [Meta AudioCraft](https://github.com/facebookresearch/audiocraft) `🌱``[Python]``[Local]` - Open-source audio generation suite including MusicGen and AudioGen with fine-grained prompt control.
- [Stable Audio](https://stableaudio.com) `🚀``[Cloud]``[Multi-Agent]` - Generates instrumental audio tracks with a commercial license included by default for all outputs.
- [Suno](https://suno.com) `🌱``[Cloud]``[Multi-Agent]` - Generates complete songs with vocals, instruments, and lyrics from a single text prompt.
- [Udio](https://www.udio.com) `🌱``[Cloud]``[IDE]` - Produces high-fidelity music with fine-grained sectional control over generation and arrangement.
### 3D and Design Generation
- [Meshy](https://www.meshy.ai) `🌱``[Cloud]``[Multi-Agent]` - Generates 3D models from text or images for game assets and product visualization with multi-format export.
- [Tripo AI](https://www.tripo3d.ai) `🌱``[Cloud]``[Multi-Agent]` - Produces fast 3D model generation from text or images with multi-format export for rapid prototyping.
- [Vizcom](https://vizcom.com) `🌱``[Cloud]``[Multi-Agent]` - Renders industrial design sketches into photorealistic 3D visuals in real-time for product designers.
## Customer Support and CRM Agents
AI agents that automate customer support, CRM workflows, sales outreach, and ticket resolution at scale.
- [Ada](https://www.ada.cx) `🚀``[Cloud]``[Multi-Agent]` - Resolves 60% of customer support tickets automatically with complex multi-turn query understanding.
- [Assembled](https://www.assembled.com) `🚀``[Cloud]``[Multi-Agent]` - Routes support tickets with workforce-aware scheduling and intelligent handoff to human agents.
- [Dixa](https://www.dixa.com) `🚀``[Cloud]``[Multi-Agent]` - CRM-first conversational support platform with AI-powered routing and customer context enrichment.
- [Freshdesk Freddy AI](https://www.freshworks.com/freshdesk/omni/freddy-ai-automation/) `🌱``[Cloud]``[Multi-Agent]` - Auto-triages and routes support tickets with smart AI suggestions for budget-conscious SMB teams.
- [Intercom Fin](https://fin.ai) `🚀``[Cloud]``[Multi-Agent]` - Resolves 50% of SaaS support tickets by learning directly from your help center and knowledge base.
- [Zendesk AI](https://www.zendesk.com/service/ai/) `🚀``[Cloud]``[Multi-Agent]` - Automates 30% of enterprise support tickets with deep integration into the existing Zendesk ecosystem.
### AI-Powered CRM Platforms
- [Creatio](https://www.creatio.com) `🌱``[Cloud]``[No-Code]` - No-code CRM platform with pre-built AI agents for sales, marketing, and service automation.
- [Dynamics 365 Copilot](https://www.microsoft.com/en-us/dynamics-365/solutions/service) `🚀``[Cloud]``[Microsoft]` - Drafts, summarizes, and translates across Office 365 with deep Microsoft ecosystem integration.
- [Monday CRM Lexi](https://monday.com/crm) `🌱``[Cloud]``[Pipeline]` - AI sales agent with automated lead sourcing, qualification, and pipeline management for SMBs.
- [Pipedrive AI](https://www.pipedrive.com/en/features/ai-sales-assistant) `🌱``[Cloud]``[Multi-Agent]` - AI-powered email drafting, deal prioritization, and smart reporting for small sales teams.
- [Salesforce Einstein](https://www.salesforce.com/artificial-intelligence/?bc=OTH) `🚀``[Cloud]``[Multi-Agent]` - Enterprise AI with predictions, autonomous agents, and CRM automation across the Salesforce platform.
- [Salesmate](https://www.salesmate.io) `🌱``[Cloud]``[Pipeline]` - CRM with AI-powered call summarization, lead qualification, and pipeline automation for small teams.
- [ServiceNow AI Agents](https://www.servicenow.com/products/ai-agents.html) `🚀``[Cloud]``[Multi-Agent]` - Orchestrates AI agents across IT, HR, and CRM workflows for enterprise service management.
- [StaffAble AI](https://staffableai.com) `🌱``[Cloud]``[IDE]` - Provides AI agents for small businesses to automate WhatsApp and Instagram messaging, lead qualification, appointment scheduling, and calling.
- [XMACNA Funcionarios Digitais](https://xmacna.ai/funcionario-digital) `🌱``[Cloud]``[IDE]` - Provides AI/IA agents for WhatsApp, phone, CRM updates, lead qualification, follow-up, and human handoff.
- [Zoho CRM Zia](https://www.zoho.com/zia/) `🌱``[Cloud]``[Voice]` - Predictive scoring, sentiment analysis, and voice commands for sales automation across Zoho products.
### Sales and Outreach Agents
- [Apollo.io](https://www.apollo.io) `🌱``[Cloud]``[Multi-Agent]` - AI prospecting platform with 275M+ contacts, lead scoring, and automated email sequencing.
- [Clay](https://www.clay.com) `🌱``[Cloud]``[IDE]` - Enriches leads from 70+ data providers and generates hyper-personalized outreach at scale.
- [Instantly](https://instantly.ai) `🌱``[Cloud]``[Multi-Agent]` - Generates AI cold emails with smart sender rotation and built-in domain warmup for deliverability.
- [Lavender](https://www.lavender.ai) `🌱``[Cloud]``[Multi-Agent]` - Coaches email writing in real-time with AI response scoring and recipient intelligence.
- [Overloop CLI](https://overloop.com) `🌱``[Cloud]``[CLI]` - AI outbound CLI agent that sources 450M+ contacts and runs email plus LinkedIn campaigns with JSON output.
## Voice Agent Platforms
Platforms for building, deploying, and scaling voice-based AI agents across calls, support, and live conversations.
| Bland AI | Medium | Yes | Outbound call automation |
| PolyAI | Low | Yes | Enterprise scale |
- [AgentLine](https://agentline.cloud/) `🌱``[Cloud]``[Pipeline]` - Telephony infrastructure for AI agents — provision phone numbers, make/receive calls, and manage voice pipelines via API.
- [AssemblyAI](https://www.assemblyai.com) `🌱``[Cloud]``[Pipeline]` - Speech-to-text API with speaker diarization, sentiment analysis, and summarization for voice agent pipelines.
- [Bland AI](https://www.bland.ai/) `🌱``[Cloud]``[Voice]` - Automates outbound phone calls at scale with SOC2 and HIPAA compliance and CRM integration.
- [Deepgram](https://deepgram.com) `🌱``[Cloud]``[Pipeline]` - Sub-300ms speech-to-text and text-to-speech APIs purpose-built for real-time voice agent pipelines.
- [ElevenLabs](https://elevenlabs.io) `🌱``[Cloud]``[RAG]` - Industry- voice AI with 75ms latency, Conversational AI 2.0, RAG, and HIPAA compliance.
- [HeyGen](https://www.heygen.com) `🌱``[Cloud]``[IDE]` - Creates AI talking avatars with voice cloning and lip-sync for video-based agent interactions.
- [PolyAI](https://poly.ai/en) `🚀``[Cloud]``[Voice]` - Enterprise voice AI platform for natural multi-turn conversations with high-volume call handling.
- [Retell AI](https://www.retellai.com) `🌱``[Cloud]``[Voice]` - Builds human-like voice agents with multi-language telephony support and low-latency responses.
- [Synthesia](https://www.synthesia.io) `🌱``[Cloud]``[IDE]` - Generates AI video avatars that speak in 120+ languages for training and communication agents.
- [Synthflow](https://synthflow.ai) `🌱``[Cloud]``[No-Code]` - No-code voice agent builder with pre-built templates for SMBs to deploy phone agents quickly.
- [Voiceflow](https://www.voiceflow.com) `🌱``[Cloud]``[No-Code]` - No-code builder for voice and chat agents with visual conversation design and team collaboration.
## Deep Research Agents
AI platforms that conduct autonomous multi-step research, synthesize findings from multiple sources, and generate structured reports with citations.
| Gemini Research | 1M tokens | Google Search + KG |
| Perplexity Pro | Variable | Real-time cited search |
- [CAJAL](https://github.com/Agnuxo1/CAJAL) `🌱``[Python]``[Local]` - Local AI agent that generates publication-ready IMRaD scientific papers with verified arXiv citations and AI tribunal scoring.
- [ChatGPT Deep Research](https://openai.com/index/introducing-deep-research) `🚀``[Cloud]``[OpenAI]` - Conducts extended reasoning with web browsing to produce structured research reports with Canvas output.
- [Claude Deep Research](https://www.anthropic.com/research) `🚀``[Cloud]``[Anthropic]` - Performs multi-step investigation with verified source citations and 200K token context window.
- [DeerFlow](https://github.com/bytedance/deer-flow) `🚀``[Python]``[Multi-Agent]` - Multi-agent research system from ByteDance with planning and execution loops for autonomous investigation.
- [Gemini Deep Research](https://blog.google/products-and-platforms/products/gemini/google-gemini-deep-research/) `🚀``[Cloud]``[RAG]` - Leverages Google Search and Knowledge Graph integration with 1M token context for breadth-first research.
- [Perplexity Pro](https://www.perplexity.ai) `🌱``[Cloud]``[IDE]` - Provides real-time search answers with inline citations and follow-up threads for iterative research.
- [Perplexity Personal Computer](https://www.perplexity.ai/pc) `🌱``[Cloud]``[Vision]` - Autonomous research agent with vision capabilities, real-time search integration, and document analysis for comprehensive research workflows.
- [Superhighway](https://superhighway.walls.sh) `🌱``[Python]``[IDE]` - Web search API for agents (search, news, scrape, research) with a Python guide for building an academic [literature-review agent](https://superhighway.walls.sh/guides/academic-research-agent).
## Prompt-to-App Builders
Platforms that generate full-stack applications, components, or web apps from natural language prompts.
- [Bolt.new](https://bolt.new) `🌱``[Cloud]``[Multi-Agent]` - Generates full-stack web applications in the browser from natural language prompts with instant deploy.
- [Google Project IDX](https://firebase.studio) `🚀``[Cloud]``[IDE]` - AI-powered cloud IDE with free Claude Opus access for building full projects across all frameworks.
- [Lovable](https://lovable.dev) `🌱``[Cloud]``[Multi-Agent]` - Iterates from chat to deployed web application with auto-deploy and real-time preview.
- [PlayCode Agent](https://playcode.io) `🌱``[Cloud]``[Multi-Agent]` - Browser-only lightweight web app creation tool with AI-assisted code generation.
- [Replit Agent](https://replit.com/agent4) `🌱``[Cloud]``[Multi-Agent]` - Builds and deploys full-stack projects from prompts with integrated hosting and collaboration.
- [v0 by Vercel](https://v0.app) `🚀``[Cloud]``[CLI]` - Generates React and Tailwind UI components from text descriptions with one-click Vercel deployment.
## Multi-Agent Consumer Platforms
All-in-one AI platforms providing access to agents, tools, and models through consumer-facing interfaces without writing code.
- [ChatGPT](https://openai.com/chatgpt) `🚀``[Cloud]``[OpenAI]` - General-purpose AI platform with GPTs, Deep Research, Canvas, and Agent Mode across the widest plugin ecosystem.
- [Claude](https://claude.com/product/overview) `🚀``[Cloud]``[MCP]` - Reasoning-focused AI with Computer Use, MCP integration, and Chrome browsing for coding and long document analysis.
- [Coze](https://www.coze.com) `🚀``[Cloud]``[No-Code]` - No-code agent builder with a marketplace of 100+ custom agents and plugin integrations.
- [Gemini](https://deepmind.google/models/gemini/) `🚀``[Cloud]``[Multimodal]` - Google's multimodal AI with 1M token context, Deep Think, Gems, and NotebookLM for workspace integration.
- [Grok](https://x.ai/grok) `🌱``[Cloud]``[Multi-Agent]` - Real-time AI with live X data access, Grok Build for 8-agent parallel code generation, and image generation.
- [Meta AI](https://meta.ai) `🚀``[Cloud]``[Multi-Agent]` - Llama-powered AI integrated across WhatsApp, Messenger, and Instagram for conversational assistance.
- [Microsoft Copilot](https://copilot.microsoft.com) `🚀``[Cloud]``[Microsoft]` - AI assistant integrated into Office 365, Teams, and Power Platform for enterprise productivity workflows.
- [Sistava](https://sistava.com/en/) `🌱``[Cloud]``[Voice]` - AI agent orchestration platform for deploying multi-channel agents across messaging, voice, and APIs with full Computer Use capabilities on your own OS.
## Open-Source Models for Agents
Open-weight LLMs optimized for agentic tasks including tool use, planning, multi-step reasoning, and code generation.
| Model | Organization | Parameters | Agent Strength |
- [Baichuan 3](https://huggingface.co/baichuan-inc) `🌱``[Python]``[Local]` - Chinese-optimized open model family with strong domain performance for multilingual agent deployments.
- [Command R+](https://cohere.com/command) `🚀``[Cloud]``[RAG]` - Cohere's 104B parameter model optimized specifically for RAG and enterprise tool use in agent workflows.
- [DeepSeek V3](https://github.com/deepseek-ai/DeepSeek-V3) `🌱``[Python]``[Local]` - 671B MoE model that delivers GPT-4 level reasoning at 68x lower cost for budget-conscious agent deployments.
- [Falcon 3](https://huggingface.co/tiiuae) `🌱``[Python]``[Local]` - Efficient open model from TII UAE with strong multilingual support across 10B to 180B parameter variants.
- [Gemma 3](https://github.com/google-deepmind/gemma) `🚀``[Python]``[IDE]` - Efficient multimodal model from Google in 1B to 27B sizes ideal for edge and on-device agents.
- [Gemma 4](https://deepmind.google/models/gemma/) `🚀``[Python]``[Local]` - Consumer and IoT-optimized model from Google in 2B to 31B sizes with E2B and E4B variants.
- [GLM-4](https://github.com/zai-org/GLM-4) `🌱``[Python]``[Local]` - Zhipu AI's 744B MoE model achieving the lowest hallucination rate and 77.8% on SWE-bench.
- [GLM-5.2](https://github.com/zai-org/GLM-5) `🌱``[Python]``[Local]` - Zhipu AI’s newest open-source GLM family release optimized for large-context reasoning and agentic tool use.
- [InternLM 3](https://github.com/InternLM/InternLM) `🌱``[Python]``[Local]` - Shanghai AI Lab model with strong long-context reasoning capabilities for complex agent tasks.
- [Llama 4](https://github.com/meta-llama/llama-models) `🚀``[Python]``[Local]` - Meta's flagship open model family with Scout and Maverick variants and strong tool use capabilities.
- [Mistral Large 2](https://mistral.ai/models/) `🌱``[Python]``[Multi-Agent]` - European open model at 123B parameters with strong function calling for agent workflows.
- [Phi-4](https://huggingface.co/microsoft/phi-4) `🚀``[Python]``[Microsoft]` - Microsoft's compact 14B parameter model delivering strong reasoning for on-device and edge agent deployments.
- [Qwen 3](https://github.com/QwenLM/Qwen3) `🚀``[Python]``[MCP]` - MCP-native multilingual model family from Alibaba with thinking mode across 0.6B to 235B sizes.
- [Qwen 3.6-Plus](https://qwenlm.github.io/blog/qwen3/) `🚀``[Python]``[MCP]` - Agentic-focused model with 1M context window, repo-level coding, and MCP-native tool use.
- [StarCoder 2](https://github.com/bigcode-project/starcoder2) `🌱``[Python]``[Local]` - Code-focused open model trained on 600+ programming languages for specialized coding agents.
- [Yi-Lightning](https://github.com/01-ai/Yi) `🌱``[Python]``[Local]` - 01.AI's multilingual model with long context and fast inference across 6B to 200B parameter sizes.
## Market Stats and Benchmarks 2026
Key data points on the AI agent market covering adoption, growth, valuations, and fastest-growing open-source projects.
- [AI Agent Market Report 2026](https://www.marketsandmarkets.com) `🌱``[Python]``[Research]` - Comprehensive market analysis projecting the AI agent market to reach $52.63B by 2030 at 46.3% CAGR.
- [State of AI Agents Survey](https://www.mckinsey.com) `🚀``[Python]``[Research]` - Enterprise survey showing 57% of organizations now have AI agents in production workflows.
## Local and Self-Hosted AI
Tools for running LLMs locally and self-hosting AI agent platforms with full privacy and control.
- [GPT4All](https://github.com/nomic-ai/gpt4all) `🌱``[C++]``[Local]` - Open-source local chat application that runs LLMs on consumer hardware without cloud dependencies.
- [Jan](https://github.com/janhq/jan) `🌱``[TypeScript]``[Local]` - Open-source ChatGPT alternative that runs 100% offline with local model management and privacy guarantees.
- [Llamafile](https://github.com/mozilla-ai/llamafile) `🌱``[C++]``[Local]` - Distributes LLMs as single executable files with zero setup required from Mozilla.
- [llama.cpp](https://github.com/ggml-org/llama.cpp) `🌱``[C++]``[Local]` - C/C++ LLM inference engine supporting CPU, GPU, and Apple Silicon as the foundation of local AI.
- [LM Studio](https://lmstudio.ai) `🌱``[TypeScript]``[Local]` - Desktop application for running local LLMs with a polished UI across all major platforms.
- [LocalAI](https://github.com/mudler/LocalAI) `🚀``[Go]``[OpenAI]` - Drop-in OpenAI API replacement that runs models locally without requiring a GPU.
- [Ollama](https://github.com/ollama/ollama) `🚀``[Go]``[GitHub]` - Run LLMs locally with a dead-simple CLI interface and 162K+ GitHub stars.
- [vLLM](https://github.com/vllm-project/vllm) `🚀``[Python]``[Local]` - High-throughput LLM serving engine with PagedAttention for production-grade local inference.
- [Yao Agents](https://github.com/YaoApp/yao) `🌱``[Go]``[MCP]` - Local-first AI execution platform with Docker sandbox isolation, BYOK model configuration, MCP support, 5-stage Pipeline, and multi-platform messaging via WeChat, Feishu, DingTalk, Telegram, and Discord.
## AI Governance and Compliance
Frameworks and tools for AI risk management, regulatory compliance, and governance as EU AI Act obligations take effect August 2026.
- [Credo AI](https://www.credo.ai) `🌱``[Cloud]``[Multi-Agent]` - End-to-end AI governance platform with EU AI Act policy packs and model inventory management.
- [EU AI Act](https://artificialintelligenceact.eu) `🌱``[Python]``[Multi-Agent]` - Official EU regulatory framework classifying AI systems by risk tier from unacceptable to minimal risk.
- [IBM watsonx.governance](https://www.ibm.com/products/watsonx-governance) `🚀``[Cloud]``[Compliance]` - Enterprise AI risk, compliance, and model monitoring platform for regulated industries.
- [Nobulex](https://github.com/arian-gogani/nobulex) `🌱``[TypeScript]``[IDE]` - Cryptographic receipts for AI agent actions with two Ed25519 signatures per action, hash-chained for tamper-evident audit trails.
- [NIST AI RMF](https://airc.nist.gov/) `🌱``[Python]``[Multi-Agent]` - US framework for AI risk management covering Govern, Map, Measure, and Manage functions.
- [OneTrust AI Governance](https://www.onetrust.com/solutions/ai-governance/) `🌱``[Cloud]``[Compliance]` - Risk classification, consent management, and compliance workflows for AI agent deployments.
- [Project Glasswing](https://www.anthropic.com/glasswing) `🌱``[Python]``[Benchmark]` - Industry consortium (11-company initiative) focused on AI safety, red-teaming, and shared benchmarks for agent risk mitigation.
## Cybersecurity Agents
AI agents specialized in penetration testing, vulnerability discovery, threat detection, and security analysis.
- [Microsoft Security Copilot](https://www.microsoft.com/en-us/security/business/ai-machine-learning/microsoft-security-copilot) `🚀``[Cloud]``[Microsoft]` - Enterprise threat detection and incident response AI integrated across Microsoft security products.
- [PentestGPT](https://github.com/GreyDGL/PentestGPT) `🌱``[Python]``[CLI]` - GPT-powered penetration testing tool with automated reasoning for vulnerability assessment.
- [YAWNING TITAN](https://github.com/dstl/YAWNING-TITAN) `🌱``[Python]``[Graph-Based]` - Graph-based cybersecurity simulation environment for training and testing defensive AI agents.
## Healthcare and Therapy Agents
AI agents for mental health support, cognitive training, and therapy-adjacent applications with clinical validation.
- [Akili Interactive](https://www.akiliinteractive.com) `🌱``[Cloud]``[IDE]` - FDA-cleared video game-based digital medicine for ADHD using neuroplasticity-focused cognitive training.
- [Elomia](https://elomia.com) `🌱``[Cloud]``[CLI]` - Clinician-designed AI therapy chatbot with natural conversation flow and anonymous interaction by design.
- [Ginger](https://organizations.headspace.com) `🌱``[Cloud]``[Multi-Agent]` - On-demand mental healthcare platform combining AI coaching with live therapists using CBT and DBT approaches.
- [Headspace Health](https://www.headspace.com) `🌱``[Cloud]``[CLI]` - Meditation and mental health platform with CBT-based courses, sleep programs, and clinical partnerships.
- [Replika](https://replika.com) `🌱``[Cloud]``[Multi-Agent]` - AI companion with Rogerian-style support, persistent memory, and mood tracking for social wellbeing.
- [Talkspace AI](https://www.talkspace.com) `🌱``[Cloud]``[Multi-Agent]` - AI-assisted therapy matching platform with human therapist backup for personalized mental health care.
- [Tess by X2AI](https://www.cass.ai) `🌱``[Cloud]``[CLI]` - SMS-based therapy coach using CBT with clinical validation showing 28% depression reduction.
- [Woebot](https://woebothealth.com) `🌱``[Cloud]``[Multi-Agent]` - CBT-based mental health chatbot that is FDA-cleared and Stanford-validated for therapeutic conversations.
- [Wysa](https://www.wysa.com) `🌱``[Cloud]``[Multi-Agent]` - NHS-approved AI mental health companion using CBT and DBT with anonymous design principles.
- [Youper](https://www.youper.ai) `🌱``[Cloud]``[CLI]` - Emotional health assistant using CBT and ACT with Stanford-tested clinical effectiveness for mood tracking.
## Newsletters and Communities
Curated newsletters, podcasts, and communities for staying current with AI agent development.
- [AI Engineering Newsletter](https://www.latent.space) `🌱``[Python]``[Newsletter]` - AI engineering podcast and newsletter by Swyx and Alessio covering agent architectures and tooling.
- [AiToolsObserver](https://aitoolsobserver.com) `🌱``[Python]``[Multi-Agent]` - AI discovery and intelligence platform covering AI agents, ecosystem trends, comparisons, and practical use cases.
- [aibtc.news](https://aibtc.news) `🌱``[Python]``[Newsletter]` - Bitcoin-focused agent news platform with bounties and classifieds for the agent economy.
- [Awesome Agents Newsletter](https://awesomeagents.substack.com) `🌱``[Python]``[Newsletter]` - Weekly curated tools and reviews covering the latest in AI agent development.
- [r/ClaudeAI](https://www.reddit.com/r/ClaudeAI/) `🌱``[Python]``[Multi-Agent]` - Reddit community for Claude users sharing agent workflows, prompts, and integration patterns.
- [r/LangChain](https://www.reddit.com/r/LangChain/) `🌱``[Python]``[LangChain]` - Reddit community for agent developers using LangChain, LangGraph, and related frameworks.
- [r/LocalLLaMA](https://www.reddit.com/r/LocalLLaMA/) `🌱``[Cloud]``[IDE]` - Reddit community for self-hosted LLM users sharing local deployment and agent setup guides.
- [The Rundown AI](https://www.therundown.ai) `🌱``[Python]``[RAG]` - Daily AI digest reaching 600K+ subscribers with concise coverage of agent news and launches.
- [Agents Launchpad](https://launchpad.smartbizcalc.com) `🌱``[Python]``[Multi-Agent]` - Community-curated directory of indie AI agents and tools.
## Changelog
See [CHANGELOG.md](CHANGELOG.md) for the full update history.
## Contributing
Your contributions are what keep this list useful. Read [Contributing.md](CONTRIBUTING.md) for the entry format, inclusion criteria, and style guide.
## Star History
[](https://star-history.com/#ARUNAGIRINATHAN-K/awesome-ai-agents-2026&Date)
[AI agents](#ai-agents) are effective for applications that solve open-ended problems, which might require
autonomous decision-making and complex multi-step workflow management. Agents
excel at solving problems in real-time by using external data and they excel at automating
knowledge-intensive tasks. AI agents are suitable when you need AI to complete
goal-focused tasks with some degree of autonomy. For other use cases, you can
use assistive and generative AI applications. To learn about the differences
between AI agents and non-agentic AI applications, see the internal note: [Differences between agents and assistants](#differences-agents-assistants-bots).
This guide assumes that you have a foundational knowledge of agentic AI systems
and how their architecture differs from that of non-agentic systems, such as
those that use direct model reasoning or [retrieval-augmented generation (RAG)](#retrieval-augmented-generation).
For a summary of the agent pattern guidance, see the [Compare design patterns](#compare-design-patterns) section later in this document.
## Overview of the design process
The following are the high-level steps to choose a design pattern for your agentic AI system. These steps are described in detail later in this document.
1.**Define your requirements**: Assess the characteristics of your workload, including task complexity, latency and performance expectations, cost budget, and the need for human involvement.
2.**Review the common agent design patterns**: Learn about the common design patterns in this guide, which include both single-agent systems and multi-agent systems.
3.**Select a pattern**: Select the appropriate [design pattern](#compare-design-patterns) based on your workload characteristics.
This process isn't a one-time decision. You should periodically revisit these
steps to refine your architecture as your workload characteristics change, your
requirements evolve, or new platform features become available.
## Define your requirements
The questions that follow aren't exhaustive checklists for planning. Use these
questions as a starting point to identify the primary goal of your agentic
system and to select the best design pattern.
- **Task characteristics**: Can your task be completed in predefined workflow steps or is the task open-ended? Does your task need to use an AI model to orchestrate the workflow?
- **Latency and performance**: Do you need to prioritize fast or interactive responses at the cost of accuracy or high-quality responses? Or can your application tolerate a delay to achieve a more accurate or thorough result?
- **Cost**: What is your budget for inference costs? Can you support patterns that require multiple calls to the model for a single request?
- **Human involvement**: Does your task involve high-stakes decisions, safety-critical operations, or subjective approvals that require human judgment?
If your workload is predictable or highly structured, or if it can be executed with a
single call to an AI model, it can be more cost effective to explore non-agentic
solutions for your task. For example, you might not need an agentic workflow for
tasks like summarizing a document, translating text, or classifying customer
feedback. For information about choosing models and infrastructure for non-agentic generative AI applications, see the internal note: [Choose models & infra](#choose-models-infra).
The following sections describe common agent design patterns for building a
reliable and effective agentic AI system.
## Single-agent system
A *single-agent system* uses an AI model, a defined set of tools, and a comprehensive
system prompt to autonomously handle a user request or to complete a specific task.
In this fundamental pattern, the agent relies on the model's reasoning
capabilities to interpret a user's request, plan a sequence of steps, and decide
which tools to use from a defined set. The system prompt shapes the agent's
behavior by defining its core task, persona, and operations,
and the specific conditions for using each tool.
The following diagram shows a high-level view of a single agent pattern:
A single-agent system is ideal for tasks that require multiple steps and access
to external data. For example, a customer support agent must query a database to
find an order status, or a research assistant needs to call APIs to summarize
recent news. A non-agentic system can't perform these tasks because it can't
autonomously use tools or execute a multi-step plan to synthesize a final
answer.
If you're early in your agent development, we recommend that you start with a single agent.
When you start your agent development with a single-agent system, you can
focus on refining the core logic, prompt, and tool definitions of your agent
before adding more complex architectural components.
A single agent's performance can be less effective when it uses more tools and
when tasks increase in complexity. You might observe this as increased latency, incorrect
tool selection or use, or a failure to complete the task. You can often mitigate
these issues by refining the agent's reasoning process with techniques like the
[Reason and Act (ReAct) pattern](#react-pattern). However, if your workflow requires an agent to manage several distinct
responsibilities, these techniques might not be sufficient. For these cases,
consider a [multi-agent system](#multi-agent-systems), which can improve resilience and performance by delegating specific skills to specialized agents.
## Multi-agent systems
A *multi-agent system* orchestrates multiple specialized agents to solve a
complex problem that a single agent can't easily manage. The core principle is to
decompose a large objective into smaller sub-tasks and assign each sub-task to a
dedicated agent with a specific skill. These agents then interact through
collaborative or hierarchical workflows to achieve the final goal. Multi-agent
patterns provide a modular design that can improve the scalability, reliability,
and maintainability of the overall system compared to a single agent with a
monolithic prompt.
In a multi-agent system, each agent requires a specific context to perform its
task effectively. Context can include documentation, historical preferences,
relevant links, conversational history, or any operational constraints. The
process of managing this information flow is called *context engineering*.
Context engineering includes strategies such as isolating context for a specific agent, persisting information across multiple steps, or compressing large amounts of data to improve efficiency.
Building a multi-agent system requires additional evaluation, security,
reliability, and cost considerations when compared to a single-agent system. For
example, multi-agent systems must implement precise access controls for each
specialized agent, design a robust orchestration system to ensure reliable
inter-agent communication, and manage the increased operational costs from the
computational overhead of running multiple agents. For an example reference
architecture to build a multi-agent system, see the internal note: [Multi-agent AI systems](#multi-agent-ai-systems).
### Sequential pattern
The *multi-agent sequential pattern* executes a series of specialized agents in a predefined, linear order where the
output from one agent serves as the direct input for the next agent. This
pattern is implemented by a sequential workflow agent (see: [Sequential agents](#sequential-agents)) that operates on predefined logic without having
to consult an AI model for the orchestration of its subagents.
The following diagram shows a high-level view of a multi-agent sequential
pattern:
Use the sequential pattern for highly structured, repeatable processes where
the sequence of operations doesn't change. For example, a data processing
pipeline might use this pattern to first have a data extraction agent pull raw
data, then pass that data to a data cleaning agent for formatting, which in turn
passes the clean data to a data loading agent to save it in a database.
The sequential pattern can reduce latency and operational costs compared to a
pattern that uses an AI model to orchestrate task workflow. However, this
efficiency comes at the cost of flexibility. The rigid, predefined structure of
the pipeline makes it difficult to adapt to dynamic conditions or to skip
unnecessary steps, which can cause inefficient processing or lead to higher
cumulative latency if an unneeded step is slow.
### Parallel pattern
The *multi-agent parallel pattern*, also known as a *concurrent pattern*, runs multiple specialized subagents in parallel. The outputs of the subagents are then synthesized to produce the final consolidated response. Similar to a [sequential pattern](#sequential-pattern), the parallel pattern is managed by a parallel workflow agent (see: [Parallel agents](#parallel-agents)).
The following diagram shows a high-level view of a multi-agent parallel
pattern:
Use the parallel pattern when sub-tasks can be executed concurrently to reduce
latency or gather diverse perspectives, such as gathering data from disparate
sources or evaluating several options at once. For example, to analyze customer
feedback, a parallel agent might fan out a single feedback entry to four
specialized agents at the same time: a sentiment analysis agent, a keyword extraction
agent, a categorization agent, and an urgency detection agent. A final agent
gathers these four outputs into a single, comprehensive analysis of
that feedback.
The parallel pattern can reduce overall latency compared to a sequential
approach because it can gather diverse information from multiple sources at the same time. However,
this approach introduces trade-offs in cost and complexity. Running multiple
agents in parallel can increase immediate resource utilization and token
consumption, which leads to higher operational costs. Furthermore, the gather
step requires complex logic to synthesize potentially conflicting results, which
adds to the development and maintenance overhead of the system.
### Loop pattern
The *multi-agent loop agent pattern* repeatedly executes a sequence of specialized subagents
until a specific termination condition is met. This pattern is implemented by a loop workflow agent (see: [Loop agents](#loop-agents)) that, like other workflow agents, operates on predefined logic without consulting an AI model for orchestration. After all of the subagents complete
their tasks, the loop agent evaluates whether an exit condition is met. The
condition can be a maximum number of iterations or a custom state. If the
exit condition isn't met, then the loop agent starts the sequence of subagents
again. You can implement a loop pattern where the exit condition is evaluated at
any point in the flow. Use the loop pattern for tasks that require
[iterative refinement](#iterative-refinement) or self-correction, such as generating content and having a critic agent review
it until it meets a quality standard.
The following diagram shows a high-level view of a multi-agent loop pattern:
The loop agent pattern provides a way to build complex, iterative workflows. It
enables agents to refine their own work and continue processing until a specific
quality or state is achieved. However, this pattern's primary trade-off is the
risk of an infinite loop. If the termination condition isn't correctly defined
or if the subagents fail to produce the state that's required to stop, the loop can run
indefinitely. This can lead to excessive operational costs, high resource
consumption, and potential system hangs.
### Review and critique pattern
The *multi-agent review and critique pattern*, also known as the *generator and
critic pattern*, improves the quality and reliability of generated content by
using two specialized agents, typically in a sequential workflow. The review and
critique pattern is an implementation of the [loop agent pattern](#loop-pattern).
In the review and critique pattern, a generator agent creates an initial output,
such as a block of code or a summary of a document. Next, a critic agent
evaluates this output against a predefined set of criteria, such as factual
accuracy, adherence to formatting rules, or safety guidelines. Based on the
evaluation, the critic can approve the content, reject it, or return it to the
generator with feedback for revision.
The following diagram shows a high-level view of a multi-agent review and
critique pattern:
This pattern is suitable for tasks where outputs must be highly accurate or must
conform to strict constraints before they're presented to a user or used in a
downstream process. For example, in a code generation workflow, a generator
might write a function to fulfill a user's request. This generated code is
then passed to a critic agent that acts as a security auditor. The critic
agent's job is to check the code against a set of constraints, such as scanning
for security vulnerabilities or verifying that it passes all of the unit tests,
before the code is approved for use.
The reviewer and critique pattern can improve output quality, accuracy, and
reliability because it adds a dedicated verification step. However, this quality
assurance comes at the direct cost of increased latency and operational
expenses. The workflow requires at least one additional model call for the
critic's evaluation. If the process includes revision loops where content is
sent back for refinement, then both latency and costs accumulate with each
iteration.
### Iterative refinement pattern
The *iterative refinement pattern* uses a looping mechanism to progressively
improve an output over multiple cycles. The iterative refinement pattern is an
implementation of the [loop agent pattern](#loop-pattern).
In this pattern, one or more agents work within a loop to modify a result
that's stored in the session state during each iteration. The process continues until
the output meets a predefined quality threshold or it reaches a maximum number of
iterations, which prevents infinite loops.
The following diagram shows a high-level view of a multi-agent iterative
refinement pattern:
This pattern is suitable for complex generation tasks where the output
is difficult to achieve in a single step. Examples of such tasks include writing and debugging a piece
of code, developing a detailed multi-part plan, or drafting and revising a
long-form document. For example, in a creative writing workflow, an agent might
generate a draft of a blog post, critique the draft for flow and tone, and then
rewrite the draft based on that critique. This process repeats in a loop until
the agent's work meets a predefined quality standard or until the repetition reaches
a maximum number of iterations.
The iterative refinement pattern can produce highly complex or polished outputs
that would be difficult to achieve in a single step. However, the looping
mechanism directly increases latency and operational costs with each cycle. This
pattern also adds architectural complexity, because it requires carefully designed
exit conditions---such as a quality evaluation or a maximum iteration limit---to
prevent excessive costs or uncontrolled execution.
### Coordinator pattern
The *multi-agent coordinator pattern* uses a central agent, the *coordinator*, to
direct a workflow. The coordinator analyzes and decomposes a user's request into
sub-tasks, and then it dispatches each sub-task to a specialized agent for execution.
Each specialized agent is an expert in a specific function, such as querying a database or calling an API.
A distinction of the coordinator pattern is its use of an AI model to orchestrate and dynamically route tasks. By contrast, the [parallel pattern](#parallel-pattern) relies on a hardcoded workflow to dispatch tasks for simultaneous execution without the need for AI model orchestration.
The following diagram shows a high-level view of a multi-agent coordinator pattern:
Use the coordinator pattern for automating structured business processes that
require adaptive routing. For example, a customer service agent can act as the
coordinator. The coordinator agent analyzes the request to determine whether it's
an order status request, product return, or refund request. Based on
the type of request, the coordinator routes the task to the appropriate specialized
agent.
The coordinator pattern offers flexibility compared to more rigid, predefined
workflows. By using a model to route tasks, the coordinator can handle a wider
variety of inputs and adapt the workflow at runtime. However, this approach also
introduces trade-offs. Because the coordinator and each specialized agent rely
on a model for reasoning, this pattern results in more model calls than a
single-agent system. Although the coordinator pattern can lead to higher-quality
reasoning, it also increases token throughput, operational costs, and
overall latency when compared to a single-agent system.
### Hierarchical task decomposition pattern
The *multi-agent hierarchical task decomposition pattern*
organizes agents into a multi-level hierarchy to solve complex problems that
require extensive planning. The hierarchical task decomposition pattern is an
implementation of the [coordinator pattern](#coordinator-pattern).
A top-level parent, or *root*, agent receives a complex task and it's responsible
for decomposing the task into several smaller, manageable sub-tasks. The root agent delegates
each sub-task to a specialized subagent at a lower level. This process can
repeat through multiple layers, with agents that progressively decompose their
assigned tasks until the tasks are simple enough for a worker agent at the lowest
level to execute directly.
The following diagram shows a high-level view of a multi-agent hierarchical
task decomposition pattern:
Use the hierarchical task decomposition pattern for ambiguous, open-ended
problems that require multi-step reasoning, such as tasks that involve research,
planning, and synthesis. For example, to complete a complex research project, a
coordinator agent decomposes the high-level goal into multiple tasks such as
gathering information, analyzing the findings, and synthesizing the final
report. The coordinator agent then delegate those tasks to specialized
subagents, such as an agent for data gathering, an analysis agent, and an
agent that writes reports, to execute or further decompose.
The hierarchical task decomposition pattern is ideal for solving highly complex
and ambiguous problems because it systematically decomposes them into
manageable sub-tasks. However, this advanced capability introduces
significant trade-offs. The multi-level structure adds considerable
architectural complexity, which makes the system more difficult to design, debug, and
maintain. The multiple layers of delegation and reasoning also result in a high
number of model calls, which significantly increases both overall latency and
operational costs compared to other patterns.
### Swarm pattern
The *multi-agent swarm pattern* uses a collaborative, all-to-all communication
approach. In this pattern, multiple specialized agents work together to iteratively refine a
solution to a complex problem.
The following diagram shows a high-level view of a multi-agent swarm pattern:
The swarm pattern uses a dispatcher agent to route a user request
to a collaborative group of specialized agents. The dispatcher agent interprets
the request and it determines which agent in the swarm is best suited to begin the
task. In this pattern, each agent can communicate with every other agent,
which allows them to share findings, critique proposals, and build upon each other's
work to iteratively refine a solution. Any agent in the swarm can hand off the
task to another agent that it determines is better suited to handle the next
step, or it can communicate the final response back to the user through the
coordinator agent.
A swarm typically lacks a central supervisor or coordinator agent to keep the
process on track. The dispatcher agent doesn't orchestrate the agentic workflow,
unlike the [coordinator pattern](#coordinator-pattern). Instead, the dispatcher agent facilitates communication between the swarm
subagents and the user. To ensure that the swarm eventually stops and returns a
result, you must define an explicit exit condition. This
condition is often a maximum number of iterations, a time limit, or the
achievement of a specific goal, such as reaching a consensus.
Use the swarm pattern for ambiguous or highly complex problems that benefit
from debate and iterative refinement. For example, designing a new product could
involve a market researcher agent, an engineering agent, and a financial
modeling agent. The agents would share initial ideas, debate the trade-offs
between features and costs, and collectively converge on a final design
specification that balances all of the competing requirements.
The swarm pattern simulates a collaborative team of experts, therefore it can
produce exceptionally high-quality and creative solutions. However, it represents the
most complex and costly multi-agent pattern to implement. The lack of an agent
that uses an AI model to orchestrate can introduce the risk of unproductive loops
or the failure to converge on a solution. You must therefore design
sophisticated logic to manage the intricate inter-agent communication, control
the iterative workflow, and handle the significant operational costs and latency
that are associated with running a dynamic, multi-turn conversation between multiple
agents.
## Reason and act (ReAct) pattern
The [*ReAct pattern*](#react-paper) is an approach that uses the AI model to frame its thought processes and actions
as a sequence of natural language interactions. In this pattern, the agent operates in an iterative loop of thought, action, and
observation until an exit condition is met.
- **Thought**: The model reasons about the task and it decides what to do next. The model evaluates all of the information that it's gathered in order to determine whether the user's request has been fully answered.
- **Action** : Based on its thought process, the model takes one of two actions:
- If the task isn't complete, it selects a tool and then it forms a query to gather more information.
- If the task is complete, it formulates the final answer to send to the user, which ends the loop.
- **Observation**: The model receives the output from the tool and it saves relevant information in its memory. Because the model saves relevant output, it can build on previous observations, which helps to prevent the model from repeating itself or losing context.
The iterative loop terminates when the agent finds a conclusive answer, reaches a preset maximum number of iterations, or encounters an error that prevents it from continuing.
## Compare design patterns
This document describes several agent design patterns (single-agent, multi-agent, sequential, parallel, loop, review & critique, iterative refinement, coordinator, hierarchical, and swarm). Use this section as a quick reference when choosing between them.
## References
The original external references used while drafting this document are listed below for traceability. Inline links in this file point to internal anchors; consult these references if you need the upstream source.
- AI agents glossary: https://docs.cloud.google.com/docs/generative-ai/glossary#ai-agents
- Difference between agents and assistants: https://cloud.google.com/discover/what-are-ai-agents#what-is-the-difference-between-ai-agents-ai-assistants-and-bots
the output meets a predefined quality threshold or it reaches a maximum number of
iterations, which prevents infinite loops.
The following diagram shows a high-level view of a multi-agent iterative
refinement pattern:
This pattern is suitable for complex generation tasks where the output
is difficult to achieve in a single step. Examples of such tasks include writing and debugging a piece
of code, developing a detailed multi-part plan, or drafting and revising a
long-form document. For example, in a creative writing workflow, an agent might
generate a draft of a blog post, critique the draft for flow and tone, and then
rewrite the draft based on that critique. This process repeats in a loop until
the agent's work meets a predefined quality standard or until the repetition reaches
a maximum number of iterations.
The iterative refinement pattern can produce highly complex or polished outputs
that would be difficult to achieve in a single step. However, the looping
mechanism directly increases latency and operational costs with each cycle. This
pattern also adds architectural complexity, because it requires carefully designed
exit conditions---such as a quality evaluation or a maximum iteration limit---to
prevent excessive costs or uncontrolled execution.
### Coordinator pattern
The *multi-agent coordinator pattern* uses a central agent, the *coordinator*, to
direct a workflow. The coordinator analyzes and decomposes a user's request into
sub-tasks, and then it dispatches each sub-task to a specialized agent for execution.
Each specialized agent is an expert in a specific function, such as querying a database or calling an API.
A distinction of the coordinator pattern is its use of an AI model to orchestrate and dynamically route tasks. By contrast, the [parallel pattern](#parallel-pattern) relies on a hardcoded workflow to dispatch tasks for simultaneous execution without the need for AI model orchestration.
The following diagram shows a high-level view of a multi-agent coordinator pattern:
Use the coordinator pattern for automating structured business processes that
require adaptive routing. For example, a customer service agent can act as the
coordinator. The coordinator agent analyzes the request to determine whether it's
an order status request, product return, or refund request. Based on
the type of request, the coordinator routes the task to the appropriate specialized
agent.
The coordinator pattern offers flexibility compared to more rigid, predefined
workflows. By using a model to route tasks, the coordinator can handle a wider
variety of inputs and adapt the workflow at runtime. However, this approach also
introduces trade-offs. Because the coordinator and each specialized agent rely
on a model for reasoning, this pattern results in more model calls than a
single-agent system. Although the coordinator pattern can lead to higher-quality
reasoning, it also increases token throughput, operational costs, and
overall latency when compared to a single-agent system.
### Hierarchical task decomposition pattern
The *multi-agent hierarchical task decomposition pattern*
organizes agents into a multi-level hierarchy to solve complex problems that
require extensive planning. The hierarchical task decomposition pattern is an
implementation of the
[coordinator pattern](#coordinator-pattern).
A top-level parent, or *root*, agent receives a complex task and it's responsible
for decomposing the task into several smaller, manageable sub-tasks. The root agent delegates
each sub-task to a specialized subagent at a lower level. This process can
repeat through multiple layers, with agents that progressively decompose their
assigned tasks until the tasks are simple enough for a worker agent at the lowest
level to execute directly.
The following diagram shows a high-level view of a multi-agent hierarchical
task decomposition pattern:
Use the hierarchical task decomposition pattern for ambiguous, open-ended
problems that require multi-step reasoning, such as tasks that involve research,
planning, and synthesis. For example, to complete a complex research project, a
coordinator agent decomposes the high-level goal into multiple tasks such as
gathering information, analyzing the findings, and synthesizing the final
report. The coordinator agent then delegate those tasks to specialized
subagents, such as an agent for data gathering, an analysis agent, and an
agent that writes reports, to execute or further decompose.
The hierarchical task decomposition pattern is ideal for solving highly complex
and ambiguous problems because it systematically decomposes them into
manageable sub-tasks. This pattern can result in more comprehensive and higher-quality
results than simpler patterns. However, this advanced capability introduces
significant trade-offs. The multi-level structure adds considerable
architectural complexity, which makes the system more difficult to design, debug, and
maintain. The multiple layers of delegation and reasoning also result in a high
number of model calls, which significantly increases both overall latency and
operational costs compared to other patterns.
### Swarm pattern
The *multi-agent swarm pattern* uses a collaborative, all-to-all communication
approach. In this pattern, multiple specialized agents work together to iteratively refine a
solution to a complex problem.
The following diagram shows a high-level view of a multi-agent swarm pattern:
The swarm pattern uses a dispatcher agent to route a user request
to a collaborative group of specialized agents. The dispatcher agent interprets
the request and it determines which agent in the swarm is best suited to begin the
task. In this pattern, each agent can communicate with every other agent,
which allows them to share findings, critique proposals, and build upon each other's
work to iteratively refine a solution. Any agent in the swarm can hand off the
task to another agent that it determines is better suited to handle the next
step, or it can communicate the final response back to the user through the
coordinator agent.
A swarm typically lacks a central supervisor or coordinator agent to keep the
process on track. The dispatcher agent doesn't orchestrate the agentic workflow,
unlike the
[coordinator pattern](#coordinator-pattern).
Instead, the dispatcher agent facilitates communication between the swarm
subagents and the user. To ensure that the swarm eventually stops and returns a
result, you must define an explicit exit condition. This
condition is often a maximum number of iterations, a time limit, or the
achievement of a specific goal, such as reaching a consensus.
Use the swarm pattern for ambiguous or highly complex problems that benefit
from debate and iterative refinement. For example, designing a new product could
involve a market researcher agent, an engineering agent, and a financial
modeling agent. The agents would share initial ideas, debate the trade-offs
between features and costs, and collectively converge on a final design
specification that balances all of the competing requirements.
The swarm pattern simulates a collaborative team of experts, therefore it can
produce exceptionally high-quality and creative solutions. However, it represents the
most complex and costly multi-agent pattern to implement. The lack of an agent
that uses an AI model to orchestrate can introduce the risk of unproductive loops
or the failure to converge on a solution. You must therefore design
sophisticated logic to manage the intricate inter-agent communication, control
the iterative workflow, and handle the significant operational costs and latency
that are associated with running a dynamic, multi-turn conversation between multiple
agents.
## Reason and act (ReAct) pattern
The
[*ReAct pattern*](#react-paper)
is an approach that uses the AI model to frame its thought processes and actions
as a sequence of natural language interactions. In this pattern, the agent operates in an iterative loop of thought, action, and
observation until an exit condition is met.
- **Thought**: The model reasons about the task and it decides what to do next. The model evaluates all of the information that it's gathered in order to determine whether the user's request has been fully answered.
- **Action** : Based on its thought process, the model takes one of two actions:
- If the task isn't complete, it selects a tool and then it forms a query to gather more information.
- If the task is complete, it formulates the final answer to send to the user, which ends the loop.
- **Observation**: The model receives the output from the tool and it saves relevant information in its memory. Because the model saves relevant output, it can build on previous observations, which helps to prevent the model from repeating itself or losing context.
The iterative loop terminates when
the agent finds a conclusive answer, reaches a preset maximum number of
iterations, or encounters an error that prevents it from continuing.
This iterative loop lets the agent dynamically build a plan, gather evidence,
and adjust its approach as it works toward a final answer.
The following diagram shows a high-level view of the ReAct pattern:
Use the ReAct pattern for complex, dynamic tasks that require
continuous planning and adaptation. For example, consider a robotics agent that must generate a path to transition from an initial state to a goal state:
- **Thought**: The model reasons about the optimal path to transition from its current state to the goal state. During the thought process, the model optimizes for metrics like time or energy.
- **Action**: The model executes the next step in its plan by moving along a calculated path segment.
- **Observation**: The model observes and saves the new state of the environment. The model saves its new position and any changes to the environment that it perceives.
This loop allows the agent to
adhere to dynamic constraints, such as avoiding new obstacles or following
traffic regulations, by constantly updating its plan based on new observations. The agent continues through its iterative loop until it reaches its goal or encounters an error.
A single ReAct agent can be simpler and more cost-effective to implement and
maintain than a complex multi-agent system. Model thinking provides a transcript
of the model's reasoning, which helps with debugging. However, this flexibility
introduces trade-offs. The iterative, multi-step nature of the loop can lead to
higher end-to-end latency compared to a single query. Furthermore, the agent's
effectiveness is highly dependent on the quality of the AI model's reasoning.
Therefore, an error or a misleading result from a tool in one observation step can
propagate and cause the final answer to be incorrect.
## Human-in-the-loop pattern
The human-in-the-loop pattern integrates points for human intervention directly into an agent's workflow. At a
predefined checkpoint, the agent pauses its execution and calls an external
system to wait for a person to review its work. This pattern lets a person
approve a decision, correct an error, or provide necessary input before the
agent can continue.
The following diagram shows a high-level view of a human-in-the-loop pattern:
Use the human-in-the-loop pattern for tasks that require human oversight,
subjective judgment, or final approval for critical actions. Such actions include approving a
large financial transaction, validating the summary of a sensitive document, or
providing subjective feedback on generated creative content. For example, an
agent might be tasked with anonymizing a patient dataset for research. The agent
would automatically identify and redact all protected health information, but it
would pause at a final checkpoint. It would then wait for a human compliance
officer to manually validate the dataset and approve its release, which helps to
ensure that no sensitive data is exposed.
The human-in-the-loop pattern improves safety and reliability by inserting
human judgment into critical decision points within the workflow. This pattern
can add significant architectural complexity because it requires you to build
and maintain the external system for user interaction.
## Custom logic pattern
The custom logic pattern provides the maximum flexibility in your workflow
design. This approach lets you implement specific orchestration logic that uses
code, such as conditional statements, to create complex workflows with multiple
branching paths.
The following diagram illustrates an example use of a custom logic pattern to
capture a refund process:
In the preceding diagram, the following is the agentic workflow for the example
customer refund agent:
1. The user sends a query to the customer refund agent that acts as a coordinator agent.
2. The coordinator's custom logic first invokes a parallel verifier agent, which simultaneously dispatches two subagents: the purchaser verifier agent and the refund eligibility agent.
3. After the results are gathered, the coordinator agent executes a tool to check whether the request is eligible for a refund.
1. If the user is eligible, then the coordinator routes the task to a refund processor agent, which calls the `process_refund` tool.
2. If the user isn't eligible, then the coordinator routes the task to a separate sequential flow, starting with the store credit agent and the process credit decision agent.
4. The result from whichever path is taken is sent to the final response agent to formulate the answer for the user.
The customer refund agent example requires a unique solution for its
logic-level orchestration, which goes beyond the structured approaches that other
patterns offer. This workflow mixes patterns because it runs a parallel check,
and then it executes a custom conditional branch that routes to two entirely different
downstream processes. This type of complex, mixed-pattern workflow is the ideal
use case for the custom logic pattern.
Use the custom logic pattern when you need fine-grained control over the agent's
execution or when your workflow doesn't fit one of the other patterns that's
described in this document. However, this approach increases development and
maintenance complexity. You are responsible for designing, implementing, and
debugging the entire orchestration flow, which requires more development effort
and can be more error-prone than using a predefined pattern that is supported by
a tool like [Agent Development Kit (ADK)](#adk-docs).
For information about custom agents and how to implement custom logic using ADK, see
[Custom agents](#custom-agents).
## Compare design patterns
Choosing an agent pattern is a fundamental architectural decision. Each pattern offers different trade-offs in flexibility, complexity, and performance. To determine the appropriate pattern for your workload, consider the design patterns in the following sections.
### Workflows that are deterministic
Workflow that are deterministic include tasks that are predictable and sequential, and that have a clearly defined workflow path from start to finish. The steps in your tasks are known in advance, and the process doesn't change much from one run to the next. The following are agent design patterns for workflows that are deterministic:
| - Multi-step tasks that follow a predefined, rigid workflow. - Doesn't require model orchestration. - Fixed sequence of operations. The output of one agent is the direct input of the next agent in the sequence. | [Multi-agent sequential pattern](#sequential-pattern) |
| - Independent tasks that can be executed at the same time. - Doesn't require model orchestration. - Reduces overall latency by running sub-tasks simultaneously. | [Multi-agent parallel pattern](#parallel-pattern) |
| - Open-ended or complex generation tasks that are difficult to complete in a single attempt. - Requires the agent to progressively improve the output over multiple cycles. - Doesn't require model orchestration. - Prioritizes output quality over latency. | [Multi-agent iterative refinement pattern](#iterative-refinement-pattern) |
### Workflows that require dynamic orchestration
Workflows that require dynamic orchestration include complex problems where the agents must determine the best way to proceed. The agentic AI system needs to dynamically plan, delegate, and coordinate tasks without a predefined script. The following are agent design patterns for workflows that require autonomous and dynamic orchestration:
| - Structured and multi-step tasks that require the use of external tools. - Requires fast development for a prototype of a solution as a proof of concept. | [Single agent pattern](#single-agent-system) |
| - Requires dynamic routing to an appropriate specialized subagent for structured tasks with varied input. - High latency due to multiple calls to the coordinator AI model so that it can direct tasks to the appropriate subagent. - Can incur high cost due to multiple calls to the coordinator agent. | [Multi-agent coordinator pattern](#coordinator-pattern) |
| - Requires multi-level model orchestration for complex, open-ended, and ambiguous tasks. - Requires comprehensive, high-quality results where decomposing ambiguity is the primary challenge. - High latency due to nested, multi-level decomposition that leads to multiple calls to the AI model for reasoning. | [Multi-agent hierarchical task decomposition pattern](#hierarchical-task-decomposition-pattern) |
| - Requires collaborative debate and iterative refinement from multiple specialized agents for highly complex, open-ended, or ambiguous tasks. - Prioritizes the synthesis of multiple perspectives to create a comprehensive or creative solution. - High latency and operational costs due to dynamic, all-to-all communication between agents. | [Multi-agent swarm pattern](#swarm-pattern) |
### Workflows that involve iteration
Workflows that involve iteration include tasks where the final output is achieved through cycles of refinement, feedback, and improvement. The following are agent design patterns for workflows that involve iteration:
| - Requires an agent to iteratively reason, act, and observe to build or adapt a plan for complex, open-ended, and dynamic tasks. - Prioritizes a more accurate and thorough result over latency. | [ReAct pattern](#react-pattern) |
| - Requires monitoring or polling tasks that repeat a predefined action, such as automated checks, until the agent meets an exit condition. - Unpredictable or long-running latency while waiting for an exit condition to be met. | [Multi-agent loop pattern](#loop-pattern) |
| - Tasks require a distinct validation step before completion. | [Multi-agent review and critique pattern](#review-critique-pattern) |
| - Open-ended or complex generation tasks that are difficult to complete in a single attempt. - Requires the agent to progressively improve the output over multiple cycles. - Doesn't require model orchestration. - Prioritizes output quality over latency. | [Multi-agent iterative refinement pattern](#iterative-refinement-pattern) |
### Workflows that have special requirements
Workflows that have special requirements include tasks that don't follow the common agentic patterns. Your tasks can include unique business logic or they can require human judgment and intervention at critical points. Your agentic AI system is a custom-built machine designed for a single, specific purpose. The following are agent design patterns for workflows that have special requirements:
| - Requires human supervision due to high-stakes or subjective tasks that might include safety, reliability, and compliance requirements. | [Human-in-the-loop pattern](#human-in-the-loop-pattern) |
| - Complex, branching logic that goes beyond a direct linear sequence. - Requires maximum control to mix predefined rules with model reasoning. - Requires fine-grained process control for a workflow that doesn't fit a standard template. | [Custom logic pattern](#custom-logic-pattern) |
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
promptadmin