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.
ClawScan is a Go-based CLI tool for composable security scanning of AI agent skills and plugins. It orchestrates multiple external scanners (e.g., Snyk, VirusTotal, Socket, AIG, Cisco, SkillSpector) against skill directories, collects raw evidence, and optionally feeds results to an LLM judge for evaluation. The tool supports profile-based configuration (built-in profiles like `clawhub` and `openclaw-install-policy`), Docker sandboxing, declarative gate rules for automated policy enforcement, and benchmark execution against datasets like SkillTrustBench and clawhub-security-signals. It is distributed via npm (`@openclaw/clawscan`) and GitHub Releases, with a rich CI/CD pipeline including automated runtime image builds, dependency updates, and a Hugging Face leaderboard for security signals research. While primarily an application, it has strong data/research elements through its benchmark infrastructure and leaderboard submission validation.
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.
ClawGuard is a security application designed to protect AI agent ecosystems through static code analysis, runtime monitoring, and sandboxed execution. The backend is a FastAPI server providing authentication (JWT), a code security check pipeline (AST scanning + sandbox execution with sys.settrace monitoring), and audit log storage in SQLite. The frontend is a single-page HTML dashboard with Chinese/English i18n, simulating a defense matrix with real-time feedback. The system demonstrates a multi-layered defense: static prevention (AST blacklist), dynamic detection (monkey-patched builtins, runtime behavior monitoring), and mitigation (timeout, permission errors). It is a well-structured, self-contained application with clear separation of concerns, though the frontend is monolithic. The code quality is strong, with reusable components in the core modules, but the overall architecture is tightly coupled to the specific security policy.
This repository is a TypeScript monorepo for an AI-powered autonomous web browsing agent called 'open-browser'. It consists of three packages: core library (open-browser), CLI (@open-browser/cli), and sandbox (@open-browser/sandbox). The core library orchestrates an agent loop that uses Playwright to control a Chromium browser, extracts DOM state via CDP, sends it to an LLM (OpenAI, Anthropic, Google) which decides actions in structured JSON, and executes those actions via a CommandExecutor. The system supports vision screenshots, extended thinking, compact mode, planning, evaluation, replay recording, and MCP server integration. The CLI provides commands for running agents, interactive sessions, and direct browser manipulation. The sandbox provides resource-limited execution. Key entry points include the Agent class, Viewport browser session, CommandExecutor, and BridgeServer. External dependencies include Playwright, Vercel AI SDK, Zod, Turndown, and various LLM provider SDKs. The architecture follows a modular monorepo with clear separation of concerns, event-driven communication via EventHub, and a guard/watchdog pattern for browser lifecycle management. The codebase demonstrates strong engineering practices with extensive use of Zod schemas for structured outputs, a command catalog pattern, and comprehensive telemetry and cost tracking.
This repository is a static website for a Chinese-language educational course titled 'Deep Agents 实战' (Deep Agents in Action). It provides 16 chapters of technical content on building AI agents using LangChain and LangGraph, including text, video links, and downloadable PDFs. The site is built with Astro 6, Tailwind CSS 4, and TypeScript, and is deployed to GitHub Pages via GitHub Actions. The codebase is well-structured: content is authored in Markdown under `content/`, metadata is managed in `scripts/chapters.json`, and a preprocessing script injects frontmatter into the Astro content collection. Custom Astro components handle layout, navigation, theme toggling, and a responsive table of contents. The repository also includes CI/CD workflows for asset validation and cross-platform installation testing. While the primary purpose is educational content delivery, the build and content pipelines demonstrate reusable patterns for static site generation with Astro.
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.
This is a cross-platform sandbox runtime library developed by Anthropic for securely executing untrusted commands within restricted environments. It is designed to be embedded by AI agent runtimes (such as Claude Code) to enforce network and filesystem access controls, perform TLS-terminating HTTP/SOCKS proxying, and mask credentials like API keys and AWS SigV4 secrets. The system operates as a filtering forward proxy with an optional external 'decider' process for per-request allow/deny/body-inspection verdicts, and it supports Linux (via bubblewrap + seccomp), macOS (via Seatbelt profiles), and Windows (via WFP and a Rust helper). The repository is primarily an application library with a CLI tool (`srt`), not a data or research project. It demonstrates high engineering quality with extensive test coverage, careful security invariants, and thoughtful handling of platform edge cases. However, its complexity is extreme—spanning three OS backends, custom proxy servers, TLS MITM, credential injection, and violation monitoring—and it carries significant drift risks from external binary dependencies, runtime-specific workarounds, and a large test surface with conditional skips.
Entropic is a local-first desktop AI workspace built with Tauri and React. It provides a full desktop environment including chat with an AI agent, file management (Finder), web browsing, office document editing (OnlyOffice integration), voice control, task board with cron jobs, and an integration marketplace (OAuth for Google, Outlook, Slack, etc.). The application runs a sandboxed runtime (OpenClaw) inside Docker/Colima on macOS/Linux or WSL2 on Windows, ensuring secure execution of agent actions. Communication with the agent gateway happens via WebSocket with structured RPC frames. The system supports two modes: local API keys (user provides LLM keys) and managed proxy mode with hosted authentication and billing via Supabase/Stripe. The architecture is a monolith with separate microservices for browser automation (Playwright) and skill scanning (Cisco AI Defense). The frontend uses React 18, TypeScript, Vite 5, and Tailwind CSS 4, while the backend is Rust with Tauri v2 plugins for deep-link, updater, store, stronghold, and shell access. The codebase demonstrates strong engineering practices with reusable hooks for audio recording/transcription, a custom markdown renderer with workspace link support, and a resilient WebSocket client. However, some components are monolithic (Chat.tsx ~4000 lines, Files.tsx ~3000 lines) and there are hardcoded model lists and pricing that may drift over time.