browser-use is a comprehensive Python framework that enables AI agents to automate web browser interactions. It provides a unified interface for controlling browsers through Playwright/CDP, integrates with multiple LLM providers for decision-making, and includes sophisticated features like structured data extraction, security controls, token usage tracking, and sandboxed execution. The architecture is modular with clear separation between agent reasoning, browser management, tool execution, and extensibility mechanisms. Key innovations include a flexible action registry system with special parameter injection, domain-aware security watchdogs, automatic LLM cost tracking, and MCP integration for extending agent capabilities. The project demonstrates strong engineering practices with extensive testing, CI/CD pipelines, and comprehensive documentation through examples.
OpenViking is an agent-native context database that unifies memories, resources, and skills under a virtual filesystem paradigm (viking:// URIs). It provides a three-tier context model (L0 abstract, L1 overview, L2 full content), recursive directory-based retrieval with visualized trajectories, and automatic session memory extraction. The system consists of a FastAPI HTTP server with embedded Rust components (RAGFS filesystem, vector index engine), a Rust CLI (ov), Python SDKs, a React/Vite Web Studio dashboard, and VikingBot - an agent framework with multi-channel support (Telegram, Slack, Feishu, etc.) and MCP integration. It integrates with OpenClaw, Claude Code, Codex, OpenCode, Hermes, and LangChain/LangGraph. The codebase demonstrates strong engineering: clean separation of concerns, async-first design, comprehensive test coverage (unit, integration, e2e), and production-ready deployment artifacts (Docker, Helm, multi-arch builds). Benchmarks show significant improvements over baseline agents on LoCoMo (82% vs 24-57% accuracy), tau2-bench (+6-12pp), and HotpotQA (91% at top-20).
Chakra UI is a React component library that provides accessible, customizable UI components with a design system foundation. The monorepo contains the core component library (@chakra-ui/react), styling system (Emotion-based with Panda CSS preset), CLI tools for project scaffolding and codemods for migration, a Next.js documentation site, an interactive example gallery, framework sandboxes for Next.js/Remix/Vite integration, and an MCP server for AI tool access. The architecture emphasizes composable APIs, theme-driven design via design tokens, and comprehensive accessibility coverage. Key entry points include the core library index, styled system factory, CLI commands, documentation layout, example compositions, and MCP server entry point.
Goca is a CLI tool for generating Go applications following Clean Architecture principles. It scaffolds complete projects with domain, usecase, repository, and handler layers, supporting multiple databases (PostgreSQL, MySQL, MongoDB, etc.) and protocols (HTTP, gRPC, CLI, worker). The tool includes safety mechanisms (dry-run, backup, force), dependency injection generation, middleware creation, and Model Context Protocol (MCP) integration for AI-assisted development. Its architecture emphasizes layer separation and dependency management, generating production-ready code with built-in validation, testing scaffolding, and CI/CD pipeline generation.
Hermes Studio is a self-hosted AI agent orchestration platform providing a unified interface for multiple AI agents (Hermes, Ekko, Claude Code, Codex, Pi) with chat, workflow automation, agent management, and skill-based extensibility. The architecture features a Vue 3 frontend, Node.js/Koa backend, Electron desktop client, and hybrid TypeScript/Python agent runtime. Key capabilities include real-time collaboration via Socket.IO, voice processing with multiple STT/TTS providers, file management with preview capabilities, usage analytics, and Model Context Protocol (MCP) integration for extending agent tools. The platform supports social messaging integrations (Feishu, Telegram, Weixin) and MCU device support for embedded voice processing.
PPTAgent is an agentic PowerPoint generation system designed for integration with AI coding agents (Claude Code, Codex, OpenCode). It creates editable PowerPoint presentations from text briefs through a workflow involving HTML slide authoring, rendering, visual review (either multimodal or via external visual models), and PPTX export. The system features a dual-codepath architecture: 'deeppresenter/' as the current runtime with CLI, multi-agent orchestration, and MCP tool integration, and 'pptagent/' as the legacy core generation library still used for the MCP server entrypoint. Key capabilities include template-driven slide generation, visual quality validation, context management to prevent overflow, and support for optional document processing (MinerU) and search APIs. The skill-based architecture allows coding agents to invoke presentation generation as a tool while maintaining editable source artifacts.
This repository demonstrates the implementation of the A2UI (Agent-to-UI) protocol for building AI-powered mobile applications. It provides a complete example consisting of: 1) A Python A2A agent server (stock_lookup) that uses Google ADK to process user queries and generate structured UI responses, 2) A Flutter client (GenUIDemo) that connects to the agent via A2A protocol, parses A2UI messages, and renders them as native Flutter UI, and 3) Supporting documentation explaining the A2UI protocol, MCP integration, and AI-assisted engineering practices. The core innovation is the separation of concerns where AI agents generate declarative UI JSON that clients render natively, enabling rich interactions without executing arbitrary code. The repository includes reusable base classes for building A2UI agents that handle schema validation, event processing, and response formatting.
ByteRover CLI is an AI-powered development assistant that provides persistent, structured memory for AI coding agents through a context tree. It features a multi-layered architecture with CLI (OCLIF), TUI (React Ink), and WebUI (React/Vite) interfaces, backed by a daemon service handling core agent logic. The system enables knowledge curation, synthesis, version control for context trees, swarm-based querying across multiple LLM providers, and integration with external AI agents via MCP. Key capabilities include tool execution (file operations, code execution), review workflows for AI-generated changes, and telemetry tracking.
Manifold is an AI agent platform enabling multi-step workflow automation through teams of AI assistants. The system provides a chat interface for interacting with configurable specialist agents, a visual workflow editor (WARPP) for creating reusable automation, and an experimentation playground for testing prompts and models. Built with a Go backend and Vue.js frontend, it features extensible tool systems, layered memory architectures (belief, evolving, decision), MCP integration for external tools, and comprehensive observability via OpenTelemetry. The architecture emphasizes modularity with clear separation between agent execution, persistence, tool discovery, and memory subsystems.
This repository is a comprehensive tutorial on building AI agent harnesses, structured as 17 progressive lessons. Each lesson introduces a single mechanism (tool use, permissions, hooks, planning, subagents, skill loading, context compaction, memory, task system, background tasks, cron scheduler, agent teams, MCP integration, workflow runtime, and goal loop) that extends a core agent loop without modifying it. The harness enables a language model (Claude) to perceive, reason, and act through tool interactions while managing context, permissions, and collaboration. The repository includes runnable Python implementations for each lesson and an interactive Next.js web application with visualizations for learning and experimentation.
The google/adk-go repository is a production-grade, open-source Go framework for building, orchestrating, and deploying multi-agent AI systems. It provides a comprehensive set of abstractions including agents, workflows, tool integrations, model backends (Gemini, OpenAI, Apigee), session management, artifact storage, and human-in-the-loop (HITL) support. The architecture centers around a workflow engine that supports graph-based execution with nodes, edges, retry, concurrency, and dynamic branching. It also implements agent-to-agent (A2A) and Model Context Protocol (MCP) for inter-agent communication. The framework is designed to be deployed via REST API, WebSocket, SSE, or as a console application, and includes launchers for Google Cloud Run and Vertex AI Agent Engine. While primarily an application framework, it also includes telemetry and analytics plugins for observability. The codebase is well-structured with extensive unit and integration tests, but some internal packages and experimental features (e.g., OpenAI model adapter) indicate ongoing development and potential for interface drift.
MultiGen is an AI agent platform designed for private, on-premise deployment. It features a planner-react architecture where a planner agent creates task plans and a react agent executes them using various tools (web browsing, shell commands, file operations, multimodal generation). The system maintains persistent session history via PostgreSQL, enabling conversation continuity and agent memory retention. Extensibility is supported through Model Context Protocol (MCP) and Agent-to-Agent (A2A) integrations. The backend is built with FastAPI using a layered architecture (Interface/Application/Domain/Infrastructure), the frontend with Next.js 14 App Router, and execution occurs in a sandboxed Docker container with Ubuntu, Chrome, and VNC. Real-time updates are delivered via Server-Sent Events (SSE) powered by Redis streams.
SuperClaude Framework is a context engineering framework for Claude Code, transforming it into a structured development platform via behavioral instruction injection. It provides 30+ slash commands, 20+ domain-specific agents, 7 behavioral modes, and 8 optional MCP server integrations. The core delivery mechanism is a Python package (pip-installable) with a CLI that installs Markdown instruction files into Claude Code's configuration directory, enabling automated workflows, quality gates (confidence checks, self-validation, error learning via Reflexion), and parallel execution patterns. The architecture is hybrid: a Python package (src/superclaude/) provides the CLI, pytest plugin, and execution engine, while a parallel plugin directory (plugins/superclaude/) holds the Markdown-based agent definitions and command instructions. This dual structure indicates an ongoing migration from a pure Markdown configuration to a Python-backed system, with significant duplication between the two trees. The framework is designed for token efficiency, employing progressive context loading, symbol compression, and lazy-loaded skills to reduce startup costs. It includes a Project Manager Agent (PM Agent) that orchestrates sub-agents, enforces PDCA cycles, and maintains session persistence with cross-session learning via JSONL-based memory. While the repo contains extensive research documentation (token efficiency, parallel execution, migration studies), the core deliverable is a developer tool, not a data pipeline.
OpenAgentd is a local-first, coding-focused AI agent platform that provides a desktop application (Tauri), mobile companion (iOS), browser-based UI (React/Vite), CLI, and an API server. The system orchestrates an agent loop with pluggable LLM providers (Anthropic, OpenAI, DeepSeek, Grok, Ollama, etc.), MCP tool integration, filesystem tools, code analysis, and a scheduler for recurring tasks. It features a dual backend architecture: a legacy Python/FastAPI implementation and a newer Rust v3 rewrite (axum-based) that is progressively replacing the Python version. The web frontend is a rich SPA with real-time streaming, workspace management, telemetry/observability dashboards, and extensive settings panels. The repository also includes code health analysis scripts, document chunking for RAG, and a comprehensive test suite across all layers.
AutoGen is a multi-agent AI framework originally from Microsoft Research, now in maintenance mode and succeeded by Microsoft Agent Framework. The codebase is a large monorepo containing Python packages (autogen-core, autogen-agentchat, autogen-ext, autogen-studio, agbench) and a .NET implementation (Microsoft.AutoGen.*), with Python as the primary language. The architecture is layered: Core provides event-driven agent runtime, message passing, and distributed infrastructure via gRPC; AgentChat offers higher-level multi-agent teams and patterns; Extensions integrate external services (OpenAI, Azure, MCP, GraphRAG, etc.); Studio is a FastAPI web UI with a Gatsby frontend for no-code agent prototyping. Key entry points include AssistantAgent, group chat managers, and various team orchestrators. The system relies heavily on LLM clients, Pydantic models, gRPC for distributed runtimes, and OpenTelemetry for tracing. Despite the maintenance mode status, the code shows solid engineering with clear separation of concerns, extensive test suites, and well-structured packages. However, the ecosystem is in transition, with active development shifted to the successor framework.
Magic is a large, polyglot enterprise AI-agent and collaboration platform. The production core is a PHP Hyperf backend (`backend/magic-service`) with strict DDD layering, a Python agent runtime (`backend/super-magic`) for tools/skills/browser automation, a Go engine for knowledge processing/embedding, and a React/TypeScript frontend (`frontend/magic-web`) that spans desktop, mobile, admin, and a visual flow editor. The platform delivers chat/messaging, AI agents, workflow automation (MagicFlow), knowledge bases with vector search, an LLM/model gateway, file storage, low-code data tables (MagicBase), MCP integration, and multi-channel bot deployment (DingTalk, Feishu, WeCom). It is fundamentally an application rather than a research repository; the knowledge-base and data-processing subsystems serve product features, not analysis. Architecturally, the strongest parts are the PHP library packages — async-event, cloudfile, flow-expr-engine, code-executor, and easy-dingtalk — which are cleanly separated and demonstrate genuine, extractable craftsmanship. The frontend likewise includes reusable packages for flow editing, HTML-to-PPTX conversion, and UI components. However, the repository is physically enormous and shows maintenance risk: substantial code duplication exists between `backend/magic-service` and `backend/super-magic-module`, several enterprise features are intentionally stubbed out with open-source no-ops, migration rollback methods are frequently empty, and the mix of PHP, Python, Go, and TypeScript adds integration complexity. The codebase is actively developed, but quality is uneven across the many modules.
Vizra ADK is a retired Laravel package (final release v0.0.48) that provides a comprehensive framework for building AI agents with LLM orchestration, tool systems, memory, workflows, evaluations, tracing, and MCP integration. It is not a standalone application but a library designed to be installed into Laravel projects. The architecture follows Laravel package conventions: service providers, facades (Agent, Workflow), Eloquent models, Artisan commands, Livewire components, and database migrations. Key entry points include the Agent facade for running agents, the Workflow facade for orchestrating multi-agent workflows, and a set of CLI generators for scaffolding agents, tools, and evaluations. The system supports multiple LLM providers via Prism PHP, persistent memory (session, user, vector), tool chaining, sub-agent delegation, and an evaluation framework with LLM-as-a-Judge assertions. The codebase is well-structured with strong test coverage (Pest + Mockery), but the package is officially retired with no further development, leading to high technical drift as dependencies age out. Despite retirement, many components (e.g., ToolChain, VersionablePrompts, AgentVectorProxy, HasLogging) are self-contained and demonstrate reusable patterns suitable for extraction into new projects.
This is a leaked internal source of 'Claude Code', a terminal-based AI coding assistant CLI built by Anthropic. The application is a monolith written in TypeScript with React/Ink for terminal UIs, running on the Bun runtime. In production, it provides an interactive REPL that connects to Claude LLMs to perform software engineering tasks: reading/writing files, executing bash/PowerShell commands, searching code with grep/glob, managing git operations, spawning sub-agents, running MCP servers, and more. It features a sophisticated permission engine, plugin ecosystem, skill system, IDE bridge (VS Code/JetBrains), and remote session support. The architecture is centered around a QueryEngine that orchestrates LLM API calls with streaming, tool loops, and retries. There are ~40+ tools (BashTool, FileEditTool, MCPTool, etc.) and ~50+ slash commands (/commit, /review, /config, /doctor). The codebase is extremely large (~1900 files, 512K+ lines) with significant internal complexity. However, it contains many stubs for removed internal packages (@ant/*, @anthropic-ai/mcpb, etc.), heavy use of bun:bundle feature flags, and countless ant-only conditionals (process.env.USER_TYPE === 'ant') that gate internal-only features. This means the source cannot be run as-is without Anthropic's infrastructure. While the engineering quality is high in places (clean TypeScript with Zod schemas, well-structured tool pipelines, a custom Ink renderer with Yoga layout), the codebase is not designed for external reuse or portability. It requires Bun, has many hardcoded internal service URLs, and the stubbed packages would need real implementations. For learning and inspiration, however, it offers excellent examples of: terminal UI architecture, permission engines, plugin systems, and AI agent tool frameworks.