Total Recall is a memory system for Claude Code that provides persistent, curated memory across sessions. It implements a tiered architecture with daily logs for raw capture, registers for structured domain knowledge, working memory for essential context (auto-loaded every session), and archive for historical data. The core innovation is its write gate mechanism that evaluates whether information should be saved based on whether it changes future behavior, preventing memory bloat. The system includes automatic hooks for session context loading and pre-compaction flushing, a sophisticated ID-based metadata system for tracking memory entries, and maintenance routines for pressure-based cleanup. It's designed as both a plugin and standalone installation with comprehensive slash commands for all memory operations.
This repository is an AI-powered stock research platform that combines a full-stack application (FastAPI backend, React/TypeScript frontend, Electron desktop app) with extensive data/research capabilities. It ingests market data from over a dozen providers (Tushare, yfinance, AkShare, etc.) with priority-based fallback chains, performs AI analysis via LiteLLM (supporting multiple LLM providers), and generates structured research reports, decision signals, and backtesting results. The platform supports multi-agent discussions, strategy screening, portfolio management, alerts, and multi-channel notifications (WeChat, Feishu, Telegram, email, etc.). It covers 13 international markets with trading calendars and market phase detection. The architecture is a monolith with modular services, using SQLite per-workspace isolation. While primarily an application, it has strong data/research characteristics including a screening engine derived from AlphaSift, decision signal lifecycle with outcome tracking, and skill opinion weight calibration. The codebase is well-structured with extensive tests, CI/CD, and reusable patterns like the data fetcher base class and notification sender template.
OysterWorkflow is an open-core desktop application (Electron + React) that records a user's computer activity via Screenpipe (screen, audio, UI events), then uses multi-stage LLM calls to extract reusable, structured 'skills' (workflow graphs) that AI agents (Codex, Claude, Hermes) can execute. The system provides a full lifecycle: capture → ingest → normalize → segment → LLM-based workflow discovery → skill extraction → workflow graph generation → quality evaluation → installation into agent skill directories → execution via MCP or Hermes CLI. It also includes a cloud sync layer (Supabase), a marketplace (ClawHub), and a local runtime HTTP server for the UI. Architecturally, it is a hybrid monolith with clear module boundaries: a desktop shell (Electron main process), a local runtime server (Express), a CLI (commander), a React UI (Vite + React Flow), and a product state layer (SQLite-backed with cloud sync). The codebase is TypeScript-first, ESM-only, and heavily tested (200+ test files). It demonstrates strong engineering practices: atomic file I/O, bounded child process management, immutable revision control for workflow graphs, and a sophisticated prompt registry with versioned inheritance. While primarily an application, it contains a significant data pipeline component (ingest → normalize → segment → LLM extraction) that could be considered a research-grade feature engineering system. The repo is actively maintained with frequent commits, CI, and issue triage. Notable risks include heavy sidecar bundling (Screenpipe, Hermes, ffmpeg), rapid prompt set version churn, and a mixed licensing model (Apache 2.0 open core + PolyForm Noncommercial for product code).
Weft is a full-stack, AI-powered personal task management application built with React and Cloudflare Workers. It provides a Kanban-style board where users create tasks that can be executed by AI agents (Claude) using the Model Context Protocol (MCP) to interact with external services like Gmail, Google Docs, Google Sheets, and GitHub. The system features a sophisticated approval workflow: sensitive tool calls (e.g., sending email, creating PRs) require human approval with specialized UI components for reviewing diffs, documents, and spreadsheets. It supports scheduled task execution, real-time WebSocket updates, OAuth-based integrations, and a command palette for keyboard-driven navigation. The architecture leverages Cloudflare Durable Objects for stateful board management, Workflows for long-running agent execution, and a sandboxed environment for running untrusted code. The frontend is a single-page React application with a custom design system, while the backend is entirely serverless on Cloudflare's edge network.
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.
Stagehand is a Python SDK for the Stagehand API, an AI-driven browser automation framework. The SDK provides sync and async clients (`Stagehand`, `AsyncStagehand`) that interact with remote or local browser sessions via natural language commands like `observe`, `act`, `extract`, and `execute`. It supports both cloud-based (via REST API) and local execution modes, the latter using a compiled SEA binary managed by `SeaServerManager`. The codebase is primarily auto-generated by Stainless from an OpenAPI spec, with hand-written custom modules for session binding, binary management, and local server orchestration. The architecture follows a resource-based client pattern: the main client holds resource objects (e.g., `sessions`) that expose typed methods returning Pydantic models. Request parameters are defined as `TypedDict` subclasses with camelCase aliases, and responses are deserialized into strongly-typed models. The SDK includes comprehensive error handling (hierarchy of `APIError` subclasses), configurable retries and timeouts, SSE streaming support, and Pydantic v1/v2 compatibility. External dependencies include `httpx` for HTTP, `pydantic` for models, and optional `aiohttp`, `playwright`, or `pydoll` for advanced browser control. Key entry points are the `Stagehand` and `AsyncStagehand` classes, which can be instantiated with an API key and base URL. Sessions are started via `client.sessions.start()`, then methods like `session.act()`, `session.extract()`, `session.observe()`, and `session.execute()` perform browser automation tasks. The `_custom/session.py` module wraps the generated resource to provide a bound session object with page-aware frame handling. The SDK also ships a `_sea` binary for local execution, packaged via custom Hatch build hooks.
PiPiClaw is a cross-platform AI agent application that enables users to interact with local and remote systems via natural language commands. It features a built-in web UI for remote control, scheduled task management, file operations, command execution, and a skill system for extending capabilities. The application is designed to be lightweight and portable, utilizing .NET 10.0 AOT compilation to produce a single binary of approximately 2MB. It maintains conversation history and long-term memory with embeddings for context-aware interactions.
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.
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.
NetCoreKevin is an enterprise-level AI middleware platform built on .NET 9 with a Vue 3 frontend. It provides a multi-tenant SaaS backend with AI agent capabilities, RAG knowledge base, permission management, file storage, messaging, and code generation. The architecture follows Domain-Driven Design with modular plug-ins, featuring a generic repository pattern, base service classes, and extensive cross-cutting concerns (caching, logging, transaction management, distributed locks). The AI agent framework supports tool calling, skill management, memory, safety layers, and streaming responses. The frontend uses Ant Design Vue with multi-theme support. While the codebase is well-structured and feature-rich, it exhibits some technical debt such as static service locators, large helper classes, and raw SQL usage in places. Overall, it is a solid, production-ready application with reusable components.
This repository provides a template for building and deploying an AI agent using the ElizaOS framework on the Nosana decentralized compute network. It includes the necessary configuration files for containerization (Dockerfile), dependency management (package.json), agent personality definition (character file), and Nosana deployment specifications. The template emphasizes privacy and decentralization, allowing users to run their agent on infrastructure they control via Nosana's distributed GPU network. The agent leverages Nosana-hosted LLM (Qwen3.5-27B) and embedding models for inference, with environment variables configured to point to Nosana's endpoints. Users can customize the agent by modifying the character file, adding ElizaOS plugins for extended functionality (e.g., web search, social media), and implementing custom logic in the provided TypeScript entry point (src/index.ts). The template follows ElizaOS best practices and includes clear documentation for local development and deployment to Nosana. While the repository serves as a solid starting point, it requires user customization to become a functional agent. The codebase is well-maintained with recent commits, uses current dependencies, and demonstrates proper project structure for an ElizaOS application. It successfully fulfills its purpose as a challenge template for creating personalized AI agents on decentralized infrastructure.
This repository is a comprehensive skill manager for AI agents, providing a CLI tool (Node.js and Python) to search, install, list, and update a large library of over 300 skill definitions. The skills are structured markdown files with YAML frontmatter, each defining a specific capability or workflow for an AI assistant (e.g., code review, security audit, database optimization, TDD orchestration). The application includes a catalog generation pipeline, validation scripts with baseline support, and CI checks to ensure skill quality and consistency. While the bulk of the repository is composed of skill content (instruction playbooks), the active software layer—the CLI, catalog builder, and validator—represents a well-engineered dual-language application with tests and automation.
TripStar is a full-stack, multi-agent AI travel planning platform. It uses a FastAPI backend with a modular agent system (trip planner, weather, hotel agents) orchestrated by a large language model, and a Vue 3 + TypeScript frontend with a dark glassmorphism UI. The backend provides REST APIs and WebSocket real-time status updates for asynchronous trip generation tasks. It integrates data from multiple sources: Xiaohongshu (via reverse-engineered signed API and SSR scraping), Google Maps, and AMap (with automatic fallback). The LLM extracts structured attractions from scraped text, plans itineraries, and repairs malformed JSON output. The system also includes user preference memory with weighted decay and TOP-K recall, a knowledge graph module, and export to image/PDF. The frontend features interactive maps, a budget panel, multi-city support, and a floating AI chat widget. The application is Dockerized with a multi-stage build and supports Chinese, English, and Japanese through i18n. The architecture is cleanly separated into backend services (agents, API routes, memory, map dispatcher, scraper), and frontend views (Home, Landing, Result, AIChat). The map dispatcher pattern provides a unified interface for geocoding and POI search across Google and AMap, and the memory manager implements a reusable preference-learning system. However, the codebase has technical debt: heavy reliance on Xiaohongshu's undocumented API (fragile), a monolithic 42k-token CSS file from Paper Kit 2 (2017) with deprecated techniques, and a complex ~2000-line Result.vue component. Dependencies are not fully locked, and the scraper's JavaScript signature engine may break with anti-bot updates. Overall, TripStar is a solid, functional application with several reusable patterns, but it carries moderate maintenance risks due to its external dependencies and some aging code. Note: This is a hybrid application with a strong data-crawling component (Xiaohongshu scraping and LLM extraction), but the dominant character is a production-ready web application with a clear user interface and API.
This repository is the web-based user interface for the Google Agent Development Kit (ADK). It functions as a comprehensive IDE and debugging console for building, running, and evaluating AI agents. The application is built on Angular (v21.0.0) using Standalone Components and Signals, serving as a client to a backend agent runtime. Key capabilities include a visual workflow builder for agent graphs, real-time chat interfaces supporting text/audio/video streaming, OpenTelemetry trace ingestion and visualization, and a structured evaluation framework for agent performance metrics. It acts as the control plane for agent execution, handling configuration via YAML and managing session state through WebSocket and HTTP communication.
Integuru is a Python application that reverse-engineers API requests from browser traffic to generate runnable integration code. It takes a HAR file (HTTP archive) containing browser network requests and cookie data, then uses LLMs to analyze these requests to identify which endpoint performs a user-specified action. The system builds a dependency graph to determine what prerequisite requests are needed to gather dynamic parameters (like IDs, tokens), and finally generates Python code that can reproduce the action by making the necessary HTTP requests in the correct order. The architecture uses LangGraph for workflow orchestration, with specialized LLM-powered agents handling different aspects of the analysis (URL identification, dynamic parameter extraction, dependency resolution).
This repository is a curated skill library for data analysis workflows, designed to be consumed by AI agents (Claude Code, Codex). It contains 31 skills organized into 6 categories: data quality validation, documentation/knowledge management, data analysis/investigation, data storytelling/visualization, stakeholder communication, and workflow optimization. Each skill is defined by a SKILL.md file with YAML frontmatter, a step-by-step process, required inputs/outputs, and optional scripts, reference materials, and asset templates. The scripts are standalone Python CLIs that generate synthetic data for demo purposes and can be adapted to real datasets. The repo is not a deployable application or a data pipeline; it is a structured knowledge base and toolset for performing data analysis tasks programmatically. It covers common analytical patterns such as null counting, duplicate detection, cohort retention, funnel conversion, A/B testing, time series anomaly detection, metric calculation, and more. The codebase is well-organized and follows consistent conventions, but shows signs of staleness (future dates in README and LICENSE, no recent activity). Dependencies are not pinned, and no environment definitions are provided, limiting reproducibility without manual setup.
ChatWiki is an open-source, multi-service AI chatbot and workflow automation platform primarily targeting the WeChat ecosystem. In production, it operates as a suite of Go microservices (chatwiki, message_service, code_run, websocket, plugin, llm_runner) behind a Gin web server, with a Vue 3 admin panel, separate mobile/PC/Electron frontends, and an embeddable SDK. The core functionality includes knowledge base management (document ingestion, chunking, vector storage with pgvector), a LogicFlow-based visual workflow builder, multi-channel messaging (WeChat Official Account, Mini Program, Feishu, DingTalk, Telegram, WhatsApp, LINE), and an AI agent framework called Clawbot with skill reuse. External dependencies include PostgreSQL (with pgvector and AGE graph extension), Redis, NSQ message queue, and optional Neo4j and E2B sandbox. While the system is primarily an application, it incorporates data-intensive components such as RAG pipelines, LLM request logging, and daily statistics, giving it a hybrid character.
This repository is a comprehensive, structured library of over 50 marketing 'skills' designed for AI coding agents (Claude Code, Codex, Cursor, etc.). Each skill is a self-contained directory with a SKILL.md (frontmatter + workflow), a references/ folder with deep-dive documentation and benchmarks, and evals/evals.json for behavioral testing. The skills cover the full marketing lifecycle: copywriting, SEO, paid ads (Meta, Google, LinkedIn), email, social, CRO, pricing, offers, attribution, market research, and more. Additionally, the repository includes 40+ zero-dependency Node.js CLI scripts that act as API clients for marketing tools like Ahrefs, Semrush, GA4, Meta Ads, Mailchimp, etc., each following a consistent pattern with dry-run support and environment variable authentication. Several integration guides and a central tool registry (REGISTRY.md) complete the ecosystem. While primarily a content library, the CLI scripts and validation/sync tooling demonstrate strong engineering patterns. The skills are designed to be consumed by AI agents to execute complex, multi-step marketing tasks, with cross-skill references and a shared context document (product-marketing.md) enabling orchestration.
This repository is a curated collection of skill plugins for AI coding agents such as Claude Code, Codex, and Cursor. Each skill is a self-contained directory with a SKILL.md descriptor, executable scripts, reference documents, and templates. The ecosystem covers a wide range of capabilities: multi-provider media generation (images, video, audio), browser automation via CDP, macOS app telemetry auditing, document format replication, open-source preparation (secret scanning, license generation), Cloudflare Workers deployment, trend aggregation, and video processing. The skills are designed to be invoked by an AI agent reading the SKILL.md and executing workflows via CLI scripts. While primarily an application-oriented collection, some skills (e.g., happy-app-audit) incorporate data analysis and reverse-engineering methodology, giving it a hybrid character. The architecture is modular: each skill is independent, with consistent patterns for provider abstraction, async polling, and template-based output. This makes the repository a practical toolkit for extending agent capabilities rather than a standalone production service.
This repository is an educational course on harness engineering for AI coding agents. It is a collection of lecture materials, code examples, and project templates that teach how to build environments, state management, verification, and control mechanisms for AI coding agents. The course is structured as 14 lectures and 8 projects, with a sample Electron knowledge-base app used as a running example. The repository is primarily documentation and educational content, with some reusable templates and scripts for harness creation and auditing.