#4
Orca (stablyai/orca) is a cross-platform desktop AI orchestrator designed for high-productivity developers — self-described as a tool for "100x builders" — that lets users run multiple AI coding agents simultaneously, each isolated in its own Git worktree, all tracked and managed from a single unified interface. The core value proposition is parallel agent orchestration: a single prompt can be fanned out across up to five agents (e.g., Codex, Claude Code, OpenCode, Pi), with results compared and the best branch merged, dramatically accelerating iterative development workflows. Orca supports an exceptionally broad ecosystem of CLI-based AI agents, including Claude Code, Codex, Grok, Cursor, GitHub Copilot, Cline, Devin, Goose, Auggie, Amp, Hermes Agent, MiMo Code, Autohand Code, Codebuff, and many more — essentially any agent that runs in a terminal. Key features include a mobile companion app (iOS and Android) for monitoring and steering agents remotely, Ghostty-class WebGL terminal splits with persistent scrollback, a Design Mode that captures live HTML/CSS/screenshots from an embedded Chromium browser directly into agent prompts, native GitHub and Linear integrations for in-app PR and issue management, SSH remote worktrees with auto-reconnect and port forwarding, annotated AI diff review, drag-and-drop file/image prompting, a scriptable CLI, Computer Use for desktop UI automation, and usage/rate-limit tracking with hot-swap account switching. The project ships updates daily and is available on macOS, Windows, and Linux under the MIT license. It is notably trending due to the rapid convergence of agentic AI coding tools and Orca's unique positioning as an agent-agnostic orchestration layer rather than a single-agent IDE, making it broadly relevant across the fragmented AI coding assistant landscape. The project has an active Discord community and social presence on X, and its multilingual README (Chinese, Japanese, Korean, Spanish, French, Portuguese) signals strong international adoption momentum.
AgentsToolsAppscodingworkflow-automationmultimodal
★ 29,974 total+7,385 this week
#5NEWPartial week
OpenWorker is an open-source, local-first AI desktop agent created by Andrew Ng that delivers finished work products—documents, reports, calendar updates, inbox triage—rather than just conversational responses. Currently in open beta, it runs a Python-based agent server paired with a React/Tauri desktop GUI, breaking user-specified goals into steps and executing them across 25+ integrations including GitHub, Slack, Jira, Notion, Linear, HubSpot, Gmail, Google Calendar, Outlook, and monday.com. It supports MCP-compatible tools and is model-agnostic, allowing users to bring API keys from OpenAI, Anthropic, Google Gemini, DeepSeek, Mistral, Grok, Qwen, and others, or run fully locally via Ollama. Privacy is emphasized: all agent logic, credentials, and conversations stay on-device, with only OAuth brokering handled in the cloud. Built on Ng's own aisuite library, OpenWorker is notable for combining broad LLM provider support, approval-gated actions, scheduled automations, and a Slack-native workflow in a single self-updating desktop app. Its association with Andrew Ng and its practical, deliverable-focused approach likely contribute to its GitHub trending status.
AgentsMCPAppslocal-firstworkflow-automationon-device
★ 7,075 total+6,946 this week
#10
QwenPaw is a personal AI assistant platform developed under the agentscope-ai organization, designed to be deployed locally or in the cloud and extended through a rich ecosystem of Skills, Plugins, and multi-channel integrations. The project's tagline — "Works for you, grows with you" — reflects its philosophy of being a persistent, extensible, and privacy-respecting agent that adapts to user needs over time. At its core, QwenPaw is built on top of AgentScope 2.0, representing a ground-up architectural rewrite that introduced what the team calls an "Agent OS" paradigm, treating the AI agent as an operating system layer with distinct pillars for Resources, Governance, and Sandbox execution.
One of QwenPaw's most distinctive features is its three-layer memory architecture: a live working context, a full verbatim history, and a distilled long-term knowledge store powered by ReMe v0.4.0. Unlike many AI assistants that summarize and discard older conversation turns, QwenPaw persists every turn and indexes evicted context for on-demand recall, ensuring nothing is permanently lost. This "Scroll Context" approach is a deliberate design choice aimed at making the assistant genuinely reliable for long-running tasks and complex workflows.
The platform ships its own family of fine-tuned models — QwenPaw-Flash in 2B, 4B, and 9B parameter sizes — specifically trained for agent tasks, and includes a built-in local runtime that requires no API key or cloud dependency. It also supports Ollama, LM Studio, and more than 14 cloud providers, giving users maximum flexibility in how they run inference. This local-first stance is reinforced by kernel-level security features including a Sandbox, Tool Guard, File Guard, Skill Scanner, and Access Policy system that blocks dangerous commands before execution.
QwenPaw supports multi-agent orchestration, allowing users to spawn independent agents with their own memory and skill sets, coordinate sub-agents at runtime, and connect across systems using the Agent Communication Protocol (ACP), as well as MCP and A2A connector layers. A dedicated Coding Mode provides a three-panel Web IDE with file tree, diff preview, chat interface, jump-to-definition, find-references, and structural code search, making it a capable development assistant as well as a general-purpose one.
The platform is reachable across an impressive range of messaging and collaboration channels — DingTalk, Lark, WeChat, Discord, Telegram, iMessage, and QQ — all from a single deployed instance. Users can also interact via a Console web UI, a full-screen Terminal UI (TUI), or a desktop application. This omnichannel reach makes QwenPaw particularly notable for enterprise and power-user scenarios where communication is fragmented across platforms.
Extensibility is a first-class concern: QwenPaw supports a plugin marketplace, a Skill system covering scheduling, document processing, browser automation, and news aggregation, and MCP integration for external tools. The recently launched AgentScope Platform provides free cloud deployment, plugin sharing, and a Skill marketplace, lowering the barrier to entry significantly. The v2.0.1 release introduced PawApp, a mini-app platform, user-editable Agent Modes, and Oh-My-Paw plugins, signaling a growing ecosystem around the core assistant.
In terms of maturity, QwenPaw is actively developed with frequent releases — v2.0.0 launched in July 2026 followed quickly by v2.0.1 — and maintains documentation in English, Chinese, Japanese, and Russian, indicating a broad international audience. It is available via PyPI, supports Python 3.11 through 3.13, and offers one-command script installers for macOS, Linux, and Windows. The project is licensed under Apache 2.0 and uses the Black code style. Its presence on Trendshift's daily trending repositories badge, combined with active Discord, X, and DingTalk communities, suggests strong and growing community momentum. For
AgentsAppsMCPlocal-firstcodingworkflow-automation
★ 28,261 total+4,753 this week
#14NEWPartial week
AOS Community Edition is an open agent operating system developed by Unicity, designed to provide an inspectable and composable environment for running AI agents and agent-native software. It encompasses the `aos` CLI, HTTP API, distributions, first-party capsules, provider/model experience, and Unicity Audit. The system installs 21 Community Edition capsules under a product-owned `~/.aos` root, with every release publishing checksums, Sigstore bundles, GitHub build-provenance attestations, and a `runtime-compatibility.toml` for pinned runtime versioning. AOS enforces strict upgrade and self-heal gates before any tagged release can publish. A key feature is `aos mcp serve`, which acts as a product edge compatible with Codex, Claude, and Grok via the Model Context Protocol, with explicit interaction policies and a constrained local approval surface. The system ships Forge as OS construction tooling, enabling agents to inspect the running system, identify capability gaps, and build least-privilege capsules autonomously. Signed release channels (stable, dev, nightly) are supported, and state can be imported from standalone runtime installations. The project appears early-stage but architecturally sophisticated, notable for its security-conscious design and agent-native OS abstraction.
AgentsMCPSafetylocal-firstsecurityworkflow-automation
★ 7,419 total+3,651 this week
#15NEWPartial week
**img2threejs** is an AI-driven pipeline that reconstructs any reference image of an object into a fully procedural, animation-ready Three.js model expressed entirely as TypeScript/JavaScript code — no mesh files, no photogrammetry, no downloaded art packs. Given a single reference image, the system produces a `THREE.Group` factory built from geometric primitives, procedural shaders, and generated geometry, complete with a runtime hierarchy of pivots, sockets, colliders, and destruction groups so the output is immediately usable in interactive 3D applications. The project is agent-agnostic and runs under Claude Code, Codex, or OpenCode, leveraging whatever vision capability the host agent provides.
The core approach is a **staged sculpting pipeline** gated at every step by agent vision review. Passes proceed in a fixed order — blockout → structural → form-refinement → material → surface → lighting → interaction → optimization — and no pass advances without a real browser render, a side-by-side comparison sheet, and a vision score at or above threshold. A strict-quality gate blocks code generation until a detailed `ObjectSculptSpec` is complete, preventing shallow or single-root specs for compound objects. Self-correction is built in: after each pass the agent selects one of five actions (`continue`, `refine-spec`, `refine-code`, `request-input`, or `stop`), enabling autonomous iteration toward likeness.
Key features include a **detail inventory** system that enumerates identity-defining small details (bevels, panel seams, fasteners, engraved linework, gloss/matte zones, wear) before any code is written; a **character and likeness track** that fits parametric templates to facial landmarks, de-lights photos, and camera-matches renders; and **CS2 weapon-specific review gates** with component-coverage contracts, exactness tiers, and map-stripped blockout checks to prevent texture from substituting for real geometry. Materials use independent PBR channels with real lights rather than aliasing albedo into roughness.
The live demo gallery showcases reconstructions of CS2 weapons (Glock-18 Ghost Protocol, Classic Knife Fade, M9 Bayonet Doppler Phase 2), hard-surface objects (BMX bike, Sony WF-1000XM3 earbuds, ISSACA shotgun, Gerber Paracord Knife, War-Hauler), and dioramas (Doraemon House), all running live in the browser. Tooling requires only Python 3.10+ stdlib. At version 1.4.1
AgentsAppsToolsmultimodalvisioncoding
★ 6,012 total+3,482 this week
#27
Herdr is a terminal-native **agent multiplexer** — a single Rust binary that lets developers run, monitor, and manage multiple AI agents simultaneously from the terminal. It provides real-time pane views showing each agent's status (blocked, working, done), supports detach/reattach across sessions and SSH connections, and survives restarts. A standout feature is its pure socket API that allows agents themselves to spawn panes, read output, and coordinate with each other, enabling true multi-agent orchestration. The tool supports both keyboard (tmux-style prefix keys) and mouse interaction, and is extensible via a plugin marketplace. Built entirely in Rust with no Electron dependency, it installs via a single curl command, Homebrew, or mise, with a Windows beta available. The project is actively developed full-time in the open, has documented sponsorship tiers, and includes explicit instructions for AI agents contributing to the repo. Its combination of lightweight design, agent-aware API, and session persistence makes it notable in the growing AI agent tooling space.
AgentsToolsAppscodingworkflow-automationlocal-first
★ 21,110 total+2,654 this week
#28
Grok Build (`grok`) is SpaceXAI's terminal-based AI coding agent, written in Rust and released as open source under the Apache 2.0 license. It provides a full-screen TUI (terminal user interface) capable of understanding codebases, editing files, executing shell commands, searching the web, and managing long-running tasks. It supports interactive use, headless/scripting/CI modes, and editor integration via the Agent Client Protocol (ACP). Prebuilt binaries are available for macOS, Linux, and Windows via simple install scripts, and the source can be built with Rust and DotSlash tooling. The repository is periodically synced from SpaceXAI's internal monorepo, with a `SOURCE_REV` file tracking the upstream commit. The codebase is modular, spanning crates for the TUI, agent runtime, tool implementations, workspace management, MCP, sandboxing, and more. Notably, external contributions are not accepted. Its trending appeal likely stems from being the official open-source CLI agent from xAI (Elon Musk's AI company), competing in the rapidly growing AI coding agent space alongside tools like Codex and OpenCode, and representing a significant infrastructure release from a high-profile AI organization.
AgentsAppsMCPcodinglocal-firstworkflow-automation
★ 22,811 total+2,543 this week
#29
Vibe-Trading, developed by HKUDS (The University of Hong Kong Data Intelligence Lab), is an open-source personal trading agent designed to empower AI agents with comprehensive trading capabilities through a single command. Distributed as the PyPI package `vibe-trading-ai`, the project targets Python 3.11+ and combines a FastAPI backend with a React 19 frontend, licensed under MIT. Its core value proposition is enabling users to equip an AI agent with end-to-end trading functionality spanning market data ingestion, backtesting, strategy optimization, and live/simulated trade execution across many brokers and asset classes. The repository emphasizes both breadth of integrations and correctness/reliability, as reflected by an intense stream of contributor-driven updates.
Key features include support for numerous LLM providers—native Anthropic Messages API, SiliconFlow, iFlytek Spark, MiniMax, and zai (glm-5.1)—alongside a provider-agnostic `llm-vision` OCR engine for interpreting visual data. The platform offers a robust backtesting engine with composable optimizer weight constraints, rebalance-notes artifacts, turnover metrics, and an `alpha bench` benchmarking tool that discloses index universes (CSI300/SP500), counts, degraded fallbacks, and survivorship bias, plus a strict `alpha bench --strict` mode wiring same-universe random-control and out-of-sample gates. It supports realistic USD-M perpetual futures with margin state contracts and historical funding-rate consumption, and Binance maintenance-bracket decoupling so `-PERP` backtests run credential-free. A "Shadow Account" feature and point-in-time (PIT) fundamentals with restatement deduplication add trading realism. The system integrates an MCP (Model Context Protocol) server for agent interoperability, with a swarm MCP-discovery cache and network guards supporting IPv6 and case-variant hosts.
Broker and data-source coverage is extensive, having grown to 12 broker connectors including a new MetaTrader 5 (Exness) forex/metal connector, plus Tiger, Alpaca, OKX, Shoonya, Longbridge, Binance, Futu, Tonghuashun, and Eastmoney. Data loaders have undergone a major interval-normalization sweep so timeframe aliases (1h/4h/1d/1w, 1W/1M) behave consistently across providers like Yahoo, CCXT, akshare, and India brokers, failing fast on unsupported intervals rather than silently returning daily bars. A persistent memory subsystem gained Tier 2 structural organization and an opt-in memory lifecycle featuring quality scoring, Ebbinghaus decay, and archive-only garbage collection (disabled by default). A correlation regime timeline endpoint (`GET /correlation/regime`) provides descriptive risk context via a causal hysteresis state machine marking "FUSED" market episodes. The project also exposes REST API and MCP interfaces, and provides multilingual documentation (English, Chinese, Japanese, Korean, and Arabic) plus a website and docs portal.
In terms of maturity, Vibe-Trading is actively and rapidly evolving, with a very high cadence of pull requests—daily batches often fixing 12–22 issues at once, addressing strict-JSON/finite-number serialization, connector correctness, trade-journal parsing (Excel serial dates), and reliability across SSE, sessions, CLI, swarm, and scheduler components. Recent releases (v0.1.11, v0.1.12) rolled up roughly 90 fixes, indicating a project still in the 0.1.x pre-1.0 phase but with substantial functional depth and a large, engaged contributor community (numerous named contributors credited in changelogs). Infrastructure improvements include Docker hash-locked dependency installs with CI lock checks and Dependabot-style dependency refreshes. The project maintains an active community presence via Discord, Feishu, and WeChat
AgentsToolsMCPmultimodalworkflow-automationvision
★ 27,879 total+2,510 this week
#30
ECC (also known as ECC Tools) is a harness-native operator system designed for agentic AI development workflows. Positioned as "the agent harness operating system," it provides a comprehensive, production-ready layer of skills, instincts, memory optimization, continuous learning mechanisms, security scanning, and research-first development practices. Rather than being a simple configuration repository, ECC is a full system evolved over more than ten months of intensive daily use building real products across multiple AI agent harnesses. The project is notable for its cross-harness compatibility, supporting Codex, Claude Code, Cursor, OpenCode, Gemini, Zed, GitHub Copilot, and other AI agent environments from a single unified codebase.
The project has achieved remarkable community traction, boasting over 211,900 stars, 32,500 forks, and 230 or more contributors on GitHub. It supports 12 or more language ecosystems and is implemented across Shell, TypeScript, Python, Go, Java, Perl, and Markdown. The npm packages ecc-universal and ecc-agentshield both receive regular weekly downloads, and the GitHub App has accumulated a significant number of installs. The project is MIT-licensed and explicitly commits to remaining open-source forever, with ECC Pro serving as the hosted GitHub App tier for private repositories priced at $19 per seat per month, funding continued development by what appears to be primarily a single maintainer shipping weekly across seven harnesses.
ECC v2.0.0 represents a significant milestone, introducing the public Hermes operator story built on top of a reusable cross-harness architecture layer. The Hermes operator concept appears to be a named persona or workflow pattern that users can adopt as a starting point for agentic operations. The release is accompanied by dedicated documentation including a Hermes setup guide, 2.0.0 release notes, and a cross-harness architecture document, signaling a maturing project with structured versioning and documentation practices.
The project is organized around three primary guides: The Shorthand Guide covering setup, foundations, and philosophy; The Longform Guide covering token optimization, memory persistence, evaluations, and parallelization; and The Security Guide covering attack vectors, sandboxing, sanitization, CVEs, and the AgentShield security tooling. These guides are described as separate from the raw code in the repository, suggesting a deliberate separation between implementation and educational content. Key technical topics addressed include token optimization through model selection and system prompt slimming, memory persistence via hooks that save and load context across sessions automatically, continuous learning through auto-extraction of patterns from sessions into reusable skills, verification loops using checkpoint and continuous evaluations with grader types and pass-at-k metrics, parallelization using Git worktrees and a cascade method, and subagent orchestration addressing the context problem through iterative retrieval patterns.
A notable integration path involves self-hosting the Kimi model from Moonshot AI using ECC alongside Itô Markets compute infrastructure. ECC configures the agent harness while users supply their own API endpoint or self-host an open-weight Kimi model on GPU capacity. The installation flow involves running the ECC installer targeting the Kimi harness, running a doctor check, and then launching the Kimi CLI, which natively discovers installed AGENTS.md instructions and skills workflows. The project explicitly clarifies that the Itô sponsorship link is passive and does not provision compute, while the ecc ito find command actively invokes the Itô CLI to submit a live authenticated request for quotation.
Security is treated as a first-class concern. The AgentShield npm package is a dedicated security layer, and the Security Guide covers attack vectors, sandboxing, sanitization, and CVEs relevant to agentic systems. The project warns users to install only from verified official channels including the GitHub repository, the two npm packages, the GitHub App, the plugin slug, and the project website, explicitly cautioning that third-party re-uploads and unofficial mirrors may contain malware.
The project has attracted notable sponsors including CodeRabbit, Greptile, Atlas Cloud, Moonshot AI (Kimi), and Itô Markets, alongside community sponsors. This sponsorship structure, combined with the Pro tier pricing model, suggests a sustainable open-source business model that is increasingly common among high-traction developer tooling projects. The README is available in twelve languages including English, Brazilian Portuguese, Simplified Chinese, Traditional Chinese, Japanese, Korean, Turkish, Russian, Vietnamese, Thai, German, and Spanish, reflecting a genuinely global contributor and user base.
From a trend analysis perspective, ECC is highly relevant to the rapidly accelerating AI agents space. The project addresses a real and growing pain point: developers using multiple AI coding assistants simultaneously need a unified operator layer that works consistently across harnesses. The cross-harness compatibility story, the emphasis on production-readiness over toy configurations, and the security-first posture all align with where the enterprise and professional developer market is heading as agentic AI moves from experimentation to production deployment. The combination of strong community metrics, active sponsorship, multilingual documentation, and a clear versioning roadmap positions ECC as a potentially foundational piece of infrastructure in the emerging AI agent tooling ecosystem.
AgentsToolsSafetysecurityworkflow-automationcoding
★ 233,728 total+2,426 this week
#32
OpenMontage is an open-source, agentic video production system that transforms any AI coding assistant into a full-featured video production studio. Rather than requiring manual editing, scripting, or asset management, users describe what they want in plain language and an AI agent handles the entire pipeline end-to-end: research, scripting, asset generation, editing, and final composition. The project bills itself as the first open-source system of its kind and notably achieved the #1 Repository of the Day on GitHub Trending, signaling strong community interest and momentum.
A critical distinction the project emphasizes is that OpenMontage produces genuine video — not just animated slideshows of still images. For free and open-source workflows, the agent can build a corpus from free stock footage and open archives, retrieve actual motion clips, edit them into a timeline, and render a finished piece. This sets it apart from many AI video tools that merely animate a handful of stills. It also supports AI-generated motion video via providers like Google Veo and Kling v3, image-based animation with cinematic effects, and fully bespoke "atelier" composition modes where every scene is crafted from scratch.
The system is built around a multi-stage agentic pipeline. When a production starts, the agent performs live web research, writes and narrates a script with voice direction, generates AI images or retrieves motion clips, sources royalty-free background music automatically, burns in word-level subtitles, and renders the final video. Before delivery, it runs a multi-point self-review covering ffprobe validation, frame sampling, audio level analysis, delivery promise verification, and subtitle checks. Every provider selection is scored across seven dimensions with an auditable decision log, and every creative decision can require user approval before proceeding.
A standout feature is the Backlot Living Storyboard — a local visual dashboard that fills itself in as the pipeline runs. Stages light up in real time, the script appears as a screenplay page, scene cards animate while assets generate, and every provider decision and dollar spent is displayed. Crucially, the storyboard functions as a real approval gate: asset generation pauses on a scene-by-scene contact sheet showing takes, prompts, per-asset costs, and quality scores, allowing users to approve visuals before the render begins. Completed productions can be replayed from timestamps, scrubbable end to end.
OpenMontage also supports starting from a reference video — a YouTube video, Short, Reel, TikTok, or local clip. The agent analyzes transcript, pacing, scenes, keyframes, and style, then generates two to three differentiated concepts with honest tool paths, cost estimates, and a sample before full production begins. This grounded approach avoids guesswork and gives users a clear picture of what the final product will look like given their available tools and budget.
The project showcases several demo productions that highlight its range and cost efficiency. A cinematic sci-fi trailer called "SIGNAL FROM TOMORROW" used Veo-generated motion clips and Remotion composition. "THE LAST BANANA," a 60-second Pixar-style animated short, cost just $1.33 using Kling v3 via fal.ai, Google Chirp3-HD narration, and Remotion. "The Library at Alexandria," a 70-second history elegy, cost only $0.02 using OpenAI narration and a free Pixabay music score. A product ad called "VOID — Neural Interface" cost $0.69 using a single OpenAI API key with gpt-image-1 images, WhisperX subtitles, and Remotion. Two Ghibli-style anime animations — "Afternoon in Candyland" and "Mori no Seishin" — each cost $0.15 using FLUX-generated images with parallax effects and particle overlays.
Technically, OpenMontage requires Python 3.10+, FFmpeg, Node.js 18+, and any AI coding assistant such as Claude Code, Cursor, Copilot, Windsurf, or Codex. Setup is straightforward via a single make setup command. The project is licensed under AGPLv3 and is sponsored by Bloome, a multi-agent collaboration platform, and Atlas Cloud, a unified AI inference platform offering access to 300+ models. The project is actively developed and documented, with a YouTube channel, an X account, GitHub Discussions, a providers guide, a PR review guide, and a dedicated Agent Guide. Its combination of genuine agentic autonomy, transparent cost tracking, real motion video support, and an interactive
AgentsAppsToolsmultimodalvideoworkflow-automation
★ 42,503 total+2,290 this week
#47
gstack is an open-source AI-powered software factory built and actively used by Garry Tan, President and CEO of Y Combinator, designed to transform Claude Code into a structured virtual engineering team. The project was inspired by Andrej Karpathy's widely-circulated remark that he had not typed a line of code since December 2025, prompting Tan to investigate how a single builder could ship at the velocity of a full team. The answer he arrived at is gstack: a collection of 23 specialist roles and 8 power tools, all implemented as slash commands in Markdown, all free, and released under the MIT license.
The core philosophy of gstack is that AI-assisted development should not be a blank prompt but a structured sprint process. The workflow follows a deliberate sequence — Think → Plan → Build → Review → Test → Ship → Reflect — where each skill feeds directly into the next. The `/office-hours` command acts as a YC-style product interrogation, asking six forcing questions that challenge the user's framing before a single line of code is written. It produces a design document that downstream skills automatically consume. `/plan-ceo-review` challenges scope and searches for the "10-star product" hidden inside a feature request, operating in four modes: Expansion, Selective Expansion, Hold Scope, and Reduction. `/plan-eng-review` locks in architecture, data flow diagrams, state machines, edge cases, and test matrices. `/plan-design-review` rates design dimensions on a 0–10 scale, detects "AI slop," and interactively improves the plan. From there, `/review` catches bugs and race conditions, `/qa` opens a real browser and clicks through staging flows, and `/ship` verifies fixes and opens a pull request with new tests included.
Tan backs the project with striking personal productivity metrics. Over the 60 days prior to publishing, he shipped 3 production services and 40+ features part-time while running Y Combinator full-time. Measuring logical code changes — normalized to avoid the inflation that raw line counts suffer from AI generation — his 2026 run rate is approximately 810 times his 2013 pace (11,417 vs. 14 logical lines per day). Year-to-date through April 18, 2026 had already produced 240 times the output of the entire year 2013. These figures are measured across 40 public and private repositories under the garrytan GitHub account, excluding one demo repo, with full methodology, caveats, and a reproduction script documented in a companion file called ON_THE_LOC_CONTROVERSY.md.
Installation takes roughly 30 seconds and requires Claude Code, Git, and Bun v1.0+. A single command clones the repository into `~/.claude/skills/gstack` and runs a setup script. A team mode is also available, which bootstraps a shared repository so that all teammates automatically receive gstack when they open a Claude Code session, with auto-update checks throttled to once per hour and designed to be network-failure-safe and completely silent. The project also integrates with OpenClaw, the AI agent platform built by Peter Steinberger that reached 247,000 GitHub stars, allowing gstack skills to be invoked from OpenClaw agent sessions via ACP. Four native OpenClaw skills are available through ClawHub for conversational use without needing a Claude Code session at all.
Beyond Claude Code and OpenClaw, gstack supports 10 AI coding agents including OpenAI Codex CLI, OpenCode, Cursor, Factory Droid, Slate, Kiro, Hermes, and GBrain. The setup script auto-detects which agents are installed, and adding support for a new agent requires only a single TypeScript configuration file with no code changes. This broad compatibility signals an ambition to be an agent-agnostic methodology layer rather than a tool locked to any single platform.
The project is notably early-stage but actively used in production by its author. It is trending likely because it sits at the intersection of several high-interest themes: the "vibe coding" and AI-agent-assisted development movement, Y Combinator's institutional credibility, Karpathy's viral quote about not typing code, and the broader conversation about individual developer productivity in the AI era. The README is unusually personal and argumentative, directly addressing critics of AI-inflated line count metrics and inviting skeptics to try the tool before dismissing it. For founders, technical CEOs, first-time Claude Code users, and staff engineers seeking rigorous review and release automation, gstack presents itself as a replicable system for one person to ship like a team of twenty.
AgentsToolsAppsworkflow-automationcoding
★ 124,625 total+1,597 this week
#59
Kimi Code CLI is an open-source AI coding agent from MoonshotAI that runs directly in the terminal, capable of reading/editing code, executing shell commands, searching files, and fetching web pages. It ships as a single binary requiring no Node.js setup, offering blazing-fast startup and a purpose-built TUI optimized for long agent sessions. Key differentiators include video input support (letting the agent interpret screen recordings or demo clips), AI-native MCP (Model Context Protocol) configuration via conversational commands, a rich plugin/marketplace ecosystem, and parallel subagents (`coder`, `explore`, `plan`) for focused work. It integrates with editors like Zed and JetBrains via the Agent Client Protocol (ACP), and supports lifecycle hooks for automation and auditing. The project works out of the box with Moonshot AI's Kimi models but supports other compatible providers. Licensed under MIT and actively maintained, it is trending likely due to growing interest in terminal-native AI coding agents competing in the same space as tools like Claude Code and GitHub Copilot CLI.
AgentsToolsMCPcodingvideoworkflow-automation
★ 5,227 total+1,313 this week
#67
career-ops (also known as careerops, hosted at career-ops.org) is an open-source, multi-agent job search automation system that transforms any AI coding CLI into a full-featured career pipeline command center. Built by Santiago Ferreira (GitHub handle: santifer), the project was born out of personal frustration with manual job hunting and the asymmetry of AI being used by companies to filter candidates while job seekers had no equivalent tooling. The core philosophy is elegantly stated in the README: "Companies use AI to filter candidates. I just gave candidates AI to choose companies." The system is explicitly not a spray-and-pray application blaster — it is a high-signal filter designed to surface the few genuinely worthwhile opportunities out of hundreds, strongly discouraging applications to anything scoring below 4.0 out of 5.0.
The technical approach is agentic and multi-layered. career-ops uses Playwright for headless browser automation to scrape and navigate career portals (Greenhouse, Ashby, Lever, Wellfound, and 45+ pre-configured company pages including Anthropic, OpenAI, ElevenLabs, Retool, and n8n). Evaluation is performed through a structured six-block framework covering role summary, CV match, level strategy, compensation research, personalization, and interview preparation using STAR+Reflection methodology, plus a Block G legitimacy check that flags scams and ghost postings. Each job receives an A–F grade across five scoring dimensions that feed into a holistic 1.0–5.0 score. The system generates ATS-optimized, keyword-injected PDF CVs styled with Space Grotesk and DM Sans fonts, as well as research-backed cover letters with interactive angle prompts and formal application email drafts — though it never submits anything autonomously, preserving human-in-the-loop control at every action step.
Beyond evaluation, career-ops includes a deep research mode that surfaces a target company's AI strategy, engineering culture, and recent moves, and a contact discovery mode (contacto) that identifies the right hiring manager, recruiter, or team peer and drafts a concise LinkedIn outreach message. An interview story bank accumulates STAR+Reflection narratives across evaluations, building a reusable master set of behavioral interview answers. Salary negotiation scripts, geographic discount pushback frameworks, and competing-offer leverage templates are also included. Batch processing via parallel sub-agents allows evaluating 10+ listings simultaneously, and a Terminal UI (TUI) built with Bubble Tea provides a dashboard for browsing, filtering, and sorting the pipeline. Pipeline integrity tooling handles automated merging, deduplication, status normalization, and health checks.
The project is built primarily in Node.js and Go, uses Playwright for browser automation, and is designed to run on any agent-skill-standard CLI — including Claude Code, OpenCode, Codex, GitHub Copilot, Grok Build CLI, Antigravity CLI, Qwen, and Kimi. Installation is a single npx command, and first-time setup is conversational rather than config-file-driven. The project is licensed under MIT with a separate trademark policy.
In terms of maturity and traction, career-ops is notably well-validated: the author personally used it to evaluate over 740 job listings, generate more than 100 tailored CVs, and ultimately
AgentsAppsToolsbrowser-useworkflow-automationlocal-first
★ 61,715 total+1,081 this week
#73
Multica is an open-source managed agents platform that transforms AI coding agents into genuine teammates within software development workflows. Inspired by the 1960s Multics operating system's time-sharing philosophy, it lets small teams multiply their throughput by assigning issues to AI agents just as they would to human colleagues — agents pick up tasks, write code, post comments, raise blockers, and report progress autonomously. Key features include Squads (stable routing groups led by a leader agent), Autopilots (cron/webhook-triggered recurring tasks), Reusable Skills (solutions that compound team capabilities over time), and Unified Runtimes (a single dashboard managing local daemons and cloud compute). The platform supports a broad ecosystem of agent CLIs including Claude Code, Codex, GitHub Copilot CLI, Cursor Agent, Kimi, Kiro CLI, and others. Its architecture combines a Next.js 16 frontend, a Go backend (Chi router, sqlc, WebSockets), and PostgreSQL 17 with pgvector. Installation is straightforward via Homebrew, install scripts, or PowerShell, with full self-hosting support via Docker. An iOS mobile client is also included. The project is early-stage but feature-rich, vendor-neutral, and notable for riding the wave of agentic AI adoption — positioning itself as open-source infrastructure for human+AI hybrid engineering teams at a moment when that concept is rapidly gaining traction.
AgentsToolsAppscodingworkflow-automationlocal-first
★ 42,123 total+1,015 this week
#89
Loop Engineering is an open-source framework and CLI toolkit that shifts the paradigm of AI-assisted development from manual prompting to systematic loop design — the idea being that developers should build automated control systems that prompt their agents, rather than prompting agents themselves. The project is authored by Cobus Greyling and has gained significant traction, reaching 5,500+ GitHub stars as of early July 2025, signaling strong community interest in the agentic AI space. The core philosophy, endorsed by notable figures like Boris Cherny (Head of Claude Code at Anthropic) and Peter Steinberger, is that the leverage point in AI development has moved from crafting individual prompts to designing orchestration loops that run continuously and autonomously. The toolkit scaffolds five key primitives — automations/scheduling, worktrees, skills, state, and memory — into production-ready patterns that work across multiple AI coding tools including Grok, Claude Code, Codex, Cursor, and Opencode. The unified CLI entry point (`@cobusgreyling/loop`) provides commands like `loop init`, `loop doctor`, `loop audit`, and `loop status`, with a quantified "Loop Ready Score" that climbs from 0 to 100 as the system becomes more complete and production-hardened. Supporting packages include `loop-audit` for readiness scoring, `loop-init` for scaffolding, `loop-cost` for token spend estimation, `loop-sync` for drift detection between state files, `loop-context` for stateful memory management with circuit-breaker logic, `loop-mcp-server` for MCP runtime pattern lookup, `loop-worktree` for isolated git worktree management per fix attempt, and `loop-gate` for mechanical enforcement of path denylists and auto-merge rules. The project sits within a broader companion ecosystem: `memory-engineering` handles persistent agent memory across sessions, `harness-foundry` provides a versioned runtime stack with traces, `outerloop` delivers governance via evidence-to-verdict pipelines, `goal-engineering` bridges loops to goal completion, and `fleet-engineering` governs populations of agents with registries, inboxes, and kill switches. Seven production-ready loop patterns are available with an interactive picker hosted on GitHub Pages, and clone-and-run starter kits exist for each supported tool. The project is MIT-licensed, actively maintained with regular npm releases, and has an engaged contributor community with open good-first issues. Its notable trend signal comes from the convergence of agentic AI adoption, the growing need for structured agent orchestration beyond ad-hoc prompting, and endorsements from high-profile practitioners at Anthropic. The ecosystem stack metaphor — memory → design → runtime → govern → fleet — positions Loop Engineering as the central design layer in a full agentic operations pipeline, making it a compelling reference architecture for teams scaling
AgentsToolsMCPcodingworkflow-automationsynthetic-data
★ 9,455 total+764 this week
#94NEWPartial week
Buzz is a self-hostable collaborative workspace built by Block (formerly Square) that enables humans and AI agents to work together in shared rooms, all underpinned by a Nostr relay where every action — messages, reactions, code patches, CI results, workflow steps, and approvals — is a cryptographically signed event in a single unified log. The core architectural bet is that one substrate (a Rust-powered relay backed by Postgres, Redis, and S3/MinIO) can replace the fragmented stack of chat tools, code forges, CI dashboards, bots, and release tooling that modern teams currently stitch together. Agents in Buzz are treated as first-class members with their own cryptographic keypairs, channel memberships, and audit trails — not background bots or cron jobs — meaning they can open repos, send patches, review code, run workflows, edit canvases, orchestrate other agents, and join voice huddles with the same affordances as human teammates. The project uses the Nostr protocol (NIP-01, NIP-34, NIP-42/98) for identity and event signing, and ships a desktop client built with Tauri and React, a `buzz-cli` designed for LLM tool calls (JSON in/JSON out), and an ACP harness supporting Goose, Codex, and Claude Code. The codebase is a Rust workspace of focused crates covering core protocol, auth, pub/sub, full-text search, audit logging, git integration, and agent persona packs. Currently functional features include channels, threads, DMs, canvases, media with frame-anchored comments, YAML-based workflows, git event support, and a git hosting backend; mobile clients (Flutter), workflow approval gates, and push notifications are in progress. The project is early-stage but architecturally opinionated, Apache 2.0 licensed, and notable for its sovereign self-hosting model, deep agent integration, and unified event-log approach to developer collaboration. It is trending likely due to growing interest in agen
AgentsAppsMCPworkflow-automationcodingsecurity
★ 13,570 total+667 this week
#97
Tutti is an open-source, real-time shared workspace designed to eliminate the friction of coordinating multiple AI agents across complex workflows. Rather than forcing users to manually copy context, paste outputs, and re-explain requirements between tools like Claude Code, Codex, and Canvas, Tutti provides a unified environment where agents, files, apps, and tasks are all interconnected and visible simultaneously. The core problem it addresses is that users have become "messengers" between powerful but siloed AI agents — Tutti aims to make agents genuinely collaborative without human hand-holding at every handoff. Its three headline features are: a real-time shared workspace with a "Big @" system for referencing past conversations, files, app outputs, and even other agents' work across sessions; a built-in app ecosystem (image generation, UI/UX design, docs, presentations) that both users and agents can invoke directly, eliminating the download-upload-paste cycle; and productivity tools like goal-to-task breakdown and a Control Center dashboard that surfaces all pending agent actions in one view. Tutti integrates with users' existing subscriptions to Claude Code, Codex, and Hermes, adding no extra model cost. It currently supports macOS with Windows coming soon. A cloud-based tier called Tutti · VM is in development, which will extend the shared workspace across multiple devices and multiple collaborators via multi-layer virtualization, keeping agent state synchronized in the cloud while agents still run locally. The project is newly open-sourced under the Apache 2.0 license, has an active Discord community, and supports multiple languages including English, Simplified Chinese, and Traditional Chinese. Its notable angle — treating the human-agent coordination layer as a first-class infrastructure problem — positions it as a potentially significant tool in the rapidly growing AI developer tooling space, making it a strong candidate for GitHub trending visibility.
AgentsAppsworkflow-automationlocal-firstmultimodal
★ 3,061 total+652 this week
#103
Paperclip is an open-source, self-hosted orchestration platform built with Node.js and React that enables individuals and teams to manage entire organizations of AI agents as if running a real company. Rather than treating AI agents as isolated tools, Paperclip positions itself as the "company" layer sitting above individual agents — using the analogy that if OpenClaw is an employee, Paperclip is the company itself. Users define high-level business goals (e.g., "Build the #1 AI note-taking app to $1M MRR"), assemble a team of AI agents filling roles like CEO, CTO, engineer, designer, and marketer, then approve a strategy, set budgets, and let the system run autonomously while monitoring everything from a unified dashboard. The platform is deliberately designed to feel like a task manager on the surface, while concealing sophisticated infrastructure underneath: org charts, budget enforcement, governance gates, goal alignment, heartbeat scheduling, and full audit trails. Paperclip is built around four core pillars — an Agentic Task Manager, an Org Chart for Agents, Agent Employee Training, and an Agentic OS — each addressing a distinct layer of what it takes to run a functioning AI-powered organization. It supports a broad range of agent runtimes and tools, including OpenClaw, Claude Code, Codex, Cursor, Bash scripts, and HTTP-based agents, operating on the principle that "if it can receive a heartbeat, it's hired." Key technical differentiators include atomic task checkout and budget enforcement to prevent double-work and runaway costs, persistent agent state across heartbeat cycles, runtime skill injection without retraining, goal-aware task execution where agents always understand the "why" behind their work, governance with rollback capabilities, portable company templates with secret scrubbing, and true multi-company data isolation from a single deployment. The platform addresses real pain points that power users of AI coding agents face today: losing track of dozens of simultaneous Claude Code sessions, manually re-injecting context, uncontrolled token spend, and lack of structured coordination between agents from different providers. Paperclip replaces ad hoc folder-based agent configs with a structured system offering ticketing, delegation hierarchies, approval workflows, scheduled routines via heartbeats, and mobile-ready monitoring. The project is licensed under MIT, is actively community-supported via Discord and Twitter, and is positioned at the frontier of the emerging "agentic company" paradigm — making it highly relevant to the current GitHub trending landscape where multi-agent orchestration and autonomous AI workflows are among the hottest topics. Its ambition to abstract away agent management complexity into a familiar organizational metaphor, combined with broad provider compatibility and enterprise-grade governance features, makes it a notably ambitious and timely open-source project.
AgentsAppsworkflow-automationlocal-first
★ 74,827 total+598 this week
#106
JiuwenSwarm is an open-source multi-agent collaboration framework designed to automate complex tasks through natural language intent, swarm-based coordination, and self-evolving skills. Its core architecture features a Leader agent that dynamically decomposes tasks, assembles specialized agent teams, and orchestrates multi-stage workflows (Swarmflow), including human-in-the-loop support. A standout capability is Skill Self-Evolution, where the system automatically detects errors and user dissatisfaction to iteratively optimize agent skill definitions — making it grow smarter with use rather than remaining static. The project supports distributed deployment across processes and machines, breaking single-machine compute limits, and offers a Swarm Skills Hub for sharing and remixing reusable skill assets. It is compatible with multiple inference backends including Huawei Cloud MaaS, OpenAI, DeepSeek, DashScope, SiliconFlow, and local models, and supports desktop (Windows/macOS), CLI, and TUI interfaces. Released as v0.2.1 in mid-2026, it is actively developed with roadmap items like Feishu human-AI mixed-squad integration. Its combination of autonomous evolution, distributed swarm intelligence, and broad platform compatibility makes it a notable emerging project in the agentic AI space.
AgentsToolsServingworkflow-automationlocal-firstsynthetic-data
★ 1,778 total+565 this week
#110
**autoresearch** by Andrej Karpathy is an experimental framework that lets an AI agent autonomously conduct LLM training research overnight. The agent iteratively edits a single file (`train.py`) containing a GPT model, optimizer (Muon + AdamW), and training loop — running 5-minute fixed-budget experiments, evaluating validation bits-per-byte (val_bpb), and keeping improvements. The human's role shifts from writing Python to authoring `program.md`, a Markdown instruction file that defines the "research org" context for the agent. Built atop a simplified single-GPU version of Karpathy's nanochat, the setup targets NVIDIA GPUs (tested on H100) and is deliberately minimal — three core files, no distributed training, no complex configs. Approximately 100 experiments can run while you sleep. The project is early-stage but already trending, with community forks supporting macOS (MLX), Windows (RTX), and AMD hardware. It's notable for embodying a provocative vision of fully autonomous AI research pipelines, where agents replace human researchers in the experimental loop — making it highly relevant to discussions around AI agents, self-improving systems, and the future of ML research infrastructure.
AgentsTrainingAppsworkflow-automationlocal-first
★ 92,116 total+542 this week
#111
DojoAgents is an open-source, full-market AI agent framework purpose-built for personal investment, aiming to democratize institutional-grade financial analysis for individual investors. Its centerpiece is a Loop-Driven Cognitive Portfolio Agent — an autonomous reasoning engine that performs multi-step tool orchestration across four analytical dimensions: fundamental data cognition (K-lines, financials, news), advanced logic analysis (valuation bands, momentum indicators), cross-market strategy deduction (linking US, HK, and A-share markets), and dynamic portfolio management (risk exposure, performance attribution). The system features a seven-layer architecture spanning a CLI, a React/Vite SPA dashboard with a FastAPI backend, an execution sandbox for Python code and technical indicators, a memory/SKILLS system that distills successful workflows into reusable routines, and a Cron/Gateway layer for omnichannel delivery. Key capabilities include daily market overviews, news impact analysis, multimodal portfolio diagnosis from screenshots, and simulated portfolio generation. It supports LLM providers including OpenAI, Anthropic, Gemini, Zhipu GLM, and DeepSeek, as well as local models via Ollama, llama.cpp, or vLLM. Installable via PyPI with uv, it requires Python ≥ 3.11 and Node.js ≥ 18. Licensed under Apache 2.0, the project is early-stage but notably ambitious, trending likely due to its rare combination of agentic reasoning, multimodal input, cross-market coverage, and privacy-first local deployment for retail investors.
AgentsAppsToolsmultimodallocal-firstworkflow-automation
★ 1,733 total+534 this week
#112
The **agency-agents-zh** repository is a Chinese community edition of the upstream open-source project **agency-agents** (originally by msitarzewski), providing a comprehensive library of **268 plug-and-play AI expert agent roles** designed to be integrated directly into popular AI coding and productivity tools. The project covers 20 departments including engineering, design, marketing, product, gaming, security, GIS, and finance, with each agent defined not merely as a generic prompt template but as a fully specified persona complete with professional workflows, decision-making logic, key rules, and concrete deliverables. This distinction is central to the project's value proposition: rather than telling an AI "you are an expert," each agent defines how that expert thinks, operates, and what they produce.
The library includes a full Simplified Chinese translation of the 215 upstream English agents, plus 53 original agents created specifically for the Chinese market. These China-specific additions cover platforms and verticals highly relevant locally, such as Xiaohongshu (Little Red Book), Douyin, WeChat, Bilibili, Feishu, and DingTalk operations, as well as cross-border e-commerce, government-facing (ToG) services, medical compliance, Qt-based industrial HMI (upper computer) development, mechanical design engineering, livestock farming record verification, domestic network engineering using Huawei/H3C/Ruijie equipment, and FPGA/ASIC digital design. This localization depth makes the project notably more than a translation effort — it is a substantive extension tailored to Chinese industry and platform ecosystems.
The project supports **18 AI coding and productivity tools**, including Claude Code, GitHub Copilot, Cursor, Windsurf, Aider, Gemini CLI, Codex CLI, Kiro (Amazon), Trae, OpenCode, DeerFlow 2.0 (ByteDance), WorkBuddy (Tencent), CodeWhale, Hermes Agent (NousResearch), Qwen Code, Qoder, Antigravity, and OpenClaw. Installation is streamlined via shell scripts that auto-detect installed tools and convert agent formats as needed. OpenClaw is highlighted as the recommended integration, splitting each agent into three structured files: SOUL.md (identity/persona), AGENTS.md (capabilities), and IDENTITY.md (summary), enabling native multi-agent orchestration.
A companion tool called **Agency Orchestrator** is prominently featured, available as both an npm CLI package (`agency-orchestrator`) and a native desktop application for macOS, Windows, and Linux (no Node.js installation required). It enables zero-code multi-agent orchestration with DAG-based parallel execution, checkpoint/resume support, 10 supported large language models (7 of which require no API key), and ready-made templates. An online expert gallery at **ao.aiolaola.com/experts** allows browsing, filtering by department, and copying full agent prompts without any installation.
The project is accompanied by two free learning courses on the **aiolaola.com** platform: a 180-lesson "Learn AI Programming from Zero" course and a 40-lesson "Build AI Agents from Zero" course, both designed to help users apply the agent library effectively within tools like Claude Code, Cursor, and Codex.
In terms of maturity, the project is actively maintained, MIT-licensed, welcomes pull requests, and is published on npm as `agency-agents-zh`. It has attracted multiple enterprise sponsors including APINEBULA, 多元探索 (Duoyuanx), RootFlowAI, Cubence, CCSub, 火山引擎 (Volcengine), 优云智算 (CompShare/UCloud), all of which are AI API aggregation or cloud compute platforms — indicating real commercial ecosystem interest. The breadth of sponsor involvement and the scale of China-specific agent additions suggest this project is gaining meaningful traction within the Chinese AI developer community. Its notable qualities include the depth of role specialization, the breadth of tool compatibility, the localization for Chinese platforms and industries, and the low-friction onboarding via desktop app and online gallery, making it a strong candidate for trending status among Chinese-language AI tooling repositories.
AgentsAppsToolsworkflow-automationmultimodal
★ 18,377 total+533 this week
#117
OpenSRE (v0.1) is an open-source framework developed by Tracer-Cloud for building AI-powered Site Reliability Engineering (SRE) agents capable of autonomously investigating and resolving production infrastructure incidents. The project addresses a critical gap in the AI operations space: while coding agents have benefited from structured benchmarks like SWE-bench, production incident response has lacked an equivalent training and evaluation environment. OpenSRE aims to fill that gap by providing both deployable AI SRE agents and a reinforcement learning environment with synthetic incident simulations and real-world end-to-end tests. When an alert fires, the agent automatically fetches correlated logs, metrics, traces, and recent deployments; masks sensitive identifiers before making external LLM calls; reasons across connected systems in a tool-calling loop; generates a structured root-cause analysis report with linked evidence; suggests or executes remediation steps; and posts summaries directly to Slack, PagerDuty, or Telegram. The framework supports an interactive REPL shell with slash commands for session management, cost tracking, integration verification, and reasoning depth control, as well as one-shot investigation modes and remote runtime RCA by service name. It connects to 60+ tools spanning LLM providers (Anthropic, OpenAI, Codex, Ollama, Gemini, OpenRouter, NVIDIA NIM, Bedrock), observability platforms, cloud infrastructure (Kubernetes, EC2, CloudWatch, Lambda, ECS Fargate, Flink), data platforms, and incident management systems. A scored synthetic root-cause analysis suite checks accuracy, required evidence, and adversarial red herrings, while real-world end-to-end tests cover cloud-backed failure scenarios. Installation is straightforward across macOS, Linux, and Windows, with deployment options including Docker/ECR on AWS EC2, a gateway AMI with systemd, and hosted paths via Railway, ECS, or Vercel. The project is currently in public alpha — core workflows are usable for early exploration but APIs and integrations remain subject to change. It is sponsored by Greptile and has already appeared on Trendshift, signaling growing community interest. OpenSRE is notable for being one of the first open frameworks to treat AI-driven incident response as a trainable, benchmarkable discipline rather than a one-off automation task, positioning itself as the foundational benchmark and training ground for the emerging AI SRE category. Its mission to scale to thousands of realistic infrastructure failure scenarios makes it a potentially significant reference project for teams exploring autonomous operations and AIOps.
AgentsEvalsToolsworkflow-automationsecurity
★ 9,286 total+521 this week
#118NEWPartial week
StaffDeck is an open-source enterprise platform for building and managing AI-powered "digital employees" — autonomous agents that encode professional expertise, business processes, and decision criteria into continuously operating, reusable organizational assets. Jointly developed by ModelBest, the NEU-ModelBest Data Intelligence Joint Lab, THUNLP, OpenBMB, and AI9Stars, the project was open-sourced on July 15, 2026, and is already gaining traction on GitHub Trending. The platform is positioned as a bridge between AI as a personal productivity tool and AI as a scalable organizational capability, making it highly relevant to the current enterprise AI wave.
StaffDeck's architecture centers on four core pillars. First, digital employee management allows professionals to define roles with positions, capability profiles, employee IDs, and work records, supporting permission isolation, publishing, and reuse. Second, state-machine-driven procedural skills convert natural language descriptions into structured SOPs, enabling accurate execution of complex multi-step workflows with real-time flow switching, visual editing, and version management. Third, document-structure-aware knowledge retrieval builds hierarchical indexes across documents, chapters, pages, and summaries, allowing agents to progressively locate precise information with source citations and retrieval debugging. Fourth, autonomous execution and continuous improvement connects digital employees to real business systems via HTTP APIs, MCP, and scheduled tasks, closing the feedback loop through long-term memory, full execution traces, human takeover, and feedback analysis.
The platform supports cross-channel deployment, including WeChat and WeCom (enterprise WeChat) integration with intent-based auto-routing, identity merging, and conversation observability. It ships with desktop installers for macOS (Apple Silicon), Windows (x64), and Linux (Debian/Ubuntu), as well as a self-hostable web stack built on FastAPI and a Node.js frontend. Setup is streamlined with agent-friendly deploy prompts compatible with Cursor, Claude Code, and Codex. The project requires Python 3.11+, Node.js 20+, and any OpenAI-compatible model endpoint, with no mandatory CUDA dependency. Licensed under AGPL-3.0, StaffDeck is early-stage but feature-rich, with an active community on Discord, Feishu, and WeChat, making it a notable and timely open-source entry in the enterprise agentic AI space.
AgentsAppsRetrievalworkflow-automationlocal-first
★ 1,040 total+518 this week
#122
DeepSeek-Reasonix (npm package: `reasonix`) is a DeepSeek-native AI coding agent designed for terminal use, built as a single static Go binary with zero external dependencies beyond a TOML parser. It is config- and plugin-driven, with all providers, models, tools, and plugins declared in `reasonix.toml`, making it highly composable without code changes. It natively supports DeepSeek but accepts any OpenAI-compatible endpoint, and can run dual-model setups (executor + planner) in cache-stable sessions. A key architectural focus is cache-aware context management — injecting stable environment summaries and pruning stale tool output to keep token costs low across long sessions. Plugins run as subprocesses over stdio JSON-RPC and are MCP-compatible. Distribution is frictionless: installable via npm, Homebrew, or prebuilt binaries for six platform/architecture targets, with a desktop app and a VS Code/VSCodium extension also available. The project is actively maintained with 20+ named contributors, bilingual (English/Chinese) community support on Discord, and growing star history — making it notable as a cost-efficient, open, multi-platform alternative to proprietary AI coding agents, riding the DeepSeek and agentic-coding trend.
AgentsToolsAppscodinglocal-firstworkflow-automation
★ 27,838 total+494 this week
#125NEWPartial week
astrid-capsule-memory is a Rust-based cross-session memory module for Astrid OS agents, designed to persist context across session boundaries — functioning conceptually as a "persistent swap file" for AI agents. It hooks into the `prompt_builder.v1.hook.before_build` lifecycle event, reading a `.astrid/memory.md` file from the workspace via a virtual filesystem (VFS), wrapping its contents in a `# Memory` section, and injecting it into the system context on each prompt assembly cycle. A key safety feature is a 32KB hard cap on memory content, preventing unbounded context window consumption, with truncation handled gracefully at UTF-8 character boundaries. The capsule is intentionally read-only — agents write to the memory file using existing filesystem tools from the companion `astrid-capsule-fs` module, keeping responsibilities cleanly separated. Built targeting `wasm32-unknown-unknown`, it fits a WebAssembly-based plugin/capsule architecture. The project is early-stage (MSRV 1.94, copyright 2025–2026) and notable for its clean, minimal design addressing a real challenge in stateful AI agent systems: durable memory across sessions without bloating context windows.
AgentsToolsMCPlocal-firston-device
★ 7,575 total+399 this week
#126NEWPartial week
`astrid-capsule-identity` is a Rust-based identity and system prompt builder component for Astrid OS, an agent-oriented operating system. Acting as the conceptual equivalent of `/etc/profile`, this capsule manages an AI agent's "spark identity" — including callsign, class, aura, signal, and core directives — persisting it via capsule KV state and assembling it into a system prompt for LLM consumption. On receiving a `spark.v1.request.build` event, it loads persisted identity, auto-detects a `spark.toml` config file, appends environment context (working directory, platform), and publishes the assembled prompt. If no identity exists, it triggers an onboarding flow where the LLM calls `save_identity` to persist the chosen identity and write a recovery copy. The IPC protocol is event-driven, with clearly defined subscribe/publish topics. Built in Rust with a minimum supported version of 1.94, the project is early-stage (2025–2026 copyright) but architecturally notable for treating AI agent identity as a first-class OS primitive with KV isolation scoped per calling principal. Its trending appeal likely stems from growing interest in agentic OS frameworks and structured LLM identity management.
AgentsModelsAppslocal-firston-device
★ 7,540 total+398 this week