go-workflows is a Go library for building durable, fault-tolerant workflow applications. It implements an event-sourced execution engine inspired by Temporal/Cadence: workflows are modeled as histories of events, and workers execute them by replaying those histories against backend queues. The library exposes a public client API for starting, signaling, and waiting on workflows, and provides a workflow/activity authoring model with sub-workflows, timers, signals, retries, cancellation, and context propagation. Execution is built on a custom coroutine-based async runtime (internal/sync) that gives workflows deterministic control flow, and multiple storage backends (Redis, MySQL, PostgreSQL, SQLite, plus in-memory/monoprocess) implement the same backend interface. Key entry points include the client package, the worker package, the workflow/activity authoring packages, and the tester package for unit testing workflows without a real backend. The repository also contains a separate static analyzer module (analyzer/) that enforces workflow determinism at compile time, and a benchmark tool (bench/) for comparing backend performance. External dependencies include OpenTelemetry for tracing, slog for structured logging, and backend-specific drivers for Redis, MySQL, PostgreSQL, and SQLite. CI runs tests with the race detector across all backends, and Docker Compose provides the required databases. The codebase is substantial and well-tested, but carries maintainability debt: each backend duplicates significant logic (diagnostics queries, event insertion), Redis uses hand-written Lua scripts that can drift, and the embedded diagnostic web app requires a separate Node.js build step. The separate analyzer module also risks version drift from the main module. Despite these caveats, the core abstractions are clean and several components are genuinely reusable.
SIA (Self-Improving AI) is a framework that orchestrates a three-agent loop (meta-agent, target agent, feedback/improvement agent) to iteratively improve an AI system's performance on a benchmark task. In production, it runs as a CLI tool (`sia run`) that sets up a virtual environment, loads task files, and executes generations: the meta-agent reads `task.md` and generates `target_agent.py`, the target agent executes the task and logs results, and the feedback agent reviews the execution and rewrites the target agent for the next generation. A FastAPI web dashboard auto-launches to visualize per-generation accuracy, agent code, trajectories, and improvement plans. The architecture is a CLI-driven monolith with a plugin system for agent backends (Claude, OpenHands, PydanticAI), JSON-based provider/profile configuration, and Docker sandboxing for secure target-agent execution. It relies on external LLM APIs (Anthropic, OpenAI, Gemini, Nebius, OpenRouter, Together) and optionally on Modal/SandboxFusion for the RL-based weights mode. The repository also bundles four benchmark tasks (GPQA, lawbench, longcot-chess, spaceship-titanic) with public/private data splits and evaluators, giving it a hybrid character that includes data/research components. However, its primary function is as an application for running and visualizing self-improvement experiments.
Claude Delegator is a Claude Code plugin that provides GPT (via Codex CLI) and Gemini (via Gemini CLI) as specialized expert subagents. It offers five domain experts (Architect, Plan Reviewer, Scope Analyst, Code Reviewer, Security Analyst) that can advise or implement based on task requirements. The plugin uses MCP (Model Context Protocol) to connect to external CLIs, featuring sophisticated delegation logic with proactive triggers, session management (single-shot and multi-turn), and response synthesis. A key innovation is the zero-dependency Gemini MCP bridge that wraps the Gemini CLI in a standard MCP interface.
SuperAgentX is a modular, open-source multi-agent AI framework designed for orchestrating autonomous agents that plan, act, and execute real-world workflows. It supports 100+ LLM providers (OpenAI, Azure, Gemini, Claude, Bedrock, Ollama, LiteLLM) and 10,000+ MCP tools via the Model Context Protocol. The architecture centers on `AgentXPipe` pipelines that sequence or parallelize agents, each composed of an `Engine` that wraps an LLM client and a set of tool handlers. Handlers are defined using a `@tool` decorator pattern that auto-generates LLM function schemas. The framework includes built-in human-in-the-loop approval channels (console, Slack, Teams), persistent memory with SQLite and vector stores (Chroma, OpenSearch), full observability via OpenTelemetry and SQL-based telemetry, and a CLI for project scaffolding. It also features a production-grade browser automation engine based on Playwright for tasks where APIs are unavailable.
Kubewall is a production-grade, open-source Kubernetes dashboard that provides real-time multi-cluster management through a single-binary web application. It combines a Go backend (Echo framework, client-go informers) with a React/TypeScript frontend (Redux Toolkit, shadcn/ui, TanStack Router) to offer live monitoring, YAML editing, pod log streaming, port forwarding, and an AI-powered troubleshooting assistant (kwAI). The architecture relies on Server-Sent Events (SSE) to push Kubernetes resource updates to the browser, with an in-memory informer cache per cluster. The backend exposes REST endpoints for every standard Kubernetes resource type as well as Custom Resource Definitions (CRDs), while the frontend uses virtualized data tables, Radix UI primitives, and lazy-loaded Monaco editor for editing. The system supports multiple kubeconfig authentication methods and includes a Helm chart for deployment.
Ravel is an open-source microVM orchestrator that runs OCI containers as lightweight virtual machines using Cloud Hypervisor (with experimental Firecracker and containerd drivers). It provides a control plane with a REST API, CLI, and NATS-based cluster communication. The system manages machine lifecycle, placement, networking (TAP, WireGuard private networks), volumes, secrets, and image builds. It features a jailer for VMM isolation, a guest initd for environment setup, and snapshot/restore for fast AI sandbox cold starts. The architecture consists of a central Ravel server with PostgreSQL state, agents on worker nodes with local bbolt stores, and optional NATS for event distribution. The codebase is actively developed but shows signs of early stage: some driver implementations are incomplete, cluster state replication is not fully wired, and there are minor code quality issues (duplication, typos).
agentsre is a Python library that applies Site Reliability Engineering (SRE) practices to AI agent systems. It provides reliability instrumentation for production agents: semantic validation of agent outputs, SLI metrics collection, circuit breaking, escalation baseline detection, cost tracking, and structured audit logging. The codebase is organized as a package with a core reliability module (aos_reliability.py), an orchestration subpackage for control-plane SLIs, a validation layer for agent decisions, and a cost optimizer for LLM spend. It also includes a fintech orchestration demo and documentation for running agents in payment systems. Architecturally, it is a library rather than a service: consumers import the Python API and embed checks into their agent loop. The primary data flow is agent action -> semantic validation -> reliability/risk checks -> orchestration SLI recording -> audit log. The system tracks metrics like escalation rates and decision quality, and can block or allow requests via a circuit-breaker style interface. External dependencies are minimal, with optional cost-optimizer imports guarded by try/except. Maintenance is active, with CI workflows, tests, and a changelog. The code is well-documented and the modules are mostly self-contained, making several components extractable for reuse in other agent platforms.
Mage is an open-source data pipeline orchestration platform that combines a visual notebook-style editor with a production-grade scheduling and execution engine. The system enables users to build, run, and monitor data pipelines composed of Python, SQL, R, and dbt blocks. Architecturally, it is a full-stack web application with a Python backend (Tornado-based server, SQLAlchemy ORM, REST API) and a Next.js/React frontend with a custom component library. Key entry points include the CLI (`mage` command), the web UI served by `mage_ai/server/server.py`, and the API layer at `mage_ai/api/` which exposes CRUD resources for pipelines, blocks, runs, schedules, users, and integrations. Data flows center around pipeline execution: blocks are connected in a DAG, each block can be a data loader, transformer, or exporter. Execution is handled by a configurable executor (local, K8s, EMR, PySpark) and scheduled via a built-in scheduler or external triggers. The platform integrates with dozens of data sources and destinations through a Singer-based integration framework, supports streaming pipelines, and includes advanced features like RBAC, version control, AI-assisted pipeline generation, and a command center for global search. It depends heavily on external services such as cloud storage (S3, GCS, Azure), databases (PostgreSQL, BigQuery, Snowflake, etc.), and authentication providers (OAuth, LDAP, OIDC).