CodeFuse-muAgent is a Python-based open-source framework that orchestrates multiple autonomous AI agents to collaboratively solve complex tasks. Developers define individual agents with specialized skills—such as data processing, natural language understanding, or external API interaction—and configure communication protocols for dynamic task delegation. The framework provides centralized memory management, logging, and monitoring, while remaining model-agnostic, supporting integration with popular LLMs and custom AI models. By leveraging CodeFuse-muAgent, teams can build modular AI workflows, automate multi-step processes, and scale deployments across diverse environments. Flexible configuration files and extensible APIs enable rapid prototyping, testing, and fine-tuning, making it suitable for use cases in customer support, content generation pipelines, research assistants, and more.

The Contract Net Protocol repository provides a full Java implementation of the FIPA Contract Net interaction protocol. Developers can create manager and contractor agents that exchange CFP (Call For Proposal), proposals, acceptances, and rejections over agent communication channels. The code includes core modules for broadcasting tasks, collecting bids, evaluating proposals based on customizable criteria, awarding contracts, and monitoring execution status. It can be integrated into larger multi-agent frameworks or used as a standalone library for research simulations, industrial scheduling, or robotic coordination.

CrewAI Agent Generator leverages a command-line interface to let you initialize a new AI agent project with opinionated folder structures, sample prompt templates, tool definitions, and testing stubs. You can configure connections to OpenAI, Azure, or custom LLM endpoints; manage agent memory using vector stores; orchestrate multiple agents in collaborative workflows; view detailed conversation logs; and deploy your agents to Vercel, AWS Lambda, or Docker with built-in scripts. It accelerates development and ensures consistent architecture across AI agent projects.

demo_smolagents is a reference implementation of SmolAgents, a Python-based microframework for creating autonomous AI agents powered by large language models. This demo includes examples of how to configure individual agents with specific toolkits, establish communication channels between agents, and manage task handoffs dynamically. It showcases LLM integration, tool invocation, prompt management, and agent orchestration patterns for building multi-agent systems that can perform coordinated actions based on user input and intermediate results.

Dial4JaCa is a Java library plugin for the JaCaMo multi-agent platform that intercepts inter-agent messages, encodes agent intentions, and routes them through LLM backends (OpenAI, local models). It manages dialogue context, updates belief bases, and integrates response generation directly into AgentSpeak(L) reasoning cycles. Developers can customize prompts, define dialogue artifacts, and handle asynchronous calls, enabling agents to interpret user utterances, coordinate tasks, and retrieve external information in natural language. Its modular design supports error handling, logging, and multi-LLM selection, ideal for research, education, and rapid prototyping of conversational MAS.

The RAG-Llama3 Multi-AGI Django Website Code Generator is a specialized AI framework that combines retrieval-augmented generation techniques with multiple Llama3-based agents. It processes user-defined requirements and external documentation to retrieve relevant code snippets, orchestrates several AI agents to collaboratively draft Django model definitions, view logic, templates, URL routing, and project settings. This iterative approach ensures that generated code aligns with user expectations and best practices. Users start by seeding a knowledge base of documentation or code samples, then prompt the agent for specific features. The system returns a complete Django project scaffold, complete with modular apps, REST API endpoints, and customizable templates. The modular nature allows developers to integrate custom business logic and deploy directly to production environments.

Fetch.ai is an open-source platform and software development kit designed for building autonomous agents that represent digital twins on a decentralized network. It provides a Python and Rust SDK, an Open Economic Framework (OEF) for peer discovery, and seamless integration with its ledger for secure transactions. Developers can define custom agent skills—such as market making, data provision, or task bidding—and deploy them to testnets or mainnets. Fetch.ai agents autonomously communicate, negotiate, and execute smart contracts, enabling powerful multi-agent coordination for supply chains, IoT ecosystems, mobility services, energy grids, and beyond.

Emergent Communication in Agents is an open-source PyTorch framework designed for researchers exploring how multi-agent systems develop their own communication protocols. The library offers flexible implementations of cooperative reinforcement learning tasks, including referential games, combination games, and object identification challenges. Users define speaker and listener agent architectures, specify message channel properties like vocabulary size and sequence length, and select training strategies such as policy gradients or supervised learning. The framework includes end-to-end scripts for running experiments, analyzing communication efficiency, and visualizing emergent languages. Its modular design allows easy extension with new game environments or custom loss functions. Researchers can reproduce published studies, benchmark new algorithms, and probe compositionality and semantics of emergent agent languages.

Esquilax is a lightweight TypeScript framework designed for building and orchestrating complex AI agent workflows. It provides developers with a clear API to declaratively define agents, assign memory modules, and integrate custom plugin actions such as API calls or database queries. With built-in support for context handling and multi-agent coordination, Esquilax streamlines the creation of chatbots, digital assistants, and automated processes. Its event-driven architecture allows tasks to be chained or triggered dynamically, while logging and debugging tools offer full visibility into agent interactions. By abstracting away boilerplate code, Esquilax helps teams rapidly prototype scalable AI-driven applications.

The F1Tenth Two-Agent Simulator is a specialized simulation framework built on ROS and Gazebo to emulate two 1/10th scale autonomous vehicles racing or cooperating on custom tracks. It supports realistic tire-model physics, sensor emulation, collision detection, and data logging. Users can plug in their own planning and control algorithms, adjust agent parameters, and run head-to-head scenarios to evaluate performance, safety, and coordination strategies under controlled conditions.

Fabrice AI empowers developers to craft sophisticated AI agent systems leveraging large language models (LLMs) across Node.js and browser contexts. It offers built-in memory modules for retaining conversation history, tool integration to extend agent capabilities with custom APIs, and a plugin system for community-driven extensions. With type-safe prompt templates, multi-agent coordination, and configurable runtime behaviors, Fabrice AI simplifies building chatbots, task automation, and virtual assistants. Its cross-platform design ensures seamless deployment in web applications, serverless functions, or desktop apps, accelerating development of intelligent, context-aware AI services.

GenWorlds is an AI development framework designed to facilitate the creation of multi-agent systems. Utilizing an event-based communication framework via websocket, it allows developers to set up interactive environments where autonomous agents can asynchronously interact with each other and their surroundings. These agents collaborate, plan actions, and execute complex tasks collectively, making GenWorlds a robust platform for creating scalable and flexible AI ecosystems.

AWS Bedrock Multi-Agent Collaboration is a managed service feature that enables you to orchestrate multiple AI agents powered by foundation models to work together on complex tasks. You configure agent personas with specific roles, define messaging schemas for communication, and set shared memory for context retention. During execution, agents can request data from downstream sources, delegate subtasks, and aggregate each other's outputs. This collaborative approach supports iterative reasoning loops, improves task accuracy, and allows dynamic scaling of agents based on workload. Integrated with AWS console, CLI, and SDKs, the service offers monitoring dashboards to visualize agent interactions and performance metrics, simplifying development and operational oversight of intelligent multi-agent workflows.

Hashiru AgentX is a unified AI workflow orchestrator hosted on Hugging Face Spaces. It allows users to input natural language instructions and choose from prebuilt agents for code execution, web search, and document analysis. Behind the scenes, it dynamically composes tool chains, runs Python snippets in a secure sandbox, queries online resources, and extracts insights from uploaded files. Results are returned in a conversational format, enabling iterative refinement and easy download of outputs.

HMAS is an open-source Python framework that enables development of hierarchical multi-agent systems. It offers abstractions for defining agent hierarchies, inter-agent communication protocols, environment integration, and built-in training loops. Researchers and developers can use HMAS to prototype complex multi-agent interactions, train coordinated policies, and evaluate performance in simulated environments. Its modular design makes it easy to extend and customize agents, environments, and training strategies.

HFO_DQN combines Python and TensorFlow to deliver a complete pipeline for training soccer agents using Deep Q-Networks. Users can clone the repository, install dependencies including the HFO simulator and Python libraries, and configure training parameters in YAML files. The framework implements experience replay, target network updates, epsilon-greedy exploration, and reward shaping tailored for the half field offense domain. It features scripts for agent training, performance logging, evaluation matches, and plotting results. Modular code structure allows integration of custom neural network architectures, alternative RL algorithms, and multi-agent coordination strategies. Outputs include trained models, performance metrics, and behavior visualizations, facilitating research in reinforcement learning and multi-agent systems.

Microsoft AutoGen is designed to facilitate the end-to-end development of autonomous AI agents by providing modular components for memory management, task planning, tool integration, and communication. Developers can define custom tools with structured schemas and connect to major LLM providers such as OpenAI and Azure OpenAI. The framework supports both single-agent and multi-agent orchestration, enabling collaborative workflows where agents coordinate to complete complex tasks. Its plug-and-play architecture allows easy extension with new memory stores, planning strategies, and communication protocols. By abstracting the low-level integration details, AutoGen accelerates prototyping and deployment of AI-driven applications across domains like customer support, data analysis, and process automation.

JADE is a Java-based agent development framework that simplifies the creation of distributed multi-agent systems. It provides FIPA-compliant infrastructure including a runtime environment, message transport, directory facilitator, and agent management. Developers write agent classes in Java, deploy them in containers, and use graphical tools like RMA and Sniffer for debugging and monitoring. JADE supports agent mobility, behavior scheduling, and lifecycle operations, enabling scalable and modular designs for research, IoT coordination, simulations, and enterprise automation.

jason-RL adds a reinforcement learning layer to the Jason multi-agent framework, allowing AgentSpeak BDI agents to learn action-selection policies via reward feedback. It implements Q-learning and SARSA algorithms, supports configuration of learning parameters (learning rate, discount factor, exploration strategy), and logs training metrics. By defining reward functions in agent plans and running simulations, developers can observe agents improve decision making over time, adapting to changing environments without manual policy coding.

Layra is designed to simplify developing LLM-powered agents by providing a modular architecture that integrates with various tools and memory stores. It features a planner that breaks down tasks into subgoals, a memory module for storing conversation and context, and a plugin system to connect external APIs or custom functions. Layra also supports orchestrating multiple agent instances to collaborate on complex workflows, enabling parallel execution and task delegation. With clear abstractions for tools, memory, and policy definitions, developers can rapidly prototype and deploy intelligent agents for customer support, data analysis, RAG, and more. It is framework-agnostic toward modeling backends, supporting OpenAI, Hugging Face, and local LLMs.