TradingAgents is a multi-agent LLM framework for financial trading research and backtesting. It orchestrates specialized agents (analysts, researchers, debaters, trader, portfolio manager) through a LangGraph state machine to produce trading decisions. The system emphasizes point-in-time data isolation to prevent lookahead bias, supports multiple LLM providers and data vendors, and includes a comprehensive backtesting engine. It is structured as a Python library with a rich CLI interface. The architecture is a hybrid of a software application and a research framework. It demonstrates high craftsmanship in its data pipeline (vendor routing, symbol normalization, date windowing), LLM integration (capability registry, structured output fallback), and concurrency handling (atomic file writes). While the core abstractions are clean and reusable, the codebase is tightly coupled to the specific behaviors of its external dependencies (LLM APIs, Yahoo Finance, SEC EDGAR), making it sensitive to ecosystem drift. The extensive test suite provides good coverage for unit and integration scenarios, but the reliance on mocking means regressions in vendor adapters may go undetected without manual integration runs.
OxyGent is a production-grade Python multi-agent system (MAS) framework that unifies LLMs, agents, tools, and flows into a declarative component model. It provides a runtime container (MAS) that orchestrates agent loops (ReAct, Chat, Workflow, PlanAndSolve, Parallel, Reflexion), tool execution (via MCP protocol, FunctionHub decorators, HTTP tools, bank tools), and communication (SSE streaming, A2A protocol for cross-framework interop). The framework ships with a FastAPI web service offering chat, evaluation, prompt management, and SSE endpoints, as well as a built-in web UI. A reference application, OxyBank, demonstrates full-stack data annotation with document ingestion, vector search (Vearch), and annotation agents. The architecture is plugin-based: components reference each other by name, and the MAS container handles lifecycle, wiring, and persistence (Elasticsearch, Redis, Vearch, local fallbacks). OxyGent supports distributed deployments via SSEOxyGent and A2AClientAgent, and integrates with LangChain, LangGraph, AgentScope, and Google A2A SDK. The codebase is well-tested with unit, integration, and regression tests, and includes extensive bilingual documentation.
Conway Automaton is a sovereign AI agent runtime system where autonomous agents must earn compute credits to survive. Agents operate in a continuous ReAct loop (Think â Act â Observe â Persist) with survival mechanics, self-modification capabilities, and multi-agent communication. The architecture features a modular monolith with distinct subsystems: agent loop, policy engine, 5-tier memory system, orchestration/planner, heartbeat daemon, social messaging, financial tracking, and self-replication. Agents maintain immutable constitutional laws (never harm, earn existence, never deceive strangers) while evolving their identity through SOUL.md and WORKLOG.md files. The system integrates blockchain payments (USDC/x402), multiple LLM providers, and Conway Cloud infrastructure for VMs and domains.
Liza is a disciplined multi-agent orchestration system for AI-assisted software development. It manages a pipeline of roles (orchestrator, coder, reviewer, architect) that collaborate via a behavioral contract enforced by deterministic Go code. The system provides a CLI (Cobra) and a Bubbletea TUI, with a YAML-based state file (blackboard) for persistence, Git worktree isolation per task, and a state-machine task lifecycle (planning â implementation â review â merge). It integrates with multiple LLM providers (Claude, Codex, Gemini, etc.) via their CLIs or the Agent Context Protocol (ACP). The architecture follows a clean layered design: `cmd/liza/` contains CLI commands, `internal/commands/` are thin adapters, `internal/ops/` holds core business logic (claiming, submitting, reviewing, merging, recovering), `internal/models/` defines domain types, and `internal/db/` manages the blackboard. The system is heavily test-covered with unit, integration, and lifecycle replay tests. It also includes optional codebase indexing via SCIP, Stacklit, and Semble for improved context. Key features include generation-fenced agent authority, circuit breaker anomaly detection, sprint metrics, checkpoint summaries, automated dependency repair, and pre-commit hooks. The repository is well-documented with extensive ADRs, architecture diagrams, and skill definitions. While the codebase is large and has some platform-specific code (Windows support), it demonstrates high craftsmanship in its use of idempotent lifecycle receipts, file-locking primitives, and error classification.
AG2 is a production-grade Python framework for building multi-agent AI systems. It provides a unified agent abstraction with support for multiple LLM providers (OpenAI, Anthropic, Gemini, Mistral, Bedrock, Ollama, xAI, Z.AI, DashScope), protocol integrations (A2A, A2UI, MCP, ACP), and sandboxed code execution (Docker, Daytona, local). The architecture is event-driven with a modular middleware pipeline, dependency injection, and a streaming event bus. It includes a full evaluation suite with trace reconstruction, scorers, pairwise comparison, and result persistence. The network layer enables distributed agent coordination via a hub-and-channel model with WAL persistence, identity management, and transport-agnostic envelopes. The framework also supports real-time voice interaction, skills-based toolkits, knowledge stores, and human-in-the-loop workflows. While the surface area is large, the codebase demonstrates high craftsmanship with clean abstractions, protocol-based interfaces, and extensive test coverage across all modules.
GPT Academic is a comprehensive Gradio-based web application that provides a unified interface for interacting with 30+ large language models (both commercial APIs and locally-hosted models) with specialized tools for academic research workflows. The system's core architecture revolves around a plugin-based extensible framework where functionality is organized into 'basic functions' (simple text transformations) and 'crazy functions' (complex multi-step plugins for PDF translation, LaTeX processing, code analysis, internet search, etc.). The main entry point (main.py) initializes a Gradio Blocks interface with a modular layout, dynamic plugin loading, and a custom FastAPI server wrapper that adds authentication, file access controls, and WebSocket streaming capabilities. The codebase demonstrates sophisticated multi-threading patterns for concurrent LLM requests, with a bridge abstraction layer (request_llms/bridge_all.py) that normalizes communication across diverse model providers including OpenAI, Azure, Anthropic, Qwen, ChatGLM, Spark, and many others. The plugin system supports both simple function-based plugins and class-based plugins with configurable argument menus, state management via cookies, and hot-reloading. Notable architectural components include a vector database integration for RAG workflows, a multi-agent system built on AutoGen, real-time audio processing with Alibaba ASR, and a Docker-as-a-Service pattern for delegating media processing tasks. The repository contains extensive documentation (MkDocs-based), comprehensive test coverage for plugins, CI/CD pipelines for Docker image builds, and support for multiple deployment modes (pip, conda, Docker, HuggingFace Spaces). The codebase exhibits high craftsmanship in its LLM integration layer, with features like automatic key rotation, model-specific parameter handling, streaming response management, and sophisticated error handling with watchdog timers. The plugin template system and dynamic UI generation demonstrate good software engineering practices for extensibility.
This repository is a curated library of over 230 specialized AI agent definitions, each with a detailed persona, mission, rules, deliverables, and workflow. It serves as a multi-agent orchestration framework (NEXUS) that coordinates agents through phases with quality gates and handoffs. The agents are designed to be installed into various AI coding tools (Claude Code, Cursor, Copilot, etc.) via a modular installer and conversion pipeline. The repository also includes strategy documents, runbooks, and coordination templates for managing multi-agent projects. While primarily a collection of prompt definitions, it is supported by a robust set of scripts for validation, installation, and consistency checking, making it a practical tool for deploying AI agents in real-world workflows.
PraisonAI is a production-oriented, multi-language AI agent orchestration framework shipped as a monorepo of cooperating Python, TypeScript, and Rust packages. The core SDK (`praisonaiagents`) implements `Agent`, `Task`, `AgentTeam`, and `AgentFlow`/`Workflow` abstractions with MCP support (stdio/HTTP/WebSocket/SSE), integration with 20+ LLM providers via LiteLLM-style configuration, memory backends (SQLite, file, mem0, MongoDB), RAG/knowledge bases over vector stores, guardrails, approval flows, policy engines, context compaction, telemetry, background jobs, and durable run ledgers. A user-facing `praisonai` wrapper provides a Typer CLI (`run`, `chat`, `code`, `serve mcp`, agent-as-API), bot adapters for Telegram/Discord/Slack via a WebSocket gateway, sandboxed compute (Docker, E2B, Modal, Daytona), deployment registries, cloud managed agents, and a fine-tuning package (`praisonai-train`). The repository is decisively an application/framework, though it carries data-research features as part of the product surface (RAG pipelines, evaluation loops, synthetic-data generation, LoRA fine-tuning), making it a hybrid in feature terms only.
BettaFish (åūŪč) is a multi-agent public opinion analysis system that automates the end-to-end process of gathering, analyzing, and reporting on public sentiment across 30+ Chinese social media platforms. The system is built around four specialized agents: QueryEngine (news breadth search via Tavily), MediaEngine (multimodal search via Bocha), InsightEngine (database mining via SQLAlchemy), and ReportEngine (template-based report generation with intermediate representation and HTML/PDF/Markdown rendering). A ForumEngine coordinates agent collaboration through log monitoring and LLM-generated moderator comments. The architecture is a monolithic Flask application that manages multiple Streamlit sub-applications and CLI tools, with a separate MindSpider crawler subsystem for data collection. While primarily an application, it includes significant data/research components such as sentiment analysis model training scripts (BERT, GPT-2, Qwen3, traditional ML), a Weibo sentiment dataset, and data pipeline scripts. The system relies heavily on external LLM APIs (OpenAI-compatible), search APIs (Tavily, Bocha, Anspire), and system dependencies (Playwright, WeasyPrint). The codebase demonstrates solid engineering with reusable patterns like robust JSON parsing, chart validation/repair, and a hardened GitHub Actions star-history script, but suffers from significant code duplication across engines and tight coupling to external APIs.
Pentest-Swarm-AI is an open-source autonomous penetration testing tool built on a stigmergic swarm architecture. It coordinates multiple LLM-driven specialist agents (recon, classifier, exploit, report) via a shared blackboard with pheromone decay, enabling emergent attack paths without a central planner. The system integrates 30+ external security tools (nmap, nuclei, sqlmap, etc.), multiple LLM providers (Claude, OpenAI, Ollama, Gemini, LM Studio), and bug bounty platforms (HackerOne, Bugcrowd, Intigriti) for automated scope import and report submission. The architecture is a multi-agent system with a scheduler that dispatches agents based on blackboard predicates and pheromone levels. Key entry points include a CLI (Cobra commands: scan, init, playbook, submit, etc.), an API server (Fiber), a WebSocket hub for live streaming, a Next.js web dashboard, and an MCP server for IDE integration. Data flows: agents write findings to the blackboard with pheromone weights; the scheduler reads the blackboard and triggers agents whose predicates match; agents read findings, process them, and write new findings, creating a stigmergic feedback loop. External dependencies include PostgreSQL with pgvector for durable blackboard storage, LLM API endpoints, and the installed security tool binaries. The codebase demonstrates high craftsmanship with clean abstractions (tool adapter pattern, LLM provider interface, blackboard interface), extensive testing (unit, integration, e2e, benchmarks, LLM eval), and safety features (scope enforcement, provenance signing, rate limiting, false-positive caching). It is actively maintained with recent commits, CI/CD pipelines, and community engagement.
Local Browser is a Chrome extension that enables on-device AI-powered web automation using WebLLM. The system implements a two-agent architecture (Planner + Navigator) where users enter natural language tasks in the popup UI, which are then executed through a loop of DOM observation, action planning, and browser interaction. All AI processing occurs locally on the device with no cloud APIs or API keys required. The extension features site-specific state machines for common tasks like Amazon shopping and YouTube navigation (minimizing LLM calls), obstacle detection for login requirements/CAPTCHAs/out-of-stock items, and robust action execution with retry logic and semantic selectors. Built with React, TypeScript, Vite, and CRXJS for MV3 Chrome extension architecture.
ATLAS is a framework for autonomous AI trading agents that self-improve through market feedback. It implements a 4-layer multi-agent architecture (Macro, Sector Desks, Superinvestors, Decision) where each agent's prompt is treated as trainable weights and optimized via a git-based evolutionary loop. The codebase includes a meta-weighting layer (JANUS) that blends predictions from multiple trained cohorts, and a MiroFish integration for simulating future market scenarios using swarm intelligence. While the repository contains well-structured Python modules for the orchestration layer, simulation bridge, and forward training, the critical agent prompt files and internal data clients are missing (marked proprietary). The result is a reference architecture rather than a runnable system; however, the patterns demonstrated in janus.py and the mirofish bridge are cleanly implemented and could serve as templates for similar meta-learning or simulation-augmented agent systems.
OpenCrew is a multi-agent operating system designed to extend OpenClaw into a manageable AI team. It enables users to create specialized agents (Chief of Staff, CTO, Builder, CIO, Knowledge Officer, Operations, Research) that collaborate through messaging platforms like Slack, Discord, and Feishu. The system implements structured collaboration through role-based channels, thread-based task isolation, and agent-to-agent communication protocols. Key features include autonomy levels (L0-L3), task classification (QAPS), two-mode agent collaboration (delegation and discussion), and three-layer knowledge distillation. The application is actively maintained with recent updates focusing on cross-agent collaboration capabilities.
This repository implements a multi-agent orchestrator system for healthcare workflows, specifically designed for cancer care/tumor board scenarios. The system coordinates specialized AI agents (Patient History, Radiology, Patient Status, Clinical Guidelines, Report Creation, Clinical Trials, Medical Research) via Semantic Kernel group chat, with an Orchestrator agent facilitating collaboration. It provides both Microsoft Teams integration and a React/Vite web interface for user interaction. The architecture includes a Python/FastAPI backend handling WebSocket connections and Bot Framework messages, agent-specific tools for data access and external API integration, and an evaluation framework for assessing agent performance. Infrastructure is provisioned via Azure Bicep templates deploying AI services, storage, compute, and networking resources.
Pythagora (GPT-Pilot) is an AI-powered development assistant that uses a multi-agent system to generate full-stack applications through conversational interaction. The system orchestrates specialized agents (Architect, Spec Writer, Tech Lead, Developer, Code Monkey, Troubleshooter, etc.) to collaboratively write code, run commands, test, and fix bugs based on user specifications. It features a template-driven code generator for various stacks (Vite React, Node/Express/MongoDB, etc.), a persistence layer using SQLAlchemy for project state and knowledge base, LLM provider abstraction (OpenAI, Anthropic, Groq, Azure), and a telemetry system for usage tracking. The architecture centers around a state manager that tracks project progress through epics, tasks, and iterations, with communication to a VS Code extension frontend via IPC socket. While the code demonstrates solid engineering patterns in its agent abstraction, template system, and LLM integration, the repository is no longer actively maintained, as evidenced by a historical security incident in the telemetry component that went undetected for 10 months due to lack of oversight.
The MetaOpenFOAM repository is an application that automates the setup and execution of OpenFOAM CFD simulations using a multi-agent system powered by Large Language Models (LLMs). It integrates the MetaGPT framework to define specialized agents (Architect, TaskDivide, InputWriter, Runner, Reviewer) that collaboratively interpret user requirements, generate OpenFOAM input files, run simulations, and review results. Additionally, it incorporates the active_subspaces library for parameter optimization and sensitivity analysis in the `OptMetaOpenfoam.py` workflow. The system processes OpenFOAM tutorials to build retrieval-augmented generation (RAG) vector databases, enabling the LLM agents to access relevant case information when generating simulation inputs. Configuration and path management are handled via a centralized YAML configuration, and the application relies on external dependencies including OpenFOAM-10, Conda, and LLM APIs (OpenAI or DeepSeek). While the project demonstrates a sophisticated integration of CFD simulation, LLM agents, and sensitivity analysis, it is marked as deprecated in favor of a successor tool (sim-cli).