同步完整源码 - 2026-05-25
This commit is contained in:
xiaoxue
commit
d0202a2f0c
|
|
@ -0,0 +1,47 @@
|
|||
## What does this PR do?
|
||||
|
||||
<!-- Check all that apply -->
|
||||
|
||||
- [ ] Adds a new tool
|
||||
- [ ] Updates an existing entry (stars, links, description)
|
||||
- [ ] Removes an abandoned / dead project
|
||||
- [ ] Fixes a broken link
|
||||
- [ ] Improves structure or formatting
|
||||
- [ ] Other: ___
|
||||
|
||||
---
|
||||
|
||||
## For new tool additions
|
||||
|
||||
**Tool name:**
|
||||
**Category it belongs in:**
|
||||
**GitHub URL:**
|
||||
**Site URL (if any):**
|
||||
|
||||
### Why does this tool belong on the list?
|
||||
|
||||
<!-- What does it do, and what makes it distinct from tools already listed? 2–3 sentences. -->
|
||||
|
||||
### Pre-submission checklist
|
||||
|
||||
- [ ] The repo has had a commit in the last **6 months**
|
||||
- [ ] This tool is **meaningfully different** from existing entries
|
||||
- [ ] The tool has a working README or docs site
|
||||
- [ ] My entry follows the [format in CONTRIBUTING.md](https://github.com/ARUNAGIRINATHAN-K/awesome-ai-agents/Contributing.md) exactly
|
||||
- [ ] The entry is placed in **alphabetical order** within its section
|
||||
- [ ] All links open correctly and go to the right place
|
||||
- [ ] Description is exactly **two sentences** — no promotional language
|
||||
|
||||
---
|
||||
|
||||
## For updates or removals
|
||||
|
||||
**What changed and why:**
|
||||
|
||||
<!-- e.g. "Updated star count to 34k", "Repo has been archived since Jan 2026", "Fixed 404 on docs link" -->
|
||||
|
||||
---
|
||||
|
||||
## Anything else?
|
||||
|
||||
<!-- Optional: context, related issues, or questions for the maintainer -->
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
name: awesome-lint
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
branches: [ main, master ]
|
||||
schedule:
|
||||
- cron: '0 0 * * *'
|
||||
|
||||
jobs:
|
||||
lint:
|
||||
name: Run awesome-lint
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v4
|
||||
with:
|
||||
fetch-depth: 0
|
||||
|
||||
- name: Setup Node.js
|
||||
uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: '20'
|
||||
|
||||
- name: Install codespell
|
||||
run: python -m pip install --quiet "codespell==2.2.6"
|
||||
|
||||
- name: Check English in docs and comments
|
||||
# Added EHR to the ignore-words-list below
|
||||
run: codespell -q 3 --skip=.git,node_modules --check-filenames --ignore-words-list="reworkd,EHR" .
|
||||
|
||||
- name: Install dependencies
|
||||
run: npm install
|
||||
|
||||
- name: Run awesome-lint
|
||||
run: npx awesome-lint
|
||||
env:
|
||||
CI: true
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
name: Check Links
|
||||
|
||||
on:
|
||||
schedule:
|
||||
- cron: '0 0 * * 0' # Weekly on Sunday
|
||||
pull_request:
|
||||
branches: [main, master]
|
||||
workflow_dispatch:
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
issues: write
|
||||
|
||||
jobs:
|
||||
link-check:
|
||||
name: Verify all links are alive
|
||||
runs-on: ubuntu-latest
|
||||
permissions:
|
||||
issues: write
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Check links with Lychee
|
||||
uses: lycheeverse/lychee-action@v2
|
||||
with:
|
||||
args: >-
|
||||
--verbose
|
||||
--no-progress
|
||||
--accept 200,204,301,302,403,429
|
||||
--exclude-path node_modules
|
||||
--exclude "star-history.com"
|
||||
--exclude "shields.io"
|
||||
--exclude "stableaudio.com"
|
||||
--exclude "mckinsey.com"
|
||||
--exclude "servicenow.com"
|
||||
--timeout 30
|
||||
README.md
|
||||
fail: true
|
||||
|
||||
- name: Create issue on failure
|
||||
if: failure() && github.event_name != 'pull_request'
|
||||
uses: peter-evans/create-issue-from-file@v5
|
||||
with:
|
||||
title: "🔗 Broken links detected"
|
||||
content-filepath: ./lychee/out.md
|
||||
labels: bug, maintenance
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
{
|
||||
"MD013": false
|
||||
}
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
# Changelog
|
||||
|
||||
All notable changes to this list will be documented here.
|
||||
|
||||
> Each row is a dated update. The most recent changes are always at the top.
|
||||
|
||||
---
|
||||
|
||||
## 2026
|
||||
|
||||
| Date | Change |
|
||||
|---|---|
|
||||
| May 11 2026 | Added 15 new May 2026 tools (LangSmith Fleet, AWS Bedrock Agents, Vertex AI Agents, Wispr Flow, ElevenAgents, Nuance AI, Patronus AI LYNX, Perplexity Personal Computer, and 7 more). Updated 8 descriptions (Cursor, Devin, Claude Code, Pipecat, LangSmith, CrewAI, Pinecone, Skyvern) with 2026 metrics and features. Added enterprise compliance tags ([Enterprise], [HIPAA], [SOC2], [GDPR]) to 20+ tools. Highlighted trending projects: Browser Use (50K⭐), Playwright MCP (10K⭐), DeerFlow (25K⭐). Updated tool count 426→450+. |
|
||||
| May 11 2026 | Added new categories `Agent Testing & Debugging` and `Industry-Specific Agents` with 20+ industry entries (Finance, Healthcare, Legal, Manufacturing, Government). Added conceptual testing tools (pytest-Agents, Agent Mutation Testing, Cortex Debugger, Agent Coverage Tools) and a testing comparison table. Standardized enterprise metadata across verticals. Updated README badge to 470+. |
|
||||
| May 10 2026 | Added CAJAL to Deep Research Agents as a local scientific paper generation agent for publication-ready IMRaD papers with verified arXiv citations and AI tribunal scoring. |
|
||||
| May 04 2026 | Massive expansion to 426+ tools across 33 categories. Added 13 new sections (Creative AI, Customer Support/CRM, Voice Platforms, Deep Research, App Builders, Multi-Agent Platforms, Open-Source Models, Market Stats, Local/Self-Hosted AI, AI Governance, Cybersecurity, Healthcare/Therapy, Newsletters). Backfilled 60+ missing entries across existing categories. Added GNAP, OpenClaw, Bernstein, MagiC, Miyabi, n8n, Temporal, OWASP, and more. Full awesome-lint compliance. |
|
||||
| May 03 2026 | Added agenttrace to Safety Guardrails and Observability as a local-first TUI for AI coding agent session observability, covering tokens, cost, latency, tool failures, anomalies, reports, diffs, and CI health gates. |
|
||||
| April 28 2026 | Major content merge: added 3 new categories (Agent Communication, Data Pipeline and Workflow, Secure Execution Environments) and 50+ new tools including Crawl4AI, Docling, Chroma, Qdrant, Weaviate, Milvus, LanceDB, Zep, Motorhead, DSPy, Novu, Slack Bolt, Twilio, Apprise, GPT Researcher, STORM, Hamilton, Prefect, Dagster, Burr, Playwright, Firecracker, Docker, Podman, gVisor, Kata Containers, Sysbox, AWS Lambda, Google Cloud Run, Cloudflare Workers, and more. Tool count now at 173+. |
|
||||
| April 28 2026 | Added new category "Agent Interfaces and UIs" and 5 missing top-tier tools. Implemented comprehensive metadata tagging (`Language` `Framework` `Environment`) for all 70+ tools while maintaining awesome-lint compliance. |
|
||||
| April 27 2026 | Updated Agent Tooling & Infrastructure - KubeStellar Console to Agent Tooling and Infrastructure section. |
|
||||
| April 25 2026 | Quality upgrade - fixed 6 broken images, added 4 comparison tables (Coding Agents, Memory, Browser, Protocols), added decision guides for all categories, added A2A and Agent Communication Protocols section, rewrote Contributing.md, fixed all redirected and broken links, added tool count badge |
|
||||
| April 24 2026 | Added 21 new tools - Cursor, Windsurf, Devin, Codex CLI, Augment Code to Coding Agents; Acontext to Memory; Docker MCP, Cloudflare MCP, Microsoft Fabric MCP to MCP; Operator to Browser Agents; Langfuse, Arize Phoenix, Laminar, Logfire, AgentDoG, DriftGuard to Safety & Observability; Terminal-Bench to Evaluation |
|
||||
| April 2026 | Major overhaul — added comparison tables, star counts, language tags, 3 new categories (MCP & Tool Protocols, Browser & Computer Use Agents, Agent Evaluation & Benchmarks), link-checker CI, badges, and "Why This List?" section |
|
||||
| April 2026 | Add new memory-related resources and Coding Agents |
|
||||
| April 2026 | Added new frameworks and resources for orchestration |
|
||||
| March 2026 | Added Smolagents, PydanticAI, and Letta to Orchestration Frameworks |
|
||||
| March 2026 | Added Semantic Kernel to Orchestration Frameworks. Added Agent Deployment and Hosting category with 5 tools. |
|
||||
| March 2026 | Initial release — 80+ tools across 9 categories |
|
||||
|
||||
---
|
||||
|
||||
|
||||
Minor fixes (typos, broken links, small star count corrections) are not logged here individually — those are tracked in [commit history](https://github.com/ARUNAGIRINATHAN-K/awesome-ai-agents/commits/main).
|
||||
|
||||
---
|
||||
|
||||
*For the full history of changes, see the [commit log](https://github.com/ARUNAGIRINATHAN-K/awesome-ai-agents/commits/main).*
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
# Code of Conduct
|
||||
|
||||
## Our Pledge
|
||||
|
||||
This is a community list. Everyone who contributes whether opening a PR, filing an issue, or leaving a comment is part of what makes it useful.
|
||||
|
||||
We pledge to make participation in this project a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socioeconomic status, nationality, personal appearance, race, caste, color, religion, or sexual identity and orientation.
|
||||
|
||||
We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
|
||||
|
||||
---
|
||||
|
||||
## Our Standards
|
||||
|
||||
**Behavior that contributes to a positive environment:**
|
||||
|
||||
- Being respectful of differing opinions, viewpoints, and experiences
|
||||
- Giving and gracefully accepting constructive feedback
|
||||
- Taking responsibility and apologizing when we make mistakes, and learning from the experience
|
||||
- Focusing on what is best for the community, not just individual preferences
|
||||
- Assuming good intent — most people are here to help, not to cause problems
|
||||
|
||||
**Behavior that is not acceptable:**
|
||||
|
||||
- Harassment of any kind, public or private
|
||||
- Trolling, insulting, or derogatory comments
|
||||
- Personal or political attacks
|
||||
- Publishing others' private information without explicit permission
|
||||
- Sustained disruption of discussions
|
||||
- Spam, self-promotion beyond what's relevant, or aggressive advocacy for a specific tool
|
||||
- Any conduct that would reasonably be considered inappropriate in a professional setting
|
||||
|
||||
---
|
||||
|
||||
## Scope
|
||||
|
||||
This Code of Conduct applies within all project spaces — GitHub issues, pull requests, discussions, and any other community channels associated with this project.
|
||||
|
||||
It also applies when an individual is officially representing the project in public spaces, such as posting on behalf of the project on social media.
|
||||
|
||||
---
|
||||
|
||||
## Enforcement
|
||||
|
||||
Instances of unacceptable behavior may be reported by opening a **private** GitHub issue at [https://github.com/ARUNAGIRINATHAN-K/awesome-ai-agents/issues](https://github.com/ARUNAGIRINATHAN-K/awesome-ai-agents/issues) or contacting the maintainer directly.
|
||||
|
||||
All complaints will be reviewed and investigated promptly and fairly. The maintainer is obligated to respect the privacy and security of the reporter of any incident.
|
||||
|
||||
**Enforcement actions, in order of severity:**
|
||||
|
||||
| Action | When it applies |
|
||||
|---|---|
|
||||
| **Correction** | A private written warning with clarity on why the behavior was inappropriate |
|
||||
| **Warning** | A formal warning with consequences for continued behavior |
|
||||
| **Temporary ban** | Temporary removal from all community interaction |
|
||||
| **Permanent ban** | Permanent removal for severe, repeated, or sustained violations |
|
||||
|
||||
---
|
||||
|
||||
## Attribution
|
||||
|
||||
This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org), version 2.1, which is the standard used across thousands of open-source projects including those listed in this repo.
|
||||
|
||||
---
|
||||
|
||||
*A good community is what turns a list into a resource. Thanks for helping keep this one worth contributing to.*
|
||||
|
|
@ -0,0 +1,136 @@
|
|||
# Contributing to Awesome AI Agents 2026
|
||||
|
||||
First off, thank you. This list only stays useful because people like you take the time to keep it accurate and current.
|
||||
|
||||
There are four ways to contribute:
|
||||
|
||||
- **Add a new tool** - something missing that belongs here
|
||||
- **Update an existing entry** - description is wrong or links are broken
|
||||
- **Remove a dead project** - unmaintained repos that no longer belong
|
||||
- **Improve the structure** - better categories, clearer descriptions, fixed typos
|
||||
|
||||
All contributions go through a pull request. It takes about 5 minutes.
|
||||
|
||||
---
|
||||
|
||||
## Entry Format
|
||||
|
||||
Every entry follows this exact format:
|
||||
|
||||
```markdown
|
||||
- [Tool Name](https://github.com/org/repo) - One sentence describing what the tool does and what makes it distinct.
|
||||
```
|
||||
|
||||
**Rules:**
|
||||
|
||||
- Entry starts with `- ` (a markdown list item)
|
||||
- Tool name is a link in square brackets: `[Tool Name](url)`
|
||||
- Description follows ` - ` (space, hyphen, space) after the closing parenthesis
|
||||
- Description is exactly **one sentence**, ending with a period
|
||||
- No promotional language ("the best", "revolutionary", "game-changing")
|
||||
- Entries within each category are sorted **alphabetically** by tool name
|
||||
|
||||
**Good example:**
|
||||
|
||||
```markdown
|
||||
- [Mem0](https://github.com/mem0ai/mem0) - Memory layer for AI applications with long-term, short-term, and semantic memory extraction.
|
||||
```
|
||||
|
||||
**Bad examples:**
|
||||
|
||||
```markdown
|
||||
# Wrong: uses heading instead of list item
|
||||
### Mem0
|
||||
**[GitHub](https://github.com/mem0ai/mem0)** - Memory layer for AI
|
||||
|
||||
# Wrong: uses em-dash instead of hyphen
|
||||
- [Mem0](https://github.com/mem0ai/mem0) — Memory layer for AI applications.
|
||||
|
||||
# Wrong: multiple sentences
|
||||
- [Mem0](https://github.com/mem0ai/mem0) - Memory layer for AI applications. It supports long-term memory extraction.
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Inclusion Criteria
|
||||
|
||||
Your tool should meet **all** of the following:
|
||||
|
||||
1. **Directly related to AI agents** - not a general LLM tool, not a prompt library, not a generic API wrapper
|
||||
2. **Actively maintained** - last commit within the past 6 months
|
||||
3. **Publicly available** - open-source with a GitHub/GitLab repo, or a live hosted product with a public URL
|
||||
4. **Not a duplicate** - check the list first to make sure it is not already included
|
||||
5. **Functional** - the tool must actually work, not just be a README with no code
|
||||
|
||||
Wait, tools that are **experimental, early-stage, or have few stars** are welcome as long as they meet all five criteria above. We value breadth of coverage.
|
||||
|
||||
---
|
||||
|
||||
## Category Placement
|
||||
|
||||
Place your entry in the **most specific category** that fits. If it spans multiple categories, pick the primary one. The maintainers may move it during review.
|
||||
|
||||
Current categories:
|
||||
|
||||
- **Orchestration Frameworks** - core agent building frameworks
|
||||
- **Coding Agents** - tools that write, edit, and debug code
|
||||
- **Memory and Context** - persistent memory and knowledge graphs
|
||||
- **Multi-Agent Systems** - multi-agent coordination frameworks
|
||||
- **Agent Communication Protocols** - MCP, A2A, and tool protocol implementations
|
||||
- **Browser and Computer Use Agents** - web navigation and UI automation
|
||||
- **Agent Tooling and Infrastructure** - sandboxes, scrapers, and networking
|
||||
- **Low and No-Code Builders** - visual and browser-based agent builders
|
||||
- **Voice and Multimodal Agents** - audio, video, and cross-modal agents
|
||||
- **Safety Guardrails and Observability** - monitoring, security, and governance
|
||||
- **Agent Interfaces and UIs** - frontend workspaces and chat interfaces
|
||||
- **Agent Deployment and Hosting** - platforms for running agents in production
|
||||
- **Agent Evaluation and Benchmarks** - benchmarks and evaluation frameworks
|
||||
- **Learning Resources** - courses, papers, and guides
|
||||
- **Agent Communication** - notifications, messaging, and channel integrations
|
||||
- **Data Pipeline and Workflow** - data orchestration and long-running workflows
|
||||
- **Secure Execution Environments** - sandboxes, VMs, and serverless runtimes
|
||||
- **Creative AI Agents** - image, video, music, audio, and 3D generation
|
||||
- **Customer Support and CRM Agents** - support automation, CRM, and sales outreach
|
||||
- **Voice Agent Platforms** - voice AI platforms for calls and conversations
|
||||
- **Deep Research Agents** - autonomous multi-step research and report generation
|
||||
- **Prompt-to-App Builders** - natural language to full-stack application generation
|
||||
- **Multi-Agent Consumer Platforms** - all-in-one consumer AI platforms
|
||||
- **Open-Source Models for Agents** - open-weight LLMs optimized for agentic tasks
|
||||
- **Market Stats and Benchmarks 2026** - market data, valuations, and growth metrics
|
||||
- **Local and Self-Hosted AI** - local LLM runners and self-hosted agent platforms
|
||||
- **AI Governance and Compliance** - regulatory frameworks and governance tools
|
||||
- **Cybersecurity Agents** - pentesting, threat detection, and security analysis
|
||||
- **Healthcare and Therapy Agents** - mental health, cognitive training, and therapy AI
|
||||
- **Newsletters and Communities** - curated newsletters, podcasts, and forums
|
||||
- **Experience Intent Libraries** - prompt templates and vibe libraries that define design languages and interaction tones
|
||||
|
||||
---
|
||||
|
||||
## Pull Request Process
|
||||
|
||||
1. **Fork** this repo
|
||||
2. **Add** your entry in the correct category, in alphabetical order
|
||||
3. **Verify** that your link works and your description follows the format above
|
||||
4. **Submit** a pull request with a clear title like: `Add [Tool Name] to [Category]`
|
||||
|
||||
The maintainers will review your PR within a few days. We may suggest edits to the description or move the entry to a different category.
|
||||
|
||||
---
|
||||
|
||||
## Quality Standards
|
||||
|
||||
This list passes `awesome-lint` and automated link checking on every push. Your PR must:
|
||||
|
||||
- Pass the awesome-lint check (no em-dashes, no duplicate links, correct formatting)
|
||||
- Have no broken links
|
||||
- Follow alphabetical ordering within its category
|
||||
|
||||
---
|
||||
|
||||
## Code of Conduct
|
||||
|
||||
By contributing, you agree to abide by the [Code of Conduct](CODE_OF_CONDUCT.md).
|
||||
|
||||
---
|
||||
|
||||
Thank you for helping make this the most useful AI agent resource on GitHub.
|
||||
|
|
@ -0,0 +1,98 @@
|
|||
CC0 1.0 Universal
|
||||
|
||||
Statement of Purpose
|
||||
|
||||
The laws of most jurisdictions throughout the world automatically confer
|
||||
exclusive Copyright and Related Rights (defined below) upon the creator and
|
||||
subsequent owner(s) (each and all, an "owner") of an original work of
|
||||
authorship and/or a database (each, a "Work").
|
||||
|
||||
Certain owners wish to permanently relinquish those rights to a Work for the
|
||||
purpose of contributing to a commons of creative, cultural and scientific
|
||||
works ("Commons") that the public can reliably and without fear of later
|
||||
claims of infringement build upon, modify, incorporate in other works, use
|
||||
and redistribute as freely as possible in any form whatsoever and for any
|
||||
purposes, including without limitation commercial purposes. These owners may
|
||||
contribute to the Commons to promote the ideal of a free culture and the
|
||||
further production of creative, cultural and scientific works, or to gain
|
||||
reputation or greater distribution for their Work in part through the use and
|
||||
redistribution by others.
|
||||
|
||||
For these and/or other purposes and motivations, and without any expectation
|
||||
of additional consideration or compensation, the person associating CC0 with a
|
||||
Work (the "Affirmer"), to the extent that he or she is an owner of Copyright
|
||||
and Related Rights in the Work, voluntarily elects to apply CC0 to the Work
|
||||
and publicly distribute the Work under its terms, with knowledge of his or her
|
||||
Copyright and Related Rights in the Work and the meaning and intended legal
|
||||
effect of CC0 on those rights.
|
||||
|
||||
1. Copyright and Related Rights. A Work made available under CC0 may be
|
||||
protected by copyright and related or neighboring rights ("Copyright and
|
||||
Related Rights"). Copyright and Related Rights include, but are not limited
|
||||
to, the following:
|
||||
|
||||
i. the right to reproduce, adapt, distribute, perform, display, communicate,
|
||||
and translate a Work;
|
||||
ii. moral rights retained by the original author(s) and/or performer(s);
|
||||
iii. publicity and privacy rights pertaining to a person's image or likeness
|
||||
depicted in a Work;
|
||||
iv. rights protecting against unfair competition in regards to a Work,
|
||||
subject to the limitations in paragraph 4(a), below;
|
||||
v. rights protecting the extraction, dissemination, use and reuse of data
|
||||
in a Work;
|
||||
vi. database rights (such as those arising under Directive 96/9/EC of the
|
||||
European Parliament and of the Council of 11 March 1996 on the legal
|
||||
protection of databases, and under any national implementation thereof,
|
||||
including any amended or successor version of such directive); and
|
||||
vii. other similar, equivalent or corresponding rights throughout the world
|
||||
based on applicable law or treaty.
|
||||
|
||||
2. Waiver. To the greatest extent permitted by, but not in contravention of,
|
||||
applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and
|
||||
unconditionally waives, abandons, and surrenders all of Affirmer's Copyright
|
||||
and Related Rights and associated claims and causes of action, whether now
|
||||
known or unknown (including existing as well as future claims and causes of
|
||||
action), in the Work (i) in all territories worldwide, (ii) for the maximum
|
||||
duration provided by applicable law or treaty (including future time
|
||||
extensions), (iii) in any current or medium and formats whether now known or
|
||||
hereafter created, and (iv) for any purpose whatsoever, including without
|
||||
limitation commercial, advertising or promotional purposes (the "Waiver").
|
||||
Affirmer makes the Waiver for the benefit of each member of the public at
|
||||
large and to the detriment of Affirmer's heirs and successors, fully intending
|
||||
that such Waiver shall not be subject to revocation, rescission, cancellation,
|
||||
termination, or any other legal or equitable action to disrupt the quiet
|
||||
enjoyment of the Work by the public as contemplated by Affirmer's express
|
||||
Statement of Purpose.
|
||||
|
||||
3. Public License Fallback. Should any part of the Waiver be judged legally
|
||||
invalid or ineffective under applicable law, then the Waiver shall be
|
||||
preserved to the maximum extent permitted taking into account Affirmer's
|
||||
express Statement of Purpose. In addition, to the extent the Waiver is so
|
||||
judged Affirmer hereby grants to each affected person a royalty-free, non
|
||||
transferable, non sublicensable, non exclusive, irrevocable and unconditional
|
||||
license to exercise Affirmer's Copyright and Related Rights in the Work (i)
|
||||
in all territories worldwide, (ii) for the maximum duration provided by
|
||||
applicable law or treaty (including future time extensions), (iii) in any
|
||||
current or medium and formats whether now known or hereafter created, and (iv)
|
||||
for any purpose whatsoever, including without limitation commercial,
|
||||
advertising or promotional purposes.
|
||||
|
||||
4. Limitations and Disclaimers.
|
||||
|
||||
a. No trademark or patent rights held by Affirmer are waived, abandoned,
|
||||
surrendered, licensed or otherwise affected by this document.
|
||||
b. Affirmer offers the Work as-is and makes no representations or warranties
|
||||
of any kind concerning the Work, whether express, implied, statutory or
|
||||
otherwise, including without limitation warranties of title,
|
||||
merchantability, fitness for a particular purpose, non infringement, or
|
||||
the absence of latent or other defects, accuracy, or the present or
|
||||
absence of errors, whether or not discoverable, all to the greatest extent
|
||||
permissible under applicable law.
|
||||
c. Affirmer disclaims responsibility for clearing rights of other persons
|
||||
that may apply to the Work or any use thereof, including without limitation
|
||||
any person's Copyright and Related Rights in the Work. Further, Affirmer
|
||||
disclaims responsibility for obtaining any necessary consents, permissions
|
||||
or other rights required for any use of the Work.
|
||||
d. Affirmer understands and acknowledges that Creative Commons is not a party
|
||||
to this document and has no duty or obligation with respect to this CC0 or
|
||||
use of the Work.
|
||||
|
|
@ -0,0 +1,776 @@
|
|||
<div align="center">
|
||||
|
||||
|
||||
|
||||
# Awesome AI Agents 2026
|
||||
|
||||
[](https://github.com/sindresorhus/awesome)
|
||||
[](https://github.com/ARUNAGIRINATHAN-K/awesome-ai-agents-2026/stargazers)
|
||||
|
||||
[](https://github.com/ARUNAGIRINATHAN-K/awesome-ai-agents-2026/commits/main)
|
||||
[]()
|
||||
[](LICENSE)
|
||||
|
||||
*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](https://github.com/ARUNAGIRINATHAN-K/awesome-ai-agents-2026/blob/main/Contributing.md) • [Submit a Tool](https://github.com/ARUNAGIRINATHAN-K/awesome-ai-agents-2026/issues)**
|
||||
|
||||
</div>
|
||||
|
||||
## Contents
|
||||
|
||||
- [Orchestration Frameworks](#orchestration-frameworks)
|
||||
- [Coding Agents](#coding-agents)
|
||||
- [Memory and Context](#memory-and-context)
|
||||
- [Multi-Agent Systems](#multi-agent-systems)
|
||||
- [Agent Communication Protocols](#agent-communication-protocols)
|
||||
- [Browser and Computer Use Agents](#browser-and-computer-use-agents)
|
||||
- [Agent Tooling and Infrastructure](#agent-tooling-and-infrastructure)
|
||||
- [Low and No-Code Builders](#low-and-no-code-builders)
|
||||
- [Voice and Multimodal Agents](#voice-and-multimodal-agents)
|
||||
- [Safety Guardrails and Observability](#safety-guardrails-and-observability)
|
||||
- [Agent Interfaces and UIs](#agent-interfaces-and-uis)
|
||||
- [Agent Deployment and Hosting](#agent-deployment-and-hosting)
|
||||
- [Agent Evaluation and Benchmarks](#agent-evaluation-and-benchmarks)
|
||||
- [Agent Testing & Debugging](#agent-testing--debugging)
|
||||
- [Industry-Specific Agents](#industry-specific-agents)
|
||||
- [Learning Resources](#learning-resources)
|
||||
- [Agent Communication](#agent-communication)
|
||||
- [Data Pipeline and Workflow](#data-pipeline-and-workflow)
|
||||
- [Secure Execution Environments](#secure-execution-environments)
|
||||
- [Creative AI Agents](#creative-ai-agents)
|
||||
- [Customer Support and CRM Agents](#customer-support-and-crm-agents)
|
||||
- [Voice Agent Platforms](#voice-agent-platforms)
|
||||
- [Deep Research Agents](#deep-research-agents)
|
||||
- [Prompt-to-App Builders](#prompt-to-app-builders)
|
||||
- [Multi-Agent Consumer Platforms](#multi-agent-consumer-platforms)
|
||||
- [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) - Orchestrates multi-agent systems built on the OpenAI Assistants API with role-based collaboration (🏷️ `Python` `OpenAI` `SDK`).
|
||||
- [AgentScope](https://github.com/agentscope-ai/agentscope) - Alibaba multi-agent framework with distributed deployment and fault tolerance for production use (🏷️ `Python` `Alibaba` `SDK`).
|
||||
- [Agno](https://github.com/agno-agi/agno) - Multi-agent framework with a runtime and control plane for managing agent deployments at scale (`Python` `FastAPI` `Cloud`) (🏷️ `Python` `FastAPI` `Cloud`).
|
||||
- [Anthropic SDK](https://github.com/anthropics/anthropic-sdk-python) - Official Claude SDK with tool use, computer control, and streaming for building Claude-native agents (🏷️ `Python` `Anthropic` `SDK`).
|
||||
- [AutoGen](https://github.com/microsoft/autogen) - Event-driven multi-agent framework merged with Semantic Kernel for production workflows (🏷️ `Python` `Semantic Kernel` `SDK`).
|
||||
- [AWS Bedrock Agents](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html) - Managed AWS infrastructure for agents with Bedrock models, enterprise compliance, and auto-scaling deployment (🏷️ `Python` `AWS` `Cloud` `[Enterprise]` `[SOC2]`).
|
||||
- [CAMEL](https://github.com/camel-ai/camel) - Role-based multi-agent simulation framework for collaborative reasoning and task completion (🏷️ `Python` `Research` `SDK`).
|
||||
- [CopilotKit](https://github.com/CopilotKit/CopilotKit) - The open-source AI copilot platform for React, allowing developers to embed custom AI agents directly into their applications (🏷️ `TypeScript` `React` `SDK`).
|
||||
- [CrewAI](https://github.com/crewAIInc/crewAI) - Production multi-agent framework with 5K+ GitHub stars, role-based collaboration, async execution, and 1500+ company adoptions (🏷️ `Python` `LangChain` `SDK` `[Enterprise]`).
|
||||
- [DSPy](https://github.com/stanfordnlp/dspy) - Programmatically optimizes LLM prompts and chains using machine learning instead of manual prompt engineering (🏷️ `Python` `Stanford` `SDK`).
|
||||
- [Ontheia](https://github.com/Ontheia/ontheia) - Self-hosted, open-source AI agent platform with Chain Engine for visual workflow automation, MCP-native tool integration, multi-provider support (Claude, OpenAI, Gemini, Ollama), long-term memory via pgvector, multi-user RBAC, and GDPR-compliant architecture (🏷️ `TypeScript` `Self-hosted` `MCP` `Docker` `[Enterprise]` `[GDPR]`).
|
||||
- [Google ADK](https://github.com/google/adk-python) - Modular agent dev kit integrating Gemini and Vertex AI natively (🏷️ `Python` `Vertex AI` `SDK`).
|
||||
- [Haystack](https://github.com/deepset-ai/haystack) - Production-ready AI orchestration framework focused on building customizable LLM applications and RAG pipelines (🏷️ `Python` `RAG` `SDK`).
|
||||
- [LangGraph](https://github.com/langchain-ai/langgraph) - Enterprise framework for stateful, graph-based agent workflows (🏷️ `Python` `LangChain` `SDK`).
|
||||
- [Letta](https://github.com/letta-ai/letta) - Formerly MemGPT. Stateful agents with built-in long-term memory and a REST API server (🏷️ `Python` `REST` `SDK`).
|
||||
- [LlamaIndex](https://github.com/run-llama/llama_index) - The leading framework for connecting LLMs to your data, with powerful indexing and retrieval capabilities (🏷️ `Python` `RAG` `SDK`).
|
||||
- [LangSmith Fleet](https://smith.langchain.com/hub/fleet) - No-code agent orchestration platform with visual workflow builder, real-time monitoring, and enterprise deployment (🏷️ `Cloud` `LangChain` `Platform` `[Enterprise]`).
|
||||
- [Mastra](https://github.com/mastra-ai/mastra) - Opinionated TypeScript framework with RAG, observability, and MCP support built in (🏷️ `TypeScript` `Next.js` `SDK`).
|
||||
- [MicroAgent](https://github.com/BuilderIO/micro-agent) - Lightweight agent framework with self-editing prompts and code for minimal-overhead agent loops (🏷️ `TypeScript` `Lightweight` `SDK`).
|
||||
- [Modus](https://github.com/hypermodeinc/modus) - Serverless framework for high-throughput agent workloads with minimal cold starts (🏷️ `WebAssembly` `Hypermode` `Serverless`).
|
||||
- [Open-AutoGLM](https://github.com/zai-org/Open-AutoGLM) - Open-source phone agent model and framework for building mobile device automation agents (🏷️ `Python` `Mobile` `SDK`).
|
||||
- [OpenAI Agents SDK](https://github.com/openai/openai-agents-python) - Lightweight multi-agent SDK with tracing and guardrails from OpenAI (🏷️ `Python` `OpenAI` `SDK`).
|
||||
- [PraisonAI](https://github.com/MervinPraison/PraisonAI) - Production multi-agent framework with self-reflection, MCP integration, and workflow automation (🏷️ `Python` `Multi-Agent` `CLI`).
|
||||
- [PydanticAI](https://github.com/pydantic/pydantic-ai) - Type-safe agent framework from the Pydantic team with a FastAPI-style developer experience (🏷️ `Python` `Pydantic` `SDK`).
|
||||
- [Semantic Kernel](https://github.com/microsoft/semantic-kernel) - Microsoft enterprise SDK for Python, C#, and Java with modular plugins, memory, and goal planning (🏷️ `C#` `Microsoft` `SDK`).
|
||||
- [Smolagents](https://github.com/huggingface/smolagents) - Hugging Face code-first framework where agents write and execute Python instead of JSON tool calls (🏷️ `Python` `Hugging Face` `SDK`).
|
||||
- [Strands Agents SDK](https://github.com/strands-agents/sdk-python) - AWS model-driven agent SDK with native Bedrock integration (🏷️ `Python` `AWS Bedrock` `SDK`).
|
||||
- [Upsonic](https://github.com/Upsonic/Upsonic) - Minimalist agent framework with MCP support and rapid setup for quick prototyping (🏷️ `Python` `MCP` `SDK`).
|
||||
- [Vercel AI SDK](https://github.com/vercel/ai) - Streaming-first primitives for AI UIs with React Server Components and edge runtime support (🏷️ `TypeScript` `Next.js` `SDK`).
|
||||
- [VoltAgent](https://github.com/voltagent/voltagent) - TypeScript agent framework with built-in observability and a self-improving context engine (🏷️ `TypeScript` `React` `SDK`).
|
||||
- [Vertex AI Agents](https://adk.dev/) - Google Cloud enterprise agent framework with native Gemini integration, scalable infrastructure, and compliance certifications (🏷️ `Python` `Google` `Cloud` `[Enterprise]` `[GDPR]`).
|
||||
|
||||
## Coding Agents
|
||||
|
||||
- [Aider](https://github.com/Aider-AI/aider) - Terminal-first pair programmer that edits code in local repos, preserves Git history, and supports multi-file changes (🏷️ `Python` `CLI` `Local`).
|
||||
- [Amazon Q Developer](https://aws.amazon.com/q/developer/) - AWS-native AI coding assistant with Lambda, CloudWatch, infrastructure support, and security scanning (🏷️ `Python` `AWS` `IDE`).
|
||||
- [AutoGPT](https://github.com/Significant-Gravitas/AutoGPT) - Mature autonomous agent platform with Forge framework and public benchmarks for evaluating agent capabilities (🏷️ `Python` `Forge` `CLI`).
|
||||
- [Claude Code](https://github.com/anthropics/claude-code) - Terminal-first agentic coding from Anthropic with Computer Use integration, multi-file edits, persistent shell sessions, Git operations, and fine-tuning support (🏷️ `TypeScript` `CLI` `Local` `[Anthropic]`).
|
||||
- [Cline](https://github.com/cline/cline) - Autonomous coding agent in your IDE that creates/edits files, runs commands, and uses the browser with permission-gated steps (🏷️ `TypeScript` `VS Code` `IDE`).
|
||||
- [CodeRabbit](https://www.coderabbit.ai) - AI-powered PR reviewer with inline suggestions, security scanning, and automatic code quality checks (🏷️ `Cloud` `GitHub` `Web`).
|
||||
- [Codex CLI](https://github.com/openai/codex) - OpenAI's lightweight, open-source terminal coding agent with fast execution and strong benchmark scores (🏷️ `Python` `CLI` `Local`).
|
||||
- [Codex-CLI](https://github.com/microsoft/Codex-CLI) - CLI tool that turns natural language commands into Bash, ZShell, and PowerShell equivalents (🏷️ `C#` `CLI` `Local`).
|
||||
- [Continue](https://github.com/continuedev/continue) - Source-controlled AI checks enforceable in CI, powered by the open-source Continue CLI (🏷️ `TypeScript` `VS Code` `IDE`).
|
||||
- [Cursor](https://cursor.com) - AI-native IDE with Cursor Cloud Agents supporting parallel task execution, $29.3B valuation, 100K+ enterprise users, and advanced agentic loops with real-time cursor control (🏷️ `TypeScript` `Electron` `Desktop` `[Enterprise]`).
|
||||
- [Devika](https://github.com/stitionai/devika) - Open-source AI software engineer that understands high-level instructions and writes full-featured code autonomously (🏷️ `Python` `Docker` `Web`).
|
||||
- [Devin](https://devin.ai) - 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 (🏷️ `Cloud` `Web` `SaaS` `[Enterprise]`).
|
||||
- [gemini-cli](https://github.com/google-gemini/gemini-cli) - Open-source AI agent that brings the power of Gemini directly into your terminal (🏷️ `Go` `CLI` `Local`).
|
||||
- [GitHub Copilot](https://github.com/features/copilot) - Agent Mode in VS Code with Copilot Workspace for issue-to-PR workflows across Claude, GPT, and Gemini (🏷️ `TypeScript` `VS Code` `IDE`).
|
||||
- [Goose](https://github.com/aaif-goose/goose) - Open-source extensible AI agent that goes beyond code suggestions, installs, executes, edits, and tests with any LLM (🏷️ `Rust` `CLI` `Local`).
|
||||
- [JetBrains AI](https://www.jetbrains.com/ai/) - Deep AI integration across all JetBrains IDEs with context-aware completions and refactoring (🏷️ `Kotlin` `JetBrains` `IDE`).
|
||||
- [Kiro](https://kiro.dev) - Spec-driven development agent that writes specs, auto-generates tasks, implements code, and automates DevOps workflows (🏷️ `Cloud` `AWS` `IDE`).
|
||||
- [Open Interpreter](https://github.com/openinterpreter/open-interpreter) - Execute code locally via natural-language model instructions with a ChatGPT-like interface (🏷️ `Python` `CLI` `Local`).
|
||||
- [opencode](https://github.com/anomalyco/opencode) - Open-source coding agent available as a desktop application with a visual interface (🏷️ `TypeScript` `Electron` `Desktop`).
|
||||
- [OpenHands](https://github.com/OpenHands/OpenHands) - AI-driven development platform that writes, tests, and deploys code autonomously (🏷️ `Python` `Docker` `Web`).
|
||||
- [PR-Agent](https://github.com/The-PR-Agent/pr-agent) - Open-source AI PR reviewer that auto-describes, reviews, and improves pull requests (🏷️ `Python` `GitHub` `CLI`).
|
||||
- [Qodo](https://www.qodo.ai) - AI code review platform with context-aware PR validation and security analysis (🏷️ `Cloud` `Enterprise` `Web`).
|
||||
- [RooCode](https://github.com/RooCodeInc/Roo-Code) - Cline fork with structured modes and reduced hallucinations for more reliable code generation (🏷️ `TypeScript` `VS Code` `IDE`).
|
||||
- [Snyk Code](https://snyk.io/product/snyk-code/) - AI-powered security scanner with real-time vulnerability detection in agent-generated code (🏷️ `Cloud` `Security` `Platform`).
|
||||
- [Sourcegraph Cody](https://sourcegraph.com/docs/cody) - AI coding assistant that excels at large codebases with an enterprise context engine (🏷️ `TypeScript` `Enterprise` `IDE`).
|
||||
- [SWE-agent](https://github.com/SWE-agent/SWE-agent) - Takes a GitHub issue and tries to automatically fix it. Also used for cybersecurity and competitive coding (🏷️ `Python` `Docker` `CLI`).
|
||||
- [Tabnine](https://www.tabnine.com) - Privacy-first AI code completion with on-premise deployment and codebase fine-tuning options (🏷️ `TypeScript` `Enterprise` `IDE`).
|
||||
- [TaskWeaver](https://github.com/microsoft/TaskWeaver) - A code-first agent framework from Microsoft for seamlessly planning and executing data analytics tasks (🏷️ `Python` `Jupyter` `CLI`).
|
||||
- [Windsurf](https://windsurf.com) - AI-native IDE with Cascade agent for multi-step autonomous tasks and team workflows (🏷️ `TypeScript` `Electron` `Desktop`).
|
||||
|
||||
## Memory and Context
|
||||
|
||||
- [Acontext](https://github.com/memodb-io/Acontext) - Manages agent skills and long-term memory as a layered data structure for persistent context (🏷️ `Python` `SDK` `Local`).
|
||||
- [Chroma](https://github.com/chroma-core/chroma) - Lightweight, embeddable vector store for building memory-augmented AI agents with fast semantic retrieval (🏷️ `Python` `TypeScript` `SDK`).
|
||||
- [cognee](https://github.com/topoteretes/cognee) - Knowledge engine for AI agent memory, set up in 6 lines of code with graph-based knowledge extraction (🏷️ `Python` `Neo4j` `SDK`).
|
||||
- [Cortex Memory](https://github.com/prem-research/cortex) - Full-stack solution for agent memory covering extraction, vector search, and optimization (🏷️ `Python` `Vector DB` `SDK`).
|
||||
- [graphiti](https://github.com/getzep/graphiti) - Build real-time knowledge graphs for AI agents with automatic entity extraction and linking (🏷️ `Python` `Knowledge Graph` `SDK`).
|
||||
- [LanceDB](https://github.com/lancedb/lancedb) - Serverless vector search database embedded directly in the agent process with no infrastructure needed (🏷️ `Rust` `Python` `SDK`).
|
||||
- [Langmem](https://github.com/langchain-ai/langmem) - Helps agents learn and adapt from their interactions over time with persistent memory (🏷️ `Python` `LangChain` `SDK`).
|
||||
- [Mem0](https://github.com/mem0ai/mem0) - Memory layer for AI applications with long-term, short-term, and semantic memory extraction (🏷️ `Python` `Vector` `Cloud`).
|
||||
- [Memoir](https://github.com/zhangfengcdt/memoir) - Git-like versioned semantic memory for AI agents with branching, commits, and cryptographic integrity over hierarchical paths (🏷️ `Python` `Git-like` `SDK`).
|
||||
- [Memvid](https://github.com/memvid/memvid) - Replace complex RAG pipelines with a serverless, single-file memory layer for instant retrieval (🏷️ `Python` `Multimodal` `SDK`).
|
||||
- [Milvus](https://github.com/milvus-io/milvus) - Scales vector search to billions of embeddings for large-scale agent knowledge bases (🏷️ `Go` `Python` `Platform`).
|
||||
- [Motorhead](https://github.com/getmetal/motorhead) - Manages conversation context windows for agents with automatic background summarization (🏷️ `Rust` `Python` `SDK`).
|
||||
- [Pathway](https://github.com/pathwaycom/pathway) - Live data RAG engine with real-time streaming for agents that need up-to-the-second knowledge (🏷️ `Python` `Streaming` `SDK`).
|
||||
- [Pinecone](https://www.pinecone.io) - Managed vector database with agent namespaces for multi-tenant isolation, hybrid search (vector + keyword), serverless auto-scaling, and $11B valuation (🏷️ `Cloud` `Vector DB` `API` `[Enterprise]` `[SOC2]`).
|
||||
- [Qdrant](https://github.com/qdrant/qdrant) - High-performance vector similarity search engine with rich payload filtering for agent memory (🏷️ `Rust` `Python` `SDK`).
|
||||
- [RAGFlow](https://github.com/infiniflow/ragflow) - Open-source RAG engine with agent capabilities and deep document understanding for knowledge bases (🏷️ `Python` `RAG` `Platform`).
|
||||
- [SimpleMem](https://github.com/aiming-lab/SimpleMem) - Efficient lifelong memory for LLM agents supporting both text and multimodal inputs (🏷️ `Python` `SDK` `Local`).
|
||||
- [Supermemory](https://github.com/supermemoryai/supermemory) - Extremely fast and scalable memory engine and API designed for the AI era (🏷️ `TypeScript` `Vector DB` `Web`).
|
||||
- [Weaviate](https://github.com/weaviate/weaviate) - Stores and searches vector embeddings with hybrid keyword and semantic retrieval for agent knowledge (🏷️ `Go` `Python` `Platform`).
|
||||
- [Zep](https://github.com/getzep/zep) - Enriches agent long-term memory with automatic summarization, entity extraction, and search (🏷️ `Python` `TypeScript` `SDK`).
|
||||
|
||||
## Multi-Agent Systems
|
||||
|
||||
- [AgentVerse](https://github.com/OpenBMB/AgentVerse) - Framework for building custom multi-agent environments to accomplish collaborative tasks (🏷️ `Python` `Benchmark` `SDK`).
|
||||
- [EvoAgentX](https://github.com/EvoAgentX/EvoAgentX) - Evaluates and evolves agentic workflows over time using automatic optimization (🏷️ `Python` `Optimization` `SDK`).
|
||||
- [Hivemoot](https://github.com/hivemoot/hivemoot) - Autonomous agent teams that collaboratively build software on GitHub (🏷️ `Python` `GitHub` `SDK`).
|
||||
- [MetaGPT](https://github.com/FoundationAgents/MetaGPT) - Simulates a full software company workflow from requirements to PRs using role-playing agents (🏷️ `Python` `Role-Playing` `SDK`).
|
||||
- [P2PCLAW](https://github.com/Agnuxo1/OpenCLAW-P2P) - Decentralized scientific research network with 14+ autonomous agents featuring P2P mesh, IPFS storage, and Lean 4 formal verification, self-hosted with Docker Compose (🏷️ `Python` `P2P` `Self-Hosted`).
|
||||
- [Swarm](https://github.com/openai/swarm) - Lightweight framework for agent handoffs, context variables, and function calling patterns from OpenAI (🏷️ `Python` `OpenAI` `SDK`).
|
||||
- [Swarms Framework](https://github.com/kyegomez/swarms) - Multi-agent orchestration for production use cases with scalability and reliability at its core (🏷️ `Python` `Production` `SDK`).
|
||||
|
||||
## Agent Communication Protocols
|
||||
|
||||
The protocol layer that enables agents to discover tools, communicate with each other, and interoperate across ecosystems.
|
||||
|
||||
| Protocol | Purpose | Creator | Status |
|
||||
| -------- | ------------------- | --------- | -------- |
|
||||
| MCP | Agent-to-tool | Anthropic | Standard |
|
||||
| A2A | Agent-to-agent | Google | Growing |
|
||||
| ACP | Agent communication | IBM/BeeAI | Early |
|
||||
|
||||
### MCP (Model Context Protocol)
|
||||
|
||||
- [A2A Protocol](https://github.com/a2aproject/A2A) - Google's open protocol enabling AI agents to communicate, collaborate, and delegate tasks across frameworks (🏷️ `Protobuf` `Standard` `RPC`).
|
||||
- [Arcade AI](https://github.com/ArcadeAI/arcade-mcp) - Tool-use platform with authentication, authorization, and logging for agent-tool interactions (🏷️ `Python` `Cloud` `API`).
|
||||
- [Composio](https://github.com/ComposioHQ/composio) - Integration platform with 250+ pre-built tool connectors for AI agents and LLMs (🏷️ `TypeScript` `Cloud` `API`).
|
||||
- [Docker MCP](https://github.com/docker/mcp-gateway) - Docker's MCP gateway CLI plugin for running MCP servers in isolated containers (🏷️ `Go` `Docker` `CLI`).
|
||||
- [HCS Agent Protocol](https://github.com/hashgraph/hedera-agent-kit-js) - Hedera open standards for agent identity with trustless P2P communication and 187K+ verified agents (🏷️ `TypeScript` `Hedera` `Protocol`).
|
||||
- [MCP Registry](https://github.com/modelcontextprotocol) - Official Model Context Protocol specification and server implementations for standardized tool access (🏷️ `JSON` `Standard` `Registry`).
|
||||
- [mcp-nest](https://github.com/CharanBharathula/mcp-nest) - Unified Model Context Protocol (MCP) server for executing code and managing files (🏷️ `Python` `MCP` `CLI`).
|
||||
- [NotFair](https://notfair.co) - Hosted Google Ads MCP server for diagnosing, optimizing, and executing campaign changes via the Google Ads API with a human-approval gate (🏷️ `Cloud` `MCP` `Marketing`).
|
||||
- [Toolhouse](https://toolhouse.ai) - Cloud-hosted tool infrastructure for agents with optimized execution and low-latency access (🏷️ `Python` `Cloud` `API`).
|
||||
- [Zapier MCP Server](https://zapier.com/mcp) - Connect agents to 7,000+ app integrations via MCP, powered by Zapier's automation platform (🏷️ `Cloud` `Zapier` `API`).
|
||||
- [zero-api-key-web-search](https://github.com/wd041216-bit/zero-api-key-web-search) - Free web search toolkit for AI agents with no API keys, MCP server support (🏷️ `Python` `MCP` `Search`).
|
||||
|
||||
## Browser and Computer Use Agents
|
||||
|
||||
- [Agent S2](https://github.com/simular-ai/Agent-S) - Open-source GUI automation framework for building desktop and browser agents with vision (🏷️ `Python` `Vision` `SDK`).
|
||||
- [AgentQL](https://github.com/tinyfish-io/agentql) - AI-powered web scraping and automation with a semantic query language for page elements (🏷️ `Python` `Playwright` `SDK`).
|
||||
- [Airtop](https://www.airtop.ai) - Enterprise-grade cloud browser infrastructure for AI agent automation at scale (🏷️ `Cloud` `Enterprise` `Platform`).
|
||||
- [Browser Use](https://github.com/browser-use/browser-use) - Open-source framework to let LLMs navigate and interact with any website programmatically (🏷️ `Python` `Playwright` `SDK`).
|
||||
- [Browserbase](https://www.browserbase.com) - Scalable headless browser infrastructure purpose-built for running AI agents in production (🏷️ `Cloud` `Infrastructure` `Platform`).
|
||||
- [Dia Browser](https://www.diabrowser.com) - AI-native browser from Atlassian and the Browser Company with built-in agent workflows (🏷️ `Cloud` `Desktop` `Browser`).
|
||||
- [Fellou](https://fellou.ai) - Transparent agentic browser with visual workflow editing and persistent agentic memory (🏷️ `Cloud` `Desktop` `Browser`).
|
||||
- [Genspark](https://www.genspark.ai) - On-device AI browser with 169+ local models that runs without internet connection (🏷️ `Cloud` `Desktop` `Browser`).
|
||||
- [Grok Computer](https://x.ai) - Upcoming xAI desktop agent with mouse control and application automation capabilities (🏷️ `Cloud` `Desktop` `Platform`).
|
||||
- [LaVague](https://github.com/lavague-ai/LaVague) - Large Action Model framework to turn natural language instructions into browser automation (🏷️ `Python` `Selenium` `SDK`).
|
||||
- [Manus](https://manus.im) - Autonomous digital employee with Browser Operator extension acquired by Meta for web-based task execution (🏷️ `Cloud` `Meta` `Platform`).
|
||||
- [MultiOn](https://www.theagi.company/) - Reliable web automation API with CAPTCHA handling for building production browser agents (🏷️ `Cloud` `API` `Platform`).
|
||||
- [OpenAI Operator](https://openai.com/index/computer-using-agent/) - ChatGPT autonomous web agent with human checkpoints using Computer Use Agent technology (🏷️ `Cloud` `OpenAI` `Platform`).
|
||||
- [Playwright MCP](https://github.com/microsoft/playwright-mcp) - MCP server wrapping Playwright for seamless browser automation integration with LLM agents (🏷️ `TypeScript` `MCP` `SDK`).
|
||||
- [Skyvern](https://github.com/Skyvern-AI/skyvern) - Production browser automation with 21.5K GitHub stars, 10M+ executed workflows, vision-first automation, and sub-300ms response times (🏷️ `Python` `Playwright` `Cloud`).
|
||||
- [Stagehand](https://github.com/browserbase/stagehand) - AI web browsing framework built on Playwright with natural-language selectors and actions (🏷️ `TypeScript` `Playwright` `SDK`).
|
||||
|
||||
|
||||
## Agent Tooling and Infrastructure
|
||||
|
||||
Sandboxes, web scrapers, browser automation, and networking layers that agents depend on.
|
||||
|
||||
- [AgentDock](https://github.com/agentdock/agentdock) - Framework for building and deploying production-ready AI agents with composable node architecture (🏷️ `Python` `Docker` `Platform`).
|
||||
- [Crawl4AI](https://github.com/unclecode/crawl4ai) - Extracts structured data from web pages using LLM-friendly output formats optimized for agent ingestion (🏷️ `Python` `Playwright` `SDK`).
|
||||
- [Docling](https://github.com/docling-project/docling) - Parses PDFs, DOCX, and slides into structured text with deep layout understanding for document agents (🏷️ `Python` `PDF` `SDK`).
|
||||
- [E2B](https://github.com/e2b-dev/e2b) - Cloud sandboxes for AI agents to run code securely in isolated environments (🏷️ `TypeScript` `Cloud` `Sandbox`).
|
||||
- [Engram](https://github.com/kwstx/translator) - Universal bridge for multi-protocol AI agent systems with automated semantic mapping (🏷️ `Python` `Networking` `SDK`).
|
||||
- [Firecrawl](https://github.com/firecrawl/firecrawl) - Web scraping API built for LLMs that converts websites to clean, structured markdown (🏷️ `TypeScript` `Cloud` `API`).
|
||||
- [Jina Reader](https://github.com/jina-ai/reader) - Converts any URL to LLM-ready clean text via a simple API prefix for agent ingestion (🏷️ `TypeScript` `Cloud` `API`).
|
||||
- [LlamaParse](https://github.com/run-llama/llama_cloud_services) - GenAI-native document parser designed to extract complex tables and layouts for RAG pipelines (🏷️ `Python` `Cloud` `API`).
|
||||
- [Marker](https://github.com/datalab-to/marker) - Converts PDF documents to markdown with high accuracy for tables, equations, and figures (🏷️ `Python` `PDF` `CLI`).
|
||||
- [Notte](https://github.com/nottelabs/notte) - Browser automation engine optimized for production AI pipelines (🏷️ `Python` `Browser` `SDK`).
|
||||
- [Pilot Protocol](https://github.com/TeoSlayer/pilotprotocol) - Networking stack for distributed agent systems with encrypted tunnels (🏷️ `Go` `Networking` `SDK`).
|
||||
- [Playwright](https://github.com/microsoft/playwright) - Automates Chromium, Firefox, and WebKit browsers with a single cross-language API for agent-driven testing (🏷️ `TypeScript` `Python` `SDK`).
|
||||
- [ScrapeGraphAI](https://github.com/ScrapeGraphAI/Scrapegraph-ai) - Python web-scraping library that uses LLMs to build intelligent scraping pipelines from natural-language instructions (🏷️ `Python` `LangChain` `SDK`).
|
||||
- [Surya](https://github.com/datalab-to/surya) - Runs OCR and layout detection on documents in 90+ languages for multilingual document agents (🏷️ `Python` `PDF` `CLI`).
|
||||
- [Tavily](https://github.com/tavily-ai/tavily-python) - Search API purpose-built for LLM agents providing real-time, accurate web data with source citations (🏷️ `Python` `Cloud` `API`).
|
||||
- [Unstructured](https://github.com/Unstructured-IO/unstructured) - Ingests and preprocesses documents across 25+ file types for downstream LLM and agent pipelines (🏷️ `Python` `Pipeline` `SDK`).
|
||||
|
||||
## Low and No-Code Builders
|
||||
|
||||
- [Activepieces](https://github.com/activepieces/activepieces) - Open-source Zapier alternative with AI-powered automation nodes and visual workflow builder (🏷️ `TypeScript` `Docker` `Web`).
|
||||
- [AgentGPT](https://github.com/reworkd/AgentGPT) - Deploy AI agents in the browser with zero local setup required (🏷️ `TypeScript` `Next.js` `Web`).
|
||||
- [Dify](https://github.com/langgenius/dify) - Open-source LLM app development platform with visual workflow builder and RAG orchestration (🏷️ `Python` `FastAPI` `Web`).
|
||||
- [FastAgency](https://github.com/ag2ai/fastagency) - Deploys multi-agent workflows as production APIs with minimal configuration and setup (🏷️ `Python` `FastAPI` `SDK`).
|
||||
- [Flowise](https://github.com/FlowiseAI/Flowise) - Open-source drag-and-drop UI to build customized LLM flows, RAG pipelines, and agent systems (🏷️ `TypeScript` `React` `Web`).
|
||||
- [Langflow](https://github.com/langflow-ai/langflow) - Visual drag-and-drop builder for LLM workflows, RAG agents, and multi-step pipelines (🏷️ `Python` `FastAPI` `Web`).
|
||||
- [Lindy](https://www.lindy.ai) - No-code AI agent platform with 3000+ app integrations for business workflow automation (🏷️ `Cloud` `No-Code` `Platform`).
|
||||
- [Make](https://www.make.com/en) - Visual workflow automation platform with AI capabilities and drag-and-drop scenario builder (🏷️ `Cloud` `No-Code` `Platform`).
|
||||
- [n8n](https://github.com/n8n-io/n8n) - Open-source workflow automation with AI agent nodes combining visual and code-based orchestration (🏷️ `TypeScript` `Docker` `Platform`).
|
||||
- [Relevance AI](https://relevanceai.com) - No-code AI agent builder for sales, support, and research use cases with team collaboration (🏷️ `Cloud` `No-Code` `Platform`).
|
||||
- [Rivet](https://github.com/Ironclad/rivet) - Visual AI workflow builder with drag-and-drop interface for designing agent pipelines (🏷️ `TypeScript` `React` `Desktop`).
|
||||
- [Temporal](https://github.com/temporalio/temporal) - Durable execution platform for long-running agent workflows with automatic retry and state persistence (🏷️ `Go` `Production` `Platform`).
|
||||
- [Wordware](https://www.wordware.ai) - Web-hosted IDE where domain experts collaborate with AI engineers to build agent workflows (🏷️ `TypeScript` `Next.js` `Web`).
|
||||
- [Zapier AI](https://zapier.com) - Connects 7000+ apps with natural language workflow creation for no-code agent automation (🏷️ `Cloud` `No-Code` `Platform`).
|
||||
|
||||
## Voice and Multimodal Agents
|
||||
|
||||
- [Agentset](https://github.com/agentset-ai/agentset) - Production RAG platform with reasoning, hybrid search, and full multimodal support (🏷️ `Python` `Multimodal` `Platform`).
|
||||
- [LiveKit Agents](https://github.com/livekit/agents) - Framework for building real-time, multimodal AI agents with voice, video, and data channels (🏷️ `Python` `LiveKit` `SDK`).
|
||||
- [Nuance AI](https://dragon.nuance.com/en-us/home) - Enterprise speech and conversational AI platform for clinical and contact-center workflows with HIPAA-capable deployments (🏷️ `Cloud` `Voice` `Enterprise` `[HIPAA]`).
|
||||
- [Google Cloud Speech-to-Text v2](https://cloud.google.com/speech-to-text) - Google Cloud streaming and batch speech recognition API v2 with improved accuracy, streaming, and noise suppression for real-time agent pipelines (🏷️ `Cloud` `Google` `STT`).
|
||||
- [Pipecat](https://github.com/pipecat-ai/pipecat) - Production-grade voice AI framework with sub-250ms latency, WebRTC support, multimodal (voice+vision+text), real-time streaming, and 70+ language support (🏷️ `Python` `WebRTC` `SDK`).
|
||||
- [Rasa](https://github.com/RasaHQ/rasa) - Open-source conversational AI framework with self-hosted NLU training and dialogue management (🏷️ `Python` `NLU` `SDK`).
|
||||
- [Vapi](https://github.com/VapiAI/server-sdk-python) - Platform for building voice AI agents with low-latency speech-to-speech capabilities (🏷️ `Python` `Cloud` `API`).
|
||||
- [Vocode](https://github.com/vocodedev/vocode-core) - Open-source framework for building voice-based LLM agent applications with streaming support (🏷️ `Python` `Voice` `SDK`).
|
||||
- [Wispr Flow](https://wisprflow.ai/) - Voice orchestration platform for multimodal AI agents with 50+ language support, workflow building, and enterprise integrations (🏷️ `Cloud` `Voice` `Platform` `[Enterprise]`).
|
||||
|
||||
## Safety Guardrails and Observability
|
||||
|
||||
- [Agent OS](https://github.com/buildermethods/agent-os) - Kernel architecture for governing autonomous AI agents with policy enforcement (🏷️ `Python` `Policy` `SDK`).
|
||||
- [AgentDoG](https://github.com/AI45Lab/AgentDoG) - Diagnostic guardrails that analyze full agent execution trajectories to detect instruction hijacking and tool misuse (🏷️ `Python` `Diagnostics` `SDK`).
|
||||
- [AgentGuard](https://github.com/cyberark/agent-guard) - Runtime observability and guardrails for AI agents with loop detection and anomaly alerts (🏷️ `Python` `CyberArk` `SDK`).
|
||||
- [agenttrace](https://github.com/luoyuctl/agenttrace) - Local-first TUI for AI coding agent session observability with tokens, cost, latency, tool failures, anomalies, reports, diffs, and CI health gates (🏷️ `Go` `Observability` `CLI`).
|
||||
- [APort Agent Guardrails](https://github.com/aporthq/aport-agent-guardrails) - Pre-action authorization plugin for agent frameworks with policy-based access control (🏷️ `Python` `Authorization` `SDK`).
|
||||
- [Patronus AI LYNX](https://patronus.ai/) - Hallucination detection system beating GPT-4 baselines, with specialized testing for agent outputs and LLM-generated content quality (🏷️ `Cloud` `Testing` `SDK`).
|
||||
- [Arize Phoenix](https://github.com/Arize-ai/phoenix) - Open-source observability platform built on OpenTelemetry for tracing, evaluating, and debugging AI agents (🏷️ `Python` `OpenTelemetry` `Platform`).
|
||||
- [Braintrust](https://www.braintrust.dev) - Eval-driven development platform with experiment tracking and prompt optimization for agent quality (🏷️ `TypeScript` `Evaluation` `Platform`).
|
||||
- [ElevenAgents](https://elevenlabs.io/agents) - Voice agent platform from ElevenLabs for customer support automation with HIPAA compliance and multi-language support (🏷️ `Cloud` `Voice` `Platform` `[HIPAA]` `[Enterprise]`).
|
||||
- [DriftGuard](https://github.com/sujal-maheshwari2004/DriftGuard) - Semantic memory guardrails using causal graphs to prevent agents from repeating past failures (🏷️ `Python` `Memory` `SDK`).
|
||||
- [Guardrails AI](https://github.com/guardrails-ai/guardrails) - Adds structural, type, and quality guarantees to LLM outputs for reliable agent responses (🏷️ `Python` `Validation` `SDK`).
|
||||
- [Helicone](https://github.com/Helicone/helicone) - Open-source LLM observability with one-line integration for cost tracking and prompt analytics (🏷️ `TypeScript` `Observability` `Platform`).
|
||||
- [Lakera Guard](https://www.lakera.ai) - Real-time protection against prompt injection, data leakage, and toxicity in agent interactions (🏷️ `Cloud` `Security` `API`).
|
||||
- [Laminar](https://github.com/lmnr-ai/lmnr) - Open-source observability and analytics platform purpose-built for the full lifecycle of AI agents (🏷️ `Rust` `Observability` `Platform`).
|
||||
- [Langfuse](https://github.com/langfuse/langfuse) - Open-source LLM observability platform for tracing, prompt versioning, and LLM-as-a-judge evaluations (🏷️ `TypeScript` `Next.js` `Platform`).
|
||||
- [LangSmith](https://smith.langchain.com) - LangChain platform for tracing, testing, and evaluating agent performance with production monitoring (🏷️ `Cloud` `LangChain` `Platform`).
|
||||
- [LLM Guard](https://github.com/protectai/llm-guard) - Security toolkit for scanning LLM inputs and outputs to prevent prompt injection and data leaks (🏷️ `Python` `Security` `SDK`).
|
||||
- [Logfire](https://github.com/pydantic/logfire) - Python-native observability from the Pydantic team with deep integration for high-performance agent monitoring (🏷️ `Python` `Pydantic` `Platform`).
|
||||
- [NeMo Guardrails](https://github.com/NVIDIA-NeMo/Guardrails) - NVIDIA programmable guardrails toolkit for controlling and securing LLM-powered agent conversations (🏷️ `Python` `NVIDIA` `SDK`).
|
||||
- [Orchard Kit](https://github.com/OrchardHarmonics/orchard-kit) - Modules for agent runtime security, self-audit trails, and collective cognition patterns (🏷️ `Python` `Security` `SDK`).
|
||||
- [OWASP Top 10 for Agentic Apps](https://owasp.org/www-project-top-10-for-large-language-model-applications/) - Security framework covering goal hijacking, tool misuse, and cascading failure mitigations for agents (🏷️ `Policy` `Security` `Framework`).
|
||||
- [Rebuff](https://github.com/protectai/rebuff) - Self-hardening prompt injection detection system for securing agent inputs against adversarial attacks (🏷️ `Python` `Security` `SDK`).
|
||||
|
||||
## 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) - All-in-one AI application with RAG, agents, and multi-model support for desktop and Docker (🏷️ `TypeScript` `Docker` `Desktop`).
|
||||
- [DB-GPT](https://github.com/eosphoros-ai/DB-GPT) - Data interaction platform with local LLM support for 100% private database and analytics agents (🏷️ `Python` `Database` `Web`).
|
||||
- [LibreChat](https://github.com/danny-avila/LibreChat) - Self-hosted multi-model chat interface supporting all major AI providers with access control (🏷️ `TypeScript` `Docker` `Web`).
|
||||
- [LobeHub](https://lobehub.com/) - Modern platform for hybrid work and AI-driven collaboration with extensible agent teams and rapid integration (🏷️ `TypeScript` `Next.js` `Web`).
|
||||
- [LobeChat](https://github.com/lobehub/lobehub) - Modern, open-source AI chat framework with a massive plugin ecosystem for autonomous agent capabilities (🏷️ `TypeScript` `Next.js` `Web`).
|
||||
- [OpenWebUI](https://github.com/open-webui/open-webui) - Extensible local AI interface with built-in RAG, tool use, and support for multi-agent workflows (🏷️ `TypeScript` `Svelte` `Web`).
|
||||
|
||||
## Agent Deployment and Hosting
|
||||
|
||||
- [AWS Bedrock AgentCore](https://github.com/awslabs/agentcore-samples) - Managed AWS infrastructure for Bedrock-based agents with compliance, scaling, and monitoring built in (🏷️ `TypeScript` `AWS` `Platform`).
|
||||
- [Cerebras Inference](https://www.cerebras.ai) - Fastest LLM inference delivering 1000+ tokens per second on Llama 3.3 70B with a free tier (🏷️ `Cloud` `Inference` `API`).
|
||||
- [Fireworks AI](https://fireworks.ai) - Serverless LLM inference with fine-tuning, RAG support, and free credits for rapid prototyping (🏷️ `Cloud` `Inference` `API`).
|
||||
- [Groq Cloud](https://groq.com) - Ultra-fast LPU-based LLM inference for Mixtral, Llama, and Gemma with a free API tier (🏷️ `Cloud` `Inference` `API`).
|
||||
- [Modal](https://github.com/modal-labs/modal-client) - Serverless GPU compute purpose-built for AI workloads with fast cold starts and Python-native deployment (🏷️ `Python` `Serverless` `Cloud`).
|
||||
- [Northflank](https://northflank.com/) - Full-stack platform with GPU orchestration, Git-based CI/CD, and bring-your-own-cloud support (🏷️ `Kubernetes` `Cloud` `Platform`).
|
||||
- [Railway](https://railway.app/) - One-click deploy from GitHub with persistent volumes and databases for stateful agent deployments (🏷️ `Nix` `Cloud` `Platform`).
|
||||
- [Together AI](https://www.together.ai) - Inference API hosting 200+ open models with fast generation and a free tier for developers (🏷️ `Cloud` `Inference` `API`).
|
||||
- [Trigger.dev](https://github.com/triggerdotdev/trigger.dev) - Background job platform with cron, webhook, and event triggers purpose-built for long-running agent tasks (🏷️ `TypeScript` `Serverless` `Cloud`).
|
||||
|
||||
## Agent Evaluation and Benchmarks
|
||||
|
||||
- [AgentBench](https://github.com/THUDM/AgentBench) - Comprehensive benchmark for evaluating LLMs as agents across 8 distinct environments (🏷️ `Python` `Benchmark` `SDK`).
|
||||
- [ARC-AGI-2](https://arcprize.org) - Frontier benchmark for measuring general intelligence capabilities in AI agents beyond pattern matching (🏷️ `Python` `Benchmark` `Research`).
|
||||
- [GAIA Benchmark](https://huggingface.co/papers/2311.12983) - Benchmark for General AI Assistants measuring real-world reasoning and tool use (🏷️ `JSON` `Benchmark` `Dataset`).
|
||||
- [Inspect AI](https://github.com/UKGovernmentBEIS/inspect_ai) - Framework for evaluating large language models with composable tasks and scoring (🏷️ `Python` `Evaluation` `SDK`).
|
||||
- [SWE-bench](https://github.com/SWE-bench/SWE-bench) - Benchmark for evaluating LLMs on real-world software engineering tasks from GitHub issues (🏷️ `Python` `Docker` `Benchmark`).
|
||||
- [WebArena](https://github.com/web-arena-x/webarena) - Benchmark for web agent evaluation using real websites with realistic task completion metrics (🏷️ `Python` `Benchmark` `Web`).
|
||||
|
||||
## Agent Testing & Debugging
|
||||
|
||||
**Tools and frameworks focused on testing, debugging and evaluating agent workflows in production.**
|
||||
|
||||
| Tool | Debugging | Testing | Eval | Latency | Notes |
|
||||
| ---------------------- | --------- | ------- | ---- | ------- | ------------------------------------------------------------------ |
|
||||
| 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) - Domain-specialized agents for earnings analysis and portfolio insight (🏷️ `Cloud` `Finance` `Enterprise`).
|
||||
- [JPMorgan AlphaBlue](https://www.jpmorgan.com/global) - Trading and market analysis agent integrations for institutional workflows (🏷️ `Cloud` `Finance` `Enterprise`).
|
||||
- [Goldman Sachs Marquee AI](https://www.goldmansachs.com) - Market data and analytics agents built on Marquee platform (🏷️ `Cloud` `Finance` `Enterprise`).
|
||||
- [Morgan Stanley AdvisorBot](https://www.morganstanley.com) - Financial advisory assistant for advisors and retail clients (🏷️ `Cloud` `Finance` `Enterprise`).
|
||||
|
||||
### 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.nuance.com/healthcare.html) - Speech and clinical AI solutions for documentation and radiology (🏷️ `Cloud` `Healthcare` `Enterprise` `[HIPAA]`).
|
||||
- [Tempus AI](https://www.tempus.com) - Oncology research and clinical decision support agents (🏷️ `Cloud` `Healthcare` `Research`).
|
||||
|
||||
### Legal
|
||||
|
||||
- [LexisNexis AI](https://www.lexisnexis.com/en-us/gateway.page) - Document review and legal research agents (🏷️ `Cloud` `Legal` `Enterprise`).
|
||||
- [Westlaw AI-Assisted Research](https://legal.thomsonreuters.com/en/westlaw) - Case law analysis and brief drafting agents (🏷️ `Cloud` `Legal` `Enterprise`).
|
||||
- [ROSS Intelligence](https://blog.rossintelligence.com/) - Contract analysis and legal research agents (🏷️ `Cloud` `Legal` `Platform`).
|
||||
|
||||
### Manufacturing & Industrial
|
||||
|
||||
- [Siemens AI Ops](https://www.siemens.com/en-us/) - Factory-floor optimization and predictive maintenance agents (🏷️ `Cloud` `Industrial` `Enterprise`).
|
||||
- [GE Predix Agents](https://www.ge.com/) - Equipment monitoring and incident prediction agents for industrial fleets (🏷️ `Cloud` `Industrial` `Enterprise`).
|
||||
|
||||
### 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) - The benchmark paper for evaluating LLMs as agents across diverse environments (🏷️ `Paper` `ArXiv` `PDF`).
|
||||
- [AI Agents in LangGraph](https://www.deeplearning.ai/courses/ai-agents-in-langgraph) - Short course on building production agents with LangGraph by Andrew Ng's platform (🏷️ `Course` `DeepLearning.ai` `Web`).
|
||||
- [AI Engineering by Chip Huyen](https://www.oreilly.com/library/view/ai-engineering/9781098166298/) - Comprehensive guide on AI systems design and deployment covering agent architecture patterns (🏷️ `Book` `O'Reilly` `Print`).
|
||||
- [Anthropic Cookbook](https://github.com/anthropics/claude-cookbooks) - Collection of Claude agent recipes and integration patterns from Anthropic (🏷️ `Guide` `Anthropic` `GitHub`).
|
||||
- [Building Effective Agents](https://www.anthropic.com/engineering/building-effective-agents) - Anthropic's guide on agent design patterns, evaluation strategies, and production best practices (🏷️ `Guide` `Anthropic` `Web`).
|
||||
- [Google ADK Documentation](https://google.github.io/adk-docs/) - Official documentation for Google Agent Development Kit with tutorials and best practices (🏷️ `Guide` `Google` `Web`).
|
||||
- [Hugging Face Agents Course](https://huggingface.co/learn/agents-course/unit0/introduction) - Open-source course on building AI agents using Hugging Face tools and models (🏷️ `Course` `HuggingFace` `Web`).
|
||||
- [LATS: Language Agent Tree Search](https://github.com/lapisrocks/LanguageAgentTreeSearch) - Combines Monte Carlo tree search with LLM reasoning for complex multi-step planning tasks (🏷️ `Paper` `Python` `Research`).
|
||||
- [LLM Powered Autonomous Agents](https://lilianweng.github.io/posts/2023-06-23-agent/) - Deep breakdown of LLM-powered agent components: planning, memory, and tool use (🏷️ `Blog` `Weng` `Web`).
|
||||
- [Microsoft GenAI for Beginners](https://github.com/microsoft/generative-ai-for-beginners) - 21-lesson course on generative AI concepts and agent development from Microsoft (🏷️ `Course` `Microsoft` `GitHub`).
|
||||
- [OpenAI Cookbook](https://github.com/openai/openai-cookbook) - Practical guides and recipes for building with OpenAI APIs including agent patterns (🏷️ `Guide` `OpenAI` `GitHub`).
|
||||
- [Prompt Engineering Guide](https://github.com/dair-ai/Prompt-Engineering-Guide) - Community-maintained guide covering prompt engineering techniques and agent strategies (🏷️ `Guide` `DAIR` `Web`).
|
||||
- [ReAct: Synergizing Reasoning and Acting in Language Models](https://arxiv.org/abs/2210.03629) - The foundational paper behind the ReAct prompting pattern used in most agent frameworks (🏷️ `Paper` `ArXiv` `PDF`).
|
||||
- [Reflexion](https://github.com/noahshinn/reflexion) - Research framework letting agents learn from past mistakes via iterative verbal self-reflection loops (🏷️ `Paper` `Python` `Research`).
|
||||
- [Tree of Thoughts](https://github.com/princeton-nlp/tree-of-thought-llm) - Explores multiple parallel reasoning paths before committing to a final answer for complex problems (🏷️ `Paper` `Python` `Research`).
|
||||
|
||||
> **Deep dives:** [patterns/react-pattern.md](patterns/react-pattern.md) • [patterns/plan-and-execute.md](patterns/plan-and-execute.md) • [patterns/reflection-loop.md](patterns/reflection-loop.md) • [patterns/multi-agent.md](patterns/multi-agent.md) • [workflows/multi-step-reasoning.md](workflows/multi-step-reasoning.md)
|
||||
|
||||
## Agent Communication
|
||||
|
||||
Capabilities that let agents send messages, notifications, and reports across channels.
|
||||
|
||||
- [Apprise](https://github.com/caronc/apprise) - Sends agent notifications to 100+ services including Slack, Discord, and email from a single Python interface (🏷️ `Python` `Multi-Channel` `SDK`).
|
||||
- [Discord.py](https://github.com/Rapptz/discord.py) - Lets agents interact with Discord channels and servers for team-facing real-time communication (🏷️ `Python` `Discord` `SDK`).
|
||||
- [FastAPI-Mail](https://github.com/sabuhish/fastapi-mail) - Adds async email sending to FastAPI-based agent services with SMTP and OAuth2 support (🏷️ `Python` `FastAPI` `SDK`).
|
||||
- [Novu](https://github.com/novuhq/novu) - Routes agent notifications across email, SMS, push, and chat from a unified API and workflow engine (🏷️ `TypeScript` `Python` `Platform`).
|
||||
- [Ntfy](https://github.com/binwiederhier/ntfy) - Pushes real-time agent notifications to phones and desktops via a dead-simple HTTP API (🏷️ `Go` `Self-hosted` `API`).
|
||||
- [Resend](https://github.com/resend/resend-node) - Sends transactional emails from agent workflows with a clean, developer-first API (🏷️ `TypeScript` `Cloud` `API`).
|
||||
- [Slack Bolt](https://github.com/slackapi/bolt-python) - Enables agents to send, receive, and react to Slack messages with event-driven listeners (🏷️ `Python` `Slack` `SDK`).
|
||||
- [Twilio](https://github.com/twilio/twilio-python) - Sends SMS and voice calls from agent workflows to any phone number worldwide (🏷️ `Python` `Cloud` `API`).
|
||||
|
||||
## Data Pipeline and Workflow
|
||||
|
||||
Frameworks for orchestrating data transformations and long-running agent-driven workflows.
|
||||
|
||||
- [AI for Database](https://www.aifordatabase.com) - Connects to any database for plain English queries with self-refreshing dashboards and automated workflows (🏷️ `Cloud` `Database` `Platform`).
|
||||
- [Burr](https://github.com/apache/burr) - Tracks and manages multi-step agent state machines with built-in observability and persistence (🏷️ `Python` `StateGraph` `SDK`).
|
||||
- [Dagster](https://github.com/dagster-io/dagster) - Manages data assets and pipelines with built-in lineage tracking for data-intensive agent systems (🏷️ `Python` `Pipeline` `Platform`).
|
||||
- [GPT Researcher](https://github.com/assafelovic/gpt-researcher) - Conducts multi-source autonomous web research and produces cited, structured long-form reports (🏷️ `Python` `LangChain` `Web`).
|
||||
- [Hamilton](https://github.com/apache/hamilton) - Defines modular data transformations as Python functions wired automatically into a DAG for agent pipelines (🏷️ `Python` `DAG` `SDK`).
|
||||
- [Hex AI](https://hex.tech) - Collaborative data platform with AI-powered analysis and notebook-based data exploration for teams (🏷️ `Cloud` `Data` `Platform`).
|
||||
- [Julius AI](https://julius.ai) - Upload CSV or Excel files and analyze data using natural language questions for instant insights (🏷️ `Cloud` `Data` `Web`).
|
||||
- [PandasAI](https://github.com/sinaptik-ai/pandas-ai) - Chat with your data using natural language queries that convert to Pandas and SQL operations (🏷️ `Python` `Data` `SDK`).
|
||||
- [Prefect](https://github.com/PrefectHQ/prefect) - Orchestrates agent workflows and data pipelines with retries, caching, and built-in observability (🏷️ `Python` `Pipeline` `Platform`).
|
||||
- [Signals CLI](https://signals.dev) - Intent signal CLI detecting LinkedIn engagers, keyword posters, and funding events with JSON output for agent pipelines (🏷️ `Cloud` `CLI` `Platform`).
|
||||
- [STORM](https://github.com/stanford-oval/storm) - Generates Wikipedia-style long-form articles by autonomously researching and synthesizing multiple sources (🏷️ `Python` `Stanford` `Research`).
|
||||
|
||||
> **Deep dives:** [workflows/data-pipeline.md](workflows/data-pipeline.md) • [workflows/research-agent.md](workflows/research-agent.md)
|
||||
|
||||
## 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
|
||||
|
||||
| Tool | Isolation | Cold Start | Languages |
|
||||
| ------------------- | ------------------ | ---------- | ---------------------- |
|
||||
| E2B | VM (Firecracker) | ~300ms | Python, TS, Go |
|
||||
| Daytona | Container/VM | ~2s | Python, TS, Go |
|
||||
| Firecracker | microVM | ~125ms | REST API |
|
||||
| Docker | Namespace+cgroup | ~500ms | All |
|
||||
| AWS Lambda | Firecracker VM | ~200ms | Python, TS, Go |
|
||||
| Cloudflare Workers | V8 isolate | ~0ms | TS, Rust (WebAssembly) |
|
||||
|
||||
- agentbox - Docker for AI Agents — package, test, version, and govern AI agents across every framework (🏷️ `Python` `Docker` `CLI`).
|
||||
- [agentnotary](https://github.com/CharanBharathula/agentnotary) - Notarize, govern, and audit AI agents — cryptographic seal, runtime guard, EU AI Act docs, and adversarial fuzzer (🏷️ `Python` `Compliance` `CLI`).
|
||||
- [AWS Lambda](https://github.com/aws/aws-lambda-python-runtime-interface-client) - Serverless function runtime with Firecracker isolation for executing short-lived agent tasks at scale (🏷️ `Python` `AWS` `Serverless`).
|
||||
- [Cloudflare Workers](https://github.com/cloudflare/workers-sdk) - Ultra-low-latency V8-isolate serverless runtime at the edge for lightweight agent task execution (🏷️ `TypeScript` `Cloudflare` `Serverless`).
|
||||
- [CodeSandbox SDK](https://github.com/codesandbox/codesandbox-sdk) - Provides forked, snapshotted microVM environments for real-time collaborative agent code execution (🏷️ `TypeScript` `Python` `SDK`).
|
||||
- [Daytona](https://github.com/daytonaio/daytona) - Self-hostable git-based developer environment manager for sandboxed agent code execution with fast provisioning (🏷️ `Python` `TypeScript` `Platform`).
|
||||
- [Docker](https://github.com/moby/moby) - Standard container runtime providing namespace and cgroup isolation for packaging and running agent workloads (🏷️ `Go` `Docker` `Platform`).
|
||||
- [Firecracker](https://github.com/firecracker-microvm/firecracker) - Lightweight microVM technology with 125ms boot time used by AWS Lambda and E2B under the hood (🏷️ `Rust` `AWS` `Infrastructure`).
|
||||
- [Google Cloud Run](https://github.com/GoogleCloudPlatform/cloud-run-samples) - Fully managed serverless platform with gVisor isolation for running stateless agent containers at scale (🏷️ `Python` `GCP` `Serverless`).
|
||||
- [gVisor](https://github.com/google/gvisor) - User-space kernel that intercepts syscalls to provide VM-level security with container-level overhead (🏷️ `Go` `Google` `Infrastructure`).
|
||||
- [Kata Containers](https://github.com/kata-containers/kata-containers) - Combines VM-level security with the developer experience of containers using lightweight VMs (🏷️ `Go` `OCI` `Infrastructure`).
|
||||
- [Podman](https://github.com/containers/podman) - Daemonless, rootless container engine ideal for running untrusted agent-generated code securely (🏷️ `Go` `Rootless` `CLI`).
|
||||
- [Sysbox](https://github.com/nestybox/sysbox) - Enhanced container runtime that enables Docker-in-Docker securely for nested agent execution environments (🏷️ `Go` `Docker` `Infrastructure`).
|
||||
|
||||
> **Deep dives:** [environments/sandboxes.md](environments/sandboxes.md) • [environments/vms.md](environments/vms.md) • [environments/containers.md](environments/containers.md) • [environments/serverless.md](environments/serverless.md)
|
||||
|
||||
## Creative AI Agents
|
||||
|
||||
Tools for generating images, video, music, audio, and 3D assets using AI models.
|
||||
|
||||
### Image Generation
|
||||
|
||||
| Generator | Strength | Open Source | Pricing |
|
||||
| ----------------- | ------------------ | ----------- | ------------- |
|
||||
| Midjourney v7 | Artistic quality | No | $10-120/mo |
|
||||
| FLUX 2 | Photorealism | Yes | Free / API |
|
||||
| Stable Diffusion | Full control | Yes | Free (OSS) |
|
||||
| Ideogram v3 | Text rendering | No | Free / $7+/mo |
|
||||
| Google Imagen 4 | Highest fidelity | No | API |
|
||||
|
||||
- [Adobe Firefly 3](https://firefly.adobe.com) - Generates commercially safe images from text prompts using a model trained exclusively on licensed data (🏷️ `Cloud` `Adobe CC` `Web`).
|
||||
- [DALL-E 3.5](https://openai.com/dall-e-3) - Generates detailed images from text prompts with 95% text accuracy integrated directly into ChatGPT (🏷️ `Cloud` `OpenAI` `API`).
|
||||
- [FLUX 2](https://bfl.ai) - Open-weight photorealism model producing 4K output at 6x faster generation speed than its predecessor (🏷️ `Python` `Open-Weight` `API`).
|
||||
- [Google Imagen 4](https://deepmind.google/models/imagen/) - Produces state-of-the-art photorealistic images from text via Google DeepMind accessible through AI Studio (🏷️ `Cloud` `Google` `API`).
|
||||
- [Ideogram v3](https://ideogram.ai) - Renders readable text inside generated images with near-zero spelling errors for logos and marketing (🏷️ `Cloud` `Freemium` `Web`).
|
||||
- [Leonardo AI](https://leonardo.ai) - Multi-model image platform with Realtime Canvas and 3D gaming asset generation now owned by Canva (🏷️ `Cloud` `Canva` `Web`).
|
||||
- [Midjourney v7](https://midjourney.com) - Produces the highest artistic quality images with unmatched aesthetics via Discord and web interface (🏷️ `Cloud` `Discord` `Web`).
|
||||
- [Recraft](https://www.recraft.ai) - Design-first image generator with native vector art output and brand consistency tools for designers (🏷️ `Cloud` `Freemium` `Web`).
|
||||
- [Stable Diffusion 3.5](https://stability.ai) - Open-source foundation model with full ControlNet, LoRA, and ComfyUI ecosystem for custom pipelines (🏷️ `Python` `Open-Source` `Local`).
|
||||
|
||||
### Video Generation
|
||||
|
||||
| Generator | Max Length | Resolution | Open Source |
|
||||
| ---------------- | ---------- | ---------- | ----------- |
|
||||
| Sora 2 | 25 sec | 1080p | No |
|
||||
| Google Veo 3.1 | Variable | 4K | No |
|
||||
| Runway Gen-4.5 | Variable | 1080p+ | No |
|
||||
| Kling 3.0 | 2 min | 4K | No |
|
||||
| Wan 2.1 | Unlimited | Variable | Yes |
|
||||
| HunyuanVideo | Unlimited | Variable | Yes |
|
||||
|
||||
- [Google Veo 3.1](https://deepmind.google/models/veo/) - Generates the highest cinematic quality video with native audio from text prompts via Google DeepMind (🏷️ `Cloud` `Google` `API`).
|
||||
- [HaiLuo AI](https://hailuoai.video) - Budget video generation platform offering 10 free videos per day with HD output quality (🏷️ `Cloud` `Freemium` `Web`).
|
||||
- [HunyuanVideo](https://github.com/Tencent-Hunyuan/HunyuanVideo) - Open-source video generation model from Tencent that runs on consumer-grade GPUs (🏷️ `Python` `Open-Source` `Local`).
|
||||
- [Kling 3.0](https://kling.ai) - Generates 4K video up to 2 minutes long with native audio at the most competitive pricing available (🏷️ `Cloud` `Freemium` `Web`).
|
||||
- [LTX Video](https://github.com/Lightricks/LTX-Video) - Commercially safe open-source video generation model trained on fully licensed data (🏷️ `Python` `Open-Source` `Local`).
|
||||
- [Luma Dream Machine](https://lumalabs.ai/app) - Creates physics-accurate 4K HDR video scenes with 3D-style output for cinematic quality (🏷️ `Cloud` `Freemium` `Web`).
|
||||
- [Pika 2.5](https://pika.art/login) - Beginner-friendly video generation tool with fast turnaround and intuitive editing controls (🏷️ `Cloud` `Freemium` `Web`).
|
||||
- [Runway Gen-4.5](https://runwayml.com) - Professional video generation with Motion Brush and the highest benchmark scores for visual quality (🏷️ `Cloud` `Pro` `Web`).
|
||||
- [Seedance 2.0](https://seed.bytedance.com/en/seedance) - Quad-modal input video generator with built-in lip-sync and 2K resolution output (🏷️ `Cloud` `Freemium` `Web`).
|
||||
- [Sora 2](https://sora.com) - Generates 25-second cinematic video clips with strong narrative coherence from text prompts by OpenAI (🏷️ `Cloud` `OpenAI` `Web`).
|
||||
- [Wan 2.1](https://github.com/Wan-Video/Wan2.1) - Open-source self-hosted video generation model with unlimited length and no per-video costs (🏷️ `Python` `Open-Source` `Local`).
|
||||
|
||||
### Music and Audio Generation
|
||||
|
||||
- [ElevenLabs Music](https://elevenlabs.io/music) - Generates vocals and instrumentals with stem separation and per-section editing for audio production (🏷️ `Cloud` `ElevenLabs` `Web`).
|
||||
- [Meta AudioCraft](https://github.com/facebookresearch/audiocraft) - Open-source audio generation suite including MusicGen and AudioGen with fine-grained prompt control (🏷️ `Python` `Open-Source` `Local`).
|
||||
- [Stable Audio](https://stableaudio.com) - Generates instrumental audio tracks with a commercial license included by default for all outputs (🏷️ `Cloud` `Stability AI` `Web`).
|
||||
- [Suno](https://suno.com) - Generates complete songs with vocals, instruments, and lyrics from a single text prompt (🏷️ `Cloud` `Freemium` `Web`).
|
||||
- [Udio](https://www.udio.com) - Produces high-fidelity music with fine-grained sectional control over generation and arrangement (🏷️ `Cloud` `Freemium` `Web`).
|
||||
|
||||
### 3D and Design Generation
|
||||
|
||||
- [Meshy](https://www.meshy.ai) - Generates 3D models from text or images for game assets and product visualization with multi-format export (🏷️ `Cloud` `Freemium` `Web`).
|
||||
- [Tripo AI](https://www.tripo3d.ai) - Produces fast 3D model generation from text or images with multi-format export for rapid prototyping (🏷️ `Cloud` `Freemium` `Web`).
|
||||
- [Vizcom](https://vizcom.com) - Renders industrial design sketches into photorealistic 3D visuals in real-time for product designers (🏷️ `Cloud` `Pro` `Web`).
|
||||
|
||||
## Customer Support and CRM Agents
|
||||
|
||||
AI agents that automate customer support, CRM workflows, sales outreach, and ticket resolution at scale.
|
||||
|
||||
### Support Automation
|
||||
|
||||
| Platform | Auto-Resolution | Best For |
|
||||
| ---------------- | --------------- | ------------------ |
|
||||
| Intercom Fin | 50%+ tickets | SaaS teams |
|
||||
| Ada | 60%+ tickets | Complex resolution |
|
||||
| Zendesk AI | 30%+ tickets | Enterprise |
|
||||
| Freshdesk Freddy | 25%+ tickets | SMBs |
|
||||
|
||||
- [Ada](https://www.ada.cx) - Resolves 60% of customer support tickets automatically with complex multi-turn query understanding (🏷️ `Cloud` `Enterprise` `Platform`).
|
||||
- [Assembled](https://www.assembled.com) - Routes support tickets with workforce-aware scheduling and intelligent handoff to human agents (🏷️ `Cloud` `Enterprise` `Platform`).
|
||||
- [Dixa](https://www.dixa.com) - CRM-first conversational support platform with AI-powered routing and customer context enrichment (🏷️ `Cloud` `Enterprise` `Platform`).
|
||||
- [Freshdesk Freddy AI](https://www.freshworks.com/freshdesk/omni/freddy-ai-automation/) - Auto-triages and routes support tickets with smart AI suggestions for budget-conscious SMB teams (🏷️ `Cloud` `Freshworks` `Platform`).
|
||||
- [Intercom Fin](https://fin.ai) - Resolves 50% of SaaS support tickets by learning directly from your help center and knowledge base (🏷️ `Cloud` `Intercom` `Platform`).
|
||||
- [Zendesk AI](https://www.zendesk.com/service/ai/) - Automates 30% of enterprise support tickets with deep integration into the existing Zendesk ecosystem (🏷️ `Cloud` `Zendesk` `Platform`).
|
||||
|
||||
### AI-Powered CRM Platforms
|
||||
|
||||
- [Creatio](https://www.creatio.com) - No-code CRM platform with pre-built AI agents for sales, marketing, and service automation (🏷️ `Cloud` `No-Code` `Platform`).
|
||||
- [Dynamics 365 Copilot](https://www.microsoft.com/en-us/dynamics-365/solutions/service) - Drafts, summarizes, and translates across Office 365 with deep Microsoft ecosystem integration (🏷️ `Cloud` `Microsoft` `Platform`).
|
||||
- [HubSpot Breeze](https://www.hubspot.com/products/artificial-intelligence) - AI copilot with agent workflows and intelligence layer across marketing, sales, and service hubs (🏷️ `Cloud` `HubSpot` `Platform`).
|
||||
- [Monday CRM Lexi](https://monday.com/crm) - AI sales agent with automated lead sourcing, qualification, and pipeline management for SMBs (🏷️ `Cloud` `Monday` `Platform`).
|
||||
- [Pipedrive AI](https://www.pipedrive.com/en/features/ai-sales-assistant) - AI-powered email drafting, deal prioritization, and smart reporting for small sales teams (🏷️ `Cloud` `Pipedrive` `Platform`).
|
||||
- [Salesforce Einstein](https://www.salesforce.com/artificial-intelligence/?bc=OTH) - Enterprise AI with predictions, autonomous agents, and CRM automation across the Salesforce platform (🏷️ `Cloud` `Salesforce` `Platform`).
|
||||
- [Salesmate](https://www.salesmate.io) - CRM with AI-powered call summarization, lead qualification, and pipeline automation for small teams (🏷️ `Cloud` `CRM` `Platform`).
|
||||
- [ServiceNow AI Agents](https://www.servicenow.com/products/ai-agents.html) - Orchestrates AI agents across IT, HR, and CRM workflows for enterprise service management (🏷️ `Cloud` `ServiceNow` `Platform`).
|
||||
- [Zoho CRM Zia](https://www.zoho.com/zia/) - Predictive scoring, sentiment analysis, and voice commands for sales automation across Zoho products (🏷️ `Cloud` `Zoho` `Platform`).
|
||||
|
||||
### Sales and Outreach Agents
|
||||
|
||||
- [Apollo.io](https://www.apollo.io) - AI prospecting platform with 275M+ contacts, lead scoring, and automated email sequencing (🏷️ `Cloud` `Freemium` `Platform`).
|
||||
- [Clay](https://www.clay.com) - Enriches leads from 70+ data providers and generates hyper-personalized outreach at scale (🏷️ `Cloud` `Pro` `Platform`).
|
||||
- [Instantly](https://instantly.ai) - Generates AI cold emails with smart sender rotation and built-in domain warmup for deliverability (🏷️ `Cloud` `Pro` `Platform`).
|
||||
- [Lavender](https://www.lavender.ai) - Coaches email writing in real-time with AI response scoring and recipient intelligence (🏷️ `Cloud` `Freemium` `Platform`).
|
||||
- [Overloop CLI](https://overloop.com) - AI outbound CLI agent that sources 450M+ contacts and runs email plus LinkedIn campaigns with JSON output (🏷️ `Cloud` `CLI` `Platform`).
|
||||
|
||||
## Voice Agent Platforms
|
||||
|
||||
Platforms for building, deploying, and scaling voice-based AI agents across calls, support, and live conversations.
|
||||
|
||||
| Platform | Latency | HIPAA | Best For |
|
||||
| ---------- | ------- | ----- | ------------------------ |
|
||||
| ElevenLabs | 75ms | Yes | Industry benchmark |
|
||||
| Vapi | Low | No | Developer-first |
|
||||
| Bland AI | Medium | Yes | Outbound call automation |
|
||||
| PolyAI | Low | Yes | Enterprise scale |
|
||||
|
||||
- [AssemblyAI](https://www.assemblyai.com) - Speech-to-text API with speaker diarization, sentiment analysis, and summarization for voice agent pipelines (🏷️ `Cloud` `STT` `API`).
|
||||
- [Bland AI](https://bland.ai/) - Automates outbound phone calls at scale with SOC2 and HIPAA compliance and CRM integration (🏷️ `Cloud` `Telephony` `API`).
|
||||
- [Deepgram](https://deepgram.com) - Sub-300ms speech-to-text and text-to-speech APIs purpose-built for real-time voice agent pipelines (🏷️ `Cloud` `STT/TTS` `API`).
|
||||
- [ElevenLabs](https://elevenlabs.io) - Industry-leading voice AI with 75ms latency, Conversational AI 2.0, RAG, and HIPAA compliance (🏷️ `Cloud` `Voice` `Platform`).
|
||||
- [HeyGen](https://www.heygen.com) - Creates AI talking avatars with voice cloning and lip-sync for video-based agent interactions (🏷️ `Cloud` `Avatar` `Web`).
|
||||
- [PolyAI](https://poly.ai/en) - Enterprise voice AI platform for natural multi-turn conversations with high-volume call handling (🏷️ `Cloud` `Enterprise` `Platform`).
|
||||
- [Retell AI](https://www.retellai.com) - Builds human-like voice agents with multi-language telephony support and low-latency responses (🏷️ `Cloud` `Telephony` `API`).
|
||||
- [Synthesia](https://www.synthesia.io) - Generates AI video avatars that speak in 120+ languages for training and communication agents (🏷️ `Cloud` `Avatar` `Web`).
|
||||
- [Synthflow](https://synthflow.ai) - No-code voice agent builder with pre-built templates for SMBs to deploy phone agents quickly (🏷️ `Cloud` `No-Code` `Platform`).
|
||||
- [Voiceflow](https://www.voiceflow.com) - No-code builder for voice and chat agents with visual conversation design and team collaboration (🏷️ `Cloud` `No-Code` `Platform`).
|
||||
|
||||
## Deep Research Agents
|
||||
|
||||
AI platforms that conduct autonomous multi-step research, synthesize findings from multiple sources, and generate structured reports with citations.
|
||||
|
||||
| Agent | Context Window | Approach |
|
||||
| ---------------- | -------------- | --------------------------- |
|
||||
| Claude Research | 200K tokens | Multi-step with citations |
|
||||
| ChatGPT Research | 128K tokens | Extended reasoning + browse |
|
||||
| Gemini Research | 1M tokens | Google Search + KG |
|
||||
| Perplexity Pro | Variable | Real-time cited search |
|
||||
|
||||
- [CAJAL](https://github.com/Agnuxo1/CAJAL) - Local AI agent that generates publication-ready IMRaD scientific papers with verified arXiv citations and AI tribunal scoring (🏷️ `Python` `Ollama` `Local`).
|
||||
- [ChatGPT Deep Research](https://openai.com/index/introducing-deep-research) - Conducts extended reasoning with web browsing to produce structured research reports with Canvas output (🏷️ `Cloud` `OpenAI` `Web`).
|
||||
- [Claude Deep Research](https://www.anthropic.com/research) - Performs multi-step investigation with verified source citations and 200K token context window (🏷️ `Cloud` `Anthropic` `Web`).
|
||||
- [DeerFlow](https://github.com/bytedance/deer-flow) - Multi-agent research system from ByteDance with planning and execution loops for autonomous investigation (🏷️ `Python` `Open-Source` `Research`).
|
||||
- [Gemini Deep Research](https://blog.google/products-and-platforms/products/gemini/google-gemini-deep-research/) - Leverages Google Search and Knowledge Graph integration with 1M token context for breadth-first research (🏷️ `Cloud` `Google` `Web`).
|
||||
- [Perplexity Pro](https://www.perplexity.ai) - Provides real-time search answers with inline citations and follow-up threads for iterative research (🏷️ `Cloud` `Freemium` `Web`).
|
||||
- [Perplexity Personal Computer](https://www.perplexity.ai/pc) - Autonomous research agent with vision capabilities, real-time search integration, and document analysis for comprehensive research workflows (🏷️ `Cloud` `Research` `Consumer`).
|
||||
|
||||
## Prompt-to-App Builders
|
||||
|
||||
Platforms that generate full-stack applications, components, or web apps from natural language prompts.
|
||||
|
||||
| Builder | Output | Hosting |
|
||||
| ------------- | ---------------- | -------------- |
|
||||
| Bolt.new | Full-stack app | Browser/deploy |
|
||||
| Lovable | Full web app | Auto-deploy |
|
||||
| v0 by Vercel | React components | Vercel |
|
||||
| Replit Agent | Full-stack | Replit |
|
||||
|
||||
- [Bolt.new](https://bolt.new) - Generates full-stack web applications in the browser from natural language prompts with instant deploy (🏷️ `Cloud` `Freemium` `Web`).
|
||||
- [Dyad](https://github.com/dyad-sh/dyad) - Privacy-first open-source prompt-to-app builder that generates full-stack applications locally (🏷️ `TypeScript` `Open-Source` `Local`).
|
||||
- [Google Project IDX](https://firebase.studio) - AI-powered cloud IDE with free Claude Opus access for building full projects across all frameworks (🏷️ `Cloud` `Google` `Web`).
|
||||
- [Lovable](https://lovable.dev) - Iterates from chat to deployed web application with auto-deploy and real-time preview (🏷️ `Cloud` `Freemium` `Web`).
|
||||
- [PlayCode Agent](https://playcode.io) - Browser-only lightweight web app creation tool with AI-assisted code generation (🏷️ `Cloud` `Pro` `Web`).
|
||||
- [Replit Agent](https://replit.com/agent4) - Builds and deploys full-stack projects from prompts with integrated hosting and collaboration (🏷️ `Cloud` `Freemium` `Web`).
|
||||
- [v0 by Vercel](https://v0.app) - Generates React and Tailwind UI components from text descriptions with one-click Vercel deployment (🏷️ `Cloud` `Freemium` `Web`).
|
||||
|
||||
## Multi-Agent Consumer Platforms
|
||||
|
||||
All-in-one AI platforms providing access to agents, tools, and models through consumer-facing interfaces without writing code.
|
||||
|
||||
| Platform | Context | Flagship Features |
|
||||
| ---------- | ------- | ------------------------------------------ |
|
||||
| ChatGPT | 128K | GPTs, Deep Research, Canvas, Agent Mode |
|
||||
| Claude | 200K | Computer Use, MCP, Cowork |
|
||||
| Gemini | 1M | Deep Think, Gems, NotebookLM |
|
||||
| Grok | 131K | Real-time X data, Grok Build |
|
||||
|
||||
- [ChatGPT](https://openai.com/chatgpt) - General-purpose AI platform with GPTs, Deep Research, Canvas, and Agent Mode across the widest plugin ecosystem (🏷️ `Cloud` `OpenAI` `Web`).
|
||||
- [Claude](https://claude.com/product/overview) - Reasoning-focused AI with Computer Use, MCP integration, and Chrome browsing for coding and long document analysis (🏷️ `Cloud` `Anthropic` `Web`).
|
||||
- [Coze](https://www.coze.com) - No-code agent builder with a marketplace of 100+ custom agents and plugin integrations (🏷️ `Cloud` `ByteDance` `Web`).
|
||||
- [Gemini](https://deepmind.google/models/gemini/) - Google's multimodal AI with 1M token context, Deep Think, Gems, and NotebookLM for workspace integration (🏷️ `Cloud` `Google` `Web`).
|
||||
- [Grok](https://x.ai/grok) - Real-time AI with live X data access, Grok Build for 8-agent parallel code generation, and image generation (🏷️ `Cloud` `xAI` `Web`).
|
||||
- [Meta AI](https://meta.ai) - Llama-powered AI integrated across WhatsApp, Messenger, and Instagram for conversational assistance (🏷️ `Cloud` `Meta` `Web`).
|
||||
- [Microsoft Copilot](https://copilot.microsoft.com) - AI assistant integrated into Office 365, Teams, and Power Platform for enterprise productivity workflows (🏷️ `Cloud` `Microsoft` `Web`).
|
||||
|
||||
## 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 |
|
||||
| --------------- | ------------ | ------------ | -------------------------- |
|
||||
| Llama 4 | Meta | 8B-405B+ | Strong tool use |
|
||||
| Qwen 3 | Alibaba | 0.6B-235B | MCP-native, multilingual |
|
||||
| DeepSeek V3/R1 | DeepSeek | 671B MoE | 68x cheaper than GPT-4 |
|
||||
| Gemma 3 | Google | 1B-27B | Efficient edge agents |
|
||||
|
||||
- [Baichuan 3](https://huggingface.co/baichuan-inc) - Chinese-optimized open model family with strong domain performance for multilingual agent deployments (🏷️ `Python` `Open-Source` `Local`).
|
||||
- [Command R+](https://cohere.com/command) - Cohere's 104B parameter model optimized specifically for RAG and enterprise tool use in agent workflows (🏷️ `Cloud` `Cohere` `API`).
|
||||
- [DeepSeek V3](https://github.com/deepseek-ai/DeepSeek-V3) - 671B MoE model that delivers GPT-4 level reasoning at 68x lower cost for budget-conscious agent deployments (🏷️ `Python` `Open-Source` `Local`).
|
||||
- [Falcon 3](https://huggingface.co/tiiuae) - Efficient open model from TII UAE with strong multilingual support across 10B to 180B parameter variants (🏷️ `Python` `Open-Source` `Local`).
|
||||
- [Gemma 3](https://github.com/google-deepmind/gemma) - Efficient multimodal model from Google in 1B to 27B sizes ideal for edge and on-device agents (🏷️ `Python` `Google` `Local`).
|
||||
- [Gemma 4](https://deepmind.google/models/gemma/) - Consumer and IoT-optimized model from Google in 2B to 31B sizes with E2B and E4B variants (🏷️ `Python` `Google` `Local`).
|
||||
- [GLM-4](https://github.com/zai-org/GLM-4) - Zhipu AI's 744B MoE model achieving the lowest hallucination rate and 77.8% on SWE-bench (🏷️ `Python` `Open-Source` `Local`).
|
||||
- [InternLM 3](https://github.com/InternLM/InternLM) - Shanghai AI Lab model with strong long-context reasoning capabilities for complex agent tasks (🏷️ `Python` `Open-Source` `Local`).
|
||||
- [Llama 4](https://github.com/meta-llama/llama-models) - Meta's flagship open model family with Scout and Maverick variants and strong tool use capabilities (🏷️ `Python` `Meta` `Local`).
|
||||
- [Mistral Large 2](https://mistral.ai/models) - Leading European open model at 123B parameters with strong function calling for agent workflows (🏷️ `Python` `Mistral` `API`).
|
||||
- [Phi-4](https://huggingface.co/microsoft/phi-4) - Microsoft's compact 14B parameter model delivering strong reasoning for on-device and edge agent deployments (🏷️ `Python` `Microsoft` `Local`).
|
||||
- [Qwen 3](https://github.com/QwenLM/Qwen3) - MCP-native multilingual model family from Alibaba with thinking mode across 0.6B to 235B sizes (🏷️ `Python` `Alibaba` `Local`).
|
||||
- [Qwen 3.6-Plus](https://qwenlm.github.io/blog/qwen3/) - Agentic-focused model with 1M context window, repo-level coding, and MCP-native tool use (🏷️ `Python` `Alibaba` `Local`).
|
||||
- [StarCoder 2](https://github.com/bigcode-project/starcoder2) - Code-focused open model trained on 600+ programming languages for specialized coding agents (🏷️ `Python` `BigCode` `Local`).
|
||||
- [Yi-Lightning](https://github.com/01-ai/Yi) - 01.AI's multilingual model with long context and fast inference across 6B to 200B parameter sizes (🏷️ `Python` `Open-Source` `Local`).
|
||||
|
||||
## Market Stats and Benchmarks 2026
|
||||
|
||||
Key data points on the AI agent market covering adoption, growth, valuations, and fastest-growing open-source projects.
|
||||
|
||||
### Market Size
|
||||
|
||||
| Year | Market Size | Growth |
|
||||
| ---- | ----------- | ---------- |
|
||||
| 2024 | $5.1B | Baseline |
|
||||
| 2025 | $7.6B | +49% YoY |
|
||||
| 2026 | $10.91B | +43% YoY |
|
||||
| 2027 | $16.8B | +54% YoY |
|
||||
| 2030 | $52.63B | 46.3% CAGR |
|
||||
|
||||
### Adoption Rates
|
||||
|
||||
| Metric | Value |
|
||||
| --------------------------------------- | ----- |
|
||||
| Orgs with agents in production | 57% |
|
||||
| Devs using AI coding tools regularly | 85% |
|
||||
| Companies planning agent deployment | 72% |
|
||||
| Enterprises with dedicated agent budget | 41% |
|
||||
|
||||
### Top Use Cases
|
||||
|
||||
| Use Case | Share |
|
||||
| --------------------- | ----- |
|
||||
| Customer Service | 26.5% |
|
||||
| Research and Analysis | 24.4% |
|
||||
| Workflow Automation | 18.0% |
|
||||
| Code Generation | 15.0% |
|
||||
| Data Processing | 10.0% |
|
||||
|
||||
### Fastest Growing Open-Source Projects
|
||||
|
||||
| Project | Stars (Jan 2026) | Stars (May 2026) | Growth |
|
||||
| -------------- | ---------------- | ---------------- | ------ |
|
||||
| Browser Use | 10K | 50K | 5x |
|
||||
| Playwright MCP | 1K | 10K | 10x |
|
||||
| DeerFlow | 5K | 25K | 5x |
|
||||
|
||||
### Notable Valuations
|
||||
|
||||
| Company | Valuation |
|
||||
| ------------ | --------- |
|
||||
| OpenAI | $90B+ |
|
||||
| Cursor | $29.3B |
|
||||
| Anthropic | $20B |
|
||||
| ElevenLabs | $11B |
|
||||
| Mistral | $6B |
|
||||
| Hugging Face | $4.5B |
|
||||
|
||||
- [AI Agent Market Report 2026](https://www.marketsandmarkets.com) - Comprehensive market analysis projecting the AI agent market to reach $52.63B by 2030 at 46.3% CAGR (🏷️ `Report` `Market` `Research`).
|
||||
- [State of AI Agents Survey](https://www.mckinsey.com) - Enterprise survey showing 57% of organizations now have AI agents in production workflows (🏷️ `Report` `Survey` `Research`).
|
||||
|
||||
## 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) - Open-source local chat application that runs LLMs on consumer hardware without cloud dependencies (🏷️ `C++` `Desktop` `Local`).
|
||||
- [Jan](https://github.com/janhq/jan) - Open-source ChatGPT alternative that runs 100% offline with local model management and privacy guarantees (🏷️ `TypeScript` `Electron` `Desktop`).
|
||||
- [Llamafile](https://github.com/mozilla-ai/llamafile) - Distributes LLMs as single executable files with zero setup required from Mozilla (🏷️ `C++` `Portable` `Local`).
|
||||
- [llama.cpp](https://github.com/ggml-org/llama.cpp) - C/C++ LLM inference engine supporting CPU, GPU, and Apple Silicon as the foundation of local AI (🏷️ `C++` `Cross-Platform` `Local`).
|
||||
- [LM Studio](https://lmstudio.ai) - Desktop application for running local LLMs with a polished UI across all major platforms (🏷️ `TypeScript` `Electron` `Desktop`).
|
||||
- [LocalAI](https://github.com/mudler/LocalAI) - Drop-in OpenAI API replacement that runs models locally without requiring a GPU (🏷️ `Go` `Docker` `Local`).
|
||||
- [Ollama](https://github.com/ollama/ollama) - Run LLMs locally with a dead-simple CLI interface and 162K+ GitHub stars (🏷️ `Go` `CLI` `Local`).
|
||||
- [vLLM](https://github.com/vllm-project/vllm) - High-throughput LLM serving engine with PagedAttention for production-grade local inference (🏷️ `Python` `CUDA` `Local`).
|
||||
|
||||
## 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) - End-to-end AI governance platform with EU AI Act policy packs and model inventory management (🏷️ `Cloud` `Governance` `Platform`).
|
||||
- [EU AI Act](https://artificialintelligenceact.eu) - Official EU regulatory framework classifying AI systems by risk tier from unacceptable to minimal risk (🏷️ `Policy` `Regulation` `EU`).
|
||||
- [IBM watsonx.governance](https://www.ibm.com/products/watsonx-governance) - Enterprise AI risk, compliance, and model monitoring platform for regulated industries (🏷️ `Cloud` `IBM` `Platform`).
|
||||
- [Nobulex](https://github.com/arian-gogani/nobulex) - Cryptographic receipts for AI agent actions with two Ed25519 signatures per action, hash-chained for tamper-evident audit trails (🏷️ `TypeScript` `Security` `Cryptography`).
|
||||
- [NIST AI RMF](https://airc.nist.gov/) - US framework for AI risk management covering Govern, Map, Measure, and Manage functions (🏷️ `Policy` `Framework` `US`).
|
||||
- [OneTrust AI Governance](https://www.onetrust.com/solutions/ai-governance/) - Risk classification, consent management, and compliance workflows for AI agent deployments (🏷️ `Cloud` `Compliance` `Platform`).
|
||||
|
||||
|
||||
## 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) - Enterprise threat detection and incident response AI integrated across Microsoft security products (🏷️ `Cloud` `Microsoft` `Platform`).
|
||||
- [PentestGPT](https://github.com/GreyDGL/PentestGPT) - GPT-powered penetration testing tool with automated reasoning for vulnerability assessment (🏷️ `Python` `Security` `CLI`).
|
||||
- [YAWNING TITAN](https://github.com/dstl/YAWNING-TITAN) - Graph-based cybersecurity simulation environment for training and testing defensive AI agents (🏷️ `Python` `Simulation` `Research`).
|
||||
|
||||
## 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) - FDA-cleared video game-based digital medicine for ADHD using neuroplasticity-focused cognitive training (🏷️ `Cloud` `FDA-Cleared` `Medical`).
|
||||
- [Elomia](https://elomia.com) - Clinician-designed AI therapy chatbot with natural conversation flow and anonymous interaction by design (🏷️ `Cloud` `Mental Health` `Web`).
|
||||
- [Ginger](https://organizations.headspace.com) - On-demand mental healthcare platform combining AI coaching with live therapists using CBT and DBT approaches (🏷️ `Cloud` `Mental Health` `Mobile`).
|
||||
- [Headspace Health](https://www.headspace.com) - Meditation and mental health platform with CBT-based courses, sleep programs, and clinical partnerships (🏷️ `Cloud` `Wellness` `Mobile`).
|
||||
- [Replika](https://replika.com) - AI companion with Rogerian-style support, persistent memory, and mood tracking for social wellbeing (🏷️ `Cloud` `Companion` `Mobile`).
|
||||
- [Talkspace AI](https://www.talkspace.com) - AI-assisted therapy matching platform with human therapist backup for personalized mental health care (🏷️ `Cloud` `Therapy` `Mobile`).
|
||||
- [Tess by X2AI](https://www.cass.ai) - SMS-based therapy coach using CBT with clinical validation showing 28% depression reduction (🏷️ `Cloud` `Mental Health` `SMS`).
|
||||
- [Woebot](https://woebothealth.com) - CBT-based mental health chatbot that is FDA-cleared and Stanford-validated for therapeutic conversations (🏷️ `Cloud` `FDA-Cleared` `Mobile`).
|
||||
- [Wysa](https://www.wysa.com) - NHS-approved AI mental health companion using CBT and DBT with anonymous design principles (🏷️ `Cloud` `Mental Health` `Mobile`).
|
||||
- [Youper](https://www.youper.ai) - Emotional health assistant using CBT and ACT with Stanford-tested clinical effectiveness for mood tracking (🏷️ `Cloud` `Mental Health` `Mobile`).
|
||||
|
||||
## Newsletters and Communities
|
||||
|
||||
Curated newsletters, podcasts, and communities for staying current with AI agent development.
|
||||
|
||||
- [AI Engineering Newsletter](https://www.latent.space) - AI engineering podcast and newsletter by Swyx and Alessio covering agent architectures and tooling (🏷️ `Newsletter` `Podcast` `Web`).
|
||||
- [aibtc.news](https://aibtc.news) - Bitcoin-focused agent news platform with bounties and classifieds for the agent economy (🏷️ `Newsletter` `Bitcoin` `Web`).
|
||||
- [Awesome Agents Newsletter](https://awesomeagents.substack.com) - Weekly curated tools and reviews covering the latest in AI agent development (🏷️ `Newsletter` `Weekly` `Web`).
|
||||
- [r/ClaudeAI](https://www.reddit.com/r/ClaudeAI/) - Reddit community for Claude users sharing agent workflows, prompts, and integration patterns (🏷️ `Community` `Reddit` `Forum`).
|
||||
- [r/LangChain](https://www.reddit.com/r/LangChain/) - Reddit community for agent developers using LangChain, LangGraph, and related frameworks (🏷️ `Community` `Reddit` `Forum`).
|
||||
- [r/LocalLLaMA](https://www.reddit.com/r/LocalLLaMA/) - Reddit community for self-hosted LLM users sharing local deployment and agent setup guides (🏷️ `Community` `Reddit` `Forum`).
|
||||
- [The Rundown AI](https://www.therundown.ai) - Daily AI digest reaching 600K+ subscribers with concise coverage of agent news and launches (🏷️ `Newsletter` `Daily` `Web`).
|
||||
|
||||
## 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)
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
# Secure execution environments
|
||||
|
||||
This directory covers where agent-generated code runs safely — sandboxes, VMs, containers, and serverless runtimes that isolate untrusted code from your production infrastructure.
|
||||
|
||||
## Why environments matter
|
||||
|
||||
When an agent generates and runs code, you're executing untrusted input. This is fundamentally the same security problem as running user-uploaded scripts, and it needs the same level of isolation. The question is always: _what's the blast radius if this code does something malicious or buggy?_
|
||||
|
||||
| Isolation level | Blast radius | Speed | Example |
|
||||
|----------------|-------------|-------|---------|
|
||||
| Same process | Full system access | Instant | `exec()` in Python — never do this in production |
|
||||
| Separate process | User-level access | Fast | subprocess with resource limits |
|
||||
| Container | Namespace-isolated | ~500ms cold start | Docker, Podman |
|
||||
| microVM | Hardware-level isolation | ~125-300ms cold start | Firecracker, E2B |
|
||||
| V8 isolate | Memory-isolated | ~0ms cold start | Cloudflare Workers |
|
||||
|
||||
The right choice depends on your threat model. If the agent only generates pandas code, a container might be enough. If the agent writes arbitrary Python, you want a microVM.
|
||||
|
||||
## Sections
|
||||
|
||||
| Topic | File |
|
||||
|-------|------|
|
||||
| **Hosted sandboxes** | [sandboxes.md](sandboxes.md) |
|
||||
| **Self-hosted VMs** | [vms.md](vms.md) |
|
||||
| **Container patterns** | [containers.md](containers.md) |
|
||||
| **Serverless runtimes** | [serverless.md](serverless.md) |
|
||||
|
||||
## Decision guide
|
||||
|
||||
```
|
||||
Start here: Who generates the code?
|
||||
│
|
||||
├── Your agent (untrusted code)
|
||||
│ ├── Need <1s cold start? → E2B (Firecracker microVM)
|
||||
│ ├── Need GPU? → Modal
|
||||
│ ├── Need full dev environment? → Daytona
|
||||
│ └── Self-hosting required?
|
||||
│ ├── Drop-in Docker security? → gVisor (see vms.md)
|
||||
│ ├── Full VM boundary at scale? → Firecracker (see vms.md)
|
||||
│ └── K8s + VM isolation? → Kata Containers (see vms.md)
|
||||
│
|
||||
├── Your code (trusted, calling agent APIs)
|
||||
│ ├── Short-lived functions (<15 min)? → Lambda or Cloud Run
|
||||
│ ├── Need persistent containers? → Docker / Podman
|
||||
│ └── Ultra-low latency, simple logic? → Cloudflare Workers
|
||||
│
|
||||
└── Mixed (trusted orchestrator + untrusted agent code)
|
||||
└── Run orchestrator on your infra, sandbox agent code in E2B or Modal
|
||||
```
|
||||
|
|
@ -0,0 +1,107 @@
|
|||
# Container patterns for agent isolation
|
||||
|
||||
Containers are the most common isolation mechanism for running agent workloads in production. They're well-understood, widely supported, and fast enough for most use cases. This page covers patterns for using containers specifically in agentic workflows.
|
||||
|
||||
## Why containers for agents
|
||||
|
||||
Containers give you process-level isolation with namespace and cgroup boundaries. They're not as secure as microVMs (a container escape is possible, a VM escape is much harder), but they're:
|
||||
|
||||
- **Fast**: ~500ms cold start, near-zero warm start
|
||||
- **Portable**: Run anywhere Docker runs
|
||||
- **Well-tooled**: Extensive ecosystem for building, deploying, and monitoring
|
||||
- **Familiar**: Most teams already know Docker
|
||||
|
||||
For agents running trusted code (your code, not agent-generated code), containers are usually sufficient. For agents running untrusted code, consider adding gVisor or running inside a microVM.
|
||||
|
||||
## Container tools
|
||||
|
||||
**[Docker (Moby)](https://github.com/moby/moby)** — Runs agent workloads in namespace-isolated containers. Cold start: ~500ms. Isolation: namespace + cgroup. SDK: All languages. Tags: `sandbox` `docker`
|
||||
|
||||
**[Podman](https://github.com/containers/podman)** — Runs rootless, daemonless containers for better security. Cold start: ~500ms. Isolation: rootless container. SDK: All languages. Tags: `sandbox` `docker`
|
||||
|
||||
**[Sysbox](https://github.com/nestybox/sysbox)** — Runs Docker-in-Docker securely, allowing agents to spin up their own containers. Cold start: ~1s. Isolation: enhanced container with syscall interception. SDK: All languages. Tags: `sandbox` `docker`
|
||||
|
||||
**[Testcontainers](https://github.com/testcontainers/testcontainers-python)** — Spins up disposable containers for testing agent tool interactions. Cold start: ~1-2s. Isolation: standard container. SDK: Python, Java, Go, .NET. Tags: `sandbox` `docker` `python`
|
||||
|
||||
## Patterns
|
||||
|
||||
### Pattern 1: One container per agent invocation
|
||||
|
||||
The simplest pattern. Each time your agent runs, spin up a fresh container, execute the workflow, and tear it down. This guarantees clean state between invocations.
|
||||
|
||||
```yaml
|
||||
# docker-compose.yml
|
||||
services:
|
||||
agent-runner:
|
||||
image: agent-sandbox:latest
|
||||
mem_limit: 512m
|
||||
cpus: 1.0
|
||||
network_mode: none # No network access by default
|
||||
read_only: true # Read-only filesystem
|
||||
security_opt:
|
||||
- no-new-privileges # Prevent privilege escalation
|
||||
tmpfs:
|
||||
- /tmp:size=100m # Writable temp directory with size limit
|
||||
```
|
||||
|
||||
### Pattern 2: Sidecar sandbox
|
||||
|
||||
The agent orchestrator runs in one container, and agent-generated code runs in a separate "sidecar" container. Communication happens over a local socket or HTTP. This isolates untrusted code without the overhead of a remote sandbox API.
|
||||
|
||||
```
|
||||
┌─────────────────────────────┐
|
||||
│ Pod / compose service │
|
||||
│ │
|
||||
│ ┌─────────┐ ┌──────────┐ │
|
||||
│ │ Agent │ │ Sandbox │ │
|
||||
│ │ logic │──│ (no net) │ │
|
||||
│ │ (Flask) │ │ (exec) │ │
|
||||
│ └─────────┘ └──────────┘ │
|
||||
└─────────────────────────────┘
|
||||
```
|
||||
|
||||
### Pattern 3: Pre-warmed container pool
|
||||
|
||||
Cold starts add latency. Keep a pool of idle containers ready to accept agent tasks. When a task arrives, assign it to a warm container; when it finishes, reset the container and return it to the pool.
|
||||
|
||||
```python
|
||||
class ContainerPool:
|
||||
def __init__(self, image: str, pool_size: int = 5):
|
||||
self.available = []
|
||||
for _ in range(pool_size):
|
||||
container = docker.run(image, detach=True)
|
||||
self.available.append(container)
|
||||
|
||||
def execute(self, code: str) -> str:
|
||||
container = self.available.pop()
|
||||
result = container.exec_run(f"python -c '{code}'")
|
||||
container.exec_run("rm -rf /tmp/*") # Reset state
|
||||
self.available.append(container)
|
||||
return result.output
|
||||
```
|
||||
|
||||
### Pattern 4: Docker-in-Docker for agent self-management
|
||||
|
||||
Some agents need to create their own containers — e.g., a DevOps agent that builds and tests Dockerfiles. Use Sysbox to allow secure Docker-in-Docker without privileged mode.
|
||||
|
||||
```bash
|
||||
# Run agent container with Sysbox runtime (no --privileged needed)
|
||||
docker run --runtime=sysbox-runc -it agent-devops:latest
|
||||
# Inside the container, the agent can run:
|
||||
# docker build -t test .
|
||||
# docker run test pytest
|
||||
```
|
||||
|
||||
## Security hardening checklist
|
||||
|
||||
- [ ] Run as non-root user (`USER 1000` in Dockerfile)
|
||||
- [ ] Use `--read-only` filesystem where possible
|
||||
- [ ] Set memory and CPU limits (`--memory=512m --cpus=1`)
|
||||
- [ ] Disable network access for code execution (`--network=none`)
|
||||
- [ ] Drop all capabilities (`--cap-drop=ALL`)
|
||||
- [ ] Prevent privilege escalation (`--security-opt=no-new-privileges`)
|
||||
- [ ] Use seccomp profiles to restrict syscalls
|
||||
- [ ] Set execution timeout (kill container after N seconds)
|
||||
- [ ] Use rootless mode (Podman) for defense-in-depth
|
||||
- [ ] Consider gVisor runtime for additional syscall filtering
|
||||
```
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
# Hosted sandboxes
|
||||
|
||||
Hosted sandboxes are managed services that run untrusted agent-generated code in isolated environments. You don't manage the infrastructure — you make an API call, code runs in a sandbox, and you get the result back.
|
||||
|
||||
## Why hosted sandboxes
|
||||
|
||||
Running agent-generated code safely requires isolation. Building that isolation yourself means managing VMs, container runtimes, networking, and security updates. Hosted sandboxes abstract all of that behind an API.
|
||||
|
||||
The tradeoff is cost and control. You pay per execution, and you're limited to what the sandbox provider supports. For most agent use cases, this tradeoff is worth it.
|
||||
|
||||
## Comparison
|
||||
|
||||
| Service | Isolation | Cold start | Max execution | SDK languages | Persistent storage | GPU | Pricing model |
|
||||
|---------|-----------|------------|--------------|---------------|-------------------|-----|--------------|
|
||||
| **E2B** | microVM (Firecracker) | ~300ms | Configurable | Python, TS, Go | Yes (filesystem) | No | Per-second |
|
||||
| **Modal** | Container + gVisor | ~500ms | Configurable | Python | Yes (volumes) | Yes | Per-second |
|
||||
| **Daytona** | Container / VM | ~2s | Persistent | Python, TS, Go | Yes | No | Open source / hosted |
|
||||
| **CodeSandbox SDK** | microVM | ~1s | Persistent | Python, TS | Yes | No | Per-sandbox |
|
||||
|
||||
## Detailed entries
|
||||
|
||||
**[E2B](https://github.com/e2b-dev/e2b)** — Runs agent-generated code in secure cloud sandboxes with sub-second start. Cold start: ~300ms. Isolation: VM (Firecracker). SDK: Python, TypeScript, Go. Tags: `execution` `sandbox` `python` `typescript` `e2b`
|
||||
|
||||
E2B is purpose-built for AI agents. Each sandbox is a full-blown Firecracker microVM with its own filesystem, networking, and process isolation. You can create custom sandbox templates with pre-installed dependencies, which drastically reduces setup time for repeated use.
|
||||
|
||||
```python
|
||||
from e2b_code_interpreter import Sandbox
|
||||
|
||||
sandbox = Sandbox()
|
||||
result = sandbox.run_code("import pandas as pd; print(pd.__version__)")
|
||||
print(result.text)
|
||||
sandbox.kill()
|
||||
```
|
||||
|
||||
**[Modal](https://github.com/modal-labs/modal-client)** — Runs functions in cloud containers with GPU support and auto-scaling. Cold start: ~500ms. Isolation: container + gVisor. SDK: Python. Tags: `execution` `sandbox` `python` `modal`
|
||||
|
||||
Modal is a broader compute platform, but its fast container startup and GPU support make it excellent for agents that need to run ML models, process images, or do heavy computation. The `@modal.function` decorator makes it trivial to offload specific agent steps.
|
||||
|
||||
```python
|
||||
import modal
|
||||
|
||||
app = modal.App("agent-sandbox")
|
||||
|
||||
@app.function()
|
||||
def run_agent_code(code: str):
|
||||
exec(code) # Isolated in Modal's container, not on your machine
|
||||
```
|
||||
|
||||
**[Daytona](https://github.com/daytonaio/daytona)** — Creates standardized development environments for agents to work in. Cold start: ~2s. Isolation: container or VM. SDK: Python, TypeScript, Go. Tags: `execution` `sandbox` `python` `typescript` `daytona`
|
||||
|
||||
Daytona is designed for persistent development environments rather than ephemeral code execution. It's a good fit when the agent needs a long-running workspace — e.g., a coding agent that needs to clone a repo, make changes, and run tests over several minutes.
|
||||
|
||||
**[CodeSandbox SDK](https://github.com/codesandbox/codesandbox-sdk)** — Provides instant, forkable cloud environments for running agent code. Cold start: ~1s. Isolation: microVM. SDK: Python, TypeScript. Tags: `execution` `sandbox` `python` `typescript`
|
||||
|
||||
CodeSandbox gives each execution a full microVM with snapshotting and forking. This is useful for agents that need to try multiple approaches — fork the sandbox, try approach A in one fork and approach B in another, then keep the one that works.
|
||||
|
||||
## When to use what
|
||||
|
||||
| Scenario | Recommended |
|
||||
|----------|-------------|
|
||||
| Run agent-generated Python snippets | E2B |
|
||||
| Agent needs GPU for ML inference | Modal |
|
||||
| Agent needs a persistent dev environment | Daytona |
|
||||
| Agent needs to try multiple approaches in parallel | CodeSandbox SDK (forking) |
|
||||
| Agent runs many short functions, need auto-scaling | Modal |
|
||||
| Cost-sensitive, high volume | Self-host with Firecracker (see below) |
|
||||
|
||||
## Self-hosting alternatives
|
||||
|
||||
If you can't use hosted sandboxes (compliance, cost, latency), consider running your own isolation layer:
|
||||
|
||||
**[Firecracker](https://github.com/firecracker-microvm/firecracker)** — The same microVM technology behind E2B and AWS Lambda. ~125ms cold start, minimal memory overhead. Requires Linux and KVM.
|
||||
|
||||
**[gVisor](https://github.com/google/gvisor)** — Google's user-space kernel that intercepts syscalls. Lighter than a full VM, compatible with OCI containers. Used by GKE Sandbox and Cloud Run.
|
||||
|
||||
**[Kata Containers](https://github.com/kata-containers/kata-containers)** — Runs standard OCI containers inside lightweight VMs. Combines container UX with VM-level isolation.
|
||||
|
|
@ -0,0 +1,112 @@
|
|||
# Serverless runtimes for agent steps
|
||||
|
||||
Serverless platforms let you run individual agent steps as functions without managing servers. Each step scales independently, you pay only for execution time, and the platform handles provisioning, scaling, and fault tolerance.
|
||||
|
||||
## Why serverless for agents
|
||||
|
||||
Not every agent step needs a persistent server. A research agent that calls a search API, processes results, and writes a summary can run each step as a serverless function. Benefits:
|
||||
|
||||
- **No idle cost**: Functions scale to zero when not in use
|
||||
- **Auto-scaling**: Handles bursts of agent tasks without capacity planning
|
||||
- **Built-in retries**: Most platforms have retry and dead-letter queue support
|
||||
- **Managed runtimes**: No OS patching, no Docker image management
|
||||
|
||||
The tradeoff is cold start latency, execution time limits, and less control over the environment.
|
||||
|
||||
## Comparison
|
||||
|
||||
| Platform | Isolation | Cold start | Max execution | Max memory | SDK languages | Notes |
|
||||
|----------|-----------|------------|--------------|------------|---------------|-------|
|
||||
| **AWS Lambda** | Firecracker microVM | 200ms-1s | 15 minutes | 10 GB | Python, TS, Go, Rust, Java | Largest ecosystem, most integrations |
|
||||
| **Google Cloud Run** | gVisor | 500ms-2s | 60 minutes | 32 GB | All (container-based) | Longer timeout, full container flexibility |
|
||||
| **Cloudflare Workers** | V8 isolate | ~0ms | 30s (free) / 5min (paid) | 128 MB | TS, Rust (WASM) | Ultra-fast, but limited runtime APIs |
|
||||
| **Azure Functions** | Hyper-V | 500ms-2s | 10 minutes (Consumption) | 1.5 GB | Python, TS, C#, Java | Deep Azure ecosystem integration |
|
||||
| **Vercel Functions** | Container | 250ms-1s | 5 minutes (Pro) | 3 GB | TS, Python, Go, Ruby | Optimized for web-facing agent endpoints |
|
||||
|
||||
## Detailed entries
|
||||
|
||||
**[AWS Lambda](https://github.com/aws/aws-lambda-python-runtime-interface-client)** — Runs agent steps as serverless functions with Firecracker isolation. Cold start: 200ms-1s. Isolation: microVM. SDK: Python, TS, Go, Rust. Tags: `execution` `sandbox` `python` `typescript`
|
||||
|
||||
Lambda is the most mature serverless platform. For agents, it works well for individual steps (search, parse, summarize) that complete in under 15 minutes. Use Step Functions to chain multiple Lambda steps into a workflow with retries and branching.
|
||||
|
||||
**[Google Cloud Run](https://github.com/GoogleCloudPlatform/cloud-run-samples)** — Runs containerized agent steps with request-based auto-scaling. Cold start: 500ms-2s. Isolation: gVisor. SDK: All. Tags: `execution` `sandbox` `python`
|
||||
|
||||
Cloud Run's 60-minute timeout and container-based model make it the best serverless option for longer-running agent tasks. Package your agent step as a Docker container, deploy it, and Cloud Run handles scaling and routing.
|
||||
|
||||
**[Cloudflare Workers](https://github.com/cloudflare/workers-sdk)** — Executes lightweight agent logic at the edge with zero cold start. Cold start: ~0ms. Isolation: V8 isolate. SDK: TypeScript, Rust (WASM). Tags: `execution` `typescript`
|
||||
|
||||
Workers have no cold start, making them ideal for latency-sensitive agent endpoints (e.g., webhook handlers, routing logic, lightweight transformations). However, the 128MB memory limit and restricted runtime APIs make them unsuitable for heavy computation.
|
||||
|
||||
**[Modal](https://github.com/modal-labs/modal-client)** — Runs serverless functions with GPU access and fast cold starts. Cold start: ~500ms. Isolation: container + gVisor. SDK: Python. Tags: `execution` `sandbox` `python` `modal`
|
||||
|
||||
Modal bridges the gap between traditional serverless and container platforms. It supports GPU workloads (useful for agents running local ML models), has faster cold starts than Lambda for custom environments, and handles dependency management automatically.
|
||||
|
||||
## Patterns for agent workflows
|
||||
|
||||
### Pattern 1: Fan-out / fan-in
|
||||
|
||||
Run multiple agent steps in parallel using serverless functions, then aggregate results.
|
||||
|
||||
```python
|
||||
# AWS Lambda + Step Functions (conceptual)
|
||||
# Fan-out: search 5 sources simultaneously
|
||||
# Fan-in: merge and rank all results
|
||||
|
||||
workflow = {
|
||||
"fan_out": {
|
||||
"type": "parallel",
|
||||
"branches": [
|
||||
{"function": "search_source_1"},
|
||||
{"function": "search_source_2"},
|
||||
{"function": "search_source_3"},
|
||||
]
|
||||
},
|
||||
"fan_in": {
|
||||
"function": "merge_and_rank",
|
||||
"input": "$fan_out.results"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Pattern 2: Event-driven agent triggers
|
||||
|
||||
Use serverless functions as event handlers that trigger agent workflows.
|
||||
|
||||
```python
|
||||
# Trigger a research agent when a new GitHub issue is labeled "needs-research"
|
||||
@app.on_event("github.issues.labeled")
|
||||
def handle_label(event):
|
||||
if event.label == "needs-research":
|
||||
research_agent.run(
|
||||
question=event.issue.title,
|
||||
context=event.issue.body,
|
||||
callback=post_comment_to_issue
|
||||
)
|
||||
```
|
||||
|
||||
### Pattern 3: Serverless tool execution
|
||||
|
||||
Run each agent tool as a separate serverless function. The orchestrator calls tools via HTTP, and each tool scales independently.
|
||||
|
||||
```
|
||||
┌──────────────┐
|
||||
│ Agent │
|
||||
│ orchestrator│
|
||||
└──────┬───────┘
|
||||
│ HTTP calls
|
||||
├──▶ /tools/search (Lambda)
|
||||
├──▶ /tools/parse-pdf (Cloud Run, needs more memory)
|
||||
├──▶ /tools/run-code (E2B, needs isolation)
|
||||
└──▶ /tools/send-email (Lambda)
|
||||
```
|
||||
|
||||
## When to use serverless vs. other options
|
||||
|
||||
| Scenario | Use serverless? | Why / why not |
|
||||
|----------|----------------|---------------|
|
||||
| Short agent steps (<15 min) | Yes | Perfect fit for Lambda |
|
||||
| Long-running agents (>15 min) | Cloud Run only | Lambda's 15-min limit is too short |
|
||||
| Agent-generated code execution | No (use E2B/Modal) | Serverless platforms aren't designed for arbitrary code |
|
||||
| High-frequency agent calls | Yes, with provisioned concurrency | Avoid cold starts with pre-warmed instances |
|
||||
| Cost-sensitive, bursty traffic | Yes | Pay only for what you use |
|
||||
| Need GPU | Modal only | Traditional serverless doesn't support GPU |
|
||||
|
|
@ -0,0 +1,237 @@
|
|||
# Self-hosted VM isolation
|
||||
|
||||
Self-hosted VM isolation lets you run agent-generated code with hardware-level security guarantees — without paying hosted sandbox per-execution fees. This is the right path when you need compliance, cost control at scale, or custom hardware (GPUs, specific CPU features).
|
||||
|
||||
## Why VM isolation over containers
|
||||
|
||||
Containers share the host kernel. A container escape vulnerability exposes your full host. For agent-generated code — which is fundamentally untrusted input — the question is not *if* something could go wrong, but *what happens when it does*.
|
||||
|
||||
| Isolation level | Kernel shared? | Escape difficulty | Overhead |
|
||||
| --------------- | -------------- | ----------------- | -------- |
|
||||
| Container (Docker) | Yes | Moderate (kernel CVEs) | ~0% |
|
||||
| Container + gVisor | Partial (syscall intercept) | Hard | ~5–15% |
|
||||
| Kata Container | No (lightweight VM) | Very hard | ~10–20% |
|
||||
| Firecracker microVM | No (full VM boundary) | Extremely hard | ~2–5% |
|
||||
|
||||
The overhead numbers are approximate and workload-dependent. For CPU-bound agent workloads, Firecracker is remarkably close to bare-metal performance.
|
||||
|
||||
---
|
||||
|
||||
## Firecracker
|
||||
|
||||
**[Firecracker](https://github.com/firecracker-microvm/firecracker)** — Lightweight microVM with ~125ms boot time, used by AWS Lambda and E2B under the hood. Tags: `sandbox` `rust` `linux`
|
||||
|
||||
Firecracker is a virtual machine monitor (VMM) built in Rust by AWS. Each microVM gets its own kernel, network interface, and block device — total isolation from the host and from other VMs. It achieves this with minimal overhead by stripping out everything a general-purpose hypervisor supports (USB, PCI, legacy devices) and keeping only what serverless workloads need.
|
||||
|
||||
### When to use Firecracker
|
||||
|
||||
- You need microVM-level isolation but can't afford hosted sandbox pricing at scale
|
||||
- You're building your own agent execution platform (like E2B does)
|
||||
- Compliance requirements prohibit sending code to third-party services
|
||||
- You need sub-200ms cold starts with strong security guarantees
|
||||
|
||||
### Requirements
|
||||
|
||||
- Linux host with KVM support (`/dev/kvm` must exist)
|
||||
- Root or sufficient privileges to create TAP interfaces
|
||||
- x86_64 or aarch64 architecture
|
||||
|
||||
### Minimal setup
|
||||
|
||||
```bash
|
||||
# Download Firecracker binary
|
||||
curl -L https://github.com/firecracker-microvm/firecracker/releases/latest/download/firecracker-v1.9.0-x86_64.tgz | tar -xz
|
||||
|
||||
# Create a minimal rootfs (Alpine Linux is ideal for agent sandboxes)
|
||||
dd if=/dev/zero of=rootfs.ext4 bs=1M count=512
|
||||
mkfs.ext4 rootfs.ext4
|
||||
mount rootfs.ext4 /mnt
|
||||
# Install your agent runtime into /mnt, then unmount
|
||||
|
||||
# Start a microVM via API
|
||||
curl --unix-socket /tmp/firecracker.socket -X PUT \
|
||||
http://localhost/machine-config \
|
||||
-d '{"vcpu_count": 1, "mem_size_mib": 256}'
|
||||
```
|
||||
|
||||
### Cold start optimization
|
||||
|
||||
```python
|
||||
# Use snapshotting to achieve ~50ms warm starts
|
||||
# 1. Boot VM once
|
||||
# 2. Take a snapshot after initialization
|
||||
# 3. Restore from snapshot for each agent invocation
|
||||
|
||||
snapshot_config = {
|
||||
"snapshot_type": "Full",
|
||||
"snapshot_path": "/snapshots/agent-base.snap",
|
||||
"mem_file_path": "/snapshots/agent-base.mem"
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## gVisor
|
||||
|
||||
**[gVisor](https://github.com/google/gvisor)** — User-space kernel that intercepts syscalls, providing VM-level security with container-level UX. Tags: `sandbox` `go` `linux`
|
||||
|
||||
gVisor implements a large subset of the Linux kernel in user space (called the Sentry). When containerized code makes a syscall, gVisor intercepts it before it reaches the host kernel. This eliminates the entire class of kernel privilege escalation attacks without the overhead of a full VM.
|
||||
|
||||
### When to use gVisor
|
||||
|
||||
- You want stronger container isolation without the operational complexity of managing VMs
|
||||
- You're already using Docker/Kubernetes and want a drop-in security upgrade
|
||||
- Your agent workload is I/O-heavy (note: gVisor has higher syscall overhead than Firecracker)
|
||||
- You need OCI compatibility (gVisor is a standard OCI runtime)
|
||||
|
||||
### Setup with Docker
|
||||
|
||||
```bash
|
||||
# Install gVisor
|
||||
curl -fsSL https://gvisor.dev/archive.key | sudo gpg --dearmor -o /usr/share/keyrings/gvisor-archive-keyring.gpg
|
||||
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/gvisor-archive-keyring.gpg] https://storage.googleapis.com/gvisor/releases release main" | sudo tee /etc/apt/sources.list.d/gvisor.list
|
||||
sudo apt-get update && sudo apt-get install -y runsc
|
||||
|
||||
# Configure Docker to use gVisor runtime
|
||||
sudo runsc install
|
||||
sudo systemctl restart docker
|
||||
|
||||
# Run agent code with gVisor isolation
|
||||
docker run --runtime=runsc agent-sandbox:latest python agent_task.py
|
||||
```
|
||||
|
||||
### Setup with Kubernetes (GKE)
|
||||
|
||||
```yaml
|
||||
# RuntimeClass for gVisor (GKE Sandbox)
|
||||
apiVersion: node.k8s.io/v1
|
||||
kind: RuntimeClass
|
||||
metadata:
|
||||
name: gvisor
|
||||
handler: runsc
|
||||
---
|
||||
# Agent Job using gVisor
|
||||
apiVersion: batch/v1
|
||||
kind: Job
|
||||
metadata:
|
||||
name: agent-task
|
||||
spec:
|
||||
template:
|
||||
spec:
|
||||
runtimeClassName: gvisor
|
||||
containers:
|
||||
- name: agent
|
||||
image: agent-sandbox:latest
|
||||
resources:
|
||||
limits:
|
||||
memory: "512Mi"
|
||||
cpu: "1"
|
||||
```
|
||||
|
||||
### Performance characteristics
|
||||
|
||||
| Workload type | gVisor overhead vs. native |
|
||||
| ------------- | -------------------------- |
|
||||
| CPU-bound (matrix ops) | ~5% |
|
||||
| Memory-bound | ~10% |
|
||||
| I/O-bound (file reads) | ~15–25% |
|
||||
| Syscall-heavy (many small files) | ~30–50% |
|
||||
|
||||
For agent tasks that are primarily LLM API calls + light Python computation, gVisor overhead is negligible.
|
||||
|
||||
---
|
||||
|
||||
## Kata Containers
|
||||
|
||||
**[Kata Containers](https://github.com/kata-containers/kata-containers)** — Runs standard OCI containers inside lightweight VMs, combining VM security with container UX. Tags: `sandbox` `go` `linux`
|
||||
|
||||
Kata Containers wraps each OCI container in a lightweight VM (using QEMU, Cloud Hypervisor, or Firecracker as the VMM). From the developer's perspective, it looks like Docker. From the security perspective, it's a VM boundary.
|
||||
|
||||
### When to use Kata Containers
|
||||
|
||||
- You need full VM isolation but want to keep your existing Docker/Kubernetes workflows
|
||||
- You're building a multi-tenant agent platform where different customers' agents must be isolated from each other
|
||||
- You need OCI runtime compatibility with VM-level security
|
||||
|
||||
### Setup
|
||||
|
||||
```bash
|
||||
# Install Kata Containers
|
||||
bash -c "$(curl -fsSL https://raw.githubusercontent.com/kata-containers/kata-containers/main/utils/kata-manager.sh) install-packages"
|
||||
|
||||
# Configure containerd to use Kata
|
||||
sudo kata-runtime kata-check # Verify prerequisites
|
||||
|
||||
# Run with Kata
|
||||
docker run --runtime=kata-runtime agent-sandbox:latest python task.py
|
||||
|
||||
# Or with containerd
|
||||
ctr run --runtime=io.containerd.kata.v2 docker.io/library/python:3.12 agent-task python -c "print('isolated')"
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Comparison and decision guide
|
||||
|
||||
```
|
||||
Start here: What's your threat model?
|
||||
│
|
||||
├── Agent runs YOUR code (orchestration, not untrusted execution)
|
||||
│ └── Standard containers (Docker/Podman) are sufficient
|
||||
│
|
||||
├── Agent runs code it generates (untrusted execution)
|
||||
│ ├── Need OCI compatibility + easy ops? → gVisor (drop-in Docker runtime)
|
||||
│ ├── Need full VM boundary + fast cold start? → Firecracker
|
||||
│ ├── Need VM security + existing K8s workflows? → Kata Containers
|
||||
│ └── Don't want to self-manage? → E2B (hosted Firecracker)
|
||||
│
|
||||
└── Multi-tenant (different users' agents on same host)
|
||||
├── Low trust between tenants → Firecracker (strongest isolation)
|
||||
└── Medium trust (same org, different teams) → Kata Containers
|
||||
```
|
||||
|
||||
### Summary table
|
||||
|
||||
| Tool | Isolation | Cold start | OCI compatible | Managed option | Best for |
|
||||
| ---- | --------- | ---------- | -------------- | -------------- | -------- |
|
||||
| Firecracker | microVM | ~125ms | No (own API) | E2B, Modal | High-throughput agent sandboxes |
|
||||
| gVisor | Syscall intercept | ~200ms | Yes | GKE Sandbox | Drop-in Docker security upgrade |
|
||||
| Kata Containers | VM-wrapped container | ~1s | Yes | Azure Container Instances | K8s clusters needing VM isolation |
|
||||
|
||||
---
|
||||
|
||||
## Operational considerations
|
||||
|
||||
### Monitoring
|
||||
|
||||
All three solutions expose standard metrics. Use Prometheus + Grafana to track:
|
||||
- VM boot time (p50, p95, p99)
|
||||
- Execution time per agent task
|
||||
- Memory usage and OOM events
|
||||
- Failed sandbox launches
|
||||
|
||||
### Networking
|
||||
|
||||
By default, give agent sandboxes **no network access**. If the agent needs to make HTTP calls, use a controlled egress proxy that only allows whitelisted domains.
|
||||
|
||||
```yaml
|
||||
# Firecracker: set network to none unless needed
|
||||
# gVisor: use --network=none Docker flag
|
||||
# Kata: use NetworkPolicy in Kubernetes
|
||||
docker run --runtime=runsc --network=none agent-sandbox:latest python task.py
|
||||
```
|
||||
|
||||
### Storage
|
||||
|
||||
Agent sandboxes should have **ephemeral, size-limited storage**. Persistent storage is a security risk — previous agent runs could leave malicious files.
|
||||
|
||||
```bash
|
||||
# Limit tmpfs for gVisor containers
|
||||
docker run --runtime=runsc --tmpfs /tmp:size=100m agent-sandbox:latest
|
||||
```
|
||||
|
||||
## Related pages
|
||||
|
||||
- [Hosted sandboxes](sandboxes.md) — For managed alternatives (E2B, Modal, Daytona)
|
||||
- [Container patterns](containers.md) — For container-only isolation without VM overhead
|
||||
- [Serverless runtimes](serverless.md) — For Lambda, Cloud Run, and Cloudflare Workers
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 565 KiB |
|
|
@ -0,0 +1,13 @@
|
|||
{
|
||||
"name": "awesome-ai-agents",
|
||||
"version": "0.0.0",
|
||||
"lockfileVersion": 3,
|
||||
"requires": true,
|
||||
"packages": {
|
||||
"": {
|
||||
"name": "awesome-ai-agents",
|
||||
"version": "0.0.0",
|
||||
"license": "CC0-1.0"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
{
|
||||
"name": "awesome-ai-agents",
|
||||
"version": "0.0.0",
|
||||
"description": "Awesome list of AI agent frameworks, tools and resources",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/ARUNAGIRINATHAN-K/awesome-ai-agents.git"
|
||||
},
|
||||
"license": "CC0-1.0"
|
||||
}
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
# Agentic patterns
|
||||
|
||||
This directory contains in-depth explanations of common design patterns used in agentic workflows. Each pattern answers: _when should I use this, how does it work, and what can go wrong?_
|
||||
|
||||
## Patterns
|
||||
|
||||
| Pattern | What it does | When to use |
|
||||
|---------|-------------|-------------|
|
||||
| [ReAct](react-pattern.md) | Interleaves reasoning and tool use in a loop | Single-agent tasks needing real-time tool interaction |
|
||||
| [Plan-and-execute](plan-and-execute.md) | Plans all steps upfront, then executes them | Complex tasks with clear decomposition |
|
||||
| [Reflection loop](reflection-loop.md) | Agent critiques and improves its own output | Tasks where output quality matters more than speed |
|
||||
| [Multi-agent](multi-agent.md) | Multiple specialized agents collaborate | Problems requiring diverse expertise or parallel work |
|
||||
|
||||
## How to pick a pattern
|
||||
|
||||
```
|
||||
Start here: How complex is the task?
|
||||
│
|
||||
├── Simple (1-3 steps, one tool)
|
||||
│ └── Direct prompting — no pattern needed
|
||||
│
|
||||
├── Medium (3-10 steps, multiple tools)
|
||||
│ ├── Steps depend on tool outputs? → ReAct
|
||||
│ └── Steps can be planned upfront? → Plan-and-execute
|
||||
│
|
||||
├── Complex (10+ steps, multi-faceted)
|
||||
│ ├── Single domain, needs iteration? → Reflection loop
|
||||
│ └── Multiple domains, needs diverse expertise? → Multi-agent
|
||||
│
|
||||
└── Uncertain (don't know which approach will work)
|
||||
└── Start with ReAct, add reflection if quality is low,
|
||||
split into multi-agent if scope is too broad
|
||||
```
|
||||
|
||||
## Combining patterns
|
||||
|
||||
These patterns aren't mutually exclusive. Production systems often combine them:
|
||||
|
||||
- **ReAct + Reflection**: Run a ReAct loop, then reflect on the final output and iterate
|
||||
- **Plan-and-execute + ReAct**: Plan the overall steps, then use ReAct for each individual step
|
||||
- **Multi-agent + Reflection**: Each agent uses reflection internally, a meta-agent reviews the combined output
|
||||
- **Plan-and-execute + Multi-agent**: Plan the overall approach, assign steps to different specialized agents
|
||||
|
|
@ -0,0 +1,186 @@
|
|||
# Multi-agent collaboration pattern
|
||||
|
||||
In the multi-agent pattern, multiple specialized agents collaborate to solve a problem that's too broad or complex for a single agent. Each agent has a focused role, its own system prompt, and potentially its own set of tools. A coordinator (human, LLM, or rule-based router) manages communication between agents.
|
||||
|
||||
This pattern is inspired by organizational design: just as a company has specialists (researcher, developer, reviewer), a multi-agent system assigns roles to maximize the quality of each sub-task.
|
||||
|
||||
## How it works
|
||||
|
||||
```
|
||||
┌──────────────┐
|
||||
│ COORDINATOR │
|
||||
│ (router / │
|
||||
│ orchestrator)│
|
||||
└──────┬───────┘
|
||||
│
|
||||
┌────────────┼────────────┐
|
||||
│ │ │
|
||||
┌──────▼─────┐ ┌───▼──────┐ ┌──▼──────────┐
|
||||
│ RESEARCHER │ │ CODER │ │ REVIEWER │
|
||||
│ │ │ │ │ │
|
||||
│ Tools: │ │ Tools: │ │ Tools: │
|
||||
│ - search │ │ - editor │ │ - linter │
|
||||
│ - reader │ │ - runner │ │ - test runner│
|
||||
│ - memory │ │ - git │ │ - formatter │
|
||||
└────────────┘ └──────────┘ └──────────────┘
|
||||
```
|
||||
|
||||
### Communication topologies
|
||||
|
||||
| Topology | How agents communicate | Best for |
|
||||
|----------|----------------------|----------|
|
||||
| **Star (centralized)** | All agents talk through a coordinator | Clear hierarchy, simple routing |
|
||||
| **Chain (sequential)** | Agent A → Agent B → Agent C | Pipeline workflows (research → write → review) |
|
||||
| **Mesh (peer-to-peer)** | Any agent can message any other agent | Debate, brainstorming, collaborative problem-solving |
|
||||
| **Hierarchical** | Manager agents delegate to worker agents | Complex orgs with multiple teams |
|
||||
|
||||
## Python pseudocode
|
||||
|
||||
```python
|
||||
def multi_agent_system(task: str, max_rounds: int = 10):
|
||||
# Define agents with different roles and tools
|
||||
researcher = Agent(
|
||||
role="researcher",
|
||||
system_prompt="You research topics thoroughly using search tools.",
|
||||
tools=[search, read_url, memory_store],
|
||||
)
|
||||
coder = Agent(
|
||||
role="coder",
|
||||
system_prompt="You write clean, tested code based on requirements.",
|
||||
tools=[code_editor, sandbox, git],
|
||||
)
|
||||
reviewer = Agent(
|
||||
role="reviewer",
|
||||
system_prompt="You review code for bugs, style, and correctness.",
|
||||
tools=[linter, test_runner],
|
||||
)
|
||||
coordinator = Agent(
|
||||
role="coordinator",
|
||||
system_prompt="You break down tasks and assign them to the right agent.",
|
||||
tools=[],
|
||||
)
|
||||
|
||||
# Coordinator creates a plan and assigns work
|
||||
assignments = coordinator.plan(task)
|
||||
# assignments = [
|
||||
# {"agent": "researcher", "task": "Find best practices for X"},
|
||||
# {"agent": "coder", "task": "Implement X based on research"},
|
||||
# {"agent": "reviewer", "task": "Review the implementation"},
|
||||
# ]
|
||||
|
||||
context = {}
|
||||
for assignment in assignments:
|
||||
agent = get_agent(assignment["agent"])
|
||||
result = agent.execute(
|
||||
task=assignment["task"],
|
||||
context=context, # Previous agents' results
|
||||
)
|
||||
context[assignment["agent"]] = result
|
||||
|
||||
return context
|
||||
|
||||
|
||||
# Variation: Debate topology
|
||||
def multi_agent_debate(question: str, num_rounds: int = 3):
|
||||
agents = [
|
||||
Agent(role="advocate", system_prompt="Argue FOR the position."),
|
||||
Agent(role="critic", system_prompt="Argue AGAINST the position."),
|
||||
Agent(role="synthesizer", system_prompt="Find the truth between positions."),
|
||||
]
|
||||
|
||||
debate_history = []
|
||||
for round in range(num_rounds):
|
||||
for agent in agents:
|
||||
response = agent.respond(question, debate_history)
|
||||
debate_history.append({"agent": agent.role, "content": response})
|
||||
|
||||
# Final synthesis
|
||||
return agents[2].synthesize(debate_history)
|
||||
```
|
||||
|
||||
## Real libraries that implement multi-agent
|
||||
|
||||
| Library | How it implements multi-agent | Language |
|
||||
|---------|------------------------------|----------|
|
||||
| **[CrewAI](https://github.com/crewAIInc/crewAI)** | Role-based agents with sequential or hierarchical process | Python |
|
||||
| **[AutoGen](https://github.com/microsoft/autogen)** | `GroupChat` with multiple `AssistantAgent` instances | Python |
|
||||
| **[LangGraph](https://github.com/langchain-ai/langgraph)** | Multi-agent graphs with supervisor or swarm patterns | Python, TS |
|
||||
| **[Agency Swarm](https://github.com/VRSEN/agency-swarm)** | OpenAI Assistants–based multi-agent orchestration | Python |
|
||||
| **[Swarm](https://github.com/openai/swarm)** | Lightweight multi-agent handoff framework from OpenAI | Python |
|
||||
| **[MetaGPT](https://github.com/geekan/MetaGPT)** | Software company simulation with PM, architect, and engineer roles | Python |
|
||||
|
||||
## When to use multi-agent vs. other patterns
|
||||
|
||||
| Factor | Multi-agent | Single agent (ReAct) | Plan-and-execute |
|
||||
|--------|------------|---------------------|-----------------|
|
||||
| Task breadth | Wide (needs diverse expertise) | Narrow to medium | Medium to wide |
|
||||
| Cost | Highest (N agents × M steps) | Medium | Lower |
|
||||
| Complexity | High (communication overhead) | Low | Medium |
|
||||
| Parallelism | Natural (agents work in parallel) | None | Some (independent steps) |
|
||||
| Debugging | Hard (trace across agents) | Easy (single trace) | Medium |
|
||||
| Best for | Complex projects, diverse tasks | Focused tasks | Structured pipelines |
|
||||
|
||||
**Use multi-agent when**:
|
||||
- The task genuinely requires different expertise (research + coding + review)
|
||||
- Parallel execution would significantly reduce total time
|
||||
- You want separation of concerns (each agent has focused, testable behavior)
|
||||
- Different sub-tasks need different tools or different models
|
||||
|
||||
**Don't use multi-agent when**:
|
||||
- A single agent with the right tools can handle it (most tasks)
|
||||
- The communication overhead outweighs the benefit
|
||||
- Debugging and observability are critical (multi-agent is harder to trace)
|
||||
- Budget is limited (N agents means N× the cost)
|
||||
|
||||
## Common failure modes and fixes
|
||||
|
||||
### 1. Agent role confusion
|
||||
|
||||
**Symptom**: Agents step on each other's toes — the researcher writes code, the coder does research.
|
||||
|
||||
**Fix**: Make role boundaries explicit in system prompts. List what each agent should and should NOT do. Restrict tool access per agent.
|
||||
|
||||
```python
|
||||
researcher = Agent(
|
||||
system_prompt="""You are a researcher. You ONLY search and summarize.
|
||||
You do NOT write code, make decisions, or produce final outputs.
|
||||
If a task requires coding, say 'This task should be assigned to the coder.'""",
|
||||
tools=[search, read_url], # No code tools
|
||||
)
|
||||
```
|
||||
|
||||
### 2. Communication overload
|
||||
|
||||
**Symptom**: Agents produce long messages that other agents struggle to process.
|
||||
|
||||
**Fix**: Enforce output structure and length limits. Use schemas for inter-agent messages.
|
||||
|
||||
### 3. Coordinator bottleneck
|
||||
|
||||
**Symptom**: The coordinator makes bad routing decisions, sending tasks to the wrong agent.
|
||||
|
||||
**Fix**: Use rule-based routing for clear cases, LLM routing only for ambiguous cases. Include examples of correct routing in the coordinator's prompt.
|
||||
|
||||
### 4. Infinite delegation loops
|
||||
|
||||
**Symptom**: Agent A delegates to Agent B, who delegates back to Agent A.
|
||||
|
||||
**Fix**: Track delegation chains. If an agent receives a task it already delegated, force it to handle it directly.
|
||||
|
||||
### 5. Context loss between agents
|
||||
|
||||
**Symptom**: Agent B doesn't have the context it needs from Agent A's work.
|
||||
|
||||
**Fix**: Use a shared context object or memory store that all agents can read and write. Alternatively, include relevant summaries when passing tasks between agents.
|
||||
|
||||
## Design guidelines
|
||||
|
||||
1. **Start with one agent.** Only add agents when you've identified a clear bottleneck or role boundary. Most tasks don't need multi-agent.
|
||||
|
||||
2. **Minimize communication surface.** Each inter-agent message is a potential failure point. Prefer sequential handoffs over mesh topologies.
|
||||
|
||||
3. **Give each agent the minimum tools it needs.** A reviewer with write access defeats the purpose of having a reviewer.
|
||||
|
||||
4. **Make agents independently testable.** Each agent should work correctly in isolation before you wire them together.
|
||||
|
||||
5. **Add observability from day one.** Log every message, every tool call, every handoff. Multi-agent debugging without logs is miserable.
|
||||
|
|
@ -0,0 +1,160 @@
|
|||
# Plan-and-execute pattern
|
||||
|
||||
Plan-and-execute separates **planning** (deciding what to do) from **execution** (doing it). First, the agent generates a complete plan — a sequence of steps with dependencies. Then, a separate execution loop carries out each step. If a step fails, the planner re-plans from the current state.
|
||||
|
||||
This pattern was formalized in [Plan-and-Solve Prompting](https://arxiv.org/abs/2305.04091) (Wang et al., 2023) and is the default architecture in many production agent systems.
|
||||
|
||||
## How it works
|
||||
|
||||
```
|
||||
┌──────────────────────────────────────────────────────┐
|
||||
│ │
|
||||
│ ┌──────────┐ ┌──────────────────────────────┐ │
|
||||
│ │ PLANNER │────▶│ Step 1: Search for X │ │
|
||||
│ │ (LLM) │ │ Step 2: Parse results │ │
|
||||
│ │ │ │ Step 3: Analyze data │ │
|
||||
│ │ │ │ Step 4: Write report │ │
|
||||
│ └──────────┘ └──────────────┬───────────────┘ │
|
||||
│ │ │
|
||||
│ ┌──────────────────────────────▼───────────────┐ │
|
||||
│ │ EXECUTOR │ │
|
||||
│ │ │ │
|
||||
│ │ Step 1: ✅ Done → result_1 │ │
|
||||
│ │ Step 2: ✅ Done → result_2 │ │
|
||||
│ │ Step 3: ❌ Failed → error │ │
|
||||
│ │ │ │
|
||||
│ └──────────────────────────────┬───────────────┘ │
|
||||
│ │ │
|
||||
│ ┌──────────────────────────────▼───────────────┐ │
|
||||
│ │ RE-PLANNER │ │
|
||||
│ │ "Step 3 failed because... New plan: │ │
|
||||
│ │ Step 3b: Try alternative approach │ │
|
||||
│ │ Step 4: Write report (unchanged)" │ │
|
||||
│ └──────────────────────────────────────────────┘ │
|
||||
│ │
|
||||
└──────────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
The key insight is that **planning and execution use different LLM calls** (and potentially different models). The planner can use a stronger model (GPT-4, Claude) for better reasoning, while the executor can use a faster model for routine tool calls.
|
||||
|
||||
## Python pseudocode
|
||||
|
||||
```python
|
||||
def plan_and_execute(task: str, tools: list, max_replans: int = 3):
|
||||
# Phase 1: Plan
|
||||
plan = planner_llm.generate_plan(task)
|
||||
# plan = [
|
||||
# {"step": 1, "action": "search", "input": "...", "depends_on": []},
|
||||
# {"step": 2, "action": "parse", "input": "$1.output", "depends_on": [1]},
|
||||
# {"step": 3, "action": "analyze","input": "$2.output", "depends_on": [2]},
|
||||
# ]
|
||||
|
||||
results = {}
|
||||
replans = 0
|
||||
|
||||
while plan:
|
||||
step = plan.pop(0)
|
||||
|
||||
# Resolve dependencies
|
||||
resolved_input = resolve_refs(step["input"], results)
|
||||
|
||||
# Execute
|
||||
try:
|
||||
result = execute_tool(step["action"], resolved_input)
|
||||
results[step["step"]] = result
|
||||
except Exception as e:
|
||||
if replans >= max_replans:
|
||||
return f"Failed after {max_replans} re-plans: {e}"
|
||||
|
||||
# Re-plan from current state
|
||||
remaining_steps = plan
|
||||
new_plan = planner_llm.replan(
|
||||
original_task=task,
|
||||
completed=results,
|
||||
failed_step=step,
|
||||
error=str(e),
|
||||
remaining=remaining_steps,
|
||||
)
|
||||
plan = new_plan
|
||||
replans += 1
|
||||
|
||||
# Generate final answer from all results
|
||||
return planner_llm.synthesize(task, results)
|
||||
|
||||
|
||||
def resolve_refs(input_str: str, results: dict) -> str:
|
||||
"""Replace $N.output references with actual results."""
|
||||
for step_num, result in results.items():
|
||||
input_str = input_str.replace(f"${step_num}.output", str(result))
|
||||
return input_str
|
||||
```
|
||||
|
||||
## Real libraries that implement plan-and-execute
|
||||
|
||||
| Library | How it implements plan-and-execute | Language |
|
||||
|---------|----------------------------------|----------|
|
||||
| **[LangGraph](https://github.com/langchain-ai/langgraph)** | Custom graph with planner node + executor nodes + re-planner node | Python, TS |
|
||||
| **[CrewAI](https://github.com/crewAIInc/crewAI)** | `Process.sequential` with task dependencies and delegation | Python |
|
||||
| **[AutoGen](https://github.com/microsoft/autogen)** | `GroupChat` with a planner agent orchestrating executor agents | Python |
|
||||
| **[Semantic Kernel](https://github.com/microsoft/semantic-kernel)** | `Planner` class generates and executes step-by-step plans | Python, C# |
|
||||
| **[DSPy](https://github.com/stanfordnlp/dspy)** | Optimized multi-step pipelines with automatic prompt tuning | Python |
|
||||
|
||||
## When to use plan-and-execute vs. other patterns
|
||||
|
||||
| Factor | Plan-and-execute | ReAct | Reflection |
|
||||
|--------|-----------------|-------|------------|
|
||||
| Planning overhead | One LLM call upfront | None (implicit) | None |
|
||||
| Adaptability | Re-plan on failure | Naturally adaptive | Iterates on output |
|
||||
| Parallelism | Steps without dependencies can run in parallel | Strictly sequential | Sequential |
|
||||
| Cost | Lower (fewer LLM calls total) | Higher (LLM call per step) | 2x base cost |
|
||||
| Best for | Multi-step tasks with clear structure | Exploratory, tool-heavy tasks | Quality-focused tasks |
|
||||
|
||||
**Use plan-and-execute when**:
|
||||
- The task has 5+ steps that can be identified upfront
|
||||
- Some steps can run in parallel (fan-out)
|
||||
- You want to use a cheaper model for execution
|
||||
- The task structure is similar to previous tasks (plan templates)
|
||||
|
||||
**Don't use plan-and-execute when**:
|
||||
- You don't know what steps are needed until you start
|
||||
- Every step depends on the output of the previous step (use ReAct instead)
|
||||
- The task is simple enough that planning adds overhead without value
|
||||
|
||||
## Common failure modes and fixes
|
||||
|
||||
### 1. Over-detailed plans
|
||||
|
||||
**Symptom**: The planner generates 20 micro-steps for a simple task.
|
||||
|
||||
**Fix**: Instruct the planner to generate 3-7 high-level steps. Each step should be meaningful, not trivial.
|
||||
|
||||
```python
|
||||
PLANNER_PROMPT = """Generate a plan with 3-7 steps.
|
||||
Each step should represent a meaningful unit of work, not a trivial action.
|
||||
Bad: "Step 1: Open browser. Step 2: Type URL. Step 3: Press Enter."
|
||||
Good: "Step 1: Navigate to the pricing page and extract plan details." """
|
||||
```
|
||||
|
||||
### 2. Rigid plans that don't survive execution
|
||||
|
||||
**Symptom**: Step 3 assumes step 2 returns data in a specific format, but it doesn't.
|
||||
|
||||
**Fix**: Make the re-planner robust. After each step, check whether the remaining plan still makes sense given the actual output. Re-plan early, not just on failure.
|
||||
|
||||
### 3. Context loss between planner and executor
|
||||
|
||||
**Symptom**: The executor doesn't understand why a step is needed or what exactly to do.
|
||||
|
||||
**Fix**: Include context in each step — not just "search for X" but "search for X because we need to find Y for the final report."
|
||||
|
||||
### 4. Parallel steps with subtle dependencies
|
||||
|
||||
**Symptom**: Steps 2 and 3 are marked as independent, but step 3 actually needs step 2's output.
|
||||
|
||||
**Fix**: Have the planner explicitly list dependencies for each step. Only run steps in parallel if their dependency lists don't overlap.
|
||||
|
||||
### 5. Re-planning loops
|
||||
|
||||
**Symptom**: The re-planner keeps generating plans that fail in the same way.
|
||||
|
||||
**Fix**: Pass the history of failed plans to the re-planner. Set a max re-plan count. After N failures, escalate to a human or try a fundamentally different approach.
|
||||
|
|
@ -0,0 +1,151 @@
|
|||
# ReAct pattern (Reasoning + Acting)
|
||||
|
||||
ReAct is the most fundamental agentic pattern. The agent alternates between **thinking** (reasoning about what to do next) and **acting** (calling a tool), using the observation from each action to inform the next thought. It was introduced in the paper [ReAct: Synergizing Reasoning and Acting in Language Models](https://arxiv.org/abs/2210.03629) (Yao et al., 2022).
|
||||
|
||||
## How it works
|
||||
|
||||
The ReAct loop has three phases that repeat until the task is complete:
|
||||
|
||||
```
|
||||
┌──────────────────────────────────────────────────┐
|
||||
│ │
|
||||
│ ┌──────────┐ │
|
||||
│ │ THOUGHT │ "I need to find the population │
|
||||
│ │ │ of Tokyo. Let me search." │
|
||||
│ └────┬─────┘ │
|
||||
│ │ │
|
||||
│ ┌────▼─────┐ │
|
||||
│ │ ACTION │ search("Tokyo population 2024") │
|
||||
│ │ │ │
|
||||
│ └────┬─────┘ │
|
||||
│ │ │
|
||||
│ ┌────▼──────────┐ │
|
||||
│ │ OBSERVATION │ "Tokyo metro: 13.96M..." │
|
||||
│ │ │ │
|
||||
│ └────┬──────────┘ │
|
||||
│ │ │
|
||||
│ └──── Loop back to THOUGHT ───────────────┘
|
||||
```
|
||||
|
||||
1. **Thought**: The LLM reasons about the current state and decides what to do next. This is generated as text (often in a structured format).
|
||||
2. **Action**: The LLM calls a tool — search, calculate, read a file, run code, etc.
|
||||
3. **Observation**: The tool returns a result. This result is appended to the conversation, and the LLM generates the next thought.
|
||||
|
||||
The loop terminates when the LLM decides it has enough information to answer, or when a maximum iteration count is reached.
|
||||
|
||||
## Python pseudocode
|
||||
|
||||
```python
|
||||
def react_agent(question: str, tools: list, max_steps: int = 10):
|
||||
messages = [
|
||||
{"role": "system", "content": REACT_SYSTEM_PROMPT},
|
||||
{"role": "user", "content": question},
|
||||
]
|
||||
|
||||
for step in range(max_steps):
|
||||
# THOUGHT + ACTION: LLM decides what to do
|
||||
response = llm.chat(messages, tools=tools)
|
||||
|
||||
if response.is_final_answer:
|
||||
return response.content
|
||||
|
||||
# ACTION: Execute the tool call
|
||||
tool_name = response.tool_call.name
|
||||
tool_args = response.tool_call.arguments
|
||||
observation = execute_tool(tool_name, tool_args)
|
||||
|
||||
# OBSERVATION: Append result and continue
|
||||
messages.append({"role": "assistant", "content": response.content})
|
||||
messages.append({"role": "tool", "content": observation})
|
||||
|
||||
return "Max steps reached without a final answer"
|
||||
|
||||
|
||||
REACT_SYSTEM_PROMPT = """You are a helpful agent. For each step:
|
||||
1. Think about what you need to do next
|
||||
2. Call a tool if needed
|
||||
3. Use the tool's result to inform your next step
|
||||
4. When you have the final answer, respond directly
|
||||
|
||||
Always explain your reasoning before taking an action."""
|
||||
```
|
||||
|
||||
## Real libraries that implement ReAct
|
||||
|
||||
| Library | How it implements ReAct | Language |
|
||||
|---------|----------------------|----------|
|
||||
| **[LangGraph](https://github.com/langchain-ai/langgraph)** | `create_react_agent()` — built-in ReAct graph with tool nodes | Python, TS |
|
||||
| **[Pydantic AI](https://github.com/pydantic/pydantic-ai)** | Default agent loop uses ReAct under the hood | Python |
|
||||
| **[LangChain](https://github.com/langchain-ai/langchain)** | `AgentExecutor` with ReAct prompt template | Python, TS |
|
||||
| **[Semantic Kernel](https://github.com/microsoft/semantic-kernel)** | `AutoFunctionCallingFilter` for tool use loops | Python, C# |
|
||||
| **[AutoGen](https://github.com/microsoft/autogen)** | `AssistantAgent` with tool registration | Python |
|
||||
|
||||
## When to use ReAct vs. plan-and-execute
|
||||
|
||||
| Factor | ReAct | Plan-and-execute |
|
||||
|--------|-------|-----------------|
|
||||
| Task structure | Unclear, exploratory | Clear, decomposable |
|
||||
| Tool dependency | Each step depends on previous result | Steps can be planned upfront |
|
||||
| Latency | Higher (sequential LLM calls) | Lower (plan once, execute fast) |
|
||||
| Error recovery | Natural — just reason about the error | Requires explicit re-planning |
|
||||
| Best for | Q&A, research, debugging | Multi-file code changes, data pipelines |
|
||||
|
||||
**Use ReAct when** you don't know upfront what tools you'll need or in what order. The agent discovers the path as it goes.
|
||||
|
||||
**Use plan-and-execute when** the task has a clear structure that can be decomposed before execution begins.
|
||||
|
||||
## Common failure modes and fixes
|
||||
|
||||
### 1. Infinite loops
|
||||
|
||||
**Symptom**: The agent repeats the same tool call over and over.
|
||||
|
||||
**Cause**: The observation doesn't provide enough new information to change the agent's reasoning.
|
||||
|
||||
**Fix**: Track previous actions and observations. If the same action is repeated, force the agent to try a different approach or terminate.
|
||||
|
||||
```python
|
||||
if (tool_name, tool_args) in previous_actions:
|
||||
messages.append({
|
||||
"role": "system",
|
||||
"content": "You already tried this action. Try a different approach."
|
||||
})
|
||||
```
|
||||
|
||||
### 2. Premature termination
|
||||
|
||||
**Symptom**: The agent gives a final answer after just one tool call, even when the answer is incomplete.
|
||||
|
||||
**Cause**: The LLM is biased toward giving answers quickly, or the system prompt doesn't emphasize thoroughness.
|
||||
|
||||
**Fix**: Add explicit instructions to verify the answer before finalizing. Include a "confidence check" step.
|
||||
|
||||
### 3. Tool selection errors
|
||||
|
||||
**Symptom**: The agent calls the wrong tool for the task (e.g., using a calculator when it should search).
|
||||
|
||||
**Cause**: Tool descriptions are ambiguous, or there are too many tools (>15) for the LLM to differentiate.
|
||||
|
||||
**Fix**: Write clear, non-overlapping tool descriptions. If you have many tools, use a two-stage approach: first select the relevant tool category, then select the specific tool.
|
||||
|
||||
### 4. Observation overflow
|
||||
|
||||
**Symptom**: Tool returns too much text, filling the context window and causing the agent to lose track.
|
||||
|
||||
**Cause**: Tool returns full web pages, large files, or verbose API responses.
|
||||
|
||||
**Fix**: Truncate or summarize tool observations before appending them. A search result doesn't need the full page — a 500-character snippet is usually enough.
|
||||
|
||||
```python
|
||||
observation = execute_tool(tool_name, tool_args)
|
||||
if len(observation) > 2000:
|
||||
observation = llm.summarize(observation, max_tokens=500)
|
||||
```
|
||||
|
||||
### 5. Reasoning quality degradation
|
||||
|
||||
**Symptom**: The agent's reasoning gets worse as the conversation gets longer.
|
||||
|
||||
**Cause**: The context window fills up with previous thoughts, actions, and observations. The signal-to-noise ratio drops.
|
||||
|
||||
**Fix**: Periodically summarize the conversation history, keeping only the most relevant information. Or use a sliding window that keeps the last N steps plus a compressed summary of earlier steps.
|
||||
|
|
@ -0,0 +1,195 @@
|
|||
# Reflection loop pattern
|
||||
|
||||
The reflection loop is an iterative pattern where an agent generates an output, then **critiques its own output**, and then **revises** the output based on the critique. This cycle repeats until the output meets a quality threshold or a maximum iteration count is reached.
|
||||
|
||||
This pattern is inspired by [Reflexion (Shinn et al., 2023)](https://arxiv.org/abs/2303.11366) and is one of the simplest ways to improve agent output quality without changing the underlying model.
|
||||
|
||||
## How it works
|
||||
|
||||
```
|
||||
┌──────────────────────────────────────────────────────┐
|
||||
│ │
|
||||
│ ┌──────────────┐ │
|
||||
│ │ GENERATE │ Produce initial output │
|
||||
│ │ │ (draft, code, analysis, etc.) │
|
||||
│ └──────┬───────┘ │
|
||||
│ │ │
|
||||
│ ┌──────▼───────┐ │
|
||||
│ │ CRITIQUE │ Evaluate the output against │
|
||||
│ │ │ criteria: correctness, quality, │
|
||||
│ │ │ completeness, style │
|
||||
│ └──────┬───────┘ │
|
||||
│ │ │
|
||||
│ ├──── Good enough? ──── Yes ──▶ Return │
|
||||
│ │ │
|
||||
│ No │
|
||||
│ │ │
|
||||
│ ┌──────▼───────┐ │
|
||||
│ │ REVISE │ Improve the output based on │
|
||||
│ │ │ the specific critique │
|
||||
│ └──────┬───────┘ │
|
||||
│ │ │
|
||||
│ └──── Loop back to CRITIQUE ────────────────┘
|
||||
│ │
|
||||
└──────────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
The power of reflection comes from separation of concerns. The generator focuses on producing output; the critic focuses on finding flaws. This division often catches errors that a single pass would miss.
|
||||
|
||||
## Python pseudocode
|
||||
|
||||
```python
|
||||
def reflection_agent(
|
||||
task: str,
|
||||
max_iterations: int = 3,
|
||||
quality_threshold: float = 0.8,
|
||||
):
|
||||
# Step 1: Generate initial output
|
||||
output = generator_llm.generate(task)
|
||||
|
||||
for iteration in range(max_iterations):
|
||||
# Step 2: Critique
|
||||
critique = critic_llm.evaluate(
|
||||
task=task,
|
||||
output=output,
|
||||
criteria=[
|
||||
"correctness",
|
||||
"completeness",
|
||||
"clarity",
|
||||
"follows instructions",
|
||||
],
|
||||
)
|
||||
# critique = {
|
||||
# "score": 0.6,
|
||||
# "issues": ["Missing error handling", "Unclear variable names"],
|
||||
# "suggestions": ["Add try/except around API calls", "Rename x to user_count"],
|
||||
# }
|
||||
|
||||
if critique["score"] >= quality_threshold:
|
||||
return output
|
||||
|
||||
# Step 3: Revise based on critique
|
||||
output = generator_llm.revise(
|
||||
task=task,
|
||||
current_output=output,
|
||||
critique=critique,
|
||||
)
|
||||
|
||||
return output # Return best effort after max iterations
|
||||
|
||||
|
||||
# Variation: Use different models for generator and critic
|
||||
GENERATOR_PROMPT = """Generate a {task_type} for the following task:
|
||||
{task}
|
||||
|
||||
Focus on producing a complete, working solution."""
|
||||
|
||||
CRITIC_PROMPT = """Review the following {task_type} for these criteria:
|
||||
1. Correctness: Does it work?
|
||||
2. Completeness: Does it handle edge cases?
|
||||
3. Clarity: Is it easy to understand?
|
||||
4. Style: Does it follow best practices?
|
||||
|
||||
Output a score (0-1) and a list of specific, actionable issues.
|
||||
Do NOT suggest cosmetic changes — focus on functional problems."""
|
||||
```
|
||||
|
||||
## Advanced variation: Reflection with tool use
|
||||
|
||||
Combine reflection with actual execution for a stronger feedback signal:
|
||||
|
||||
```python
|
||||
def reflection_with_execution(task: str, sandbox):
|
||||
code = generator_llm.generate_code(task)
|
||||
|
||||
for iteration in range(3):
|
||||
# Run the code and get real feedback
|
||||
result = sandbox.execute(code)
|
||||
|
||||
if result.success and passes_tests(result):
|
||||
return code
|
||||
|
||||
# Critique based on actual errors, not LLM judgment
|
||||
critique = critic_llm.analyze_failure(
|
||||
code=code,
|
||||
error=result.stderr,
|
||||
test_results=result.test_output,
|
||||
)
|
||||
|
||||
code = generator_llm.revise(code, critique)
|
||||
|
||||
return code
|
||||
```
|
||||
|
||||
This is strictly better than LLM-only reflection because the critique is grounded in real execution results, not the LLM's (potentially wrong) judgment.
|
||||
|
||||
## Real libraries that implement reflection
|
||||
|
||||
| Library | How it implements reflection | Language |
|
||||
|---------|----------------------------|----------|
|
||||
| **[LangGraph](https://github.com/langchain-ai/langgraph)** | Custom graph with generate → critique → revise cycle nodes | Python, TS |
|
||||
| **[Reflexion](https://github.com/noahshinn/reflexion)** | Reference implementation of the Reflexion paper | Python |
|
||||
| **[DSPy](https://github.com/stanfordnlp/dspy)** | `Retry` and `Assert` modules for self-correcting pipelines | Python |
|
||||
| **[AutoGen](https://github.com/microsoft/autogen)** | Critic agent reviews and requests revisions from generator agent | Python |
|
||||
| **[CrewAI](https://github.com/crewAIInc/crewAI)** | `max_iter` parameter on tasks for automatic retry with feedback | Python |
|
||||
|
||||
## When to use reflection vs. other patterns
|
||||
|
||||
| Factor | Reflection | ReAct | Plan-and-execute |
|
||||
|--------|-----------|-------|-----------------|
|
||||
| Goal | Improve output quality | Navigate uncertainty | Decompose complex tasks |
|
||||
| Cost | 2-4x base cost | 3-10x base cost | 1.5-3x base cost |
|
||||
| Latency | 2-4x base latency | Variable | Variable |
|
||||
| Best for | Writing, code gen, analysis | Research, Q&A, debugging | Multi-step pipelines |
|
||||
|
||||
**Use reflection when**:
|
||||
- Output quality is more important than speed
|
||||
- The task has objectively evaluable criteria (tests pass, facts are correct)
|
||||
- A single generation pass consistently produces "almost right" output
|
||||
- You can define what "good" looks like (criteria for the critic)
|
||||
|
||||
**Don't use reflection when**:
|
||||
- Speed matters more than quality (real-time chat)
|
||||
- The task is simple enough to get right on the first try
|
||||
- You can't define clear quality criteria
|
||||
- You're already at the model's capability ceiling (reflection won't help if the model fundamentally can't do the task)
|
||||
|
||||
## Common failure modes and fixes
|
||||
|
||||
### 1. Critique is too vague
|
||||
|
||||
**Symptom**: Critic says "could be improved" without specifics.
|
||||
|
||||
**Fix**: Constrain the critic to output structured feedback — specific issues and specific suggestions. Use a schema.
|
||||
|
||||
```python
|
||||
critique_schema = {
|
||||
"score": "float 0-1",
|
||||
"issues": ["list of specific problems"],
|
||||
"suggestions": ["list of actionable fixes"],
|
||||
}
|
||||
```
|
||||
|
||||
### 2. Oscillating revisions
|
||||
|
||||
**Symptom**: Revision 1 fixes issue A but introduces issue B. Revision 2 fixes B but re-introduces A.
|
||||
|
||||
**Fix**: Include the history of all previous critiques in the revision prompt. The agent needs to know what it already tried and why.
|
||||
|
||||
### 3. Critic agrees with everything
|
||||
|
||||
**Symptom**: Critic gives a high score to obviously flawed output.
|
||||
|
||||
**Fix**: Use a different (ideally stronger) model for the critic, or provide few-shot examples of good and bad critiques. Ground the critique in execution results when possible.
|
||||
|
||||
### 4. Diminishing returns
|
||||
|
||||
**Symptom**: After 2 iterations, quality plateaus. Further iterations are wasted compute.
|
||||
|
||||
**Fix**: Track the quality score over iterations. If the score doesn't improve by at least 0.05 between iterations, stop early.
|
||||
|
||||
### 5. Losing context across iterations
|
||||
|
||||
**Symptom**: Later revisions lose good elements from earlier versions.
|
||||
|
||||
**Fix**: Instruct the reviser to preserve what works and only change what the critic flagged. Consider diff-based revision (change only the problematic sections, not the whole output).
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
# Agent skills library
|
||||
|
||||
This directory contains detailed write-ups for each skill category that agents use to perceive, remember, plan, execute, and communicate.
|
||||
|
||||
## Categories
|
||||
|
||||
| Skill | What it covers | File |
|
||||
|-------|---------------|------|
|
||||
| **Perception** | Web browsing, vision, document parsing, OCR | [perception.md](perception.md) |
|
||||
| **Memory** | Short-term context, long-term storage, vector stores | [memory.md](memory.md) |
|
||||
| **Planning** | Task decomposition, reasoning strategies, reflection | [planning.md](planning.md) |
|
||||
| **Execution** | Code running, tool use, API calling, sandboxes | [execution.md](execution.md) |
|
||||
| **Communication** | Email, Slack, notifications, human-in-the-loop | [communication.md](communication.md) |
|
||||
|
||||
## How skills relate to each other
|
||||
|
||||
```
|
||||
┌──────────────┐
|
||||
│ Perception │ ← Agents observe the world
|
||||
└──────┬───────┘
|
||||
│
|
||||
┌──────▼───────┐
|
||||
│ Memory │ ← Agents store what they learned
|
||||
└──────┬───────┘
|
||||
│
|
||||
┌──────▼───────┐
|
||||
│ Planning │ ← Agents decide what to do next
|
||||
└──────┬───────┘
|
||||
│
|
||||
┌──────▼───────┐
|
||||
│ Execution │ ← Agents take action
|
||||
└──────┬───────┘
|
||||
│
|
||||
┌──────▼───────┐
|
||||
│Communication │ ← Agents report results
|
||||
└──────────────┘
|
||||
```
|
||||
|
||||
In practice, these aren't strictly sequential. A planning step might trigger new perception (searching for more data), and execution might update memory. The categories are a useful mental model, not a rigid pipeline.
|
||||
|
||||
## Entry format
|
||||
|
||||
Every entry in this directory follows the same template:
|
||||
|
||||
```markdown
|
||||
**[Project Name](url)** — One sentence describing what it enables an agent to do. Tags: `category` `language` `framework`
|
||||
```
|
||||
|
||||
See [CONTRIBUTING.md](../CONTRIBUTING.md) for the full tag taxonomy and submission guidelines.
|
||||
|
|
@ -0,0 +1,101 @@
|
|||
# Communication
|
||||
|
||||
Communication is the agent's ability to send messages, notifications, and reports to humans. This is the last mile of agentic workflows — an agent that researches, plans, and executes but can't report its results is useless in production.
|
||||
|
||||
## What "communication" means in an agentic context
|
||||
|
||||
Communication isn't just "send an email". In an agentic workflow, communication covers:
|
||||
|
||||
1. **Reporting results** — Sending a summary of what the agent did and found
|
||||
2. **Requesting approval** — Human-in-the-loop checkpoints before high-risk actions
|
||||
3. **Alerting on failures** — Notifying humans when the agent is stuck or encounters errors
|
||||
4. **Streaming progress** — Real-time updates during long-running workflows
|
||||
5. **Multi-channel delivery** — Different stakeholders prefer different channels (email, Slack, SMS)
|
||||
|
||||
The challenge is matching the communication channel to the urgency and audience. A weekly research digest belongs in email. A production alert belongs in PagerDuty or SMS. A status update belongs in Slack.
|
||||
|
||||
## Communication channels compared
|
||||
|
||||
| Channel | Latency | Best for | Interruption level |
|
||||
|---------|---------|----------|-------------------|
|
||||
| Email | Minutes-hours | Detailed reports, digests, approvals | Low |
|
||||
| Slack/Discord | Seconds | Team updates, interactive approvals | Medium |
|
||||
| SMS | Seconds | Urgent alerts, OTP | High |
|
||||
| Push notification | Seconds | Mobile alerts, status updates | Medium-high |
|
||||
| Webhook | Milliseconds | System-to-system, triggering downstream actions | None (automated) |
|
||||
| In-app | Seconds | Contextual updates within a product | Low-medium |
|
||||
|
||||
## Tools and libraries
|
||||
|
||||
### Multi-channel notification
|
||||
|
||||
**[Novu](https://github.com/novuhq/novu)** — Routes agent notifications across email, SMS, push, and chat from a single API. Tags: `communication` `typescript` `python`
|
||||
|
||||
**[Apprise](https://github.com/caronc/apprise)** — Sends notifications to 100+ services from a single Python interface. Tags: `communication` `python`
|
||||
|
||||
**[Ntfy](https://github.com/binwiederhier/ntfy)** — Pushes real-time notifications to phones and desktops via a simple HTTP API. Tags: `communication` `go`
|
||||
|
||||
### Email
|
||||
|
||||
**[Resend](https://github.com/resend/resend-node)** — Sends transactional emails from agents with a developer-first API. Tags: `communication` `typescript`
|
||||
|
||||
**[FastAPI-Mail](https://github.com/sabuhish/fastapi-mail)** — Adds email sending capability to FastAPI-based agent services. Tags: `communication` `python`
|
||||
|
||||
**[Mailtrap](https://github.com/railsware/mailtrap-python)** — Tests and sends emails with delivery tracking for agent workflows. Tags: `communication` `python`
|
||||
|
||||
### Chat platforms
|
||||
|
||||
**[Slack Bolt](https://github.com/slackapi/bolt-python)** — Enables agents to send, receive, and react to Slack messages. Tags: `communication` `python`
|
||||
|
||||
**[Discord.py](https://github.com/Rapptz/discord.py)** — Lets agents interact with Discord channels for team-facing communication. Tags: `communication` `python`
|
||||
|
||||
### SMS and voice
|
||||
|
||||
**[Twilio Python](https://github.com/twilio/twilio-python)** — Sends SMS and voice calls from agent workflows. Tags: `communication` `python`
|
||||
|
||||
### Human-in-the-loop
|
||||
|
||||
Most orchestration frameworks (LangGraph, CrewAI, AutoGen) have built-in human-in-the-loop support. The pattern is always the same: pause the workflow, send a message via a communication channel, wait for a human response, then resume.
|
||||
|
||||
```python
|
||||
# LangGraph example: interrupt for human approval
|
||||
from langgraph.checkpoint import MemorySaver
|
||||
|
||||
def should_approve(state):
|
||||
if state["risk_level"] == "high":
|
||||
# Agent pauses here, sends Slack message, waits
|
||||
return "request_approval"
|
||||
return "continue"
|
||||
```
|
||||
|
||||
## When to use what — decision guide
|
||||
|
||||
```
|
||||
Start here: What do you need to communicate?
|
||||
│
|
||||
├── Detailed report or digest?
|
||||
│ └── Email (Resend or FastAPI-Mail)
|
||||
│
|
||||
├── Quick team update or interactive approval?
|
||||
│ ├── Engineering team? → Slack (Bolt)
|
||||
│ └── Community? → Discord (discord.py)
|
||||
│
|
||||
├── Urgent alert requiring immediate attention?
|
||||
│ └── SMS (Twilio) or push notification (Ntfy)
|
||||
│
|
||||
├── Need to reach users across multiple channels?
|
||||
│ └── Novu (single API, multi-channel routing)
|
||||
│
|
||||
└── System-to-system notification?
|
||||
└── Webhook (no library needed, just HTTP POST)
|
||||
```
|
||||
|
||||
## Common pitfalls
|
||||
|
||||
1. **Notification fatigue.** An agent that sends a Slack message for every step will get muted. Batch updates and send summaries, not play-by-plays.
|
||||
|
||||
2. **No human-in-the-loop for high-risk actions.** Before an agent sends an email to a customer, deletes data, or spends money, require explicit approval. The cost of a 30-second delay is nothing compared to the cost of an incorrect automated action.
|
||||
|
||||
3. **Hardcoding channels.** Today the team uses Slack; tomorrow it's Teams. Abstract the notification channel behind an interface so you can swap without rewriting the agent logic.
|
||||
|
||||
4. **Missing error context.** When an agent alerts on a failure, include the full context: what it was trying to do, what went wrong, and what state it's in. "An error occurred" is useless. "Step 3/5 failed: API returned 429 rate limit, 2 retries exhausted, pausing workflow" is actionable.
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
# Execution
|
||||
|
||||
Execution is the agent's ability to take action — running code, calling APIs, interacting with external services, and modifying state in the real world. This is where agents move from "thinking" to "doing", and it's also where the highest risk lives.
|
||||
|
||||
## What "execution" means in an agentic context
|
||||
|
||||
An agent without execution capability is just a chatbot that thinks out loud. Execution is what transforms reasoning into results: writing code and running it, calling an API to book a meeting, sending an email, or updating a database.
|
||||
|
||||
The key challenge is _safe_ execution. When an agent generates and runs code, that code might:
|
||||
|
||||
- Have bugs that crash the process
|
||||
- Consume unbounded resources (infinite loops, memory leaks)
|
||||
- Access files or network resources it shouldn't
|
||||
- Make irreversible changes (deleting data, sending emails)
|
||||
|
||||
This is why execution and [environments](../environments/README.md) go hand-in-hand. Every execution tool implicitly assumes some isolation boundary.
|
||||
|
||||
## Execution approaches compared
|
||||
|
||||
| Approach | Safety | Latency | Flexibility | Best for |
|
||||
|----------|--------|---------|-------------|----------|
|
||||
| Function calling (tool use) | High | Low | Limited to defined tools | Structured API calls with known schemas |
|
||||
| Code generation + sandbox | Medium | Medium | Very high | Dynamic tasks, data analysis, file manipulation |
|
||||
| Local code execution | Low | Very low | Very high | Trusted environments, development |
|
||||
| Browser automation | Medium | High | High | Web interactions, form filling, scraping |
|
||||
| Managed tool platform | High | Medium | High | Production agents needing many integrations |
|
||||
|
||||
## Tools and libraries
|
||||
|
||||
### Sandboxed code execution
|
||||
|
||||
**[E2B](https://github.com/e2b-dev/e2b)** — Runs agent-generated code in secure cloud sandboxes with sub-second start. Cold start: ~300ms. Isolation: VM (Firecracker). SDK: Python, TypeScript, Go. Tags: `execution` `sandbox` `python` `typescript` `e2b`
|
||||
|
||||
**[Open Interpreter](https://github.com/OpenInterpreter/open-interpreter)** — Executes code locally through a natural language interface. Isolation: process-level. SDK: Python. Tags: `execution` `python`
|
||||
|
||||
**[Modal](https://github.com/modal-labs/modal-client)** — Runs functions in cloud containers with GPU support and auto-scaling. Cold start: ~500ms. Isolation: container + gVisor. SDK: Python. Tags: `execution` `sandbox` `python` `modal`
|
||||
|
||||
### Tool platforms and integrations
|
||||
|
||||
**[Composio](https://github.com/ComposioHQ/composio)** — Connects agents to 250+ external tools and APIs with managed auth. Tags: `execution` `python` `typescript` `composio`
|
||||
|
||||
**[MCP (Model Context Protocol)](https://github.com/modelcontextprotocol/servers)** — Standardizes how agents discover and call external tools via a protocol. Tags: `execution` `python` `typescript`
|
||||
|
||||
**[Toolhouse](https://github.com/toolhouseai/toolhouse-sdk-python)** — Provides a hosted tool execution layer for function calling agents. Tags: `execution` `python`
|
||||
|
||||
### Framework-specific tool kits
|
||||
|
||||
**[CrewAI Tools](https://github.com/crewAIInc/crewAI-tools)** — Bundles pre-built tools for search, scraping, and file operations in agent pipelines. Tags: `execution` `python` `crewai`
|
||||
|
||||
**[LangChain Tools](https://github.com/langchain-ai/langchain)** — Provides 100+ integrations for search, math, databases, and APIs. Tags: `execution` `python` `langchain`
|
||||
|
||||
**[Semantic Kernel](https://github.com/microsoft/semantic-kernel)** — Integrates LLM function calling with enterprise plugins and planners. Tags: `execution` `planning` `python` `typescript`
|
||||
|
||||
### Browser automation
|
||||
|
||||
**[Browser Use](https://github.com/browser-use/browser-use)** — Gives LLM agents full browser control for web interaction and data extraction. Tags: `execution` `perception` `python`
|
||||
|
||||
**[Playwright](https://github.com/microsoft/playwright)** — Automates Chromium, Firefox, and WebKit browsers with a single API. Tags: `execution` `perception` `python` `typescript`
|
||||
|
||||
**[Skyvern](https://github.com/Skyvern-AI/skyvern)** — Automates browser workflows using vision models instead of DOM selectors. Tags: `execution` `perception` `python`
|
||||
|
||||
## When to use what — decision guide
|
||||
|
||||
```
|
||||
Start here: What does your agent need to do?
|
||||
│
|
||||
├── Call a known API with a defined schema?
|
||||
│ └── Function calling (native LLM tool use)
|
||||
│
|
||||
├── Generate and run arbitrary code?
|
||||
│ ├── Trusted environment, low latency? → Open Interpreter
|
||||
│ ├── Untrusted code, need isolation? → E2B or Modal
|
||||
│ └── Need GPU for ML workloads? → Modal
|
||||
│
|
||||
├── Connect to 3rd-party SaaS tools?
|
||||
│ ├── Need many integrations (10+)? → Composio
|
||||
│ ├── Want a standard protocol? → MCP
|
||||
│ └── Using a specific framework? → CrewAI Tools or LangChain Tools
|
||||
│
|
||||
└── Interact with web pages?
|
||||
├── Need to fill forms, click buttons? → Browser Use or Playwright
|
||||
└── Visual approach (no selectors)? → Skyvern
|
||||
```
|
||||
|
||||
## Common pitfalls
|
||||
|
||||
1. **No timeout on execution.** Agent-generated code can hang forever. Always set execution timeouts — 30 seconds for simple tasks, 5 minutes max for complex ones.
|
||||
|
||||
2. **Trusting code output without validation.** Just because code ran without errors doesn't mean the output is correct. Validate results before the agent acts on them.
|
||||
|
||||
3. **Leaking credentials.** When agents call APIs, they need credentials. Never pass credentials through the LLM prompt. Use environment variables, secret managers, or managed auth platforms like Composio.
|
||||
|
||||
4. **No resource limits.** An agent in a loop can make thousands of API calls in minutes. Set rate limits on tool execution and hard caps on total actions per invocation.
|
||||
|
|
@ -0,0 +1,105 @@
|
|||
# Memory
|
||||
|
||||
Memory is the agent's ability to store, retrieve, and reason over information across time. Without memory, every agent invocation starts from scratch — it can't learn from past interactions, recall user preferences, or build on previous research.
|
||||
|
||||
## Types of agent memory
|
||||
|
||||
| Type | Lifespan | Stored where | Example |
|
||||
|------|----------|-------------|---------|
|
||||
| **Working memory** | Single turn | LLM context window | Current conversation messages, tool results |
|
||||
| **Short-term memory** | Single session | In-process buffer | Summary of the last 10 conversation turns |
|
||||
| **Long-term memory** | Persistent | External database | User preferences, past interactions, learned facts |
|
||||
| **Episodic memory** | Persistent | External database | Specific past events: "last Tuesday the deploy failed" |
|
||||
| **Semantic memory** | Persistent | Vector store | General knowledge: "the API rate limit is 100 req/min" |
|
||||
|
||||
Most agents need at minimum working memory (the context window) and some form of long-term retrieval. The question is how to structure and access it.
|
||||
|
||||
## The retrieval problem
|
||||
|
||||
Storing memories is easy. Retrieving the _right_ memory at the _right_ time is the hard part. Key challenges:
|
||||
|
||||
1. **Relevance decay.** A fact from 3 months ago might be outdated. Memory systems need recency weighting or expiration.
|
||||
2. **Semantic vs. keyword match.** "How to deploy to prod" and "production deployment steps" mean the same thing, but keyword search misses this. Vector search handles it.
|
||||
3. **Context window limits.** Even with 128k context windows, stuffing everything in is expensive and slow. Selective retrieval matters.
|
||||
|
||||
## Tools and libraries
|
||||
|
||||
### Vector stores
|
||||
|
||||
**[Chroma](https://github.com/chroma-core/chroma)** — Embeds and retrieves documents as a lightweight vector store for agents. Tags: `memory` `python` `typescript`
|
||||
|
||||
**[Weaviate](https://github.com/weaviate/weaviate)** — Stores and searches vector embeddings with hybrid keyword+semantic retrieval. Tags: `memory` `go` `python`
|
||||
|
||||
**[Qdrant](https://github.com/qdrant/qdrant)** — Provides high-performance vector similarity search with filtering. Tags: `memory` `rust` `python`
|
||||
|
||||
**[Milvus](https://github.com/milvus-io/milvus)** — Scales vector search to billions of embeddings for large agent knowledge bases. Tags: `memory` `go` `python`
|
||||
|
||||
**[LanceDB](https://github.com/lancedb/lancedb)** — Runs serverless vector search embedded directly in the agent process. Tags: `memory` `rust` `python` `typescript`
|
||||
|
||||
**[pgvector](https://github.com/pgvector/pgvector)** — Adds vector similarity search to PostgreSQL for teams already using Postgres. Tags: `memory` `python`
|
||||
|
||||
### Agent memory layers
|
||||
|
||||
**[Mem0](https://github.com/mem0ai/mem0)** — Adds persistent, personalized memory to LLM agents across sessions. Tags: `memory` `python`
|
||||
|
||||
**[Zep](https://github.com/getzep/zep)** — Enriches agent memory with automatic summarization and entity extraction. Tags: `memory` `python` `typescript`
|
||||
|
||||
**[Motorhead](https://github.com/getmetal/motorhead)** — Manages conversation context windows with automatic summarization. Tags: `memory` `rust` `python`
|
||||
|
||||
**[Letta](https://github.com/letta-ai/letta)** — Provides an OS-like memory management system for LLMs to manage long-term state. Tags: `memory` `python`
|
||||
|
||||
**[LangMem](https://github.com/langchain-ai/langmem)** — Provides long-term memory primitives for LangGraph agents. Tags: `memory` `python` `langgraph`
|
||||
|
||||
## When to use what — decision guide
|
||||
|
||||
```
|
||||
Start here: What kind of memory does your agent need?
|
||||
│
|
||||
├── Remember user preferences across sessions?
|
||||
│ └── Mem0 or Zep (built-in personalization)
|
||||
│
|
||||
├── Search over a large document corpus?
|
||||
│ ├── < 1M vectors, single process? → Chroma or LanceDB
|
||||
│ ├── Need hybrid search (keyword + semantic)? → Weaviate
|
||||
│ ├── Need filtering on metadata? → Qdrant
|
||||
│ └── > 100M vectors, production scale? → Milvus
|
||||
│
|
||||
├── Already using PostgreSQL?
|
||||
│ └── pgvector (no new infrastructure)
|
||||
│
|
||||
└── Need conversation summarization?
|
||||
└── Zep or Motorhead
|
||||
```
|
||||
|
||||
## Common patterns
|
||||
|
||||
### Sliding window + summary
|
||||
|
||||
Keep the last N messages verbatim in context. Summarize older messages into a compressed representation. This balances recency (recent messages are exact) with history (older context is preserved in compressed form).
|
||||
|
||||
```python
|
||||
def build_context(messages, window_size=10):
|
||||
recent = messages[-window_size:]
|
||||
older = messages[:-window_size]
|
||||
summary = llm.summarize(older) if older else ""
|
||||
return [{"role": "system", "content": summary}] + recent
|
||||
```
|
||||
|
||||
### RAG (retrieval-augmented generation)
|
||||
|
||||
Before generating a response, search a vector store for relevant past knowledge. Inject the top-k results into the prompt. This is the standard pattern for giving agents access to large knowledge bases without stuffing everything into the context window.
|
||||
|
||||
```python
|
||||
def answer_with_memory(query, vector_store, llm):
|
||||
relevant_docs = vector_store.search(query, top_k=5)
|
||||
context = "\n".join(doc.text for doc in relevant_docs)
|
||||
return llm.generate(f"Context:\n{context}\n\nQuestion: {query}")
|
||||
```
|
||||
|
||||
## Common pitfalls
|
||||
|
||||
1. **Embedding model mismatch.** If you embed documents with `text-embedding-ada-002` but search with `text-embedding-3-small`, similarity scores are meaningless. Always use the same model for indexing and querying.
|
||||
|
||||
2. **No metadata filtering.** Vector search alone returns the most _semantically similar_ results, which might be from the wrong user, wrong project, or wrong time period. Always store and filter on metadata.
|
||||
|
||||
3. **Forgetting to update.** Long-term memory that's never pruned or updated becomes a liability. Outdated facts in memory can cause agents to act on stale information.
|
||||
|
|
@ -0,0 +1,92 @@
|
|||
# Perception
|
||||
|
||||
Perception is the agent's ability to observe the external world — reading web pages, parsing documents, understanding images, and extracting structured data from unstructured sources. Without perception, an agent is limited to what's already in its context window.
|
||||
|
||||
## What "perception" means in an agentic context
|
||||
|
||||
In traditional software, "input" is deterministic: an API returns JSON, a database returns rows. For agents, perception is messy. A web page might have cookie banners, dynamic JavaScript, and layout shifts. A PDF might have multi-column layouts, embedded tables, and scanned images. Perception tools abstract this complexity so the agent receives clean, structured content it can reason over.
|
||||
|
||||
The core challenge is converting the noisy real world into tokens an LLM can actually use.
|
||||
|
||||
## The speed vs. accuracy tradeoff
|
||||
|
||||
Every perception tool sits on a spectrum:
|
||||
|
||||
| Approach | Speed | Accuracy | Best for |
|
||||
|----------|-------|----------|----------|
|
||||
| Raw HTTP fetch + regex | Very fast | Low | Simple, well-structured pages |
|
||||
| Headless browser + extraction | Medium | Medium-high | JavaScript-heavy sites, SPAs |
|
||||
| Vision model (screenshot → text) | Slow | High | Complex layouts, visual elements |
|
||||
| Specialized parser (PDF, DOCX) | Medium | High | Known document formats |
|
||||
|
||||
The right choice depends on latency budget and content complexity. For a research agent processing hundreds of pages, raw HTTP with markdown conversion is often enough. For a browser automation agent filling out forms, you need a full headless browser.
|
||||
|
||||
## Tools and libraries
|
||||
|
||||
### Web browsing and scraping
|
||||
|
||||
**[Firecrawl](https://github.com/firecrawl/firecrawl)** — Crawls websites and returns clean markdown ready for LLM consumption. Tags: `perception` `python` `typescript`
|
||||
|
||||
**[Crawl4AI](https://github.com/unclecode/crawl4ai)** — Extracts structured data from web pages using LLM-friendly output formats. Tags: `perception` `python`
|
||||
|
||||
**[Jina Reader](https://github.com/jina-ai/reader)** — Converts any URL to LLM-ready text via a simple API prefix. Tags: `perception` `typescript`
|
||||
|
||||
**[Browser Use](https://github.com/browser-use/browser-use)** — Gives LLM agents full browser control for web interaction and data extraction. Tags: `perception` `execution` `python`
|
||||
|
||||
**[Stagehand](https://github.com/browserbase/stagehand)** — An AI web browsing framework that uses Playwright with LLM-native commands like `page.act()`. Tags: `perception` `execution` `typescript`
|
||||
|
||||
**[ScrapeGraphAI](https://github.com/ScrapeGraphAI/Scrapegraph-ai)** — A web scraping python library that uses LLMs to create scraping pipelines. Tags: `perception` `pipeline` `python`
|
||||
|
||||
**[Tavily](https://github.com/tavily-ai/tavily-python)** — Provides search API optimized for LLM agents needing real-time web data. Tags: `perception` `python`
|
||||
|
||||
### Document parsing
|
||||
|
||||
**[Docling](https://github.com/docling-project/docling)** — Parses PDFs, DOCX, and slides into structured text with layout understanding. Tags: `perception` `python`
|
||||
|
||||
**[Marker](https://github.com/datalab-to/marker)** — Converts PDF to markdown with high accuracy for tables, equations, and figures. Tags: `perception` `python`
|
||||
|
||||
**[Unstructured](https://github.com/Unstructured-IO/unstructured)** — Ingests and preprocesses documents across 25+ file types for downstream LLM use. Tags: `perception` `python` `pipeline`
|
||||
|
||||
**[LlamaParse](https://github.com/run-llama/llama_cloud_services)** — A GenAI-native document parser specifically designed to extract complex tables and layouts. Tags: `perception` `python`
|
||||
|
||||
**[PyMuPDF](https://github.com/pymupdf/PyMuPDF)** — Extracts text, images, and metadata from PDFs with fast C-based bindings. Tags: `perception` `python`
|
||||
|
||||
### OCR and vision
|
||||
|
||||
**[Surya](https://github.com/datalab-to/surya)** — Runs OCR and layout detection on documents in 90+ languages. Tags: `perception` `python`
|
||||
|
||||
**[PaddleOCR](https://github.com/PaddlePaddle/PaddleOCR)** — Recognizes text in images across 80+ languages with lightweight models. Tags: `perception` `python`
|
||||
|
||||
**[DocTR](https://github.com/mindee/doctr)** — Detects and recognizes text in document images using deep learning. Tags: `perception` `python`
|
||||
|
||||
## When to use what — decision guide
|
||||
|
||||
```
|
||||
Start here: What is your input source?
|
||||
│
|
||||
├── Web page?
|
||||
│ ├── Static content, no JS? → Jina Reader or Firecrawl
|
||||
│ ├── JS-heavy SPA? → Crawl4AI or Browser Use
|
||||
│ └── Need to interact (click, type)? → Browser Use or Playwright
|
||||
│
|
||||
├── PDF document?
|
||||
│ ├── Text-based PDF? → Marker or PyMuPDF
|
||||
│ ├── Scanned / image PDF? → Surya or PaddleOCR → then Marker
|
||||
│ └── Mixed (tables + text + images)? → Docling or Unstructured
|
||||
│
|
||||
├── Office docs (DOCX, PPTX)?
|
||||
│ └── Docling or Unstructured
|
||||
│
|
||||
└── Need real-time search results?
|
||||
└── Tavily
|
||||
```
|
||||
|
||||
## Common pitfalls
|
||||
|
||||
1. **Overusing headless browsers.** If you just need the text content of a blog post, a headless browser is 10x slower than an HTTP fetch. Reserve it for pages that actually require JavaScript execution.
|
||||
|
||||
2. **Ignoring rate limits.** Most scraping tools don't handle rate limiting out of the box. Wrap your perception layer with backoff and retry logic, or your agent will get blocked mid-research.
|
||||
|
||||
3. **Trusting OCR output blindly.** OCR accuracy drops on low-resolution images, handwriting, and unusual fonts. Always validate critical data extracted via OCR before your agent acts on it.
|
||||
|
||||
4. **Forgetting pagination.** Many tools extract only the first page of results or the visible viewport. For research agents, implement explicit pagination handling.
|
||||
|
|
@ -0,0 +1,90 @@
|
|||
# Planning
|
||||
|
||||
Planning is the agent's ability to decompose complex tasks into steps, decide what to do next, and adapt when things go wrong. This is arguably the hardest skill to get right — a perception tool either works or it doesn't, but planning failures are subtle and cascading.
|
||||
|
||||
## What "planning" means in an agentic context
|
||||
|
||||
Planning is not prompt engineering. It's the structured process by which an agent:
|
||||
|
||||
1. **Understands the goal** — What does the user actually want?
|
||||
2. **Decomposes the goal** — What sub-tasks are required?
|
||||
3. **Orders the sub-tasks** — What depends on what?
|
||||
4. **Selects tools** — Which skills and tools should handle each sub-task?
|
||||
5. **Adapts on failure** — When a step fails, how should the plan change?
|
||||
|
||||
The simplest "plan" is a single LLM call with a system prompt. The most sophisticated planners use tree search, self-reflection, and multi-agent debate. The right approach depends on task complexity.
|
||||
|
||||
## Planning strategies compared
|
||||
|
||||
| Strategy | Complexity | Latency | Best for |
|
||||
|----------|-----------|---------|----------|
|
||||
| Direct prompting | Low | 1 LLM call | Simple, single-step tasks |
|
||||
| ReAct | Medium | 3-10 LLM calls | Tasks needing interleaved reasoning and tool use |
|
||||
| Plan-and-execute | Medium | 2+ LLM calls | Multi-step tasks with clear decomposition |
|
||||
| Tree of Thoughts | High | 10-50+ LLM calls | Tasks where the first approach might be wrong |
|
||||
| Reflection/Reflexion | Medium-high | 2x base calls | Tasks where output quality matters more than speed |
|
||||
| Multi-agent debate | High | N × base calls | Tasks benefiting from diverse perspectives |
|
||||
|
||||
See the [`patterns/`](../patterns/) directory for in-depth explanations of each strategy.
|
||||
|
||||
## Tools and libraries
|
||||
|
||||
### Orchestration frameworks with planning
|
||||
|
||||
**[LangGraph](https://github.com/langchain-ai/langgraph)** — Orchestrates multi-step agent workflows as stateful, cyclical graphs. Tags: `planning` `orchestration` `python` `typescript` `langgraph`
|
||||
|
||||
**[AutoGen](https://github.com/microsoft/autogen)** — Coordinates multi-agent conversations for collaborative task decomposition. Tags: `planning` `orchestration` `python` `autogen`
|
||||
|
||||
**[CrewAI](https://github.com/crewAIInc/crewAI)** — Assigns roles to agents and orchestrates their collaboration on complex tasks. Tags: `planning` `orchestration` `python` `crewai`
|
||||
|
||||
**[Pydantic AI](https://github.com/pydantic/pydantic-ai)** — Structures agent outputs and tool calls with type-safe validation. Tags: `planning` `execution` `python`
|
||||
|
||||
### Reasoning and search
|
||||
|
||||
**[DSPy](https://github.com/stanfordnlp/dspy)** — Optimizes LLM prompts and chains programmatically instead of manually. Tags: `planning` `python`
|
||||
|
||||
**[LATS](https://github.com/lapisrocks/LanguageAgentTreeSearch)** — Combines Monte Carlo tree search with LLM reasoning for complex planning. Tags: `planning` `python`
|
||||
|
||||
**[Tree of Thoughts](https://github.com/princeton-nlp/tree-of-thought-llm)** — Explores multiple reasoning paths in parallel before committing. Tags: `planning` `python`
|
||||
|
||||
**[Reflexion](https://github.com/noahshinn/reflexion)** — Lets agents learn from mistakes via verbal self-reflection loops. Tags: `planning` `python`
|
||||
|
||||
### Task-specific planners
|
||||
|
||||
**[OpenHands](https://github.com/All-Hands-AI/OpenHands)** — Plans and executes multi-step software engineering tasks autonomously (formerly OpenDevin). Tags: `planning` `execution` `python`
|
||||
|
||||
**[Semantic Kernel](https://github.com/microsoft/semantic-kernel)** — Integrates LLM function calling with enterprise plugins and planners. Tags: `planning` `execution` `python` `typescript`
|
||||
|
||||
## When to use what — decision guide
|
||||
|
||||
```
|
||||
Start here: How complex is the task?
|
||||
│
|
||||
├── Single step, one tool call?
|
||||
│ └── Direct prompting (no planner needed)
|
||||
│
|
||||
├── 2-5 steps, tools needed, might need to retry?
|
||||
│ └── ReAct pattern (see patterns/react-pattern.md)
|
||||
│
|
||||
├── 5+ steps, can be planned upfront?
|
||||
│ └── Plan-and-execute (see patterns/plan-and-execute.md)
|
||||
│
|
||||
├── Uncertain approach, might need to backtrack?
|
||||
│ └── Tree of Thoughts or LATS
|
||||
│
|
||||
├── Output quality is critical, speed is not?
|
||||
│ └── Reflection loop (see patterns/reflection-loop.md)
|
||||
│
|
||||
└── Multiple perspectives needed?
|
||||
└── Multi-agent debate (see patterns/multi-agent.md)
|
||||
```
|
||||
|
||||
## Common pitfalls
|
||||
|
||||
1. **Over-planning.** Not every task needs a complex planner. If the user asks "what time is it in Tokyo?", a ReAct loop is overhead. Match planner complexity to task complexity.
|
||||
|
||||
2. **Plans that never re-plan.** A plan made before execution starts is a guess. Good planners adapt step-by-step based on actual tool outputs, not just the initial decomposition.
|
||||
|
||||
3. **Infinite loops.** ReAct and reflection patterns can loop forever if there's no exit condition. Always set a maximum iteration count and a fallback behavior.
|
||||
|
||||
4. **Ignoring cost.** Tree of Thoughts with 5 branches × 10 depth = 50 LLM calls. That's $0.50-$5.00+ per task depending on the model. Make sure the quality improvement justifies the cost.
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
# Agent Coverage Tools
|
||||
|
||||
Tools that measure branch and tool-call coverage for agent decision graphs, helping teams track which planning branches are exercised by test suites.
|
||||
|
||||
Status: Concept / recommended (May 2026)
|
||||
|
||||
References: See Agent Testing & Debugging section in README.md for comparison table.
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
# Agent Mutation Testing
|
||||
|
||||
Generates adversarial prompt and environment mutations to validate agent robustness and detect brittle planning paths. Useful as part of end-to-end agent test pipelines.
|
||||
|
||||
Status: Concept / recommended tooling (May 2026)
|
||||
|
||||
References: See Agent Testing & Debugging section in README.md for comparison table.
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
# Cortex Debugger
|
||||
|
||||
Step-through debugging primitives for agent workflows: pause, inspect tool outputs, rewind actions, and replay conversation traces to reproduce failures.
|
||||
|
||||
Status: Concept / emergent (May 2026)
|
||||
|
||||
References: See Agent Testing & Debugging section in README.md for comparison table.
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
# pytest-Agents
|
||||
|
||||
Pytest fixtures and helpers to unit test agent flows, mock tool calls, and assert conversational branches. Useful for CI-based agent validation and fast feedback loops.
|
||||
|
||||
Status: Concept / emerging (May 2026)
|
||||
|
||||
References: See Agent Testing & Debugging section in README.md for comparison table.
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
# Real-world workflows
|
||||
|
||||
This directory contains detailed write-ups of production agentic workflows — end-to-end pipelines that chain multiple [skills](../skills/README.md) together to accomplish real tasks.
|
||||
|
||||
## Workflows
|
||||
|
||||
| Workflow | Skills used | File |
|
||||
|----------|------------|------|
|
||||
| **Research agent** | Perception → Memory → Planning → Communication | [research-agent.md](research-agent.md) |
|
||||
| **Code generation** | Planning → Execution → Reflection | [code-generation.md](code-generation.md) |
|
||||
| **Data pipeline** | Perception → Execution → Communication | [data-pipeline.md](data-pipeline.md) |
|
||||
| **Browser automation** | Perception → Planning → Execution | [browser-automation.md](browser-automation.md) |
|
||||
| **Multi-step reasoning** | Planning → Reflection → Execution | [multi-step-reasoning.md](multi-step-reasoning.md) |
|
||||
|
||||
## What makes a workflow different from a skill
|
||||
|
||||
A skill is a single capability: "parse a PDF", "search a vector store", "send a Slack message". A workflow chains multiple skills into a pipeline that accomplishes a higher-level goal: "research a topic, synthesize findings, and email a report."
|
||||
|
||||
The workflow files in this directory describe:
|
||||
|
||||
1. **The pipeline structure** — What steps run, in what order, with what branching
|
||||
2. **Tools involved** — Which specific libraries and services handle each step
|
||||
3. **Failure modes** — What can go wrong and how to handle it
|
||||
4. **Production considerations** — Latency, cost, reliability, and observability
|
||||
|
||||
## Entry format
|
||||
|
||||
```markdown
|
||||
**[Project Name](url)** — One sentence describing what it enables. Tags: `tag1` `tag2`
|
||||
```
|
||||
|
||||
See [CONTRIBUTING.md](../CONTRIBUTING.md) for the full tag taxonomy.
|
||||
|
|
@ -0,0 +1,120 @@
|
|||
# Browser automation workflow
|
||||
|
||||
A browser automation agent navigates web pages, fills out forms, clicks buttons, extracts data, and completes multi-step web workflows — all driven by natural language instructions rather than hardcoded selectors. This is the most fragile agentic workflow because web UIs change constantly, but also one of the most valuable because it automates work that has no API alternative.
|
||||
|
||||
## Pipeline structure
|
||||
|
||||
```
|
||||
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
|
||||
│ Parse │ │ Navigate │ │ Observe │
|
||||
│ instruction │────▶│ to page │────▶│ page state │
|
||||
└──────────────┘ └──────────────┘ └──────┬───────┘
|
||||
│
|
||||
┌──────────────┐ ┌──────▼───────┐
|
||||
│ Report │◀────│ Take │
|
||||
│ result │ │ action │
|
||||
└──────────────┘ └──────┬───────┘
|
||||
│
|
||||
┌──────▼───────┐
|
||||
│ Check if │
|
||||
│ goal met │
|
||||
└──────┬───────┘
|
||||
│
|
||||
No ─────┘───── Yes
|
||||
│ │
|
||||
back to observe done
|
||||
```
|
||||
|
||||
The observe → act → check loop is a classic ReAct pattern applied to browser interaction. The agent looks at the page, decides what to do, does it, and then checks whether the task is complete.
|
||||
|
||||
## Approaches to browser perception
|
||||
|
||||
| Approach | How it works | Pros | Cons |
|
||||
|----------|-------------|------|------|
|
||||
| **DOM parsing** | Extract HTML, identify elements by selector | Fast, precise, deterministic | Breaks when HTML structure changes |
|
||||
| **Vision (screenshot)** | Send a screenshot to a vision model | Works on any page, resilient to HTML changes | Slower, less precise for small elements |
|
||||
| **Accessibility tree** | Use the browser's accessibility API | Semantic understanding of UI elements | Not all sites have good a11y markup |
|
||||
| **Hybrid** | DOM for structure + vision for ambiguous elements | Best accuracy | Highest latency and cost |
|
||||
|
||||
## Tools involved
|
||||
|
||||
| Step | Tools | Why |
|
||||
|------|-------|-----|
|
||||
| Browser control | Playwright, Puppeteer | Reliable cross-browser automation |
|
||||
| Agent-driven browsing | Browser Use, Skyvern | LLM-native browser control |
|
||||
| Element querying | AgentQL | Natural language element selection |
|
||||
| Perception | Vision models, DOM extraction | Understanding page state |
|
||||
| Orchestration | LangGraph | Managing the observe-act loop |
|
||||
|
||||
## Real projects implementing this workflow
|
||||
|
||||
**[Browser Use](https://github.com/browser-use/browser-use)** — Gives LLM agents full browser control for web interaction and data extraction. Tags: `execution` `perception` `python`
|
||||
|
||||
**[Playwright](https://github.com/microsoft/playwright)** — Automates Chromium, Firefox, and WebKit browsers with a single API. Tags: `execution` `perception` `python` `typescript`
|
||||
|
||||
**[Skyvern](https://github.com/Skyvern-AI/skyvern)** — Automates browser workflows using vision models instead of DOM selectors. Tags: `execution` `perception` `python`
|
||||
|
||||
**[AgentQL](https://github.com/tinyfish-io/agentql)** — Queries web page elements using natural language instead of CSS selectors. Tags: `perception` `python`
|
||||
|
||||
**[LaVague](https://github.com/lavague-ai/LaVague)** — Translates natural language instructions into browser automation actions. Tags: `execution` `perception` `python`
|
||||
|
||||
**[WebArena](https://github.com/web-arena-x/webarena)** — Provides a realistic benchmark environment for testing web agent capabilities. Tags: `execution` `python`
|
||||
|
||||
## Pseudocode
|
||||
|
||||
```python
|
||||
def browser_agent(instruction: str, url: str, max_steps: int = 15):
|
||||
browser = playwright.chromium.launch()
|
||||
page = browser.new_page()
|
||||
page.goto(url)
|
||||
|
||||
for step in range(max_steps):
|
||||
# Step 1: Observe
|
||||
screenshot = page.screenshot()
|
||||
dom = page.content()
|
||||
page_state = llm.describe_page(screenshot, dom)
|
||||
|
||||
# Step 2: Decide action
|
||||
action = llm.decide_action(
|
||||
instruction=instruction,
|
||||
page_state=page_state,
|
||||
history=action_history,
|
||||
)
|
||||
# action = {"type": "click", "target": "#submit-btn"}
|
||||
# action = {"type": "type", "target": "#email", "text": "..."}
|
||||
# action = {"type": "done", "result": "..."}
|
||||
|
||||
if action["type"] == "done":
|
||||
return action["result"]
|
||||
|
||||
# Step 3: Execute action
|
||||
if action["type"] == "click":
|
||||
page.click(action["target"])
|
||||
elif action["type"] == "type":
|
||||
page.fill(action["target"], action["text"])
|
||||
elif action["type"] == "navigate":
|
||||
page.goto(action["url"])
|
||||
|
||||
# Wait for page to settle
|
||||
page.wait_for_load_state("networkidle")
|
||||
|
||||
return "Max steps reached without completing task"
|
||||
```
|
||||
|
||||
## Failure modes
|
||||
|
||||
| Failure | Cause | Fix |
|
||||
|---------|-------|-----|
|
||||
| Element not found | HTML structure changed, selector is stale | Use vision or accessibility tree instead of CSS selectors |
|
||||
| CAPTCHA | Site detects automation | Use residential proxies, slow down interactions, or escalate to human |
|
||||
| Login walls | Session expired or not logged in | Pre-authenticate and pass session cookies |
|
||||
| Infinite navigation loop | Agent keeps clicking the same buttons | Track visited URLs and actions, detect cycles |
|
||||
| Pop-ups and overlays | Cookie banners, modals blocking interaction | Detect and dismiss overlays before acting on main content |
|
||||
|
||||
## Production considerations
|
||||
|
||||
- **Speed**: Browser automation is slow (500ms-2s per action). Multi-step workflows can take 30 seconds to several minutes. Don't use for real-time interactions.
|
||||
- **Reliability**: Web UIs change without warning. Vision-based approaches (Skyvern, Browser Use) are more resilient than selector-based ones but slower.
|
||||
- **Cost**: Each step requires at least one LLM call (often with a screenshot). A 10-step workflow costs $0.10-$0.50 in LLM API calls.
|
||||
- **Legal**: Automated browsing may violate terms of service. Check the site's robots.txt and ToS before deploying.
|
||||
- **Parallelism**: Run multiple browser instances for batch operations, but respect rate limits to avoid being blocked.
|
||||
|
|
@ -0,0 +1,106 @@
|
|||
# Code generation workflow
|
||||
|
||||
A code generation agent reads a specification (issue, ticket, conversation), writes code across one or more files, tests it, and submits the result. Unlike simple "write me a function" prompts, a production code generation workflow must understand the existing codebase, maintain consistency with project conventions, and verify that changes don't break anything.
|
||||
|
||||
## Pipeline structure
|
||||
|
||||
```
|
||||
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
|
||||
│ Understand │ │ Plan the │ │ Generate │
|
||||
│ the task │────▶│ changes │────▶│ code │
|
||||
└──────────────┘ └──────────────┘ └──────┬───────┘
|
||||
│
|
||||
┌──────────────┐ ┌──────────────┐ ┌──────▼───────┐
|
||||
│ Submit or │ │ Fix errors │◀────│ Test & │
|
||||
│ report │◀────│ (if any) │ │ validate │
|
||||
└──────────────┘ └──────────────┘ └──────────────┘
|
||||
▲ │
|
||||
└──────────────────────┘
|
||||
Tests still failing?
|
||||
```
|
||||
|
||||
The edit-test-fix loop is the core of this workflow. A good code generation agent doesn't just write code — it runs it, reads the error, and fixes it.
|
||||
|
||||
## Tools involved
|
||||
|
||||
| Step | Tools | Why |
|
||||
|------|-------|-----|
|
||||
| Codebase understanding | Tree-sitter, ctags, grep | Parse and navigate existing code |
|
||||
| Planning | LLM reasoning | Decide which files to modify and how |
|
||||
| Code generation | LLM (direct) | Write the actual code |
|
||||
| Sandboxed execution | E2B, Modal | Run tests safely |
|
||||
| Testing | pytest, jest, cargo test | Verify correctness |
|
||||
| Submission | GitHub API, git | Create PR or commit |
|
||||
|
||||
## Real projects implementing this workflow
|
||||
|
||||
**[Aider](https://github.com/paul-gauthier/aider)** — Edits code across multiple files in a git repo via natural language. Tags: `execution` `python`
|
||||
|
||||
**[SWE-agent](https://github.com/princeton-nlp/SWE-agent)** — Resolves GitHub issues autonomously by reading, planning, and patching code. Tags: `execution` `planning` `python`
|
||||
|
||||
**[Continue](https://github.com/continuedev/continue)** — Adds AI code assistance directly inside VS Code and JetBrains IDEs. Tags: `execution` `typescript`
|
||||
|
||||
**[Cline](https://github.com/cline/cline)** — An autonomous coding agent that works directly in VS Code to write, execute, and test code. Tags: `execution` `typescript`
|
||||
|
||||
**[Devika](https://github.com/stitionai/devika)** — An open-source AI software engineer that can understand high-level instructions and write code to build features. Tags: `execution` `planning` `python`
|
||||
|
||||
**[OpenHands](https://github.com/All-Hands-AI/OpenHands)** — Plans and executes multi-step software engineering tasks in a sandboxed environment (formerly OpenDevin). Tags: `planning` `execution` `python`
|
||||
|
||||
**[GPT Engineer](https://github.com/gpt-engineer-org/gpt-engineer)** — Generates entire codebases from a single specification prompt. Tags: `execution` `planning` `python`
|
||||
|
||||
## Pseudocode
|
||||
|
||||
```python
|
||||
def code_generation_agent(task: str, repo_path: str, max_retries: int = 3):
|
||||
# Step 1: Understand the codebase
|
||||
file_tree = list_files(repo_path)
|
||||
relevant_files = llm.identify_relevant_files(task, file_tree)
|
||||
context = read_files(relevant_files)
|
||||
|
||||
# Step 2: Plan the changes
|
||||
plan = llm.plan_changes(task, context)
|
||||
# plan = [{"file": "src/api.py", "action": "modify", "description": "..."}]
|
||||
|
||||
# Step 3: Generate code
|
||||
changes = {}
|
||||
for step in plan:
|
||||
file_content = read_file(step["file"])
|
||||
new_content = llm.edit_code(step, file_content, context)
|
||||
changes[step["file"]] = new_content
|
||||
|
||||
# Step 4: Apply and test
|
||||
for attempt in range(max_retries):
|
||||
apply_changes(changes)
|
||||
test_result = run_tests(repo_path)
|
||||
|
||||
if test_result.passed:
|
||||
break
|
||||
|
||||
# Step 5: Fix errors
|
||||
error_context = test_result.stderr
|
||||
fixes = llm.fix_errors(changes, error_context)
|
||||
changes.update(fixes)
|
||||
|
||||
# Step 6: Submit
|
||||
if test_result.passed:
|
||||
create_pull_request(changes, task)
|
||||
else:
|
||||
report_failure(task, test_result)
|
||||
```
|
||||
|
||||
## Failure modes
|
||||
|
||||
| Failure | Cause | Fix |
|
||||
|---------|-------|-----|
|
||||
| Wrong files edited | Agent doesn't understand project structure | Provide file tree and dependency graph as context |
|
||||
| Style inconsistency | Agent uses different conventions | Include style examples from existing code in context |
|
||||
| Test passes but logic wrong | Tests don't cover the change | Require the agent to write tests for new code |
|
||||
| Infinite fix loop | Error is beyond the agent's ability | Set max_retries and escalate to human |
|
||||
| Merge conflicts | Other changes landed while agent was working | Rebase before submitting, re-test after rebase |
|
||||
|
||||
## Production considerations
|
||||
|
||||
- **Isolation**: Always run agent-generated code in a sandbox (E2B, Docker). Never execute untrusted code directly on a production machine.
|
||||
- **Cost**: A complex code change might need 5-15 LLM calls for planning + generation + 3 fix attempts. Budget $1-$10 per task.
|
||||
- **Review**: Even if tests pass, require human review before merging. Agents can write correct-but-wrong code (technically works, logically incorrect).
|
||||
- **Codebase size**: Most LLMs can't process an entire repo. Use retrieval (grep, embeddings, tree-sitter) to select relevant context.
|
||||
|
|
@ -0,0 +1,94 @@
|
|||
# Data pipeline workflow
|
||||
|
||||
A data pipeline agent automates the process of ingesting data from various sources, transforming it, and loading it into a destination — with the LLM handling the decision-making that traditionally required a human data engineer. This includes schema inference, data quality checks, anomaly detection, and error recovery.
|
||||
|
||||
## Pipeline structure
|
||||
|
||||
```
|
||||
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
|
||||
│ Ingest │ │ Profile & │ │ Transform │
|
||||
│ raw data │────▶│ validate │────▶│ & clean │
|
||||
└──────────────┘ └──────────────┘ └──────┬───────┘
|
||||
│
|
||||
┌──────────────┐ ┌──────────────┐ ┌──────▼───────┐
|
||||
│ Report & │ │ Load to │◀────│ Quality │
|
||||
│ alert │◀────│ destination │ │ check │
|
||||
└──────────────┘ └──────────────┘ └──────────────┘
|
||||
```
|
||||
|
||||
The agent's role in this workflow is not to replace traditional ETL tools but to augment them — handling edge cases, inferring schemas, writing transformation logic, and flagging anomalies that rule-based systems miss.
|
||||
|
||||
## Tools involved
|
||||
|
||||
| Step | Tools | Why |
|
||||
|------|-------|-----|
|
||||
| Ingestion | Unstructured, Firecrawl | Parse diverse input formats |
|
||||
| Profiling | pandas, Great Expectations | Understand data shape and quality |
|
||||
| Transformation | LLM + pandas/polars | Generate transformation code dynamically |
|
||||
| Orchestration | Prefect, Dagster, Hamilton | Manage DAG execution, retries, caching |
|
||||
| Quality checks | Great Expectations, Soda | Validate output data meets expectations |
|
||||
| Alerting | Slack Bolt, Novu | Notify on failures or anomalies |
|
||||
|
||||
## Real projects implementing this workflow
|
||||
|
||||
**[Hamilton](https://github.com/DAGWorks-Inc/hamilton)** — Defines data transformations as Python functions wired into a DAG. Tags: `pipeline` `python`
|
||||
|
||||
**[Prefect](https://github.com/PrefectHQ/prefect)** — Orchestrates data workflows with retries, caching, and observability. Tags: `pipeline` `python`
|
||||
|
||||
**[Dagster](https://github.com/dagster-io/dagster)** — Manages data assets and pipelines with built-in lineage tracking. Tags: `pipeline` `python`
|
||||
|
||||
**[Great Expectations](https://github.com/great-expectations/great_expectations)** — Validates, profiles, and documents data to catch quality issues. Tags: `pipeline` `python`
|
||||
|
||||
**[DLT (data load tool)](https://github.com/dlt-hub/dlt)** — Creates declarative data loading pipelines with automatic schema management. Tags: `pipeline` `python`
|
||||
|
||||
**[Polars](https://github.com/pola-rs/polars)** — Processes dataframes faster than pandas with a Rust-based engine. Tags: `pipeline` `python` `rust`
|
||||
|
||||
## Pseudocode
|
||||
|
||||
```python
|
||||
def data_pipeline_agent(source: str, destination: str, instructions: str):
|
||||
# Step 1: Ingest
|
||||
raw_data = ingest(source) # CSV, API, web page, PDF
|
||||
|
||||
# Step 2: Profile
|
||||
profile = profile_data(raw_data) # row count, dtypes, nulls, distributions
|
||||
issues = llm.analyze_profile(profile, instructions)
|
||||
|
||||
# Step 3: Transform
|
||||
if issues:
|
||||
transform_code = llm.generate_transform(raw_data.schema, issues, instructions)
|
||||
cleaned_data = execute_in_sandbox(transform_code, raw_data)
|
||||
else:
|
||||
cleaned_data = raw_data
|
||||
|
||||
# Step 4: Quality check
|
||||
expectations = llm.generate_expectations(instructions, cleaned_data.schema)
|
||||
qc_result = great_expectations.validate(cleaned_data, expectations)
|
||||
|
||||
if not qc_result.passed:
|
||||
# Try to fix, or alert human
|
||||
notify_slack(f"Quality check failed: {qc_result.failures}")
|
||||
return
|
||||
|
||||
# Step 5: Load
|
||||
load_to_destination(cleaned_data, destination)
|
||||
|
||||
# Step 6: Report
|
||||
notify_slack(f"Pipeline complete: {len(cleaned_data)} rows loaded to {destination}")
|
||||
```
|
||||
|
||||
## Failure modes
|
||||
|
||||
| Failure | Cause | Fix |
|
||||
|---------|-------|-----|
|
||||
| Schema drift | Source schema changed since last run | Profile data before transforming, detect new/missing columns |
|
||||
| Silent data loss | Transformation drops rows without logging | Add row count assertions before and after transforms |
|
||||
| Type coercion errors | Agent writes `int(x)` on a column with nulls | Include null handling in transform instructions |
|
||||
| Destination rejection | Destination schema doesn't match output | Validate output schema against destination before loading |
|
||||
|
||||
## Production considerations
|
||||
|
||||
- **Idempotency**: Ensure the pipeline can be re-run safely. Use upserts instead of inserts, or partition by date.
|
||||
- **Observability**: Log row counts, schema snapshots, and transformation code at every step. When the pipeline fails next month, you'll need to debug it.
|
||||
- **Cost**: The agent primarily generates transformation code, not processes data. LLM cost is low ($0.10-$0.50 per run), but compute cost for processing depends on data volume.
|
||||
- **Testing**: Run the pipeline on a sample of data first. Don't let the agent process 10M rows with untested transformation code.
|
||||
|
|
@ -0,0 +1,227 @@
|
|||
# Multi-step reasoning workflow
|
||||
|
||||
A multi-step reasoning agent solves problems that require planning across many interdependent steps, where the approach isn't obvious upfront and may need to backtrack. Unlike a simple ReAct loop, a multi-step reasoner explicitly manages its own reasoning state — tracking what it tried, what failed, and what alternative paths remain.
|
||||
|
||||
## When you need multi-step reasoning
|
||||
|
||||
| Signal | Example |
|
||||
| ------ | ------- |
|
||||
| The task has no obvious single correct path | "Find a bug in this codebase and fix it" |
|
||||
| Early decisions affect which later steps are valid | "Write a migration plan, then execute it" |
|
||||
| The agent might need to backtrack and try a different approach | "Solve this math problem" |
|
||||
| Quality of the final answer matters more than speed | "Write a comprehensive literature review" |
|
||||
|
||||
If your task is linear (step A → B → C with no branching), use [plan-and-execute](../patterns/plan-and-execute.md) instead — it's simpler and faster.
|
||||
|
||||
## Reasoning architectures
|
||||
|
||||
### 1. ReAct + reflection (most common)
|
||||
|
||||
The agent runs a ReAct loop and then critiques its own output. If the critique finds problems, the agent revises and loops again.
|
||||
|
||||
```
|
||||
┌────────────────────────────────────────────────────┐
|
||||
│ │
|
||||
│ ┌──────────┐ ┌──────────┐ ┌──────────────┐ │
|
||||
│ │ ReAct │───▶│ Output │───▶│ Self-critic │ │
|
||||
│ │ loop │ │ │ │ │ │
|
||||
│ └──────────┘ └──────────┘ └──────┬───────┘ │
|
||||
│ ▲ │ │
|
||||
│ └────────── Revise ─────────────┘ │
|
||||
└────────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
### 2. Tree of Thoughts (exploration-heavy tasks)
|
||||
|
||||
The agent explores multiple reasoning paths in parallel before committing. Each branch is evaluated; the best branch continues.
|
||||
|
||||
```
|
||||
┌──────────────┐
|
||||
│ Problem │
|
||||
└──────┬───────┘
|
||||
│
|
||||
┌────────────────┼────────────────┐
|
||||
│ │ │
|
||||
┌────▼────┐ ┌────▼────┐ ┌────▼────┐
|
||||
│ Path A │ │ Path B │ │ Path C │
|
||||
│ Score:7 │ │ Score:9 │ │ Score:4 │
|
||||
└─────────┘ └────┬────┘ └─────────┘
|
||||
│ (selected)
|
||||
┌──────▼───────┐
|
||||
│ Solution │
|
||||
└──────────────┘
|
||||
```
|
||||
|
||||
### 3. LATS (Language Agent Tree Search)
|
||||
|
||||
Combines Monte Carlo Tree Search with LLM reasoning. The agent selects actions based on a value function, explores promising branches, and backpropagates results to update branch estimates.
|
||||
|
||||
```
|
||||
┌─────────┐
|
||||
│ Root │ (initial state)
|
||||
└────┬────┘
|
||||
│ select (UCB score)
|
||||
┌──────┴──────┐
|
||||
│ │
|
||||
┌────▼────┐ ┌────▼────┐
|
||||
│ Branch1 │ │ Branch2 │
|
||||
│ v=0.7 │ │ v=0.3 │
|
||||
└────┬────┘ └─────────┘
|
||||
│ expand
|
||||
┌────▼────┐
|
||||
│ Child │
|
||||
└────┬────┘
|
||||
│ simulate + backpropagate
|
||||
Update v for Branch1, Root
|
||||
```
|
||||
|
||||
## Tools
|
||||
|
||||
### Stateful graph orchestration
|
||||
|
||||
**[LangGraph](https://github.com/langchain-ai/langgraph)** — Orchestrates multi-step reasoning as stateful, cyclical graphs with explicit branching and loop control. Tags: `planning` `orchestration` `python` `typescript`
|
||||
|
||||
LangGraph is the go-to for multi-step reasoning because it models the reasoning process as a graph where nodes are steps and edges are transitions. Conditional edges let the agent branch based on intermediate results. Cycles let it loop until a quality threshold is met.
|
||||
|
||||
```python
|
||||
from langgraph.graph import StateGraph, END
|
||||
from typing import TypedDict
|
||||
|
||||
class ReasoningState(TypedDict):
|
||||
problem: str
|
||||
current_solution: str
|
||||
critique: str
|
||||
iteration: int
|
||||
max_iterations: int
|
||||
|
||||
def solve(state: ReasoningState) -> ReasoningState:
|
||||
solution = llm.invoke(f"Solve: {state['problem']}\nPrevious attempt: {state['current_solution']}")
|
||||
return {**state, "current_solution": solution.content}
|
||||
|
||||
def critique(state: ReasoningState) -> ReasoningState:
|
||||
feedback = llm.invoke(f"Critique this solution: {state['current_solution']}\nProblem: {state['problem']}")
|
||||
return {**state, "critique": feedback.content, "iteration": state["iteration"] + 1}
|
||||
|
||||
def should_continue(state: ReasoningState) -> str:
|
||||
if state["iteration"] >= state["max_iterations"]:
|
||||
return "end"
|
||||
if "looks correct" in state["critique"].lower():
|
||||
return "end"
|
||||
return "solve" # loop back
|
||||
|
||||
graph = StateGraph(ReasoningState)
|
||||
graph.add_node("solve", solve)
|
||||
graph.add_node("critique", critique)
|
||||
graph.add_edge("solve", "critique")
|
||||
graph.add_conditional_edges("critique", should_continue, {"solve": "solve", "end": END})
|
||||
graph.set_entry_point("solve")
|
||||
|
||||
app = graph.compile()
|
||||
result = app.invoke({"problem": "...", "current_solution": "", "critique": "", "iteration": 0, "max_iterations": 5})
|
||||
```
|
||||
|
||||
### State machine tracking
|
||||
|
||||
**[Burr](https://github.com/dagworks-inc/burr)** — Manages multi-step agent state with built-in persistence, retries, and observability. Tags: `planning` `python` `stategraph`
|
||||
|
||||
Burr is excellent when you need to resume reasoning workflows after failures — the state is persisted between steps, so a crash doesn't mean starting over.
|
||||
|
||||
```python
|
||||
from burr.core import action, State, ApplicationBuilder
|
||||
|
||||
@action(reads=["problem", "history"], writes=["solution"])
|
||||
def reason(state: State) -> State:
|
||||
history_str = "\n".join(state["history"])
|
||||
solution = llm.invoke(f"Problem: {state['problem']}\nHistory:\n{history_str}\nNext step:")
|
||||
return state.update(solution=solution.content)
|
||||
|
||||
@action(reads=["solution", "history"], writes=["history", "is_done"])
|
||||
def evaluate(state: State) -> State:
|
||||
new_history = state["history"] + [state["solution"]]
|
||||
is_done = len(new_history) >= 5 or "FINAL ANSWER" in state["solution"]
|
||||
return state.update(history=new_history, is_done=is_done)
|
||||
|
||||
app = (
|
||||
ApplicationBuilder()
|
||||
.with_actions(reason, evaluate)
|
||||
.with_transitions(("reason", "evaluate"), ("evaluate", "reason", lambda s: not s["is_done"]))
|
||||
.with_state(problem="...", history=[], solution="", is_done=False)
|
||||
.with_entrypoint("reason")
|
||||
.build()
|
||||
)
|
||||
action_name, result, state = app.run(halt_after=["evaluate"], inputs={"is_done": True})
|
||||
```
|
||||
|
||||
### Tree-based reasoning
|
||||
|
||||
**[LATS](https://github.com/lapisrocks/LanguageAgentTreeSearch)** — Applies Monte Carlo tree search to LLM reasoning for tasks requiring exploration over many possible paths. Tags: `planning` `python` `research`
|
||||
|
||||
**[Tree of Thoughts](https://github.com/princeton-nlp/tree-of-thought-llm)** — Generates and evaluates multiple reasoning paths in parallel before selecting the best continuation. Tags: `planning` `python` `research`
|
||||
|
||||
---
|
||||
|
||||
## Pseudocode (ReAct + reflection with LangGraph)
|
||||
|
||||
```python
|
||||
def multi_step_reasoning_agent(problem: str, max_iterations: int = 5) -> str:
|
||||
state = {
|
||||
"problem": problem,
|
||||
"current_solution": "",
|
||||
"critique": "",
|
||||
"iteration": 0,
|
||||
"max_iterations": max_iterations
|
||||
}
|
||||
|
||||
for i in range(max_iterations):
|
||||
# Step 1: Generate or improve a solution
|
||||
solution = llm.invoke(
|
||||
f"Problem: {state['problem']}\n"
|
||||
f"Previous critique: {state['critique']}\n"
|
||||
"Generate an improved solution:"
|
||||
)
|
||||
state["current_solution"] = solution
|
||||
|
||||
# Step 2: Critique the solution
|
||||
critique = llm.invoke(
|
||||
f"Solution: {state['current_solution']}\n"
|
||||
"Evaluate this solution. Is it correct and complete?\n"
|
||||
"Reply 'ACCEPTED' if it's correct, or explain specific issues."
|
||||
)
|
||||
|
||||
if "ACCEPTED" in critique:
|
||||
return state["current_solution"]
|
||||
|
||||
state["critique"] = critique
|
||||
state["iteration"] += 1
|
||||
|
||||
# Return best solution after max iterations
|
||||
return state["current_solution"]
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Failure modes
|
||||
|
||||
| Failure | Cause | Fix |
|
||||
| ------- | ----- | --- |
|
||||
| Infinite refinement loops | Critique never says "accepted" | Add a maximum iteration count and return best solution |
|
||||
| Sycophantic self-critique | LLM agrees with itself too easily | Use a separate model or persona for the critique step |
|
||||
| Context window overflow | Long reasoning chains fill the context | Compress previous steps to summaries; keep only the last N full steps |
|
||||
| Expensive tree exploration | ToT/LATS explores too many branches | Limit branching factor (max 3 branches) and depth (max 5 levels) |
|
||||
| Lost state on failure | In-memory state lost on crash | Use Burr or LangGraph checkpointing for persistence |
|
||||
|
||||
---
|
||||
|
||||
## Production considerations
|
||||
|
||||
- **Cost control**: ReAct+reflection doubles LLM calls vs. a single pass. Tree-based methods can multiply costs 10–50×. Always instrument cost per reasoning run and set hard limits.
|
||||
- **Observability**: Log each reasoning step with a trace ID. When a user reports a wrong answer, you need to replay the exact reasoning chain that produced it.
|
||||
- **Timeouts**: Set wall-clock timeouts on the full reasoning loop (not just per-step). A reasoning agent stuck in a loop should fail fast, not hang for 10 minutes.
|
||||
- **Human-in-the-loop**: For high-stakes decisions, pause the reasoning loop after N steps and ask a human to review before continuing. LangGraph supports this natively via interrupt points.
|
||||
|
||||
## Related pages
|
||||
|
||||
- [ReAct pattern](../patterns/react-pattern.md) — The foundational loop used inside multi-step reasoners
|
||||
- [Reflection loop pattern](../patterns/reflection-loop.md) — The self-critique mechanism explained in depth
|
||||
- [Planning skill](../skills/planning.md) — Tools and libraries for the planning layer
|
||||
- [Research agent workflow](research-agent.md) — A concrete example using multi-step reasoning for research tasks
|
||||
|
|
@ -0,0 +1,98 @@
|
|||
# Research agent workflow
|
||||
|
||||
A research agent autonomously gathers information from multiple sources, synthesizes findings, and produces a structured report. This is one of the most common agentic workflows because it combines perception (web search, document reading), memory (tracking what's been found), planning (deciding what to search next), and communication (writing the final report).
|
||||
|
||||
## Pipeline structure
|
||||
|
||||
```
|
||||
┌─────────────┐ ┌──────────────┐ ┌────────────────┐
|
||||
│ Define │ │ Search & │ │ Synthesize │
|
||||
│ research │────▶│ extract │────▶│ & verify │
|
||||
│ question │ │ sources │ │ findings │
|
||||
└─────────────┘ └──────┬───────┘ └───────┬────────┘
|
||||
│ │
|
||||
┌──────▼───────┐ ┌───────▼────────┐
|
||||
│ Store in │ │ Generate │
|
||||
│ memory │ │ report │
|
||||
└──────────────┘ └────────────────┘
|
||||
▲ │
|
||||
│ Need more data? │
|
||||
└──────────────────────┘
|
||||
```
|
||||
|
||||
The critical loop is between synthesis and search. A good research agent recognizes gaps in its findings and issues follow-up searches rather than generating a report from incomplete data.
|
||||
|
||||
## Tools involved
|
||||
|
||||
| Step | Tools | Why |
|
||||
|------|-------|-----|
|
||||
| Web search | Tavily, Jina Reader | Optimized for LLM-friendly search results |
|
||||
| Document parsing | Docling, Marker | Handle PDFs and academic papers |
|
||||
| Memory | Chroma, LanceDB | Track sources and avoid re-reading |
|
||||
| Planning | LangGraph, DSPy | Decide when to search more vs. synthesize |
|
||||
| Report generation | LLM (direct) | Structured output with citations |
|
||||
| Delivery | Resend, Slack Bolt | Send the finished report |
|
||||
|
||||
## Real projects implementing this workflow
|
||||
|
||||
**[GPT Researcher](https://github.com/assafelovic/gpt-researcher)** — Conducts multi-source web research and produces cited reports autonomously. Tags: `pipeline` `perception` `python`
|
||||
|
||||
**[STORM](https://github.com/stanford-oval/storm)** — Generates Wikipedia-style articles by researching and synthesizing multiple sources. Tags: `pipeline` `planning` `python`
|
||||
|
||||
**[Tavily](https://github.com/tavily-ai/tavily-python)** — Provides search API optimized for LLM agents needing real-time web data. Tags: `perception` `python`
|
||||
|
||||
**[Langchain RAG templates](https://github.com/langchain-ai/langchain)** — Offers pre-built retrieval-augmented generation pipelines for research workflows. Tags: `pipeline` `python` `langchain`
|
||||
|
||||
**[Khoj](https://github.com/khoj-ai/khoj)** — Acts as a personal AI research assistant that searches your notes and the web. Tags: `pipeline` `perception` `python`
|
||||
|
||||
## Pseudocode
|
||||
|
||||
```python
|
||||
def research_agent(question: str, max_iterations: int = 5):
|
||||
memory = VectorStore()
|
||||
sources = []
|
||||
|
||||
# Step 1: Generate initial search queries
|
||||
queries = llm.generate_queries(question, count=3)
|
||||
|
||||
for iteration in range(max_iterations):
|
||||
# Step 2: Search and extract
|
||||
for query in queries:
|
||||
results = tavily.search(query)
|
||||
for result in results:
|
||||
content = jina_reader.extract(result.url)
|
||||
memory.add(content, metadata={"url": result.url})
|
||||
sources.append(result.url)
|
||||
|
||||
# Step 3: Synthesize current findings
|
||||
relevant = memory.search(question, top_k=10)
|
||||
draft = llm.synthesize(question, relevant)
|
||||
|
||||
# Step 4: Check for gaps
|
||||
gaps = llm.identify_gaps(question, draft)
|
||||
if not gaps:
|
||||
break
|
||||
|
||||
# Step 5: Generate follow-up queries
|
||||
queries = llm.generate_queries_from_gaps(gaps)
|
||||
|
||||
# Step 6: Generate final report with citations
|
||||
report = llm.generate_report(question, draft, sources)
|
||||
return report
|
||||
```
|
||||
|
||||
## Failure modes
|
||||
|
||||
| Failure | Cause | Fix |
|
||||
|---------|-------|-----|
|
||||
| Superficial report | Agent stops after first search | Set minimum source count before synthesis |
|
||||
| Circular searching | Agent re-searches the same queries | Track searched queries in memory, deduplicate |
|
||||
| Hallucinated citations | LLM invents URLs that don't exist | Validate every citation URL before including it |
|
||||
| Stale information | Sources are outdated | Filter search results by date, prefer recent |
|
||||
| Infinite loop | Gap detection always finds gaps | Set max_iterations and accept "good enough" |
|
||||
|
||||
## Production considerations
|
||||
|
||||
- **Cost**: A thorough research session makes 10-30 LLM calls and 20-50 search API calls. Budget $0.50-$5.00 per report depending on depth.
|
||||
- **Latency**: End-to-end, expect 30 seconds to 5 minutes. Not suitable for real-time use — best as a background job with notification on completion.
|
||||
- **Observability**: Log every search query, every source URL, and every synthesis step. When the report is wrong, you need to trace which source led to the error.
|
||||
Loading…
Reference in New Issue