LinkAgent provides a lightweight microkernel for building AI agents with pluggable components. Users can register language model backends, retrieval modules, and external APIs as tools, then assemble them into workflows using built-in planners and routers. LinkAgent supports memory handlers for context persistence, dynamic tool invocation, and configurable decision logic for complex multi-step reasoning. With minimal code, teams can automate tasks like QA, data extraction, process orchestration, and report generation.

Minerva is an extensible AI agent framework designed to automate complex workflows using large language models. Developers can integrate external tools—such as web search, API calls, or file processors—define custom planning strategies, and manage conversational or persistent memory. Minerva supports both synchronous and asynchronous task execution, configurable logging, and a plugin architecture, making it easy to prototype, test, and deploy intelligent agents capable of reasoning, planning, and tool use in real-world scenarios.

Multi-Agent-Seller provides a modular environment for simulating e-commerce negotiations using AI agents. It includes pre-built buyer and seller agents with customizable negotiation strategies, such as dynamic pricing, time-based concessions, and utility-based decision-making. Users can define custom protocols, message formats, and market conditions. The framework handles session management, offer tracking, and result logging with built-in visualization tools for analyzing agent interactions. It integrates easily with machine learning libraries for strategy development, enabling experimentation with reinforcement learning or rule-based agents. Its extensible architecture allows adding new agent types, negotiation rules, and visualization plugins. Multi-Agent-Seller is ideal for testing multi-agent algorithms, studying negotiation behaviors, and teaching concepts in AI and e-commerce domains.

Owl provides a developer-focused toolkit that enables the creation of autonomous AI agents capable of executing complex, multi-step tasks. At its core, Owl leverages LLMs for reasoning, augmented by a plugin system to call external APIs, execute code, and query databases. Developers define agents using a simple TypeScript API, specify toolsets, and configure memory modules to maintain state across interactions. Owl’s runtime orchestrates reasoning loops, handles tool invocation, and manages concurrency. It supports both Node.js and Deno environments, ensuring wide platform compatibility. With built-in logging, error handling, and extensibility hooks, Owl streamlines prototyping and production deployment of AI-driven workflows, chatbots, and automated assistants.

Rawr Agent is a modular, open-source Python framework that empowers developers to build autonomous AI agents by orchestrating complex workflows of LLM interactions. Leveraging LangChain under the hood, Rawr Agent lets you define task sequences either through YAML configurations or Python code, specifying tool integrations such as web APIs, database queries, and custom scripts. It includes memory components for storing conversational history and vector embeddings, caching mechanisms to optimize repeated calls, and robust logging and error handling to monitor agent behavior. Rawr Agent’s extensible architecture allows adding custom tools and adapters, making it suitable for tasks like automated research, data analysis, report generation, and interactive chatbots. With its simple API, teams can rapidly prototype and deploy intelligent agents for diverse applications.

SimplerLLM provides developers a minimalistic API to compose LLM chains, define agent actions, and orchestrate tool calls. With built-in abstractions for memory retention, prompt templates, and output parsing, users can rapidly assemble conversational agents that maintain context across interactions. The framework seamlessly integrates with OpenAI, Azure, and HuggingFace models, and supports pluggable toolkits for searches, calculators, and custom APIs. Its lightweight core minimizes dependencies, allowing agile development and easy deployment on cloud or edge. Whether building chatbots, QA assistants, or task automators, SimplerLLM simplifies end-to-end LLM agent pipelines.

SuperBot is a comprehensive AI Agent framework enabling developers to deploy autonomous, context-aware assistants via Python and the command line. It integrates OpenAI’s chat models with a memory system, function-calling features, and plugin architecture. Agents can execute shell commands, run code, interact with files, perform web searches, and maintain conversation state. SuperBot supports multi-agent orchestration for complex workflows, all configurable through simple Python scripts and CLI commands. Its extensible design allows you to add custom tools, automate tasks, and integrate external APIs to build robust AI-driven applications.

Team of AI Agents provides a modular architecture to build and deploy multi-agent systems. Each agent operates with distinct roles, utilizing a global memory store and local contexts for knowledge retention. The framework supports asynchronous messaging, tool usage via adapters, and dynamic task reassignment based on agent outcomes. Developers configure agents through YAML or Python scripts, enabling topic specialization, goal hierarchy, and priority handling. It includes built-in metrics for performance evaluation and debugging, facilitating rapid iteration. With extensible plugin architecture, users can integrate custom NLP models, databases, or external APIs. Team of AI Agents accelerates complex workflows by leveraging collective intelligence of specialized agents, making it ideal for research, automation, and simulation environments.

Toolbox-macos transforms your Mac into an AI agent hub by embedding a versatile set of AI-powered tools in a native menu bar app. It leverages OpenAI's GPT models and other APIs to enable you to select any text, summarize content, translate between languages, generate code, create custom images, search the web, or automate workflows with custom scripts and plugins. You can configure global hotkeys, define macros, and integrate third-party AI services to tailor responses. By offering instant AI capabilities across all applications without context switching, it enhances productivity, speeds up creative tasks, and centralizes your favorite AI utilities. Users can invoke commands via the macOS Command Palette or through configurable keyboard shortcuts, ensuring seamless integration with editing, browsing, or code development workflows. The open architecture allows community-driven extensions and supports local AI model execution for privacy-sensitive tasks.

A2A SDK is a developer toolkit for building, chaining, and managing AI agents in Python. It provides APIs to define agent behaviors via prompts or code, connect agents into pipelines or workflows, and enable asynchronous message passing. Integrations with OpenAI, Llama, Redis, and REST services allow agents to fetch data, call functions, and store state. A built-in UI monitors agent activity, while the modular design ensures you can extend or replace components to fit custom use cases.

Aegix provides a robust SDK for orchestrating AI Agents capable of handling complex workflows through multi-step reasoning. With support for various LLM providers, it lets developers integrate custom tools—from database connectors to web scrapers—and maintain conversation state with memory modules such as vector stores. Aegix’s flexible agent loop architecture allows the specification of planning, execution, and review phases, enabling agents to refine outputs iteratively. Whether building document question-answering bots, code assistants, or automated support agents, Aegix simplifies development with clear abstractions, configuration-driven pipelines, and easy extension points. It’s designed to scale from prototypes to production, ensuring reliable performance and maintainable codebases for AI-driven applications.

AgentIn is a Python-based AI agent framework designed to accelerate the development of conversational and task-driven agents. It offers built-in memory modules to persist context, dynamic tool integration to call external APIs or local functions, and a flexible prompt templating system for customized interactions. Multi-agent orchestration enables parallel workflows, while logging and caching improve reliability and auditability. Easily configurable via YAML or Python code, AgentIn supports major LLM providers and can be extended with custom plugins for domain-specific capabilities.

Agents with ADK is an open-source Python framework designed to streamline the creation of intelligent agents powered by large language models. It includes modular agent templates, built-in memory management, tool execution interfaces, and multi-agent coordination capabilities. Developers can quickly plug in custom functions or external APIs, configure planning and reasoning chains, and monitor agent interactions. The framework supports integration with popular LLM providers and provides logging, retry logic, and extensibility for production deployments.

Agent of Code is a versatile AI agent framework enabling developers to offload routine coding tasks to intelligent agents. It leverages large language models to translate natural language prompts into fully functional code, perform automated code reviews, debug existing code, and refactor legacy codebases. Users define agent goals and parameters through YAML or JSON configurations, select plugins for tasks like testing or CI integration, and execute agents via CLI. The framework orchestrates API calls, manages context windows, and assembles modular responses into cohesive code scripts. With an extensible architecture, developers can plug in custom modules, integrate with version control, and tailor the agent pipeline to project workflows.

Agentic-AI is an open-source Python framework that streamlines building autonomous agents leveraging large language models such as OpenAI GPT. It provides core modules for task planning, memory persistence, and tool integration, allowing agents to decompose high-level goals into executable steps. The framework supports plugin-based custom tools—APIs, web scraping, database queries—enabling agents to interact with external systems. It features a chain-of-thought reasoning engine coordinating planning and execution loops, context-aware memory recalls, and dynamic decision-making. Developers can easily configure agent behaviors, monitor action logs, and extend functionality, achieving scalable, adaptable AI-driven automation for diverse applications.

AgentPilot provides a comprehensive monorepo solution for building, managing, and deploying autonomous AI agents. At its core, it features an extensible plugin system for integrating custom tools and LLMs, a memory management layer for preserving context across interactions, and a planning module that sequences agent tasks. Users can interact via a command-line interface or a web-based dashboard to configure agents, monitor execution, and review logs. By abstracting the complexity of agent orchestration, memory handling, and API integrations, AgentPilot enables rapid prototyping and production-ready deployment of multi-agent workflows in domains such as customer support automation, content generation, data processing, and more.

Agents from Scratch TS is an open-source TypeScript framework that demonstrates how to build AI agents from the ground up using LangChain. It includes sample code for defining and registering external tools, managing conversational memory, routing user inputs to the right agent, and chaining multiple LLM calls. Developers can use it to understand best practices, customize agent behaviors, and integrate new capabilities such as web search, data retrieval, or custom plugins to automate tasks or build interactive assistants.

AgentX provides an extensible architecture for building AI-driven agents that leverage large language models, tool and API integrations, and memory modules to perform complex tasks autonomously. It features a plugin system for custom tools, support for vector-based retrieval, chain-of-thought reasoning, and detailed execution logs. Users define agents through flexible configuration files or code, specifying tools, memory backends like Chroma DB, and reasoning pipelines. AgentX manages context across sessions, enables retrieval-augmented generation, and facilitates multiturn conversations. Its modular components allow developers to orchestrate workflows, customize agent behaviors, and integrate external services for automation, research assistance, customer support, and data analysis.

AI-Agent-Framework offers a comprehensive foundation for building AI-powered agents in Python. It includes modules for managing conversation memory, integrating external tools, and constructing prompt templates. Developers can connect to various LLM providers, equip agents with custom plugins, and orchestrate multiple agents in coordinated workflows. Built-in logging and monitoring tools help track agent performance and debug behaviors. The framework's extensible design allows seamless addition of new connectors or domain-specific capabilities, making it ideal for rapid prototyping, research projects, and production-grade automation.

autogen4j is a lightweight Java library designed to abstract the complexity of building autonomous AI agents. It offers core modules for planning, memory storage, and action execution, letting agents decompose high-level goals into sequential sub-tasks. The framework integrates with LLM providers (e.g., OpenAI, Anthropic) and allows registration of custom tools (HTTP clients, database connectors, file I/O). Developers define agents through a fluent DSL or annotations, quickly assembling pipelines for data enrichment, automated reporting, and conversational bots. An extensible plugin system ensures flexibility, enabling fine-tuned behaviors across diverse applications.