LangGraph is a production-grade Python framework for building stateful, resumable, multi-step LLM agent workflows, distributed as a monorepo of Python packages (core `langgraph`, `langgraph-sdk`, `langgraph-cli`, checkpoint backends, prebuilt agents) plus JS/TS SDK examples. The core is a Pregel-inspired execution engine: `StateGraph` compiles user-defined nodes and conditional edges into a `Pregel` runnable, where typed state channels (`LastValue`, `Topic`, `DeltaChannel`) apply reducer-based updates across supersteps. The engine supports durable checkpointing (in-memory, SQLite, Postgres), interrupts for human-in-the-loop, retry/timeout policies, subgraph composition, and v3 streaming. The CLI can scaffold projects and deploy graphs to LangGraph Cloud or self-hosted runtimes via Docker; the SDK provides sync/async clients that drive remote graphs over HTTP/SSE/WebSocket with typed stream projections (messages, tool calls, lifecycle). This is purely an application/framework repo; the `examples/` notebooks are usage demonstrations, not research pipelines. Primary data flow: user code builds a graph and compiles it; invocation reads channel state from a `BaseCheckpointSaver`, runs eligible nodes (with optional caching/retry), applies channel updates via reducers, writes the new checkpoint per superstep, and emits streamed events through a transformer pipeline (`StreamMux`). The SDK's v3 streaming protocol adds reconnection, subscription fan-out, and scoped subgraph handles over an SSE/WebSocket transport. External dependencies center on `langchain-core` (messages, tools, runnables), Pydantic, `httpx`, `psycopg`, `msgpack`, `orjson`, with optional `redis` and `pycryptodome` for cache/encryption. The codebase exhibits exceptional engineering: extensive unit/integration/conformance tests, a formal conformance suite that pins checkpoint-backend behavior across implementations, security-conscious serialization (strict msgpack/json module allowlists, a patched path-traversal vulnerability in the SDK), and benchmarks. Notable weaknesses are real but contained: heavy sync/async duplication in SDK clients and transports, a fast-moving deprecation path (many renamed APIs, `MessageGraph` slated for removal), and beta features (`DeltaChannel`, `ServerRuntime`) marked unstable. The `@task`/`@entrypoint` functional API, `create_react_agent` prebuilt, and conformance test framework are the most stable and reusable surfaces.
oh-my-openagent (omo) is a massive, actively-developed TypeScript monorepo that ships as a multi-harness AI-agent orchestration plugin. Its production function is to instrument coding-agent runtimes (OpenCode, OpenAI Codex CLI, and adapters for Claude Code and other harnesses) with a rich layer of lifecycle hooks, background agents, multi-model routing, LSP/AST tooling, team-mode parallelism, and a curated prompt system โ all installable via a single `bunx oh-my-openagent install` or `npx lazycodex-ai install` command. The architecture is a workspace of 20+ pure-TypeScript core packages (model-core, rules-engine, skills-loader-core, team-core, tmux-core, delegate-core, hashline-core, lsp-core, mcp-client-core, etc.) that are consumed by two main adapter packages: `omo-opencode` (the full-featured OpenCode plugin with 11 agents, 54+ hooks, team mode, ultrawork/ULW loop, background agents, Codegraph MCP, etc.) and `omo-codex` (a lightweight Codex CLI plugin that vendories a subset of components โ rules, comment-checker, LSP, git-bash, ultrawork, ulw-loop, telemetry โ as isolated Codex components). A large shared-skills layer provides cross-harness SKILL.md files for programming languages, frontend design, ultimate browsing, debugging, and more. The codebase is notable for its aggressive package layering refactor (documented in ROADMAP.md), its strict no-excuse TypeScript policy, extensive automated QA evidence (.omo/evidence/), and its depth of agent-facing features like hash-anchored edits, prompt-async-gate, runtime fallback with model-suggestion retry, and the start-work/ULW-loop goal orchestration systems. With 64K stars, daily commits, 790 open issues, and a sprawling CI matrix, it is one of the most ambitious open-source agent-orchestration projects in maintenance today.
Herdr is a terminal workspace manager designed for AI coding agents. It features a client-server architecture where a persistent background server manages terminal panes, workspaces, and tabs, while thin clients (TUI and CLI) connect via Unix sockets/named pipes. The system enables detaching and reattaching sessions without losing agent state, provides agent-native control through CLI/socket API for spawning and managing AI agents (Claude, Codex, Copilot, etc.), and maintains session persistence across restarts and network disruptions. It includes a plugin system for extensibility, comprehensive AI agent integrations, and a rich terminal interface built with Ratatui.
Paseo is a full-stack, multi-platform development environment for orchestrating AI coding agents (Claude Code, Codex, OpenCode, Pi, etc.) from a unified interface. It consists of a daemon server that manages agent sessions, workspaces, terminals, and git operations; a cross-platform client built with React Native/Expo (iOS, Android, web, Electron desktop); a CLI tool; and a plugin ecosystem. The architecture is provider-agnostic, supporting multiple AI backends through a common protocol layer. The codebase demonstrates high engineering craftsmanship with extensive test coverage, clean separation of concerns, and reusable patterns like the plugin SDK, protocol schemas, and platform abstraction layers. It is actively maintained with rapid release cycles and a large community.
This is a full-stack web application that converts screenshots, images, text descriptions, and video recordings into functional codeโprimarily HTML with Tailwind CSS, but also supports React, Vue, Bootstrap, and Ionic stacks. The backend is a FastAPI server with a WebSocket-based streaming architecture. It orchestrates multiple AI models (OpenAI, Anthropic, Gemini) through a modular provider abstraction layer, using an agent system with tools such as create_file, edit_file, generate_images, extract_assets, and screenshot_preview. The frontend is built with React, Zustand for state management, Tailwind CSS, and shadcn/ui components. Users can upload images, paste URLs, type descriptions, import existing code, or record screen videos. Generated code is presented with live preview (desktop/mobile), version history (commits and variants), design system management, and an interactive select-and-edit mode for making targeted updates. The application also includes a sophisticated evaluation infrastructure for benchmarking different models and prompts, with agent run logging, cost tracking, and prompt reports that help developers compare outputs across configurations. Although primarily an application, the extensive eval system gives it a hybrid character with data-research elements.
Ruflo is a large, modular AI agent orchestration platform that extends Claude Code with a plugin ecosystem, swarm coordination, memory systems, neural learning, security enforcement, and federation. The core is a CLI tool (`npx ruflo`) that provides 26+ commands and 215+ MCP tools for managing agents, memory, security, hooks, and deployments. It includes a console UI inside Claude Code, a Svelte-based chat UI (ruvocal), and a React-based goal UI. The architecture is ADR-driven with clean separation into domain, application, and infrastructure layers across 35+ plugins and 20+ core packages. The system implements advanced patterns: CQRS for memory and swarm, circuit breakers for resilience, capability envelopes for security, Ed25519 signing for release integrity, and a harness loop for automated champion selection. It supports multi-model routing, hybrid vector search (HNSW + SQLite), watermarking (WASM-based Gumbel scheme), and neural learning (PPO, DQN, Decision Transformer). Federation enables cross-installation agent collaboration with zero-trust, HMAC-signed envelopes, and PII-gated data flow. While the codebase is well-structured and actively maintained, it has some maintenance risks: duplicate helper scripts across multiple directories, hardcoded version numbers in smoke tests, experimental alpha plugins, and a large regression test suite that requires ongoing upkeep. The plugin ecosystem is extensive but some plugins may be aspirational rather than production-ready.
Codewhale is an open-source, terminal-native AI coding agent that operates as a TUI (ratatui), CLI, headless runtime, MCP server, and a web frontend. It manages full development workflows: reading repositories, editing files, running commands, reviewing changes, and orchestrating multi-agent fleets. The codebase is a Rust monorepo with ~52 crates, a Next.js website with 18+ locales, a VS Code extension, packaging for npm/Homebrew/Arch/Windows, and companion pet apps. The architecture is event-driven with a pluggable tool system, model-agnostic provider routing, session-based journaling, and a contract-based command framework. It supports dozens of LLM providers (DeepSeek, OpenAI, Anthropic, Ollama, etc.) and features sandboxed execution, telemetry with a strict no-IP privacy contract, and a plugin marketplace. The project is heavily tested with unit, integration, PTY/Cucumber, and hermetic bash tests, and enforces budgets for dead code and blocking calls.
Magi is a local-first, self-hosted AI engineering workspace that orchestrates multiple AI agents to collaborate on complex engineering tasks. The system features a polyglot architecture with Rust backend services and TypeScript/JavaScript frontends (desktop Electron and web Svelte applications). It provides tool execution with governance, persistent knowledge storage, session management, workspace snapshotting, usage tracking, and integration with multiple LLM providers (Anthropic, OpenAI, xAI, MCP). The platform emphasizes secure, correct tool invocation with session/workspace scoping, observable runtime state via event aggregation, and cross-platform support with appearance theming.
OpenAgents Control (OAC) is a framework for managing, testing, and orchestrating AI coding agents. It provides a CLI tool (`oac`) to install, update, and manage agents, context files, and skills from a registry. The system includes a plugin architecture for OpenCode and a compatibility layer that converts agent definitions between OAC, Claude Code, Cursor, and Windsurf formats. A comprehensive evaluation framework tests agent behavior against critical rules (approval gates, context loading, stop-on-failure, delegation, tool usage) using YAML-defined test suites and timeline-based analysis. The repository is primarily a software development toolchain for AI-assisted coding workflows, with strong emphasis on deterministic safety rules and multi-agent coordination.
Ralph Wiggum for Cursor is an implementation of Geoffrey Huntley's Ralph Wiggum technique for autonomous AI development. It manages LLM context like memory by tracking token usage and rotating to fresh agent contexts when needed, persisting state in files and git. The system provides automated iteration loops with features like gutter detection, rate limit handling, task progress tracking via checkboxes, and support for both sequential and parallel execution modes. Key components include a sophisticated stream parser for real-time token and error monitoring, a YAML-backed task parser with caching, and retry logic with exponential backoff.
53AIHub is an open-source enterprise AI knowledge management and agent orchestration platform. The codebase reveals a multi-tenant SaaS/self-hosted system that allows organizations to build, deploy, and operate AI agents across multiple backends (OpenAI, Coze, Dify, Gemini, etc.), manage knowledge bases with full RAG pipelines (document parsing, chunking, embedding, graph extraction, wiki generation), record and transcribe meetings with insight extraction, and provide a unified search and chat interface. The architecture is a Go monolith backend using Gin and GORM, with a monorepo frontend comprising three React apps (admin console, end-user portal, and embeddable agent plugin) sharing a common business logic and component library. Data flows center on document ingestion pipelines, real-time agent relay with tool execution, and recording/speech processing. The system integrates with vector stores (Qdrant), Elasticsearch, Redis, and various LLM providers. While primarily an application, it contains substantial data processing pipelines characteristic of a data_research project, particularly the RAG and recording insight modules.
AnythingLLM is a full-stack, self-hosted AI chat platform designed for Retrieval-Augmented Generation (RAG) over private documents. It provides a web interface where users create workspaces, upload documents (PDF, DOCX, images with OCR, audio, etc.), which are then chunked, embedded, and stored in a vector database (default LanceDB, with support for PGVector, Pinecone, Qdrant, and others). Chat queries retrieve relevant document chunks and feed them to an LLM of choice (supporting 30+ providers including OpenAI, Anthropic, Ollama, and local models via KoboldCPP). The platform also features an extensible agent system (aibitat) with plugins for file system operations, SQL databases, Gmail, Google Calendar, web scraping, image generation, and scheduled jobs. A separate 'collector' microservice handles document ingestion and format conversion, while the 'open-computer' subproject provides a QEMU-based virtual machine for autonomous browser automation. The frontend is a React SPA with multi-user support, role-based access, internationalization, embeddable chat widgets, and a community hub for sharing agent skills, system prompts, and slash commands. The architecture is a monolith (Express server) with the collector as an isolated service, and the open-computer as a standalone CLI/service. It relies on external AI APIs, vector databases, and local storage, making it suitable for both cloud and on-premises deployment.
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.
This repository is a comprehensive operational playbook for 'Ralph', Geoff Huntley's methodology for running Claude Code in an autonomous loop to build software. The core deliverable is a detailed guide (README.md plus a styled index.html mirror) explaining the three-phase workflow: define requirements as JTBD-aligned specs, generate an implementation plan via a planning loop, then run a building loop where Claude picks tasks from the plan, implements them, validates against tests, and commits โ with a fresh context window per iteration. The guide is unusually well-structured, covering context management, backpressure via tests, sandbox security, and tuning strategies. Beyond documentation, the repo ships functional artifacts: two bash loop scripts (files/loop.sh, files/loop_streamed.sh) that orchestrate the Claude CLI, a dependency-free Node.js stream parser (files/parse_stream.js) for readable terminal output, and five prompt templates (PROMPT_build.md, PROMPT_plan.md, PROMPT_specs.md, PROMPT_reverse_engineer_specs.md) encoding the methodology's guardrails. It also documents sandbox environment options (E2B, Fly Sprites, Modal, Cloudflare, Docker) for safely running autonomous agents with --dangerously-skip-permissions. The prompt templates are the real product โ they encode hard-won operational knowledge about context efficiency, subagent fan-out, and steering LLM behavior. Notable patterns include escalating 9s-numbered guardrails, explicit subagent limits (500 for search, 1 for build/tests), the 'one sentence without and' topic scoping test, and a two-phase reverse-engineering prompt that produces implementation-free behavioral specs. This is a documentation-first repo with a small but functional code footprint.
This repository contains the reconstructed source code of Claude Code (v2.1.88), Anthropic's official terminal-based AI coding assistant. It is a full-featured CLI application built on a custom Ink-based React renderer for terminal UI, with a sophisticated tool system, multi-agent orchestration (swarm/teammate modes), MCP (Model Context Protocol) integration, plugin marketplace, and enterprise management features. The architecture is modular: a core state management layer (createStore, signals), a tool abstraction (buildTool with Zod schemas, permissions, and UI rendering), a permission system with classifier-based auto-approval, and a terminal UI framework with Yoga layout, keyboard/focus management, and animation support. The application supports remote sessions via WebSocket bridge, scheduled tasks (cron), vim mode, computer use (macOS native), and extensive analytics/telemetry via Datadog, GrowthBook feature flags, and first-party event logging. External dependencies include the Anthropic API, AWS Bedrock/Vertex SDKs, MCP SDK, and various cloud provider SDKs. The codebase demonstrates high craftsmanship in state management patterns, tool orchestration, and terminal UI engineering, but also carries technical debt from feature flag proliferation, deprecated sync APIs, and ant-only code paths that complicate external reuse.
Cali is a TypeScript-based CLI application designed for React Native and Expo development teams. It functions as an AI-powered orchestration layer that automates mobile quality assurance, code review, and performance analysis. The system operates by ingesting repository context (PR data, mobile artifacts) and executing structured agent loops that interact with platform-specific tools (Android/iOS SDKs) via the Vercel AI SDK. It supports both local execution and CI environments (GitHub Actions, EAS), generating structured reports in JSON and Markdown formats. Architecturally, it follows a monorepo pattern with distinct packages for the core CLI (packages/cali) and platform-specific tool wrappers (packages/tools). The core logic relies on a role-based command structure where specific tasks (QA, Review, Dev) are delegated to specialized agent roles. Data flow is deterministic, moving from context resolution through tool execution to report publishing, ensuring consistent behavior across different environments. The tool distinguishes itself by managing complex mobile development contexts, such as artifact parsing (APK/IPA) and device management, which are typically brittle in automated workflows. It integrates skill discovery for AI agents and supports multiple output publishers (local file, Vercel Blob). While it solves a specific niche problem effectively, it introduces dependencies on external binaries and rapid-versioning AI SDKs that require careful maintenance.
JiuwenSwarm is a multi-agent AI orchestration platform that runs as a set of distributed services: an AgentServer (WebSocket-based), a Gateway for multi-channel IM integration, a sandboxed execution environment (JiuwenBox), and a skill development pipeline. It enables teams of AI agents (leader/teammates) to collaborate on complex tasks, with skill retrieval and orchestration via the Symphony system. The system supports multiple frontends: web (React), TUI (terminal), and IM channels (Feishu, WeCom, DingTalk, Telegram, Discord, Slack, WeChat, Xiaoyi). The architecture is modular with an extension system, but many components are tightly coupled and some parts remain incomplete (e.g., SkillDev stages marked as 'ๅพ ๅฎ็ฐ'). The codebase is actively maintained but shows signs of drift: multiple monkeypatches, hardcoded paths, and a large dependency surface. The core strength lies in its agent orchestration logic, sandbox security, and multi-channel integration, while the skill evaluation and retrieval subsystems are functional but not yet production-ready across all stages.
Noodle is an open-source AI agent orchestration framework written in Go that manages autonomous coding agents through a kitchen-brigade model. It operates as a background daemon with a CLI (`noodle start`, `noodle status`, `noodle worktree`) and a real-time React/TypeScript web UI. The core loop reads backlog items (from markdown files via shell-script adapters), schedules multi-stage orders, dispatches agents (Claude Code, Codex) into isolated git worktrees, monitors their progress via NDJSON event logs, handles merge conflicts, and supports human-in-the-loop review gates. The system is config-driven via `.noodle.toml` and uses skills (directories with `SKILL.md` frontmatter) as the sole extension point for defining agent behavior and task types. Architecturally, Noodle is a monolith with clear internal packages: a state-machine loop (`loop/`), dispatchers for process and remote runtimes (`dispatcher/`), a parser pipeline for provider NDJSON output (`parse/`, `stamp/`), session monitoring (`monitor/`), event-sourced state management (`internal/reducer/`, `internal/state/`), a projection layer for incremental UI updates (`internal/projection/`), and a WebSocket server (`server/`). The UI is built with TanStack Router, React Query, and D3 for agent tree visualization. State is persisted as JSON/NDJSON files under `.noodle/`, with crash recovery via atomic snapshots and idempotent event ingestion. Key design patterns include: event sourcing with a deterministic reducer and effect ledger, directory-based fixture testing with source hash validation, a failure taxonomy with recoverability classification, mode gating for autonomy levels (auto/supervised/manual), and a plugin system via JSON-RPC for external runtimes. The codebase demonstrates strong engineering discipline with extensive test coverage (unit, integration, e2e with Playwright), CI/CD via GitHub Actions and GoReleaser, and a comprehensive brain vault for agent knowledge persistence.
langchaingo is a Go port of the LangChain framework, providing a modular, composable library for building LLM-powered applications. In production, it serves as an abstraction layer over dozens of LLM providers (OpenAI, Anthropic, Google AI, AWS Bedrock, Ollama, HuggingFace, etc.), vector stores (Chroma, Pinecone, Weaviate, pgvector, Redis, Qdrant, and many more), and supporting components such as chains, agents, memory, tools, document loaders, and prompt templates. The architecture is a monorepo library: users import packages and compose interfaces (`Model`, `Chain`, `VectorStore`, `Agent`, `Memory`) to orchestrate LLM workflows. Key entry points are provider constructors (e.g., `openai.New()`) and composition functions (e.g., `chains.NewLLMChain()`, `agents.NewExecutor()`). The library relies on many external SDKs and databases, creating a large dependency surface. It includes a custom HTTP record/replay testing infrastructure (`httprr`) for deterministic testing of API calls. The codebase is actively maintained with recent commits and a large community, but carries medium technical drift due to some outdated dependencies and deprecated API patterns.
This repository is a monorepo of self-contained demo applications showing how to build and deploy multi-agent AI systems using Docker Compose, Docker Model Runner, and the MCP Gateway. It contains 12+ independent examples spanning Google ADK, A2A, Agno, CrewAI, LangGraph, Langchaingo (Go), Spring AI, Akka, and a Next.js agent UI. Each subproject is a standalone composition with its own compose.yaml, Dockerfile, and README, designed to run with a single `docker compose up --build` after creating a `.mcp.env` file. The demos are reference architectures rather than a single product, emphasizing local LLM inference, MCP tool integration, and switching between local and cloud models via compose override files.