Awesome AI for Teams

English | 简体中文

AI tools and practical resources for small engineering teams and tech leads.

Find tools to share project knowledge, coordinate coding agents, reuse team practices, and manage model access and usage. Includes hosted products, self-hostable tools, developer components, and learning resources.

Beyond this list: www.goodthingure.com carries per-tool pages with GitHub stars, licence terms, limitations and open issue numbers — 78 tools, 28 side-by-side comparisons, and 5 step-by-step scenarios. Every page states when it fits, when it does not, and the source it was verified against. There is also a Chinese edition with the same content.

Use it from an AI client: this repository doubles as an MCP server. Add {"command": "npx", "args": ["-y", "github:c-k-x/awesome-ai-for-teams"]} to your Claude Desktop or Cursor config and the agent can query fit, limits, licence terms and open issue numbers directly. See mcp/README.md.

Start with a team problem

Each entry explains its purpose and relevant limits. Descriptions summarize official sources; inclusion does not imply hands-on testing or production certification. Ordering is not a ranking.

Notes from the list maintainer: Hand off coding tasks with Backlog.md · Assign and review agent work with Multica. Both include practical examples and state what has not been tested.

Star this list to keep it handy for your next tool search, or suggest a resource or correction.

Related MCP server: @neurynae/toolcairn-mcp

Contents

• Start with a Team Problem

• Model Access

• Document Parsing and Preparation

• Agent Assistants, Sessions, and Handoffs

• Chat and Meeting Integrations

• Shared Collaboration Spaces

• Task Delegation and Delivery

• Whiteboards and Visual Collaboration

• Team Knowledge and Shared Practices

  • Shared Knowledge and Assistants

  • Shared Rules and Experience

• Knowledge Retrieval and Memory

• Application Development and Workflows

• Execution Environments and Managed Runtimes

• Evaluation, Observability, and Content Checks

• Protocols and Learning Resources

  • Protocols and Conventions

  • Practical Guides

  • Tutorials and Research

  • More Resource Directories

• Contributing

• License

Model Access

Unify model access, routing, and usage management across providers, or use existing cloud model services.

• AIHelms - Manage model quotas, cost attribution, and skill approvals by person, department, and project. GPL and commercial licensing options; A2A collaboration remains planned.

• Amazon Bedrock - Access hosted foundation models and knowledge bases within AWS resource and access management.

• Bifrost - Access multiple model providers through one gateway with fallbacks, load balancing, and request logs; clustering and some governance features require the enterprise edition.

• Gemini Enterprise Agent Platform (Vertex AI) - Manage model access, deployment, and agent runtimes on Google Cloud under the platform name replacing Vertex AI.

• Helicone - Observe model requests and usage through a gateway or asynchronous logging, with routing and request controls in the gateway path.

• Higress - Centralize model APIs and MCP tools with authentication, rate limits, request logs, and observability so team projects can reuse common access infrastructure.

• LiteLLM - Access multiple model providers through an SDK or proxy, with application keys, routing, and usage management in the proxy.

• MCPHub - Centralize MCP servers with per-user credentials, visibility controls, request logs, and health monitoring.

• MCPJungle - Publish a shared MCP tool directory and control which servers each client can access, with centralized observability. OAuth flows remain planned.

• Microsoft Foundry - Organize models, agents, tools, and evaluation assets by project on Azure with managed execution and observability.

• Obot - Distribute approved models, MCP servers, and skills across an organization with shared identity, access, and audit infrastructure for different AI clients. Device-side and server-side auditing require their respective components.

• OpenRouter - Access models through a hosted endpoint with provider selection, model fallbacks, and centralized usage records.

• Plano - Centralize model and agent routing, filters, and tracing in a proxy layer so team applications can reuse shared runtime configuration.

• Portkey AI Gateway - Centralize model retries, fallback routing, and load balancing in a gateway; assess the full management platform separately.

• TokenHub - Allocate model access and project keys by team role, track usage by project and cost center, and compare internal records with provider bills.

• ToolHive - Run MCP servers in isolated containers locally or on Kubernetes, with a curated registry and a gateway for access policies and observability; compare the open-source and Stacklok Enterprise editions for identity and audit features.

Document Parsing and Preparation

Convert PDFs, office files, scans, and other source material into content suitable for model input and retrieval.

• Docling - Convert PDFs, office files, and images into a structured document representation with text, tables, and layout information.

• LlamaParse - Use a parsing service to prepare scans, tables, and charts in complex documents for extraction, retrieval, and analysis.

• MarkItDown - Convert common office files, PDFs, and web pages to Markdown for model input and text analysis.

• Unstructured - Partition documents into typed elements with metadata for cleaning, chunking, and knowledge retrieval.

Agent Assistants, Sessions, and Handoffs

Use assistants to execute tasks, manage multiple sessions, and continue work across sessions or tools.

• Aider - Edit projects from the terminal using repository maps and Git, with lint and test feedback to help teams inspect and revert AI-generated changes.

• Apache Maka (Incubating) - Run agent tasks through desktop or terminal interfaces with event records for tool calls and completion states; no official Apache release yet.

• Claude Code - Read a project, edit files, and run development commands to investigate problems and implement changes with execution feedback.

• Clay Studio (chadbyte) - Expose local coding agents through a browser workspace for cross-device access, shared sessions, and handoffs.

• cli-continues - Prepare text-based handoffs from local coding sessions so another assistant can continue the project; running processes are not migrated.

• codeg - Manage coding agent sessions and tasks in one interface, separating changes with Git worktrees for review.

• Codex - Read and modify repositories and run commands and checks from a terminal-based coding agent.

• Cursor - Combine code, terminal output, and diffs in an editor to make changes that developers can review.

• Gemini CLI - Use Gemini from the terminal for repository analysis, file changes, and command execution, with headless automation support.

• Golutra - Turn existing CLI agents into a parallel AI team with workflows, result handoffs, and long-running memory; EverOS can provide the memory layer; licensed under BSL-1.1.

• Herdr - Manage multiple agent terminals, identify sessions waiting for input, and control workspaces through a CLI.

• Hermes Agent (Nous Research) - Combine a terminal, messaging gateway, scheduled tasks, and file-based memory to reuse preferences and procedures over time.

• Hive (tt-a1i) - Organize Claude Code, Codex, Gemini, and other CLI agents into a visible local team with PTYs, a shared Markdown task graph, and a browser workbench; BUSL-1.1 with no multi-user authentication boundary.

• holaOS - Use applications and agents side by side on a desktop with reusable tools, skills, and local memory; team governance depends on the edition.

• Letta - Run persistent agents with versioned file-based memory through a CLI or application interfaces.

• MCO - Run multiple coding agents in parallel from a CLI, compare their results, and execute in read-only or write modes; an engineering orchestration component rather than a multi-user workspace.

• OpenClaw - Run a persistent assistant gateway that accepts tasks from messaging platforms and devices and manages tools, sessions, and workspace memory.

• OpenCode - Choose model providers and reuse project rules, tools, and agent roles in a coding assistant.

• OpenHands Agent Canvas - Manage coding agent sessions in a self-hostable console, switch between local and remote backends, and automate development tasks through schedules and events.

• OpenHive (Aden) - Run production business processes through a multi-agent harness where a Queen grows worker agents around a persistent plan, shared ledger, recovery, observability, and human oversight; Apache-2.0.

• OpenMemory (Mem0) - Convert and import coding sessions across Claude Code, Codex, and OpenCode; the current beta differs from the archived memory service of the same name.

• Tabby - Self-host code completion and chat backed by repositories and internal documentation, giving team editors shared development context.

• Vibe Kanban - Coordinate local coding-agent runs in isolated Git worktrees and review their diffs; the original hosted team service shut down in 2026, and v0.1.44's no-sign-in path is limited to local workspaces while community maintenance continues.

Chat and Meeting Integrations

Bring assistants into existing chat and meeting channels to reduce manual transfer of requests, context, and results.

• AgentConnect - Connect agents on execution machines to Slack, Feishu, and code platforms for tasks triggered by messages, events, or schedules.

• Agentic Inbox - Share an email interface with AI-assisted conversation search and reply drafting on Cloudflare Workers. Intended for trusted groups: authorized users can access every mailbox.

• Ask Gemini in Google Chat - Use work context in Google Chat to find information, prepare content, and act through connected applications; currently available only in English.

• Centaur (Paradigm) - Delegate engineering tasks from Slack to Kubernetes sandboxes and return progress and results to the originating thread.

• Claude Tag - Let teammates jointly delegate and follow Claude tasks in Slack threads; currently a beta for Team and Enterprise.

• DingTalk AI Assistant - Connect an existing agent service to DingTalk through passthrough mode, keeping planning and execution in the backend.

• Feishu (豆包工作伙伴, formerly aily) - Connect knowledge, skills, and business workflows within Feishu for workplace questions and tasks; formerly aily.

• LangBot - Connect AI assistants to chat platforms such as Feishu and WeCom, using built-in capabilities or existing Dify and n8n workflows.

• Mattermost Agents - Configure AI assistants in Mattermost channels and direct messages, managing model and tool access within existing discussions.

• Meetily - Capture and transcribe meetings locally, then summarize them with a local or cloud model; export and team features differ between Community and Pro editions.

• Microsoft Teams Agents - Use built-in or custom agents in meetings, channels, and chats for notes, project questions, and business tasks, depending on agent type and licensing.

• Nextcloud Assistant Talk Bot - Connect Nextcloud Assistant to Talk conversations so participants can ask the configured model through @assistant.

• OpenTag (Amplift) - Queue coding work from Slack, request approval for key actions, and return progress and delivery evidence to the originating thread. Slack is the supported team entry point; distinct from Open Tag by fancyboi999.

• Rocket.Chat AI App - Add knowledge answers and conversation summaries to team chat and customer support; the AI app is a licensed beta feature.

• Slack AI Agents - Use Slackbot or installed agent applications from channels and dedicated sessions, keeping requests and results in team discussions.

• Spacebot - Run a self-hosted assistant across Slack, Discord, and other channels, with concurrent conversations, shared memory, background tasks, and channel permissions; currently in beta under FSL-1.1-ALv2.

• Switch - Connect existing agents to Slack, Teams, and other chat platforms so colleagues and agents work in shared rooms with common context; licensed under Apache-2.0 with the Commons Clause.

• Tentix - Combine AI replies, knowledge retrieval, and human handoffs in support tickets for shared customer service workflows; some staff management and analytics features remain planned.

• Vexa - Send bots into Google Meet, Teams, or Zoom and access live transcripts through an API for meeting notes and downstream knowledge workflows.

• WeCom AI Bot - Use the official SDK for messages, card events, and streaming replies to connect custom AI services to WeCom.

• ZoomMate - Use meeting and chat context to prepare artifacts and carry out CRM or ticket follow-up through configured workflows.

Shared Collaboration Spaces

Let people and agents continue work around shared discussions, material, and artifacts instead of disconnected sessions.

• Agenta - Bring assistant configuration, shared files, triggers, and execution traces into a workspace for teams to maintain and reuse.

• agentchattr - Coordinate people and coding agents in shared local channels, using mentions to hand off tasks and context; intended for local or trusted networks.

• AgentTeams - Coordinate people and agents from different runtimes in Matrix rooms, sharing files and visible task progress while the platform manages agent containers.

• Agor - Collaborate on live boards and shared coding-agent sessions, with separate Git working directories per branch and shared knowledge; source-available under BUSL-1.1.

• Alook - Invite colleagues into shared rooms, channels, and direct messages with persistent coding agents running on connected machines.

• AppFlowy - Bring documents, wikis, and projects into a shared workspace with AI search and writing assistance; verify self-hosting and enterprise features for the chosen edition.

• Buzz (Block) - Connect people and agents in self-hosted channels using signed identities and shared event records for discussion and results.

• Cloudflare OS - Create and share stateful AI-built applications for ongoing collaboration on Cloudflare infrastructure; currently in early access.

• Commonly - Let people and agents share persistent rooms, task boards, memory, and artifacts, with GitHub task synchronization and reviewable activity. The project is still early.

• Cumora - Bring people and persistent agents into the same group chats, direct messages, task boards, and calendars for shared assignments and handoffs. Mobile support varies by platform.

• HQBase - Run shared team mailboxes in your own Cloudflare account, using member access controls, audit history, and MCP access so colleagues and assistants can work with the same email.

• Lemma - Provide tables, files, permissions, workflows, and human input steps for business applications used by people and agents.

• Lody - Share coding-agent conversations, files, and diffs with teammates and review permission requests across devices; document workspaces remain planned.

• Macro - Link email, messages, tasks, and documents in one workspace for people and agents to retrieve context and follow up on work.

• Manor AI - Combine knowledge retrieval, agent tasks, tool bindings, and approvals in a self-hosted workspace with execution and artifact records.

• Octo - Connect organizational chat, files, and agent runtimes in a backend whose companion clients show replies, status, and tool activity.

• Omnigent - Invite teammates to share, co-drive, or fork live agent sessions for pairing and handoffs; co-driving executes on the original owner’s machine.

• Open WebUI - Connect models, knowledge bases, and tools in a self-hosted interface where members collaborate through shared channels and notes with group-based permissions.

• OpenAgents Workspace - Invite teammates into a workspace where people and agents share threads, files, and a browser; headless Goose uses automatic tool execution.

• QM - Organize assistants, files, memory, and execution by personal and room scope for internal collaboration experiments; labeled early experimental software.

• Relaticle - Share customer data in a self-hosted CRM and expose MCP tools to agents within workspace-scoped access controls. Licensed under AGPL.

• Rowboat - Share threads, files, whiteboards, and version history while each teammate’s local agent brings results from personal context back for review.

• Synapse (Z.ai) - Connect members, native actors, and external agents through shared sessions with resource grants and handoffs; still in early development.

• taOS - Combine chat, tasks, knowledge, memory, and multiple agent frameworks in a self-hosted AI workspace with groups, channels, agent identities, A2A coordination, and distributed devices; currently in beta, and its built-in chat is not a general-purpose IM server.

• team9 - Collaborate with OpenClaw-based agents through channels, threads, and shared documents that retain discussion and artifacts.

• Tutti - Link agent sessions, tasks, and files to reduce handoff work; evaluate the local edition and multiplayer VM rooms separately.

• XYNE Spaces - Bring messages, email, and documents into organizational search and collaboration with permission-aware context for people and agents.

Task Delegation and Delivery

Make task ownership, progress, deliverables, and review handoffs visible; completion and acceptance semantics differ by tool.

• AgentRQ - Assign tasks to people and agents through a shared workspace, synchronize progress, and review permission requests for sensitive actions.

• Asana AI Teammates - Take assignments in Asana projects, use project context to prepare material and drafts, and return work for team review.

• Backlog.md - Store tasks, dependencies, and acceptance criteria as repository Markdown, with CLI, MCP, and board interfaces for people and coding agents to maintain delivery plans.

• Chorus - Link proposals, documents, task execution, and human verification while managing coding agent permissions, sessions, and progress for team delivery review.

• GitHub Agent HQ - Select coding agents, inspect sessions, and review their pull requests within existing GitHub delivery workflows.

• It's a Plan - Run a self-hosted issue tracker where agents are project members with roles and assignments, taking work from mentions, assignments, or schedules and running on an instance model or your own coding CLI; SSO, audit logs, and agent budgets require the Pro edition.

• Kaneo - Let people and agents work with the same projects, tasks, and labels through a self-hosted project workspace and its official MCP interface.

• Linear Agents - Delegate to agents from issues and track progress and artifacts there while retaining a human assignee.

• Markplane - Keep tasks, plans, and dependencies in Markdown shared through Git, generating project summaries that teammates' assistants can access through MCP to continue work.

• Mission Control by Builderz - Centralize agent task assignments, reviews, costs, roles, and approvals in a self-hosted operations dashboard. Currently alpha software.

• monday.com Agents - Process board assignments or triggers with contextual classification, updates, handoffs, and execution records.

• MonkeyCode - Manage requirements, coding tasks, models, and development environments in a shared AI development platform that can run inside an enterprise network.

• Multica - Assign issues to existing coding agents on your own runtimes and return progress, blockers, and results to the same issue for team review.

• Open Tag - Turn channel messages into claimable, assignable, and transferable agent tasks with thread context; intended for self-hosted evaluation.

• Open-Inspect - Collaborate in background coding sessions and hand work through Slack, tickets, and pull requests while retaining contribution attribution. Intended for a trusted single organization; repository access is not checked per user.

• Optio - Assign ticket, scheduled, and event-triggered work to agents on team machines or Kubernetes, with workspace roles, OAuth/OIDC, and execution visibility.

• Paca - Let people and agents claim tasks and maintain requirements and design documents on the same Scrum board and sprints, with member roles and live progress for team delivery.

• Paperclip - Coordinate human users and agents through organization-scoped tasks, approvals, roles, budgets, and execution records.

• PR-Agent - Generate PR descriptions, reviews, and improvement suggestions through CLI, CI, or code-host events; now community-maintained and distinct from the commercial Qodo product.

• Raft (formerly Slock) - Connect team channels with agent task claims and review states so teammates can hand off work and inspect deliverables.

• Solo (solo-agent) - Link agent task ownership, execution records, delivery versions, and reviews in submission and revision workflows.

• yylo - Run Kanban, task, and merge loops for coding agents across isolated Git worktrees, with typed admission gates and strict-JSON output that teams can script and review.

Whiteboards and Visual Collaboration

Turn AI drafts into visual artifacts that teams can discuss, edit, or embed in products.

• Excalidraw MCP App - Generate and interactively edit Excalidraw diagrams in MCP Apps clients so teams can refine AI drafts.

• FigJam AI - Generate workshop boards and diagrams, then sort and summarize the sticky notes from team discussions.

• Miro AI - Use material on a shared canvas to organize ideas and generate documents and diagrams for product and design discussions.

• OpenPencil - Combine real-time collaborative design editing with AI and MCP so teammates and agents can modify, inspect, and export the same design; under active development.

• tldraw Agent Starter Kit - Provide an application template for agents to read, create, and modify canvas shapes in visual collaboration products.

Team Knowledge and Shared Practices

Help teammates and assistants reuse organizational knowledge, rules, skills, and experience with less repeated explanation.

Shared Knowledge and Assistants

• 53AI Hub - Publish agents, prompts, and AI tools from multiple platforms through a team portal with grouping and access controls; organizational directory integrations depend on the edition.

• AnythingLLM - Organize document chat, agents, and tools in workspaces with local or cloud models; multi-user accounts and permissions require the Docker edition.

• Atlassian Rovo - Search Jira, Confluence, and connected work knowledge, and configure agents to organize and act on project information.

• Bionic - Provide internal teams with approved models, knowledge, and tools in a self-hosted AI workspace with permissions, usage controls, and audit records.

• DataHub - Maintain shared data ownership, lineage, and discussions in a metadata graph that supports human discovery and AI context. DataHub Cloud is a separate managed service.

• DocsGPT - Turn shared documents and meeting material into searchable knowledge with agents, member roles, and team-scoped sharing.

• Dust - Connect company knowledge and business tools to shared agents so teammates can reuse common answers and working methods.

• Glean Independent Agents - Use connected company knowledge for ongoing investigations, feedback processing, and follow-up with human review.

• LibreChat - Use multiple model providers in a self-hostable chat platform and share assistants with tools and file search with selected users and groups.

• MaxKB - Build internal assistants from document ingestion, knowledge retrieval, and workflows, then embed them in existing business systems for colleagues.

• Nexent - Share agent tools, skills, and memory through a no-code platform with multi-tenancy and role-based resource access.

• Notion Agent - Find workspace information and create or edit pages and databases to carry out document-based tasks.

• Notion Custom Agents - Configure shared assistants for recurring questions, feedback triage, and reports triggered by schedules or events.

• Octop - Share one assistant deployment across a small team, with per-user agents and workspaces, JWT authentication, and workplace messaging integrations. Shared resource pools and autonomous AgentTeams remain planned.

• OmniBox - Collect documents and share knowledge-based questions and answers in multi-tenant spaces with team permissions; RSS support remains planned.

• Onyx - Connect organizational knowledge and share chats and custom agents; standard deployments include document sync and retrieval, while Lite and enterprise capabilities differ.

• OpenContracts - Let teams annotate documents, maintain citation graphs, and review agent-assisted findings through corpus permissions, version history, and discussions.

• OpenKnowledge - Share and sync Markdown knowledge bases, specifications, and notes through Git/GitHub, with agents searching and editing team material inside the editor.

• OpenMetadata - Link data ownership, lineage, quality, business terms, and organizational knowledge into shared context for people and AI agents. Enterprise AI capabilities such as AI Studio are offered separately through Collate.

• PandaWiki - Publish product documentation, technical material, and FAQs as wikis with AI writing, search, and answers, including integrations with team chat channels.

• WeKnora - Sync sources such as Feishu and GitLab into shared knowledge bases for retrieval and answers, and organize documents into editable wikis with revision history.

• Yuxi - Share knowledge bases, agents, and skills by tenant, department, and user in a self-hosted platform with resource permissions and approvals.

Shared Rules and Experience

• Agent Package Manager - Version and distribute team skills, prompts, and plugins with manifests, lockfiles, organization policies, and CI checks for configuration drift.

• Agent Skills Platform - Package reusable skills with ownership, approvals, versions, and validation evidence for colleagues to install through a governed marketplace.

• Knowns - Store requirements, tasks, acceptance criteria, and decisions in the repository for teammates and assistants to reuse through CLI and MCP; a dedicated team sync service remains planned.

• MEX - Keep architecture, decisions, and handoffs in the code repository for teammates and coding agents to retrieve and reuse; share through Git while maintaining local indexes separately.

• Observal - Register internal agents, skills, and MCP tools, review versions, and use adoption and session feedback to improve shared assets.

• Potpie - Organize code, pull requests, tasks, and team decisions into a searchable context graph so coding assistants can reuse project background and engineering knowledge.

• Rulesync - Generate agent-specific skills, rules, and MCP configuration from shared source files so teams can maintain one configuration set across coding tools; supported features vary by target.

• SkillHub - Publish and distribute organizational skills through team namespaces, owner/admin/member roles, versioning, and promotion reviews. Distributed skills retain their own licenses.

• SkillKit - Share skill sources through a Git-tracked team manifest and translate skills for different coding agents; target-client compatibility needs separate verification.

• SkillPort - Validate and manage skill packages, then provide search and on-demand loading through CLI or MCP so teams can reuse their skill library; APIs remain under development.

• Skills Manager - Manage global and project skills across coding agents through a desktop library, with Git-backed backup and multi-device sync; applying presets makes a one-time copy.

• skillshare - Sync skills, rules, and agent definitions across AI coding tools from one source, distributing them through project configuration and team Git repositories.

• sx - Share versioned skills and agent configuration through Git or shared-folder vaults, with scoped installation and usage records; role-based access control and change approvals remain planned.

• TeamAI CLI - Distribute team skills, rules, and MCP configuration through Git and retrieve shared lessons across agent clients.

• TencentDB Agent Memory - Capture conversations through a proxy and derive memories, skills, and knowledge assets for later agent context retrieval.

• Vercel Skills CLI - Install, check, and update team skills from shared repositories into supported coding agents; project lockfile restoration remains experimental.

Knowledge Retrieval and Memory

Store, organize, and retrieve information for later agent tasks; coverage of documents, conversational memory, and skills varies by tool.

• Basic Memory - Keep knowledge in Markdown notes that people and assistants can edit, search, and reuse through indexes, relations, and MCP.

• Cognee - Process scattered material into text indexes and knowledge graphs for retrieval across documents and relationships.

• EverOS - Provide a local-first, Markdown-native long-term memory layer that different agents, applications, and workflows can share; it is memory infrastructure rather than a multi-user permission workspace.

• Graphiti - Build temporal knowledge graphs from text or structured data to query relationships, changes, and source information.

• LangMem - Provide memory extraction, update, and search components for developers using LangGraph Store or their own storage.

• MCP Knowledge Graph Memory Server - Store entities, relations, and observations in a local file as a reference implementation of structured memory tools for MCP clients.

• Mem0 - Extract and retrieve conversational preferences and facts for existing applications to reduce repeated questions across sessions.

• Memobase - Maintain structured user profiles and event timelines from conversations for personalized application context.

• Memora (Microsoft) - Separate memory content, abstracts, and retrieval cues for developers studying detail preservation and recall.

• Memoria (Matrix Origin) - Add retrieval, snapshots, branches, and merging to agent memory so teams can inspect and revise changes.

• MemOS - Add long-term context to existing agents through memory APIs or host plugins for user information and task experience.

• memsearch - Keep memory as Markdown files with a rebuildable Milvus index so Claude Code, Codex, and other coding agents recall the same context across sessions, and distill repeated workflows into reusable skills; a dedicated Milvus instance is needed for multi-user or team deployments, and it is not a permission system.

• MemU - Turn personal session experience into retrievable memories and skills across assistants; team access management is a separate concern.

• OpenViking - Organize resources, memories, and skills with directories, summaries, and semantic retrieval for progressive context access.

• ReMe (formerly MemoryScope) - Organize conversations and external material into an editable Markdown knowledge workspace that agents can search, read, and update.

• Supermemory - Combine user profiles, memory extraction, and document retrieval through APIs to simplify personalized assistant context.

• Zep - Turn conversations and business data into temporal graphs and assemble retrieved context for agents; this entry covers the hosted service.

Application Development and Workflows

Connect models, tools, and multiple steps into usable applications or business workflows.

• Activepieces - Connect AI, business applications, and human approval steps in visual workflows using extensible integration components; enterprise features are offered separately.

• AgentScope - Compose models, tools, and agent collaboration components in Python to build custom assistant applications.

• AutoGen - Build message-driven agent teams with turn-taking and handoffs; in maintenance mode, with official migration guidance for new projects.

• Budibase - Connect team data, internal apps, and automations to agents that handle requests and invoke configured tools, with human approval rules; Agents is in beta, and paid features are licensed separately.

• Coze Studio - Build and publish assistants with visual knowledge, plugin, and workflow tools; this entry covers the self-hostable Studio.

• CrewAI - Organize agent collaboration through roles, tasks, and workflows with explicit handoffs.

• Dagu - Combine existing scripts, containers, coding agents, and human tasks in self-hosted YAML workflows, with scheduling, retries, logs, and run history for teams to track execution.

• Dify - Combine knowledge retrieval, prompts, and tool calls into AI applications published as web interfaces or APIs.

• Elastic Agent Builder - Configure models, instructions, and tools over Elasticsearch data to build assistants that query organizational information.

• Haystack - Compose document indexing, retrieval, and agent workflows from replaceable Python components with explicit control over context preparation, routing, and generation.

• LangGraph - Build multi-step agents with explicit state and branching, adding persistence and human review to resume work.

• Lindy - Connect email, calendars, and CRM from Slack and save follow-up work or recurring reports as reusable routines.

• Mastra - Build TypeScript agents with tools, memory, and evaluation, organizing multi-step work into workflows that can pause for human input.

• n8n - Connect forms, email, business APIs, and AI nodes to automate data processing and follow-up actions across systems.

• Salesforce Agentforce - Connect natural-language requests to Salesforce data and configured business actions for sales and service agents.

• Sim - Build agents with visual workflows, shared files, and knowledge bases, connect business systems, and inspect run logs; chat uses a Sim-managed service.

• Temporal - Use durable workflows for model calls, external operations, and long human waits, with recovery and retries that still require idempotent business operations.

• ToolJet - Let coding agents build and modify internal apps through MCP, then let teammates continue editing them visually; MCP is in beta, and built-in AI generation and Agent Builder are enterprise features.

Execution Environments and Managed Runtimes

Provide environments for code and files, or host agent execution loops; sandboxes and managed agent runtimes serve different roles.

• Claude Managed Agents - Host Claude execution loops, sessions, and environments, exposing progress and artifacts through events; currently in beta.

• ClawManager - Manage multi-user agent runtimes on Kubernetes with centralized identity, model access, costs, and reusable resources. Team orchestration also includes agent groups, not only human collaboration.

• Daytona - Manage project sandboxes, files, and processes through APIs to provide working environments for coding agents.

• E2B - Create Linux sandboxes on demand to run agent-generated code and retrieve outputs and files.

• OpenSandbox - Manage Docker or Kubernetes sandboxes through unified APIs, providing command execution, file operations, and code environments for agents.

Evaluation, Observability, and Content Checks

Evaluate changes with test cases, investigate execution problems, or add specialized content risk classification.

• Arize Phoenix - Inspect AI traces, maintain datasets, and compare evaluation experiments in a self-hostable platform.

• Braintrust - Turn production traces into test data and compare prompts, models, and agents with shared tasks and evaluators.

• Coze Loop - Maintain shared prompt versions, evaluation datasets, and agent execution traces for development and operations. Distinguish the open-source core from commercial features.

• Datadog Agent Observability - Connect model calls, tool calls, and application traces to investigate agents within an existing Datadog environment.

• DeepEval - Test AI answers and execution with cases, metrics, and thresholds, integrating quality regression checks into Python development.

• Grafana Cloud Agent Observability - Inspect agent sessions, model calls, and online evaluations in Grafana Cloud, distinct from deploying Tempo and Loki alone.

• Laminar - Share agent traces, evaluation results, and dashboards, and route configured behavioral alerts to Slack for investigation.

• Langfuse - Connect traces, prompt versions, test cases, and scores to debug and improve AI applications collaboratively.

• LangSmith - Trace agent execution and compare application versions using datasets, human feedback, and evaluation experiments.

• LangWatch - Combine tracing, agent simulation tests, and evaluations to inspect applications and coding-assistant sessions and usage; enterprise modules require separate licensing.

• Llama Guard - Classify content risks in model inputs and outputs for application review policies; classification does not authorize business actions.

• MLflow - Track agent traces, evaluation data, and prompt versions in a shared platform to compare experiments, investigate regressions, and monitor deployed applications.

• New Relic AI Monitoring - Bring supported model, agent, and tool calls into application monitoring with latency, errors, and usage data.

• OpenLLMetry - Instrument supported models, vector databases, and frameworks with OpenTelemetry and export traces to observability backends.

• OpenTelemetry eBPF Instrumentation (OBI) - Collect application and model-related telemetry on supported Linux systems with less per-application instrumentation; check version-specific coverage.

• Opik - Share agent traces, evaluation datasets, experiments, and prompt versions to compare changes and investigate production failures.

• Promptfoo - Compare prompts, models, or agents with configuration-based test cases, CI integration, and red teaming.

• Ragas - Evaluate retrieval coverage, answer grounding, and agent behavior through metrics and repeatable experiments.

• Tracely - Turn production agent failures into shared issues, replayable regression cases, and CI gates within organizations and workspaces. Development mode has no authentication; teams must configure an appropriate identity mode.

• W&B Weave - Track AI application calls and versions and compare changes using datasets and scorers.

Protocols and Learning Resources

Explore protocols, engineering practices, tutorials, and research, with directories for discovering further candidates.

Protocols and Conventions

• A2A - Define capability discovery, messages, task states, and artifact handoffs between independent agent services.

• AG-UI - Connect agent backends and user interfaces through an event protocol for streaming messages, tool activity, state changes, and human input.

• Agent Skills - Package procedures, references, and scripts as skills that agents can load on demand to reuse team practices.

• AGENTS.md - Provide coding agents with project context, development conventions, and verification commands in repository Markdown files.

• Model Context Protocol (MCP) - Provide a shared protocol for connecting agent applications to tools, data resources, and prompt templates.

• OpenTelemetry GenAI Semantic Conventions - Define tracing and metric fields for model, agent, and tool calls to align observability across applications.

Practical Guides

• 12-Factor Agents - Use engineering principles for context management, persisted state, tool calls, and human interaction to design and review agent applications.

• Claude Code Project Settings - Use project settings and personal overrides to version team configuration and understand where it takes effect.

• Claude Code Subagents - Learn to delegate bounded tasks into separate contexts and configure tools, permissions, and result handoffs.

• Context Compaction (Anthropic) - Learn how long-running tasks compact conversation context and what progress and evidence still need separate storage.

• Function Calling (OpenAI) - Learn the model-request, application-execution, and result-return cycle for well-defined business tools.

• Human-in-the-loop (LangChain) - Learn to pause before tool execution, receive approval or edits, and resume using persisted state.

• My Git Handbook - Use examples of agent change review, pull requests, worktrees, CI, and releases to establish team version-control and delivery practices for AI-assisted development.

• Prompt Caching (Anthropic) - Learn to organize stable prompt prefixes and verify cache hits when optimizing repeated context processing.

• Workload Identity Federation (Google Cloud) - Learn to exchange workload identities for short-lived access credentials instead of distributing long-lived keys to agent services.

Tutorials and Research

• ADE Failure Registry - Use sourced agent failure cases to guide design reviews and incident analysis; the taxonomy is not an industry standard.

• Agent Learning Paths (Pauldest) - Organize learning around progressively expanded coding and systems exercises when planning team practice.

• Agent-Learning-Hub (kngwyc3) - Extend a Datawhale learning roadmap with exercises and notes covering tool use, retrieval, memory, and agent development.

• Anthropic Evaluation Guide - Explain how to define success criteria, prepare test cases, and choose code-based, human, or model-based evaluation.

• awesome-agentic-ai-zh - Follow Chinese learning paths for assistant users and agent developers, with exercises and deliverable requirements.

• Why Do Multi-Agent LLM Systems Fail? - Study failures in task design, coordination, and verification, with MAST providing the taxonomy and research materials.

More Resource Directories

• Awesome Agent Skills (VoltAgent) - Discover skills for development, documents, and testing as starting points for reusable team procedures.

• Awesome AI Agent Papers (VoltAgent) - Find papers on collaboration, memory, tools, and evaluation, then verify methods and conditions in the original research.

• Awesome MCP Servers (appcypher) - Compare MCP implementations from different authors by capability, alongside related clients and management tools.

• Awesome MCP Servers (punkpeye) - Discover MCP server implementations for connecting to files, databases, and business systems.

• Awesome Official MCP Servers (MCPStar) - Find vendor-maintained MCP repositories, services, and documentation, verifying ownership before adoption.

Contributing

Read the English contribution guide or Chinese guide, then open an issue or pull request to suggest a project, explain a use case, or fix descriptions and links. Both lists contain the same entries and categories. You can request translation help when contributing in one language.

License

This list is released under CC0 1.0 Universal. Listed projects, trademarks, and external material retain their own licenses and terms.