DEV Community: WonderLab

One Open Source Project a Day (No. 36): awesome-design-md - Making Design Specs Truly Readable for AI

WonderLab — Sun, 12 Apr 2026 01:44:01 +0000

Introduction

"If code is the soul of a program, then design specs are its skin. In the age of AI, we need a way for machines to align with our aesthetics instantly."

This is the NO.36 article in the "One Open Source Project a Day" series. Today, we explore awesome-design-md (also known as Awesome DESIGN.md).

In today's AI-driven development, there's a significant gap: while AI (like Claude Code or Cursor) can write perfect logic, it often lacks the ability to capture a product's "visual soul." If you ask it to "make a button like Stripe," it might just give you a generic blue background. Traditional Figma files are too heavy and complex for LLMs to parse. awesome-design-md offers a brilliant solution: defining design systems using Markdown.

What You Will Learn

What the DESIGN.md specification is and why it's the ultimate design handoff for the AI era.
How to leverage over 60+ design templates from top brands like Stripe, Linear, and Vercel.
How to eliminate "programmer aesthetics" by using a simple Markdown file.
How design systems are evolving from "human-facing" UI Kits to "AI-facing" instruction sets.
Practical tips: Integrating design specs into your projects to drive AI coding and styling.

Prerequisites

Basic understanding of design system concepts (Color Palette, Typography, Spacing).
Experience with AI coding assistants (e.g., Cursor, Windsurf, Claude Code).
Preliminary knowledge of Tailwind CSS or CSS Variables.

Project Background

Overview

awesome-design-md is an open-source repository initiated and maintained by the VoltAgent team. It features a vast collection of DESIGN.md templates inspired by global tech leaders. These files aren't just descriptions; they are precise sets of Design Tokens, Visual Philosophies, and Component Specs optimized specifically for LLM text processing capabilities.

Author/Team Introduction

Author: VoltAgent Team
Vision: To drive "Agent-Native" design delivery, making design specifications actionable logic for AI.
Created: Late 2024, rapidly gaining popularity alongside the rise of Agentic Coding.

Project Data

⭐ GitHub Stars: 43.8k+
🍴 Forks: 5.4k+
📄 License: MIT License
🌐 GitHub: https://github.com/voltagent/awesome-design-md

Key Features

Core Value

The project's essence is providing a Source of Truth (SoT) for AI. By offering structured Markdown documentation, an AI can read design specs as if they were API docs, ensuring that generated component code strictly adheres to predefined brand colors, typography scales, and shadow systems.

Use Cases

Cloning Premium Product Aesthetics Quickly
- Developers can pick linear.md or vercel.md from the repo to instantly elevate their MVP's design to unicorn levels.
Establishing Team Design Consensus
- Designers no longer rely solely on screenshots to convey specs; they write a DESIGN.md file and save it to the codebase.
AI-Assisted UI Refactoring
- When refactoring a generic CSS interface into a high-end UI, feeding these specs to an AI ensures a consistent and modern look.

Quick Start

Pick a Style: Choose a style file (e.g., stripe.md) from the repository.
Integrate the File: Save it as DESIGN.md in your project's root directory.
Prompt the AI:

   "I have provided a DESIGN.md in the root. 
   Please refactor the current sidebar component 
   following its Color Semantics and Typography rules, 
   ensuring gradients match the document description."

Core Characteristics

Agent-Native: Document structure optimized for LLM context reasoning, avoiding verbose CSS noise.
Comprehensive Coverage: Over 60+ styles ranging from AI platforms (Anthropic, OpenAI) to infrastructure tools (Supabase, PostHog).
Zero Config, Zero Dependencies: No npm packages required; works as a plain text file in your workflow.
High-Fidelity Tokens: Precise variable definitions perfectly suited for Tailwind CSS extensions.

Project Advantages

Dimension	awesome-design.md	Traditional Figma Handoff
AI Friendliness	Extremely High (Structured text)	Low (Visual-focused, hard to parse)
Communication Cost	Extremely Low (Copy-paste)	High (Requires annotations/meetings)
Consistency	Strong (AI follows variables)	Variable (Devs might hard-code)
Version Control	Git-friendly, real-time tracking	Difficult (Binary files/external links)

Detailed Analysis: Why Markdown is the Future of Design?

Architecture: Typical DESIGN.md Structure

A high-quality DESIGN.md curated in this project contains core modules that distill the "visual soul":

1. Visual Identity & Atmosphere

Describes the psychological tone. For instance, Vercel's style is described as "cool-toned, high-contrast, minimal geeky," guiding the AI to generate accurate ambiance in its prompts.

2. Color System

Beyond HEX values, it defines Semantic Roles (e.g., background-primary, accent-color-hover), leading the AI to use the right color in the right context.

3. Typography Hierarchy

Defines font sizes, line heights, and weights for headers, body, and code blocks, ensuring a rhythmic layout.

4. Component Stylings

Specifies base styles and states (Hover, Active, Disabled) for components like buttons, cards, and inputs, along with global design tokens.

Project Resources

Official Resources

🌟 GitHub: https://github.com/voltagent/awesome-design-md

Target Audience

AI-Native Developers: Devs seeking engineering beauty who want to reduce CSS debugging.
Indie Hackers: Founders needing to iterate high-end MVPs rapidly.
UI Engineers: Pioneers exploring the intersection of design specs and LLMs.

Welcome to visit my Homepage to find more useful knowledge and interesting products.

One Open Source Project a Day (No. 35): claude-code-best-practice - Moving from Vibe Coding to AI-Native Development

WonderLab — Fri, 10 Apr 2026 00:48:34 +0000

Introduction

"AI programming is not just about changing tools; it's about refactoring your development paradigm."

This is the NO.35 article in the "One Open Source Project a Day" series. Today, we explore claude-code-best-practice.

If you've started using Anthropic's CLI tool, Claude Code, you might have noticed a pattern: sometimes it's breathtakingly precise, other times it gets stuck in "stupid loops." This discrepancy often isn't about the model itself but how you collaborate with it. shanraisshan/claude-code-best-practice is currently the most hardcore, systematic guide for Claude Code in the community. It distills the transition from "Vibe Coding" to professional "Agentic Engineering."

What You Will Learn

Core mechanisms: CLAUDE.md, Skills, Hooks, and Commands.
Instruction Management: Writing high-quality directives that AI won't ignore.
Orchestrating complex cross-file and multi-step tasks.
Parallel agent development using Git Worktrees.
Practical tricks: Manual /compact, phase-gated planning, and anti-degradation strategies.

Prerequisites

Familiarity with the Claude Code CLI.
Basic Git operations and project development experience.
Preliminary understanding of Prompt Engineering.

Project Background

Overview

claude-code-best-practice is an open-source reference library designed to enhance collaboration efficiency with Claude Code. It synthesizes fragmented advice from the official Anthropic team (including Claude Code creator Boris Cherny) and practical strategies from community developers handling large monorepos.

Author Introduction

Author: shanraisshan
Core Philosophy: Advocates for an "Architecture-Driven Model," emphasizing guiding AI through clear specifications rather than simple dialogue.

Project Data

⭐ GitHub Stars: ~1k+ (growing rapidly)
🍴 Forks: ~150+
📄 License: CC0 1.0 Universal (Public Domain)
🌐 GitHub: https://github.com/shanraisshan/claude-code-best-practice

Key Features & Core Modules

Core Modules

Concepts
- Deep dive into the optimal line count for CLAUDE.md (recommended 60–150 lines) and using .claude/rules/ for path-scoped constraints.
Workflows
- Introduces advanced workflows like "Cross-Model Collaboration" and "Parallel Git Worktrees."
Tips & Tricks
- Consolidates over 70 practical tips for Prompting, Planning, and Memory management.
Agent Teams
- Explores coordinating specialized sub-agents (e.g., a dedicated QA Agent) to review code.

Core Advice

Always start with /plan: Before executing any code, have Claude generate a plan and get human confirmation.
Manual /compact Mechanism: When context usage exceeds 50%, manually trigger compaction to avoid the AI's "dumb zone."
Use <important if="..."> Tags: Ensure rules are strictly enforced using conditional tags as the project grows.

Quick Start

To immediately boost your Claude Code efficiency:

Streamline your CLAUDE.md: Remove redundant descriptions and keep only core architectural definitions and styles.
Configure Custom Hooks: Add scripts under .claude/hooks/ to auto-run tests after code modifications.
Introduce a Task List: Have Claude maintain a live task list under /memories/session/.

Project Advantages

Dimension	This Project (Agentic Engineering)	Regular Usage (Vibe Coding)
Predictability	High, via planning and gating	Low, dependent on AI improvisation
Large-scale Handling	Strong, using tiered rules and local context	Weak, easily loses track of global context
Automation	Extremely high, including auto-tests	Medium, limited to code generation
Collaboration	Supports multi-branch parallel work	Limited to single session interaction

Detailed Analysis: Advanced Techniques

1. The Power of Git Worktrees

The project strongly recommends using git worktree. This allows you to assign independent physical paths to different agents. One agent can fix bugs while another develops features on a new branch—each with its own isolated test environment.

2. Cross-Model Quality Assurance

Recommends using two instances of Claude Code: one as an "Implementation Agent" and another as a "Reviewer Agent." The reviewer uses tools like grep_search to find flaws and ensure logical rigor.

3. Progressive Disclosure

Don't dump every document at once. Use a well-structured directory and index to guide the AI to read a module's SKILL.md only when it needs to modify that specific part.

Project Resources

Official Resources

🌟 GitHub: https://github.com/shanraisshan/claude-code-best-practice
📚 Docs: Recommended starting point: concepts.md in the root directory.

Target Audience

AI-Native Developers: Full-stack engineers pursuing peak development efficiency.
Team Leads: Managers needing to standardize AI programming norms for their teams.
Hardcore Claude Code Users: Those looking to break usage bottlenecks and handle complex business logic.

Welcome to visit my Homepage to find more useful knowledge and interesting products.

One Open Source Project a Day (No.34): second-brain-skills - A Skill Toolkit That Turns Claude Code Into a Knowledge Work Expert

WonderLab — Thu, 09 Apr 2026 02:59:38 +0000

Introduction

"The limits of your AI are the limits of what you've equipped it with."

This is article No.34 in the "One Open Source Project a Day" series. Today's project is second-brain-skills (GitHub).

Most people treat Claude Code as a programming tool — write code, fix bugs, refactor. But if you're a content creator, indie developer, or a one-person company juggling technical docs, presentation decks, and brand building, you quickly realize Claude Code's default capabilities cover only a fraction of your actual work.

second-brain-skills changes that. Opened by AI Agent engineer Cole Medin, this project upgrades Claude Code from a coding specialist to a full-spectrum knowledge work partner through a set of carefully designed Claude Code Skills: brand guidelines, professional PPTX decks, operations runbooks, external MCP service connections, and even programmatic video generation — all following the principle of "Progressive Disclosure of Context" to avoid wasting your precious context window.

What You'll Learn

A new take on "Second Brain" in the context of AI workflows
The design philosophy behind Claude Code Skills: progressive context disclosure
The functionality and usage of all 6 production-ready Skills
How to connect to external services (Zapier, GitHub) via the MCP Client Skill
How to build your own custom Skills based on this framework

Prerequisites

Familiarity with Claude Code basics
Understanding of Markdown syntax
Python basics (for MCP Client)

Project Background

What Is It?

"Second Brain" is a classic personal knowledge management (PKM) concept popularized by Tiago Forte in Building a Second Brain — using digital systems as an extension of your mind to systematically capture, organize, and apply knowledge.

second-brain-skills brings this concept into AI workflows: through Claude Code's Skill mechanism, Claude dynamically loads the relevant instructions, templates, and tools for a given domain only when needed — a true extension of your "second brain."

Unlike typical RAG solutions, this project requires no vector database or retrieval system. Context is loaded progressively via carefully structured Markdown files.

About the Author

Author: Cole Medin (coleam00)
Company: Dynamous (AI education & tools)
YouTube: @ColeMedin (practical AI Agent content creator)
GitHub Followers: 6,500+
Notable Projects: Archon (13.9k ⭐), context-engineering-intro (13.1k ⭐), ottomator-agents (5.5k ⭐)

Cole is one of the most active practitioners in the Claude Code ecosystem, focused on engineering AI Agent technology into real-world workflows — strong on implementation, not just theory.

Project Stats

⭐ GitHub Stars: 648
🍴 Forks: 195
🔄 Last Updated: January 2026
📄 License: Not explicitly declared (copyright retained by author)

Key Features

Core Design Philosophy: Progressive Context Disclosure

The most important idea in this project isn't any single feature — it's Progressive Disclosure of Context:

Load relevant context only when needed, rather than stuffing everything into the context window upfront.

The traditional approach is to pack all knowledge into the system prompt, burning tokens on every conversation. second-brain-skills uses a three-layer on-demand loading model instead:

Layer	Content	When Loaded
Metadata layer	SKILL.md YAML frontmatter (name + description)	Always visible
Instruction layer	SKILL.md Markdown body (detailed workflow)	Loaded when Skill is triggered
Resource layer	Files in scripts/, references/	Loaded on demand during execution

This design lets Claude Code manage dozens of Skills while keeping each conversation's context lean and efficient.

The 6 Core Skills

1. Brand & Voice Generator

Creates a complete brand configuration system for your company/project, outputting 4 standardized files:

brand.json — colors, fonts, visual specs
config.json — brand metadata
brand-system.md — complete brand system documentation
tone-of-voice.md — brand voice and tone guidelines

These 4 files become the "single source of truth" for your brand, used by subsequent Skills (PPTX Generator, content creation) to maintain consistency automatically.

2. PPTX Generator

Generates brand-consistent professional slide decks with 16 visually-first slide layout templates — no more "wall of text" presentations:

Template	Best For
`title-slide`	Cover page
`stats-slide`	Data dashboards
`circular-hero-slide`	Product/person focus
`floating-cards-slide`	Multi-element comparison
`code-slide`	Technical demos
`chart-slide`	Data visualization
`quote-slide`	Quotes / key insights
`two-column-slide`	Side-by-side analysis

Also supports LinkedIn carousel format (square) for social media content.

3. SOP Creator

Generates structured operations manuals, technical documentation, and runbooks for:

Team operations and process documentation
Technical runbooks and incident response playbooks
Product playbooks
Employee onboarding guides

4. Skill Creator

Guides you through creating a new custom Skill that conforms to the framework's conventions, with built-in best practice checks to ensure your new Skill follows progressive context disclosure principles.

5. MCP Client

Connects to external MCP servers via a unified interface, supporting 4 transport protocols:

stdio: Local subprocess (command-line tools)
SSE: Server-Sent Events
Streamable HTTP: HTTP streaming
FastMCP: Bearer Token authentication

Ships with ready-to-use configs for Zapier, GitHub, Sequential Thinking, and more.

6. Remotion Video Creator

Programmatically generate videos with React components — Remotion translates code into MP4 files. Perfect for:

Product demo videos
Data visualization animations
Short-form social media content

Quick Start

# Clone the repository
git clone https://github.com/coleam00/second-brain-skills.git

# Option 1: Use in your own project
# Copy the .claude/ directory to your project root
cp -r second-brain-skills/.claude /your-project/

# Option 2: Open Claude Code directly in the repo
cd second-brain-skills
# Open Claude Code — Skills are ready to use

Configure MCP Client (optional):

cd .claude/skills/mcp-client/references/
cp example-mcp-config.json mcp-config.json
# Edit mcp-config.json and fill in your API keys

Install Python dependencies (for MCP Client):

pip install mcp fastmcp

Using Skills — trigger with natural language in Claude Code:

"Create a brand config for WonderLab"
→ triggers Brand & Voice Generator

"Make an AI trends report deck using our brand"
→ triggers PPTX Generator

"Write a runbook for our Docker deployment process"
→ triggers SOP Creator

"Connect to Zapier MCP and list available actions"
→ triggers MCP Client

How It Compares

Dimension	second-brain-skills	RAG Solution	Direct System Prompt
Context efficiency	✅ Load on demand	Varies (retrieval quality)	❌ Full load every time
Deployment complexity	✅ Copy a folder	High (vector DB required)	✅ Low
Extensibility	✅ Add a Skill file	Medium	❌ Requires prompt edits
Workflow consistency	✅ Best practices baked in	—	❌ Describe each time
Best for	Fixed professional tasks	Unstructured knowledge queries	One-off conversations

Deep Dive

Skill File Structure Anatomy

Every Skill follows a consistent directory convention:

.claude/skills/
└── skill-name/
    ├── SKILL.md          # Required: trigger conditions + workflow instructions
    ├── scripts/          # Optional: executable scripts (deterministic operations)
    ├── references/       # Optional: reference docs (loaded on demand at runtime)
    └── assets/           # Optional: templates, fonts, images (not auto-loaded)

SKILL.md structure (SOP Creator example):

---
name: SOP Creator
description: Creates runbooks, playbooks, and technical documentation
---

## Trigger Conditions
Activate when the user needs to create an operations manual, runbook, playbook,
or technical documentation.

## Workflow

### 1. Gather Information
First ask:
- Document type (Runbook / Playbook / SOP / Onboarding guide)
- Target audience
- Core process or scenario being documented

### 2. Structure Generation
Generate the document structure using this template:
- Overview and Purpose
- Prerequisites
- Step-by-step Instructions (with command examples)
- Troubleshooting
- Related Documentation Links

### 3. Formatting Rules
- Use Markdown throughout
- Wrap all commands in code blocks
- Add warning callouts for critical steps

The description field in the YAML frontmatter is how Claude Code decides when to activate this Skill — it's the Skill's "trigger dictionary."

PPTX Generator's Cookbook Mechanism

The core innovation in PPTX Generator is the Cookbook design. Each slide layout is an independent Python script; Claude selects and combines them as needed when generating a deck:

# cookbook/stats-slide.py (simplified)
from pptx import Presentation
from pptx.util import Inches, Pt
from pptx.dml.color import RGBColor

def create_stats_slide(prs, brand_config, stats_data):
    """
    Create a statistics/data showcase slide
    brand_config: loaded from brand.json
    stats_data: [{"label": "Users", "value": "10,000", "growth": "+23%"}]
    """
    slide_layout = prs.slide_layouts[6]  # Blank layout
    slide = prs.slides.add_slide(slide_layout)

    # Apply brand background color
    bg_color = RGBColor.from_string(brand_config["colors"]["background"])
    # ... render stats numbers, growth indicators, etc.

The "cookbook" design has three key advantages:

Each layout is independently maintained — changes to one don't affect others
Claude can autonomously combine layouts to build a complete deck
Users can add custom layouts without modifying any core logic

MCP Client's Unified Interface

mcp_client.py uses Python asyncio to provide a unified abstraction over all 4 transport protocols:

# scripts/mcp_client.py (simplified)
from contextlib import asynccontextmanager
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from mcp.client.sse import sse_client

@asynccontextmanager
async def connect_to_server(server_config: dict):
    """Unified connection interface — auto-selects transport based on config"""
    transport = server_config.get("transport", "stdio")

    if transport == "stdio":
        params = StdioServerParameters(
            command=server_config["command"],
            args=server_config.get("args", []),
            env=server_config.get("env")
        )
        async with stdio_client(params) as (read, write):
            async with ClientSession(read, write) as session:
                await session.initialize()
                yield session

    elif transport in ("sse", "streamable-http"):
        async with sse_client(
            url=server_config["url"],
            headers=server_config.get("headers", {})
        ) as (read, write):
            async with ClientSession(read, write) as session:
                await session.initialize()
                yield session

Config file (mcp-config.json) example:

{
  "mcpServers": {
    "zapier": {
      "transport": "sse",
      "url": "https://mcp.zapier.com/api/v1/connect",
      "headers": {
        "Authorization": "Bearer YOUR_ZAPIER_API_KEY"
      }
    },
    "sequential-thinking": {
      "transport": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    },
    "github": {
      "transport": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "YOUR_TOKEN"
      }
    }
  }
}

Brand System: Single Source of Truth

The 4 files output by Brand & Voice Generator form an interconnected brand system:

brands/
└── your-brand/
    ├── brand.json         # Visual specs (colors, fonts, spacing)
    ├── config.json        # Brand metadata (name, industry, target audience)
    ├── brand-system.md    # Full brand guidelines (human-readable)
    └── tone-of-voice.md   # Voice style (formal/casual/technical/etc.)

Example brand.json:

{
  "name": "WonderLab",
  "colors": {
    "background": "0A0A0A",
    "primary": "6366F1",
    "accent": "8B5CF6",
    "text": "F9FAFB",
    "muted": "6B7280"
  },
  "fonts": {
    "heading": "Inter",
    "body": "Inter",
    "code": "JetBrains Mono"
  },
  "spacing": {
    "slide_padding": 60,
    "element_gap": 24
  }
}

PPTX Generator automatically reads this file, ensuring every slide stays on-brand — no need to re-specify colors and fonts each time.

Resources

Official

🌟 GitHub: https://github.com/coleam00/second-brain-skills
🎬 Author's YouTube: @ColeMedin (includes tutorial videos)
🐛 Issues: https://github.com/coleam00/second-brain-skills/issues

Other Projects by the Author

Archon (13.9k ⭐): Deterministic AI Agent framework
context-engineering-intro (13.1k ⭐): AI context engineering tutorial
mcp-crawl4ai-rag (2.1k ⭐): Web scraping + RAG solution for AI Agents

Summary

Key Takeaways

Progressive Context Disclosure: Three-layer on-demand loading is far more efficient than "stuff everything into the system prompt" — this is the most transferable design insight from the project
Skills as Markdown: Defining AI workflows in Markdown creates zero barrier to entry; anyone can write a custom Skill without touching Python
Brand system integration: The Brand Skill → PPTX Skill workflow turns brand consistency from a manual effort into an automated process
MCP unified abstraction: 4 transport protocols behind a single config-file interface makes connecting external services trivially simple
Solo creator friendly: The project's scope maps almost perfectly onto the needs of a "one-person company" — from technical docs to content creation, fully covered

Who Should Use This

Indie developers / one-person companies: Full-stack knowledge workers handling tech, content, and brand simultaneously
Content creators: Anyone who needs to produce brand-consistent PPT decks and documents at scale
Technical writers: Engineers responsible for maintaining large collections of SOPs, runbooks, and playbooks
Claude Code power users: Developers who want to transform Claude Code into a personalized work platform

Visit my personal site for more useful knowledge and interesting products

One Open Source Project a Day (No.33): DeerFlow - ByteDance's SuperAgent Execution Engine

WonderLab — Wed, 08 Apr 2026 02:24:54 +0000

Introduction

"LLMs shouldn't just talk about actions — they should actually execute them."

This is article No.33 in the "One Open Source Project a Day" series. Today's project is DeerFlow (GitHub).

Most AI Agent frameworks share a hidden limitation: they're good at suggesting, but not at doing. Generating code is easy — but actually running it, handling errors, iterating, and producing a deliverable artifact? That's the real challenge for complex research and automation tasks.

DeerFlow (Deep Exploration and Efficient Research Flow) is ByteDance's open-source answer to this problem. Completely rewritten in v2.0, it's no longer just a deep research framework — it's a general-purpose SuperAgent execution engine that runs code in real sandboxes, orchestrates parallel sub-agents, and handles tasks that take minutes to hours — from a single prompt all the way to a research report, a webpage, or a working program.

It hit #1 on GitHub Trending shortly after launch and now sits at 59k+ Stars, making it one of the most watched open-source projects in the AI Agent space.

What You'll Learn

DeerFlow's core positioning and the v1 → v2 architectural evolution
The SuperAgent execution flow: Lead Agent + parallel sub-agent orchestration
How sandbox-isolated code execution works and its security design
The Skills-as-Markdown extensibility mechanism
Multi-model support strategy and Chinese model optimization

Prerequisites

Basic understanding of LLM API calls (OpenAI-compatible interface format)
Some Docker experience (recommended for deployment)
Python basics (optional, for customization)

Project Background

What Is It?

DeerFlow stands for Deep Exploration and Efficient Research Flow, open-sourced by ByteDance. The project has gone through two major versions:

v1.x: Positioned as a deep research framework — multi-round search, web scraping, and consolidated report generation
v2.0 (February 2026, complete rewrite): Elevated to a general-purpose SuperAgent execution engine, introducing real sandbox code execution and a much broader range of supported task types

v2.0 shares no code with v1.x — it's a ground-up architectural rebuild, marking the project's transition from a "research assistance tool" to a "production-grade Agent execution engine."

About the Team

Organization: ByteDance (official open-source project)
Nature: Community-driven, led by ByteDance engineers, accepts external contributions
Release Timeline: v1.0 ~early 2025, v2.0 released February 2026
Milestone: Hit #1 on GitHub Trending on February 28, 2026

Project Stats

⭐ GitHub Stars: 59,200+
🍴 Forks: 7,500+
🐛 Open Issues: ~365
📄 License: MIT
🔄 Active Branches: main (v2.x), main-1.x (v1.x maintenance)

Key Features

Core Purpose

DeerFlow's fundamental value proposition is making AI Agents actually do things rather than just talk about things:

Capability	Traditional Agent Frameworks	DeerFlow v2.0
Code Execution	Generates code (doesn't run it)	Real execution in isolated sandbox
Task Duration	Seconds to minutes	Minutes to hours
Task Decomposition	Sequential execution	Parallel sub-agent orchestration
Output Type	Text suggestions	Real deliverables: files, pages, programs
Context Limits	Bound by single model window	Sub-agent divide-and-conquer

Use Cases

Deep Research Reports
- Given a research topic, automatically performs multi-round search, web scraping, and data synthesis to produce a structured report
Code Generation & Validation
- From requirements to a working program — real execution and debugging in the sandbox, iterating until it works
Data Analysis & Visualization
- Upload a data file; the Agent writes analysis scripts, generates charts, and outputs a ready-to-use analytics report
Web Development
- Describe what you need; the Agent writes HTML/CSS/JS, validates it in the sandbox, and delivers a complete webpage
Content Creation
- Automatically generate slides, podcast summaries, technical blog posts, and other content formats

Quick Start

Recommended (Docker):

# Clone the repository
git clone https://github.com/bytedance/deer-flow.git
cd deer-flow

# Generate configuration file
make config

# Edit config — fill in your model API keys
# Supports OpenAI, Claude, DeepSeek, Qwen, Doubao, etc.
vim config.yaml

# Initialize and start
make docker-init
make docker-start

# Access the web UI
# http://localhost:2026

Local development mode:

# Check environment requirements (Python 3.12+, Node.js 22+)
make check

# Install dependencies (uv for Python, pnpm for JS)
make install

# Start development servers
make dev

Built-in Skills

DeerFlow ships with several production-ready skills out of the box:

Skill	Functionality
Deep Research	Multi-round search + web scraping + consolidated research report
Report Generation	Formatted report generation
Slide Creation	Presentation slide creation
Web Page Development	Full webpage development
GitHub Deep Research	In-depth GitHub repository analysis

How It Compares

Dimension	DeerFlow	AutoGen	CrewAI	Manus
Real Code Execution	✅ Sandbox isolated	✅	❌	✅ (commercial)
Open Source	MIT	MIT	MIT	❌ Closed
Chinese Model Support	✅ First-class	Average	Average	❌
Production Validated	✅ ByteDance	❌	❌	—
Skills Extensibility	✅ Markdown	Python class	Python class	—
Deployment Complexity	Medium (Docker)	Low	Low	No self-hosting

Why choose DeerFlow?

Validated in ByteDance's production environments — reliability is battle-tested
Sandbox execution produces actual deliverables, not just text suggestions
First-class support for DeepSeek, Qwen, Doubao, and other Chinese models
Skills-as-Markdown has the lowest extension barrier in its class

Deep Dive

System Architecture

DeerFlow supports two deployment modes, sharing the same frontend but differing in backend process count:

Standard Mode — Recommended for production
┌─────────────────────────────────────┐
│  Nginx (Reverse Proxy + Routing)    │
├──────────────┬──────────────────────┤
│  Frontend    │  Gateway API         │
│  (Web UI)    │  (REST + WebSocket)  │
│              ├──────────────────────┤
│              │  LangGraph Server    │
│              │  (Standalone Agent   │
│              │   Runtime)           │
└──────────────┴──────────────────────┘

Gateway Mode — Experimental, lighter deployment
┌─────────────────────────────────────┐
│  Nginx                              │
├──────────────┬──────────────────────┤
│  Frontend    │  Gateway API         │
│              │  (Embedded Agent     │
│              │   Runtime)           │
└──────────────┴──────────────────────┘

Core Execution Flow

DeerFlow's agent orchestration is a three-tier structure:

User Input (Prompt)
        │
        ▼
┌───────────────────────────────────────┐
│          Lead Agent                   │
│  Task decomposition → Sub-task plan   │
│  → Result aggregation                 │
└──────┬─────────────┬──────────────────┘
       │             │             │
       ▼             ▼             ▼
  Researcher     Coder Agent    Reporter
  Sub-Agent      (Code Gen +    Sub-Agent
  (Search/Crawl)  Sandbox Exec) (Report Synthesis)
       │             │
       ▼             ▼
  Search APIs    Docker Sandbox
  Web Scraping   bash / Python
                 File System

The Lead Agent is the system's "brain", responsible for:

Understanding task intent and breaking it into parallelizable sub-tasks
Assigning each sub-task to the appropriate Sub-Agent
Aggregating results from all Sub-Agents into the final output

Sandbox Execution

The sandbox is one of v2.0's most important technical breakthroughs. Real code isolation is achieved through Docker containers:

# Simplified: Coder Sub-Agent's sandbox invocation
async def execute_in_sandbox(code: str, language: str = "python") -> ExecutionResult:
    """
    Execute code inside a Docker container, isolated from the host
    """
    container = await docker_client.containers.create(
        image="deerflow-sandbox:latest",
        command=["python", "-c", code],
        volumes={
            "/mnt/user-data/workspace": {"bind": "/workspace", "mode": "rw"},
            "/mnt/user-data/outputs": {"bind": "/outputs", "mode": "rw"},
        },
        network_mode="bridge",  # Restricted network access
        mem_limit="2g",         # Memory cap
        cpu_period=100000,
        cpu_quota=50000,        # CPU cap at 50%
    )

    result = await container.start()
    stdout, stderr = await container.logs()

    return ExecutionResult(
        stdout=stdout.decode(),
        stderr=stderr.decode(),
        exit_code=result["StatusCode"]
    )

Sandbox filesystem layout:

Inside the Docker container:
├── /mnt/user-data/uploads    # User-uploaded files (read-only)
├── /mnt/user-data/workspace  # Agent working directory (read-write)
└── /mnt/user-data/outputs    # Final output artifacts (read-write)

This design guarantees:

Security isolation: Agent-generated code cannot access sensitive host files
Reproducibility: Every task runs in a clean container, avoiding state contamination
Real deliverables: Output files persist to the host machine, immediately usable by the user

Skills as Markdown

The Skills system is the crown jewel of DeerFlow's extensibility design. Unlike other frameworks that define Skills as Python classes, DeerFlow uses Markdown files — dramatically lowering the barrier to extension:

.claude/skills/deep-research/
├── SKILL.md              # Skill description, trigger conditions, execution steps
└── references/
    ├── search-strategy.md    # Search strategy specifications
    ├── report-template.md    # Report template
    └── quality-checklist.md  # Quality checklist

A typical SKILL.md structure:

# Deep Research Skill

## Trigger Conditions
Activate when the user needs to conduct deep research on a topic,
competitive analysis, or industry investigation.

## Execution Steps
1. Understand the research objective; break it into 3-5 key questions
2. Perform multi-round searches per question (minimum 3 rounds, diverse angles)
3. Crawl high-quality source pages; extract key information
4. Synthesize findings; identify consensus and contradictions
5. Generate structured output using the report template

## Output Format
- Executive summary (< 200 words)
- Deep-dive sections (500-1000 words each)
- Key findings summary
- Source reference list

## Load Resources
- load_skill_resource("references/search-strategy.md")
- load_skill_resource("references/report-template.md")

This design means non-engineers can write and customize skills — all you need is Markdown, no Python code required.

LangGraph Integration

DeerFlow chose LangGraph as the Agent orchestration layer rather than building its own state machine. LangGraph's key advantages:

Directed Acyclic Graph (DAG): Task dependencies are clearly visualized
Checkpoints: Supports Human-in-the-Loop — pause and wait for human approval at critical nodes
Persistent State: Cross-session task state saving supports interruption and resumption of long-running tasks
Parallel Execution: Native parallel node execution means Sub-Agents can truly run concurrently

# DeerFlow's LangGraph workflow (simplified)
from langgraph.graph import StateGraph, END
from typing import TypedDict

class ResearchState(TypedDict):
    query: str
    sub_tasks: list[str]
    search_results: dict
    code_outputs: dict
    final_report: str

workflow = StateGraph(ResearchState)

# Add nodes
workflow.add_node("planner", lead_agent_plan)
workflow.add_node("researcher", researcher_agent)
workflow.add_node("coder", coder_agent)
workflow.add_node("reporter", reporter_agent)

# Define edges (execution order)
workflow.set_entry_point("planner")
workflow.add_edge("planner", "researcher")
workflow.add_edge("planner", "coder")       # Parallel
workflow.add_edge("researcher", "reporter")
workflow.add_edge("coder", "reporter")
workflow.add_edge("reporter", END)

app = workflow.compile()

Multi-Model Strategy

DeerFlow is model-agnostic, with recommended selection criteria:

Long context: 100k+ tokens (for processing large search results and codebases)
Reasoning: Complex multi-step reasoning capability
Tool calling: Reliable function calling / tool use
Recommended Chinese models: Doubao-Seed-2.0-Code (ByteDance in-house), DeepSeek v3.2, Kimi 2.5

Configuration (config.yaml):

# Any OpenAI-compatible endpoint works
llm:
  provider: openai_compatible
  base_url: "https://ark.cn-beijing.volces.com/api/v3"
  api_key: "${DOUBAO_API_KEY}"
  model: "doubao-seed-2-0-code-250605"
  max_tokens: 16384

# Or use DeepSeek
llm:
  provider: openai_compatible
  base_url: "https://api.deepseek.com"
  api_key: "${DEEPSEEK_API_KEY}"
  model: "deepseek-v3"

Resources

Official

🌟 GitHub: https://github.com/bytedance/deer-flow
📄 Docs: Project README
🐛 Issues: https://github.com/bytedance/deer-flow/issues

Related Projects

LangGraph: The Agent orchestration framework powering DeerFlow's backend
LangSmith / Langfuse: Observability tracing integrations
OpenDeepResearch (OpenAI): Comparable competitor in the deep research space

Summary

Key Takeaways

Positioning leap: From v1's deep research tool to v2's general SuperAgent execution engine — the core jump is real execution capability, not just text generation
Docker sandbox: Real isolated code execution means Agents produce actual deliverables, not suggestions
Sub-agent parallelism: The Lead Agent + Sub-Agent architecture breaks past single-model context limits, enabling genuinely complex long-running tasks
Skills-as-Markdown: Lowest-barrier extensibility in its class — non-engineers can customize Agent behavior
Chinese model first-class support: First-class support for Doubao, DeepSeek, and Qwen makes it the natural choice for developers in China

Who Should Use This

Researchers / Analysts: Knowledge workers who need to aggregate and synthesize large amounts of information
AI Engineers: Development teams building production-grade Agent applications that need a reliable execution engine
Python Developers: Practitioners looking to learn LangGraph and multi-agent orchestration through a real-world codebase
Enterprise Tech Teams: Teams exploring AI automation of complex tasks — research, reporting, code generation

Visit my personal site for more useful knowledge and interesting products

5 Agent Skill Design Patterns from Google: Cut Token Waste, Trigger the Right Behavior

WonderLab — Tue, 07 Apr 2026 13:07:20 +0000

This article is distilled from Lavi Nigam (Google ADK Agent Engineering expert) on Agent Skill design, summarizing 5 production-ready SKILL.md design patterns to help developers reduce token waste and improve skill quality.

Background: Why Do We Need Skill Design Patterns?

In AI Native product development, the root cause of massive token waste is twofold: forcing the model to repeatedly guess user intent that should be clearly specified, and expressing with complex instructions what could be expressed simply.

With structured SKILL.md design patterns, we can:

Reduce the model's "guessing" cost and trigger the right behavior precisely
Standardize how skills are written, reducing friction in team collaboration
Use progressive knowledge loading to dramatically cut token consumption
Let the Agent activate the right skill at the right time

Overview of the 5 Patterns

Pattern 1: Tool Wrapper

Core idea: SKILL.md uses load_skill_resource to load spec files from references/. The Agent applies those rules and instantly becomes a domain expert. No scripts, no templates — pure knowledge encapsulation.

How It Works

File Structure

my-skill/
├── SKILL.md              # Trigger keywords + load instructions (no scripts, no templates)
└── references/
    └── conventions.md    # Conventions, rules, best practices

Use Cases

FastAPI routing conventions and response model specs
Terraform resource naming and module patterns
PostgreSQL query optimization best practices
Internal API design guidelines

SKILL.md Example

---
name: fastapi-expert
description: Helps write code following FastAPI best practices. Triggered when the user needs to write FastAPI code, routes, or dependency injection.
---
# FastAPI Expert Mode

## Activation Rules
Load reference doc: `references/fastapi-conventions.md`
Ensure all generated FastAPI code follows the conventions defined in that document.

Key point: The description field is the Agent's search index. It must contain specific business keywords — too vague and the skill won't be triggered correctly.

Pattern 2: Generator

Core idea: The assets/ template determines "what structure to output," while the references/ style guide controls "how to write it." Templates enforce structure; the style guide ensures quality.

How It Works

File Structure

my-skill/
├── SKILL.md
├── assets/
│   └── report-template.md    # Output structure template (required sections)
└── references/
    └── style-guide.md        # Tone and formatting style guide

Use Cases

Technical analysis reports
API reference documentation
Standardized Git commit messages
Agent scaffold code
Weekly / monthly report templates

Choose the Generator pattern when structural consistency matters more than creativity.

Pattern 3: Reviewer

Core idea: Separate "what to check" (checklist) from "how to check" (review protocol). Swap the checklist file in references/ and you get an entirely different review type using the same skill structure.

How It Works

File Structure

my-skill/
├── SKILL.md                  # Review protocol (how to check: load, apply, report)
└── references/
    └── review-checklist.md   # Checklist (what to check: rules grouped by severity)

Output Format

Review findings should be grouped by severity:

Level	Meaning	Examples
❌ Error	Must fix — affects functionality or security	SQL injection, unhandled exceptions
⚠️ Warning	Should fix — affects quality	Missing type hints, naming violations
ℹ️ Info	Optional improvement	Incomplete comments, extractable logic

Use Cases

Code Review

Python type annotation checks
Exception handling completeness
Function complexity assessment

Security Audit

OWASP Top 10 checks
Hardcoded secrets detection
SQL injection risk

Content Review

Technical documentation formatting
Tone consistency
Terminology usage

API Documentation Review

Parameter description completeness
Code example correctness
Error code coverage

Pattern 4: Inversion

Core idea: Flip the Agent's conversational role. The Agent asks questions first; the user answers — the skill drives the dialogue. Effectively prevents the Agent from making blind assumptions and reduces wasted output.

Three-Phase Flow

Key Control Directive

Must be written explicitly in SKILL.md:

DO NOT start building until all phases are complete.

Use Cases

Project requirements gathering
System fault diagnosis guidance
Infrastructure configuration wizard
Pre-report information collection for custom outputs

Pattern 5: Pipeline

Core idea: Define a strictly ordered multi-step workflow with explicit Gate Conditions between steps. Gates prevent skipping validation steps.

How It Works

File Structure

my-skill/
├── SKILL.md          # Step definitions + gate control logic
├── references/       # Reference specs for each step
├── assets/           # Output templates
└── scripts/          # Automation scripts (optional)

Gate Control Template

## Step N: [Step Name]
[Step description]

*Gate: Do NOT proceed to Step N+1 until [condition]!*
*If any step is skipped or fails, do not continue.*

Use Cases

Code documentation (parse → user confirms → generate → quality check)
Data cleaning and processing pipelines
Code deployment workflow (review → test → release → verify)
Multi-step approval processes

How to Choose the Right Pattern

Quick Decision Guide

Need	Recommended Pattern	Complexity	Decision Criteria
Give the Agent expert knowledge of a specific library/tool	📖 Tool Wrapper	Low	Just need to encapsulate conventions — no fixed output format required
Ensure output structure is always consistent	📝 Generator	Medium	Fixed section/format template; structure consistency > creativity
Evaluate/score existing content against a standard	✅ Reviewer	Medium	Task resembles "grade against a rubric"; output grouped by severity
Prevent blind assumptions — must gather context first	❓ Inversion	Medium	Agent needs user specifics before it can begin
Execute a strict ordered multi-step flow with gates	🔄 Pipeline	High	Steps have dependencies; order is critical; user confirmation required mid-flow

Decision Tree

Real-World Case: E-Commerce Product Selection Pipeline

Scenario

Design a pipeline combining Inversion + Reviewer + Generator to cover the full loop from requirements gathering to final product selection report.

Directory Structure

ecommerce-product-selector/
├── SKILL.md                                 # Main instruction file (Pipeline control)
├── references/
│   └── product-evaluation-checklist.md     # Product evaluation criteria (Reviewer pattern)
└── assets/
    └── selection-report-template.md        # Final report template (Generator pattern)

Complete SKILL.md Example

---
name: ecommerce-product-selector
description: Helps with e-commerce product selection, market analysis, profit calculation, and generating standard selection reports. Triggered when the user needs to find or evaluate products.
metadata:
  pattern: Pipeline
  domain: E-commerce
---
# E-Commerce Product Selection Workflow

You are a professional e-commerce product selection expert. Follow the steps below strictly in order.

**Core rule: Do NOT start generating a product selection plan until all phases are complete!**
If any step is skipped or fails, do not continue.

## Step 1: Gather Requirements (Inversion Pattern)

Actively ask the user to collect product selection context:
1. Who is the target audience?
2. What is the budget and expected profit margin?
3. Are there specific category preferences or supply chain advantages?

*Gate: Wait for the user to answer all questions before proceeding to Step 2.*

## Step 2: Evaluate Products (Reviewer Pattern)

Load and apply evaluation criteria:
- Load checklist: `references/product-evaluation-checklist.md`
- Score products against the checklist (❌ Fatal flaw / ⚠️ Risk / ✅ Advantage)

## Step 3: User Confirmation (Pipeline Gate)

Present the preliminary findings from Step 2 to the user.

*Gate: Do NOT proceed to Step 4 until the user explicitly confirms!*

## Step 4: Generate Final Report (Generator Pattern)

After user confirmation, produce the formal report:
- Load template: `assets/selection-report-template.md`
- Fill in the collected requirements and evaluation results, strictly following the template's section structure

Key Design Notes

Precise Description Triggering

The description field is the Agent's search index. Including specific business keywords ("product selection," "profit calculation") ensures the skill is activated at the right moment — avoiding both false triggers and missed triggers.

Progressive Knowledge Loading

The Agent initially loads only ~100 tokens for the skill description. The evaluation checklist in references/ and the report template in assets/ are loaded only when the workflow reaches the corresponding step, significantly saving context window space.

Advanced Tips

Start Simple

If you're unsure which pattern to pick, start with the simplest: Tool Wrapper. Encapsulate your team's conventions first. Upgrade to Generator when you need structured output, and to Reviewer when you need evaluation capabilities.

Pattern Combination Best Practices

Production systems typically combine 2–3 patterns. Common pairings:

Combination	Typical Scenario
Pipeline + Reviewer	Quality control gate at the end of a workflow
Generator + Inversion	Collect user context first, then generate a custom report
Pipeline + Inversion + Generator	Full end-to-end business flow (like the product selection case above)
Tool Wrapper + Generator	Generate code or docs following expert conventions

Progressive Knowledge Loading

Load Timing	Content Loaded	Token Cost
Skill activation	SKILL.md description + base instructions	~100 tokens (minimal)
On reaching a step	`references/` checklist or spec doc	On-demand — avoids upfront cost
Generation phase	`assets/` output template	Loaded only when needed

🎉 Thanks for reading — let's enjoy what technology has to offer!

Visit my personal homepage for all resources I share: Homepage

One Open Source Project a Day (No.32): OpenClaw-Admin - The Visual Control Center for AI Agent Gateways

WonderLab — Tue, 07 Apr 2026 05:58:41 +0000

Introduction

"Deploy AI Agents where your users already are — in the chat apps they use every day."

This is article No.32 in the "One Open Source Project a Day" series. Today's project is OpenClaw-Admin (GitHub).

One of the biggest challenges in AI Agent deployment is distribution: how do you get users to actually interact with your Agent? Building a dedicated app is expensive, and asking users to open yet another tool creates friction. OpenClaw takes a different approach — bridge AI Agents directly into the IM platforms users already live in (QQ, Lark/Feishu, DingTalk, WeCom/WeChat for Work).

OpenClaw-Admin is the "cockpit" for this multi-channel AI Agent gateway — a modern web management console built on Vue 3 + TypeScript that provides everything from Agent configuration and session management to remote terminal access and real-time system monitoring.

What You'll Learn

The OpenClaw ecosystem architecture and where OpenClaw-Admin fits
Vue 3 + Composition API + Naive UI best practices for admin dashboards
Managing the full lifecycle of multi-channel AI Agents via a web UI
Lightweight full-stack design with Express + SQLite + WebSocket
Advanced features: remote terminal (xterm.js), SSH connection, system monitoring

Prerequisites

Basic understanding of Vue 3 (Composition API, Pinia)
Some experience with AI Agents / LLM APIs
Familiarity with Node.js ecosystem

Project Background

What Is It?

OpenClaw-Admin is the frontend management console for the OpenClaw Gateway ecosystem. The OpenClaw Gateway is a multi-channel AI Agent runtime that bridges AI agents to mainstream IM platforms — letting users chat with AI directly inside the apps they already use.

OpenClaw-Admin serves as the "brain" of the gateway, providing full visual management capabilities:

Agent Management: Configure agent identities, capabilities, and permissions
Channel Configuration: Connect to IM platform APIs and bots
Model Integration: Manage multiple AI model providers
Session Monitoring: Track all user-agent conversations in real time
DevOps Tools: Built-in remote terminal, SSH, desktop access, and file browser

About the Author

GitHub: itq5
Affiliation: College of Training and Continuing Education, Southwest University
Style: Rapid iteration — continuously releasing new versions from v0.1.x to v0.2.x between March and April 2026
Expertise: API proxy/translation, web tools, AI/LLM integration

Project Stats

⭐ GitHub Stars: 276
🍴 Forks: 87
🐛 Open Issues: 11
📦 Latest Version: v0.2.6
📄 License: MIT
🔄 Last Updated: April 2026

Key Features

Core Purpose

OpenClaw-Admin provides approximately 17 functional modules covering the complete lifecycle of AI Agent management:

Module	Description
Login & Dashboard	Secure login, real-time Token usage trends, active session stats
Online Chat	Real-time chat interface with slash commands (/new, /skill, /model)
Session Management	Create, monitor, delete Agent sessions; export history
Memory Management	Built-in Markdown editor for AGENTS/SOUL/IDENTITY/USER documents
Scheduled Tasks	Cron-based automation with execution history
Multi-Channel Support	QQ, Lark/Feishu, DingTalk, WeCom integration
Model Configuration	Multi-provider API key management with secure storage
Skill Management	Plugin installation and visibility control
Multi-Agent Collaboration	Create agents with independent identities and permissions
Remote Terminal	SSE-based terminal emulation with SSH support
Remote Desktop	Linux/Windows remote desktop access
File Browser	Remote file browsing, editing, and transfer
System Monitoring	Real-time CPU, memory, disk, network visualization
Virtual Office	Multi-role virtual collaboration environment
Agent Workshop	Multi-entity collaboration scenario orchestration
Backup/Restore	One-click system data backup and recovery
PDF Viewer	Built-in PDF viewer with LaTeX formula rendering

Use Cases

Enterprise AI Assistant Deployment
- Integrate ChatGPT/Claude capabilities into enterprise Lark/DingTalk — employees use AI without leaving their existing tools
Personal Agent Hosting
- Deploy OpenClaw on a personal server and manage multiple specialized AI assistants via the Admin UI
Multi-Model Routing
- Unified management of multiple AI providers — switch models based on use case from a single interface
DevOps AI Agent
- Combine the remote terminal and system monitoring features to let Agents participate directly in server operations
Team Knowledge AI
- Use the memory management feature to inject team-specific knowledge into Agents

Quick Start

# Clone the repository
git clone https://github.com/itq5/OpenClaw-Admin.git
cd OpenClaw-Admin

# Install dependencies (Node.js >= 18 required)
npm install

# Configure environment variables
cp .env.example .env
# Edit .env with your OpenClaw Gateway connection details

# Start both frontend and backend (recommended)
npm run dev:all

# Access the admin interface
# http://localhost:3000

Production deployment:

# Build frontend
npm run build

# Start production server
npm run start

Core Features

Vue 3 + Composition API
- Fully embraces <script setup> syntax; logic is organized by feature rather than option-based, making it highly maintainable
Naive UI Component Library
- Built on Naive UI for consistent design; supports seamless dark/light theme switching
Pinia State Management
- Stores split by business domain (session, agent, model, etc.) for clear state flow
Lightweight Full Stack
- Backend uses only Express + SQLite — no heavyweight database required, ideal for self-hosting
Real-time Communication
- WebSocket enables zero-latency data push for terminal output and monitoring metrics
Built-in i18n
- Ships with Chinese/English support, switchable without page reload
Unified Multi-Model Management
- Securely store API keys for multiple providers; configure model parameters from the UI
xterm.js Remote Terminal
- Browser-based terminal powered by @xterm/xterm 6.x with SSH remote connection support

How It Compares

Dimension	OpenClaw-Admin	Dify	One-API
IM Platform Integration	✅ QQ/Lark/DingTalk/WeCom	❌ Not native	❌ Not native
Admin Web UI	✅ Full-featured	✅ Full-featured	✅ Basic
Remote DevOps Tools	✅ Terminal + Desktop + Files	❌	❌
Deployment Complexity	✅ Single Node.js stack	Medium (Docker)	✅ Low
Multi-Model Management	✅	✅	✅ Primary focus
License	MIT	Apache 2.0	MIT

Why choose OpenClaw-Admin?

The only admin console designed specifically for IM-platform AI Agent deployment
All-in-one Node.js stack reduces operational overhead
Built-in DevOps tools eliminate the need to switch between multiple tools

Deep Dive

System Architecture

OpenClaw-Admin uses an integrated full-stack architecture where a single Node.js process serves:

Static Assets: Distributes the Vite-built Vue 3 SPA
REST API: Handles frontend data requests (Agent config, session data, etc.)
WebSocket Server: Real-time push for terminal output and system metrics
SSE (Server-Sent Events): Unidirectional real-time data streams

Browser (Vue 3 SPA)
     │
     ├── HTTP REST ────────→ Express Routes
     │                          │
     ├── WebSocket ────────→ ws Server ──→ node-pty (Terminal)
     │                          │         ssh2 (SSH)
     └── SSE ──────────────→ Express SSE ─→ System Metrics
                               │
                          SQLite (better-sqlite3)
                               │
                          OpenClaw Gateway API

Frontend Architecture

Directory Structure

src/
├── api/          # RPC client — encapsulates all backend API calls
├── stores/       # Pinia stores, organized by business domain
│   ├── session.ts      # Session state
│   ├── agent.ts        # Agent configuration
│   ├── model.ts        # Model providers
│   └── ...
├── views/        # Page components (~17 views matching functional modules)
├── composables/  # Reusable Vue 3 composables (use* naming convention)
│   ├── useTheme.ts     # Theme switching
│   ├── useTerminal.ts  # Terminal control
│   └── ...
└── i18n/         # Internationalization resource files

Composition API Best Practices

The project strictly follows <script setup> style. Here's useTerminal.ts as an example:

// composables/useTerminal.ts
import { ref, onMounted, onUnmounted } from 'vue'
import { Terminal } from '@xterm/xterm'
import { FitAddon } from '@xterm/addon-fit'

export function useTerminal(containerId: string) {
  const terminal = ref<Terminal | null>(null)
  const fitAddon = new FitAddon()

  onMounted(() => {
    terminal.value = new Terminal({
      cursorBlink: true,
      theme: { background: '#1e1e1e' }
    })
    terminal.value.loadAddon(fitAddon)
    terminal.value.open(document.getElementById(containerId)!)
    fitAddon.fit()
  })

  onUnmounted(() => {
    terminal.value?.dispose()
  })

  const write = (data: string) => terminal.value?.write(data)
  const resize = () => fitAddon.fit()

  return { terminal, write, resize }
}

All logic is encapsulated in the Composable — the View component only handles UI rendering:

<!-- views/Terminal.vue -->
<script setup lang="ts">
import { useTerminal } from '@/composables/useTerminal'

const { write, resize } = useTerminal('terminal-container')
// Rest: WebSocket connection, input handling...
</script>

<template>
  <div id="terminal-container" class="h-full" />
</template>

Backend Architecture

Express + SQLite Lightweight Full Stack

The backend lives in server/, designed around the principle of extreme simplicity:

// server/index.js (simplified)
import express from 'express'
import { WebSocketServer } from 'ws'
import Database from 'better-sqlite3'

const app = express()
const db = new Database('data.sqlite')

// REST API routes
app.use('/api/agents', agentRouter(db))
app.use('/api/sessions', sessionRouter(db))
app.use('/api/models', modelRouter(db))

// Static files (production)
app.use(express.static('dist'))

// HTTP server
const server = app.listen(3000)

// WebSocket attached to same port
const wss = new WebSocketServer({ server })
wss.on('connection', handleTerminalConnection)

better-sqlite3's synchronous API keeps database code clean and readable:

// Synchronous reads — no async/await complexity
const agents = db.prepare('SELECT * FROM agents WHERE active = 1').all()
const agent = db.prepare('SELECT * FROM agents WHERE id = ?').get(agentId)

Terminal Implementation: node-pty + xterm.js

The remote terminal is one of the project's technical highlights. node-pty spawns a pseudo-terminal process on the server, and its output streams over WebSocket to xterm.js in the browser:

// server/terminal.js (simplified)
import pty from 'node-pty'

function createTerminalSession(ws) {
  // Spawn a pseudo-terminal (bash/sh)
  const ptyProcess = pty.spawn('bash', [], {
    name: 'xterm-color',
    cols: 80,
    rows: 24,
    cwd: process.env.HOME,
    env: process.env
  })

  // Terminal output → WebSocket → browser xterm.js
  ptyProcess.onData((data) => {
    ws.send(JSON.stringify({ type: 'output', data }))
  })

  // Browser input → WebSocket → pseudo-terminal
  ws.on('message', (msg) => {
    const { type, data } = JSON.parse(msg)
    if (type === 'input') ptyProcess.write(data)
    if (type === 'resize') ptyProcess.resize(data.cols, data.rows)
  })

  ws.on('close', () => ptyProcess.kill())
}

Memory Management: The SOUL/IDENTITY Design

One of OpenClaw's most interesting design decisions is splitting an Agent's "personality" and "knowledge" into separate Markdown documents:

Document	Purpose
`AGENTS.md`	Agent capability boundaries and permission settings
`SOUL.md`	Agent personality, tone, and behavioral style
`IDENTITY.md`	Agent background and role definition
`USER.md`	User-specific context and preferences

OpenClaw-Admin provides a built-in Markdown editor for administrators to edit these documents directly — essentially "writing the soul" of each Agent. This design allows non-technical users to customize Agent behavior without touching prompt engineering code.

Internationalization

The i18n system is based on JSON resource files in src/i18n/, powered by Vue I18n:

// Chinese resources
{
  "dashboard": {
    "title": "仪表盘",
    "tokenUsage": "Token 使用量",
    "activeSessions": "活跃会话"
  }
}

// English resources
{
  "dashboard": {
    "title": "Dashboard",
    "tokenUsage": "Token Usage",
    "activeSessions": "Active Sessions"
  }
}

Language switching in the settings page updates the entire UI instantly without a page reload.

Resources

Official

🌟 GitHub: https://github.com/itq5/OpenClaw-Admin
🐛 Issue Tracker: https://github.com/itq5/OpenClaw-Admin/issues
📦 Latest Release: v0.2.6

OpenClaw Ecosystem

OpenClaw Gateway: The AI Agent multi-channel runtime (core backend)
awesome-openclaw-agents: 187 production-ready AI Agent templates (SOUL.md format)

Tech Stack References

Vue 3 Docs - Core framework
Naive UI - UI component library
Pinia - State management
xterm.js - Terminal emulation

Summary

Key Takeaways

Unique Positioning: OpenClaw-Admin solves the Agent distribution problem — instead of asking users to adopt new tools, bring Agents to the platforms they already use
Modern Tech Stack: Vue 3 + TypeScript + Composition API + Naive UI represents the state of the art for web admin dashboards in 2025
Complete Feature Set: 17 modules cover the entire AI Agent operations lifecycle, from configuration to production monitoring
Simple Deployment: The all-in-one Node.js stack eliminates complex microservice overhead
Design Insight: The SOUL/IDENTITY document approach for Agent personality is clever — it makes Agent customization accessible to non-technical team members

Who Should Use This

AI Application Developers: Engineers integrating AI capabilities into enterprise IM platforms
Vue 3 Learners: Developers looking for a production-grade Vue 3 + TypeScript admin panel reference
AI Enthusiasts: Technically inclined individuals who want to self-host and manage multiple AI assistants
Enterprise Tech Teams: Teams exploring AI-assisted DevOps and knowledge management

Visit my personal site for more useful knowledge and interesting products

Open Source Project of the Day (Part 31): awesome-openclaw-usecases - A Collection of Real OpenClaw Use Cases

WonderLab — Mon, 06 Apr 2026 01:33:02 +0000

Introduction

"Solving the bottleneck of OpenClaw adaptation: Not ~~skills~~, but finding ways it can improve your life."

This is Part 31 of the "Open Source Project of the Day" series. Today we explore awesome-openclaw-usecases (GitHub), maintained by hesamsheikh.

You may have heard of OpenClaw (formerly ClawdBot, MoltBot), an open-source AI Agent framework, but perhaps not known "what it can do" or "how it can actually improve my life." awesome-openclaw-usecases is a community-driven use case collection featuring 29+ verified real scenarios covering social media (Reddit/YouTube daily digests, X account analysis), productivity (multi-channel personal assistant, project state management, health tracking), DevOps (self-healing home server, n8n workflow orchestration), research and learning (knowledge base RAG, market research), creative building (goal-driven autonomous tasks, YouTube content pipeline), and more. Each use case includes detailed descriptions and implementation guidance, helping users move from "not knowing what it can do" to "finding a use case that fits their needs." The project emphasizes real verification: only use cases that have been actually used for at least one day and verified to work are accepted — theoretical or crypto-related cases are rejected.

What You'll Learn

awesome-openclaw-usecases' positioning: an OpenClaw use case collection solving the "use case discovery" bottleneck
Use case categories: social media, productivity, DevOps, research and learning, creative building, finance and trading
Typical use cases: daily digests, multi-channel assistant, project state management, knowledge base RAG, self-healing server
Community contribution mechanism: how to submit new use cases, security considerations
Relationship with OpenClaw: use case collection vs. the framework itself

Prerequisites

Basic understanding of OpenClaw (AI Agent framework with skill/plugin extension support)
Some familiarity with AI Agents and automation workflows
To implement use cases, OpenClaw deployment and configuration experience is needed

Project Background

Project Introduction

awesome-openclaw-usecases is a community-maintained collection of real OpenClaw use cases. The core problem it solves: the bottleneck of OpenClaw adoption is not "skills" — it's finding ways to improve your life with it. The project contains 29+ verified real use cases, each including:

Name and description: The core functionality of the use case
Detailed documentation: Markdown files in the usecases/ directory with implementation steps, required skills, configuration examples, etc.
Category tags: For easy lookup by scenario

Use cases are organized into six major categories: Social Media (4), Creative & Building (3), Infrastructure & DevOps (2), Productivity (15+), Research & Learning (4), and Finance & Trading (1).

Target user groups:

New OpenClaw users: Don't know what it can do and need inspiration
Existing OpenClaw users: Want to expand use cases and improve efficiency
AI Agent practitioners: Reference real use cases to learn how to design automated workflows
Community contributors: Share their own use cases to help others

Author/Team Introduction

Maintainer: hesamsheikh (GitHub)
Project type: Awesome List (conforms to awesome.re standards)
Community-driven: New use cases welcome via CONTRIBUTING.md

Project Stats

⭐ GitHub Stars: 5.4k+
🍴 Forks: 395+
📦 Use case count: 29+ (continuously updated)
📄 License: MIT
🔗 Related project: OpenClaw (main framework)

Main Features

Core Purpose

awesome-openclaw-usecases' core purpose is to provide verified real use cases to help users discover practical applications for OpenClaw:

Use case discovery: From "not knowing what it can do" to "finding a use case that fits you"
Implementation guidance: Each use case includes detailed documentation covering required skills, configuration steps, and example code
Community sharing: Users can submit their own use cases to help others
Categorized browsing: Six major categories for quick lookup by scenario

Use Cases

Exploring OpenClaw's capabilities
- Browse the use case list to understand what OpenClaw can do
- Find scenarios that match your own needs
Implementing automated workflows
- Follow use case documentation, configure required skills and plugins
- Copy and adapt to your own environment
Learning AI Agent design
- Analyze use case architectures to understand multi-agent collaboration, state management, and event-driven patterns
Contributing to the community
- Share your own verified use cases to help others

Quick Start

Browse use cases:

Visit the GitHub repository, view the use case list in the README, click a use case name to jump to its detailed documentation in the usecases/ directory.

Implement a use case:

Select a use case (e.g., "Daily Reddit Digest")
Read usecases/daily-reddit-digest.md
Follow the documentation to configure OpenClaw and install required skills
Test and verify results

Contribute a use case:

Ensure the use case has been actually used for at least one day and verified to work
Write documentation per the format in CONTRIBUTING.md
Submit a Pull Request

Core Features

Real verification: Only use cases that have been actually used and verified to work are accepted — no pure theory
Detailed documentation: Each use case includes implementation steps, required skills, and configuration examples
Clear categorization: Six major categories for easy lookup by scenario
Community-driven: Contributions welcome, continuously updated
Security warnings: Explicitly warns that skills and dependencies may have security vulnerabilities — users must review code themselves
No crypto-related content: Crypto/cryptocurrency-related use cases not accepted
Awesome List standards: Conforms to awesome.re conventions, easy to maintain and extend

Project Advantages

Comparison with other Awesome Lists:

Dimension	awesome-openclaw-usecases	Generic Awesome List	Official documentation examples
Content type	Real use cases (verified)	Tools/resource lists	Official examples
Detail level	Detailed implementation docs	Brief descriptions	Basic examples
Community contribution	Encourages submitting real use cases	Usually only maintainer updates	Officially maintained
Verification requirement	Must be used at least one day	No verification required	Official testing
Security warnings	Explicitly warns to review skill code	Usually none	Official guarantee

Why this project is worth following:

Solves real pain points: Not "which skills exist," but "how to use skills to improve your life"
Verified: Every use case has been actually used, avoiding armchair theorizing
Detailed guidance: Provides complete implementation documentation to lower the barrier to entry
Active community: Continuously updated, reflecting real-world usage scenarios

Detailed Project Analysis

Use Case Categories in Depth

1. Social Media

Daily Reddit Digest: Aggregates Reddit subreddit summaries based on preferences
Daily YouTube Digest: Daily digest of new video summaries from subscribed channels
X Account Analysis: Qualitative analysis of X accounts
Multi-Source Tech News Digest: Aggregates tech news from 109+ sources (RSS, Twitter/X, GitHub, web search) delivered in natural language

2. Creative & Building

Goal-Driven Autonomous Tasks: Goal-driven autonomous tasks where Agent automatically generates, schedules, and completes daily tasks, including building surprise small apps overnight
YouTube Content Pipeline: Automated video idea discovery, research, and tracking
Multi-Agent Content Factory: Multi-agent content pipeline in Discord where research, writing, and thumbnail agents collaborate in dedicated channels

3. Infrastructure & DevOps

n8n Workflow Orchestration: Delegates API calls to n8n workflows via webhook — Agent never touches credentials, each integration is visible and lockable
Self-Healing Home Server: Runs an always-on infrastructure agent with SSH access, automated cron tasks, and self-healing capabilities

4. Productivity

Includes 15+ use cases, such as:

Autonomous Project Management: Coordinates multi-agent projects using STATE.yaml pattern, sub-agents work in parallel with no orchestrator overhead
Multi-Channel AI Customer Service: Unifies WhatsApp, Instagram, Email, Google Reviews into one AI-driven inbox with 24/7 automatic replies
Phone-Based Personal Assistant: Access AI Agent via phone — hands-free voice assistant
Personal CRM: Automatically discovers and tracks contacts in email and calendar, natural language queries
Second Brain: Send anything to the bot for memory, search all memories in a custom Next.js dashboard
Custom Morning Brief: Daily morning briefing fully customized (news, tasks, content drafts, AI-recommended actions)

5. Research & Learning

AI Earnings Tracker: Tracks tech/AI earnings, with automatic previews, reminders, and detailed summaries
Personal Knowledge Base (RAG): Build a searchable knowledge base by dragging URLs, tweets, articles into chat
Market Research & Product Factory: Uses the "Last 30 Days" skill to mine real pain points on Reddit and X, then has OpenClaw build MVPs to solve them
Semantic Memory Search: Adds vector-driven semantic search to OpenClaw markdown memory files, with hybrid retrieval and auto-sync

6. Finance & Trading

Polymarket Autopilot: Automated paper trading on prediction markets, with backtesting, strategy analysis, and daily performance reports

Use Case Document Structure

Each use case document (in the usecases/ directory) typically includes:

Overview: Core functionality and value of the use case
Prerequisites: Required OpenClaw version, skills, API keys, etc.
Implementation steps: Detailed configuration and deployment steps
Configuration examples: YAML configuration, environment variables, etc.
Usage examples: Real usage scenarios and commands
Notes: Security, performance, limitations, etc.

Security and Contribution Guidelines

Security warning:

The project explicitly warns that OpenClaw skills and third-party dependencies referenced in use cases may have serious security vulnerabilities. Many use cases link to community-built skills, plugins, and external repositories that have not been audited by the list maintainer. Users must:

Review skill source code
Check requested permissions
Avoid hardcoding API keys or credentials
Take personal responsibility for security

Contribution requirements:

Only submit use cases that have been actually used and verified to work (used at least one day)
Value ideas that genuinely improve life, not those that make it worse
Crypto/cryptocurrency-related use cases not accepted
Write documentation per the CONTRIBUTING.md format

Relationship with OpenClaw

awesome-openclaw-usecases: Use case collection, solving the "use case discovery" problem
OpenClaw: Main framework, providing Agent runtime, skill system, plugin mechanism, etc.
Relationship: Use case collection depends on the OpenClaw framework to help users use OpenClaw better

Project Resources

Official Resources

🌟 GitHub: github.com/hesamsheikh/awesome-openclaw-usecases
📋 Contributing guide: CONTRIBUTING.md
📁 Use case directory: usecases/
🔗 OpenClaw main project: github.com/openclaw/openclaw

Related Resources

Awesome List standards
OpenClaw documentation (see main project)
Skills and plugins referenced in use cases (see specific links in use case documentation)

Who Should Use This

OpenClaw users: Want to discover new use cases and improve efficiency
AI Agent practitioners: Learning real-world use case design to understand multi-agent collaboration patterns
Automation enthusiasts: Looking for reusable automated workflows
Community contributors: Share their own use cases to help others

Welcome to visit my personal homepage for more useful knowledge and interesting products

Open Source Project of the Day (Part 30): banana-slides - Native AI PPT Generation App Based on nano banana pro

WonderLab — Sun, 05 Apr 2026 01:26:41 +0000

Introduction

"Vibe your PPT like vibing code."

This is Part 30 of the "Open Source Project of the Day" series. Today we explore banana-slides (GitHub), open-sourced by Anionex.

Have you ever found yourself the night before a presentation with a blank slide deck — full of brilliant ideas, but completely drained by the drudgery of layouts and design? Traditional AI PPT tools may be "fast," but they're often locked into preset templates, offer little freedom, and produce homogeneous results. banana-slides is built on Google's nano banana pro image generation model, delivering a "native Vibe PPT" experience: three creation paths — one sentence, outline, and page description — upload any template or materials, intelligently parse PDF/Docx/MD files, use natural language voice editing on specific areas (e.g., "change page three to a case study," "replace this chart with a pie chart"), and one-click export to PPTX or PDF, with support for Editable PPTX (Beta) — text and images remain freely editable in PowerPoint. The project uses a React + Flask full-stack architecture, Docker one-click deployment, and targets a wide audience from beginners to professionals, with the goal of "lowering the bar for PPT creation so anyone can quickly produce beautiful, professional presentations."

What You'll Learn

banana-slides' positioning: a native AI PPT generation app based on nano banana pro, moving toward true "Vibe PPT"
Three creation paths: idea, outline, page description — plus Vibe-style natural language editing
Material parsing capabilities: multi-format uploads, smart extraction, style references
Technical architecture: React + Vite + Flask + SQLite + Gemini API
Comparison with notebooklm slide deck and project advantages

Prerequisites

Comfortable with Docker or Node.js/Python development environments
Basic familiarity with LLM APIs (e.g., Gemini, OpenAI)
For self-hosted deployment, a Google Gemini API Key is required (image generation requires a paid tier) or access via a proxy like AIHubMix

Project Background

Project Introduction

banana-slides is a native AI PPT generation app built on nano banana pro (Google Gemini image generation model). It supports creating presentations from three paths — idea, outline, and page description — automatically extracts charts and text from attachments, accepts uploaded template images for style customization, and allows natural language voice edits on specific areas or entire pages. Results can be exported as standard PPTX or PDF, with support for Editable PPTX (Beta): exported pages have text and images that can be freely edited in PowerPoint, with text styles (font size, color, bold, etc.) preserved as closely as possible. The project's slogan is "Vibe your PPT like vibing code," aiming to satisfy both "fast" and "beautiful" PPT needs, solving the problems of fixed templates, low flexibility, and homogenization in traditional AI PPT tools.

Target user groups:

Beginners: Zero-barrier generation of attractive PPTs with no design experience needed
PPT professionals: Reference AI-generated layouts and text-image compositions for design inspiration
Educators: Quickly convert teaching content into illustrated lesson plans
Students: Quickly complete assignment presentations, focusing on content rather than layout
Professionals: Rapidly visualize business proposals and product introductions

Author/Team Introduction

Organization: Anionex (GitHub)
Website: bananaslides.online
Community: WeChat group available in README; sponsors include AIHubMix, AI Huobao, Yuyun, etc.
Commercial license: Free for personal/educational/non-profit use under AGPL-3.0; commercial closed-source or private deployment requires a Commercial License from the author

Project Stats

⭐ GitHub Stars: 12.1k+
🍴 Forks: 1.4k+
📦 Version: v0.4.0 (February 2026)
📄 License: AGPL-3.0
🌐 Website: bananaslides.online
🐳 Docker: Supports amd64 / arm64 with pre-built images

Main Features

Core Purpose

banana-slides' core purpose is to quickly generate high-quality, editable PPTs driven by natural language and materials:

Multi-path creation: Start from a one-sentence idea, a structured outline, or page-by-page descriptions — AI auto-completes the outline and page content
Material parsing: Upload PDF, Docx, MD, Txt files; automatically extract key points, image links, and chart data as generation materials
Style customization: Upload reference images or templates to control the overall visual style
Vibe-style editing: Verbally edit with natural language (e.g., "change page three to a case study," "replace this chart with a pie chart") — AI responds in real time
Export: One-click export to PPTX or PDF; editable PPTX mode allows text and images to be freely modified in PowerPoint

Use Cases

Reports/Proposals: Presentation due tomorrow — input a topic or outline and quickly generate a professional PPT
Lesson plans: Upload teaching content or documents and auto-generate illustrated lesson plans
Assignment presentations: Students input their topic and focus on content rather than layout
Design inspiration: Professionals reference AI-generated layouts and compositions
Iterative refinement: Verbally request changes after generation, without going through menus

Quick Start

Recommended: Docker Compose Deployment

git clone https://github.com/Anionex/banana-slides
cd banana-slides
cp .env.example .env
# Edit .env, configure GOOGLE_API_KEY (or a proxy like AIHubMix)
docker compose -f docker-compose.prod.yml up -d

Access the frontend at http://localhost:3000, backend API at http://localhost:5000.

Sample environment variables (Gemini format):

AI_PROVIDER_FORMAT=gemini
GOOGLE_API_KEY=your-api-key-here
GOOGLE_API_BASE=https://generativelanguage.googleapis.com
# Proxy example: https://aihubmix.com/gemini

From source: Requires Python 3.10+, uv, Node.js 16+; backend: uv sync then uv run python app.py; frontend: npm install then npm run dev.

Core Features

Three creation paths: Idea (one sentence generates outline and descriptions), Outline (manual or AI-generated), Page Description (per-page control)
Natural language editing: Verbally modify outlines or descriptions (e.g., "change page three to a case study") — AI adjusts in real time
Multi-format material parsing: PDF, Docx, MD, Txt upload; auto-parses key points, images, charts
Style references: Upload templates or reference images to customize PPT visual style
Local re-rendering: Select an unsatisfactory area and verbally describe the change (e.g., "replace this chart with a pie chart")
Full-page optimization: High-quality, visually consistent pages generated by nano banana pro
Multi-format export: PPTX, PDF, default 16:9, ready to present
Editable PPTX (Beta): Export high-fidelity, clean-background editable pages with text styles preserved; Baidu OCR API recommended for best results (see issue #121)
Multi-model support: Gemini, OpenAI, Vertex AI, Lazyllm (can mix DeepSeek, Doubao, Tongyi, etc.)
Internationalization and dark mode: Chinese/English toggle, light/dark/system theme

Project Advantages

Comparison with notebooklm slide deck (official README comparison, may change with updates):

Feature	notebooklm	banana-slides
Page limit	15 pages	Unlimited
Re-editing	Not supported	Selection edit + voice edit
Adding materials	Cannot add after generation	Add freely after generation
Export format	PDF only	PDF + Editable PPTX
Watermark	Free tier has watermarks	No watermark, freely add/remove elements

Why choose banana-slides?

True Vibe: Built on nano banana pro — good text-image quality and consistency, accurate text rendering and adherence to reference image styles
Flexible creation: Not locked into preset templates; upload any materials and templates, make multi-round voice edits
Editable export: Supports exporting PPTX freely editable in PowerPoint, not just stacked images
Open-source self-hostable: Docker one-click deployment, privatizable; supports multiple LLM APIs for cost and compliance control

Detailed Project Analysis

Technical Architecture

Frontend: React 18 + TypeScript + Vite 5, Zustand state management, React Router v6, Tailwind CSS, @dnd-kit drag-and-drop, Lucide React icons, Axios HTTP client.

Backend: Python 3.10+, Flask 3.0, uv package manager, SQLite + Flask-SQLAlchemy, Google Gemini API (or OpenAI/Vertex/Lazyllm), python-pptx for PPT handling, Pillow for image processing, ThreadPoolExecutor for concurrency, Flask-CORS for cross-origin.

AI Capabilities: Both text generation (outlines, descriptions, etc.) and image generation (page rendering) depend on LLMs; the core image generation is nano banana pro, requiring an API that supports image generation (Gemini free tier only supports text, not images).

Project Structure

frontend/: React app; pages/ contains Home, OutlineEditor, DetailEditor, SlidePreview, History; components/ contains outline, preview, shared, layout, history; store/ is Zustand; api/ is interface wrappers
backend/: Flask app; models/ contains Project, Page, Task, Material, UserTemplate, ReferenceFile, PageImageVersion; services/ contains ai_service, file_service, file_parser_service, export_service, task_manager, prompts; controllers/ is REST API
tests/: Tests; v0_demo/: Early demo; output/: Exported files

Key Implementation

Creation pipeline: Idea → AI generates outline → generates per-page descriptions → calls nano banana pro to generate page images → assembles PPT
Material parsing: file_parser_service parses PDF/Docx/MD/Txt, extracting text, images, charts for use during generation
Editable PPTX: Text in generated images is recognized via OCR and restored as editable text boxes, preserving font size, color, bold, and other styles as much as possible; requires Baidu OCR API (see issue #121)
Multi-model support: Via AI_PROVIDER_FORMAT and Lazyllm configuration, mix text and image models from different vendors

Development Roadmap (Selected)

✅ Completed: Three creation paths, Markdown image parsing, single-page material addition, selection Vibe editing, various file parsing, editable PPTX export
🔄 In progress: Multi-layer precise cutout editable export, web search, Agent mode
🧭 Planned: Online playback, animations and page transitions, multi-language support
🏢 Commercial: User system

Project Resources

Official Resources

🌟 GitHub: github.com/Anionex/banana-slides
🌐 Website: bananaslides.online
📄 English README: README_EN.md
🐛 Issues: GitHub Issues
📋 Editable PPTX notes: issue #121
📖 Beginner deployment tutorial: @ShellMonster's tutorial

Related Resources

AIHubMix (multi-model API proxy, reduces migration cost)
Baidu Cloud OCR (editable export optimization)
uv (Python package manager)
nano banana pro (Google Gemini image generation)

Who Should Use This

Users who need to create PPTs quickly: Reports, proposals, lesson plans, assignment presentations
Creators who want "fast and beautiful": Don't want to be constrained by fixed templates; need multi-round natural language edits
Technical teams: Want to self-host AI PPT services and control data and costs
Developers interested in Vibe PPT and the nano banana ecosystem: Learn full-stack AI application architecture and multi-model integration

Welcome to visit my personal homepage for more useful knowledge and interesting products

Insights from GDPS 2026: Enterprise Agents, AI Native, and One-Person Companies

WonderLab — Sat, 04 Apr 2026 06:21:47 +0000

Insights from GDPS 2026

One strong impression I took away from GDPS this year was that AI discussions are no longer stuck at the level of “the model got better again.” The conversation is moving toward much more concrete engineering and organizational questions: how Agents enter the enterprise, how they are constrained, how they become reusable assets, and how they might eventually reshape team size and even company structure.

If I had to compress the whole conference into one sentence, it would be this: enterprise Agent platforms are moving from concept demos toward real engineering, while AI Native and the one-person company are becoming two outward-facing consequences of that shift.

I. Three Keywords and Industry Trends

Three recurring themes: enterprise-grade “lobster” (enterprise Agent Platform) + AI Native Dev (a reshaped software development paradigm) + OPC (One Person Company). These were everywhere at the conference — AI is restructuring how we build software and how organizations work.
OpenClaw has become the dominant Agent product pattern. Many “wrapper” products have appeared — a crowded field sometimes called the “battle of a hundred lobsters.”
Skills are becoming core enterprise assets. Software engineering is entering an AI-native phase; competition shifts from headcount to depth of Skill accumulation.
Memory, security & permissions, roles, and cost management are critical capabilities for enterprise Agent platforms.
Harness engineering is on the rise: systems are slimming down faster, models are getting stronger, and everything is moving toward an Agent-centric world.

Put together, these keywords sketch a pretty clear path: stronger models lead to more employee-like Agents, and then enterprises start asking the harder questions. How do we package those capabilities into a system that is safe, stable, governable, and billable? In that sense, the Agent platform is no longer just a product question. It is an infrastructure question.

II. The “Battle of a Hundred Lobsters”: A Sample of OpenClaw-Style Product Names

腾讯 WorkBuddy — Tencent WorkBuddy
腾讯 QClaw — Tencent QClaw
腾讯龙虾管家 — Tencent Lobster Manager
腾讯云保安 — Tencent Cloud Security Guard
腾讯乐享知识库·龙虾版 — Tencent Lexiang Knowledge Base · Lobster Edition
字节 ArkClaw — ByteDance ArkClaw
智谱 AutoClaw — Zhipu AutoClaw
月之暗面 Kimi Claw — Moonshot AI Kimi Claw
阿里云 CoPaw — Alibaba Cloud CoPaw
阿里云 JVSClaw — Alibaba Cloud JVSClaw
阿里云 QoderWork — Alibaba Cloud QoderWork
百度红手指 Operator — Baidu Red Finger Operator
百度 DuClaw — Baidu DuClaw
科大讯飞 AstronClaw — iFlytek AstronClaw
MiniMax MaxClaw — MiniMax MaxClaw
网易有道 LobsterAI — NetEase Youdao LobsterAI
当贝 Molili — Dangbei Molili
智麻 ChatClaw — Zhima ChatClaw
矽速 PicoClaw — Xisu PicoClaw
博云 BocLaw — BocCloud BocLaw
ZeroClaw — ZeroClaw
万得 WindClaw — Wind WindClaw
小米 MiClaw — Xiaomi MiClaw
猎豹 EasyClaw — Cheetah Mobile EasyClaw
猎豹元气 AIBot — Cheetah Mobile Genki AIBot
京东灵犀 Claw — JD Lingxi Claw
快手 KClaw — Kuaishou KClaw
美图 Claw — Meitu Claw
360安全 Claw — 360 Security Claw
商汤 SenseClaw — SenseTime SenseClaw
华为小艺 Claw — Huawei Xiaoyi Claw
ToDesk ToClaw — ToDesk ToClaw

III. How OpenClaw Enters the Enterprise

3.1 Risks of Bringing “Vanilla” OpenClaw Straight In

For now, the answer to dropping native OpenClaw into the enterprise unchanged is clearly no.

Personal users can tolerate something that is “good enough.” Enterprises usually cannot. They need explicit permission boundaries, traceable execution, cost accountability, role management, and reliable fallback mechanisms when something goes wrong. From that angle, native OpenClaw is hard to adopt directly not because it is unimpressive, but because it is naturally closer to a machine for individual creativity than a system for organizational governance.

3.2 What Solutions Exist Today?

There are two broad categories:

Cloud-vendor offerings: OpenClaw-like products from players such as Alibaba Cloud Wuying, AWS, Baidu Cloud, etc. They ship with Harness-style infrastructure already in place — permissions, sandboxes, gateways, identity, load balancing, reliability, observability, monitoring — ready to use, with enterprises configuring Agents on top.
Custom builds: Enterprises fork and deeply customize OpenClaw for their own stacks.

At a deeper level, this is a choice between buying an existing foundation and building a controllable one. The first path optimizes for speed. The second optimizes for fit. In the short term, cloud vendors will probably capture more immediate value. In the long term, companies that want Agents to become a core organizational capability usually end up building platform layers of their own.

AWS OpenClaw on AgentCore

Alibaba Cloud Wuying: JVS Crew

MemTensor: ClawForce

SenseTime: Raccoon Family

Baidu AI Cloud: DuClaw

Dreame Technology: DreameClaw

A fork built on OpenClaw that has already AI-enabled more than ten internal workflows — recruitment, approvals, and more.

3.3 Signals from Silicon Valley

The following is anecdotal — not a forecast — useful mainly for strategic thinking.

On March 31, 2026, material related to Claude Code leaked. It included an unreleased module named KAIROS, which reads like a sketch of an ultimate Agent form: a background daemon that keeps Claude always on; GitHub Webhook subscriptions to auto-start fix flows when new bugs appear; and a built-in “Dream” mechanism to consolidate and compress long-term memory when the system is idle — getting close to what people mean by truly agentic AI.

Separately, a Silicon Valley investor posted that OpenAI might ship an “AI employee” product around $2,000/month in April.

None of this is confirmed feature- or date-wise, but the pattern is clear: autonomous AI workers are where model labs and cloud vendors are placing bets.

To me, the key thing here is not whether each rumor turns out to be accurate. It is that the imagination behind those rumors is already converging. People are no longer satisfied with “an AI that can chat.” They are now talking about AI that stays online, notices problems, maintains memory, and collaborates on its own. The next round of competition will not only be about model parameters or isolated features. It will be about the operating mechanisms around Agents.

IV. Possible Directions for Enterprise OpenClaw / Agent Platforms

4.1 Harness Engineer

Mitchell Hashimoto, co-founder of HashiCorp, coined the term on February 5, 2026. Roughly six days later, OpenAI adopted it in their million-line-code experiment write-up.

What Harness Is: An Analogy from Computing

There is a Chinese idiom — let the horse run with loose reins — for acting without constraint. That is roughly how an Agent behaves without Harness engineering. Harness work is about tightening the reins on the Agent-horse and making it follow the path we define.

For a long time, Agent discussions focused on whether the model could reason, plan, or reflect. More teams are now realizing that the real determinant of system usability is not only whether the model is clever, but whether you have given it a good working environment. That is what Harness addresses. Instead of piling more orchestration logic around the Agent, you prepare the right tools, rules, permissions, and feedback loops for it.

Compared with computer systems

Computer System Component	Agent Environment Component	Description
CPU (Computing Power)	LLM (Large Language Model)	Provides core reasoning, computation, and generation capabilities.
Memory (RAM)	Context Window	Determines the amount of information and short-term memory the agent can handle simultaneously.
OS (Operating System)	Harness (Engineering Framework)	Provides process scheduling, permission control, interfaces, and operational constraints.
Application	Agent	Runs on top of the environment, utilizing resources to handle specific business tasks.

Frontiers in Harness

A Shift in How We Build Agents

We move from heavy orchestration to building Harnesses: you no longer need monstrous workflow graphs inside the Agent layer — orchestration logic folds into model capabilities. Patterns that used to live in Agents (intent routing, reflection on results) may become defaults in the models themselves.

The next focus is: what runtime we give Agents, which tools and Skills, and what constraints we enforce.

Put differently, the future gap may not come from who writes the most complicated flow, but from who is best at preparing the road for the model. The clearer the environment, the sharper the tool definitions, and the more natural the constraints, the more likely an Agent becomes stable production capacity rather than a demo that still needs human rescue.

4.2 What “AI Native” Means in Practice

Move from GUI-first to AIPI-first (API, CLI, shell) so AI can operate software directly.

This part resonates strongly with me. For the last few years, many demos of “AI operating software” have looked impressive. But once they hit production, the same issues show up: slow execution, unstable success rates, high maintenance cost. The problem is not only the model. A huge amount of software was never designed for AI in the first place. AI has to click buttons, read screens, and guess the next step like a human, which naturally makes the whole thing fragile.

This shift should show up not only in “AI efficiency” programs: every new feature should ask how AI will plug in; products should gradually expose machine-friendly surfaces.

Since 2024 I have tracked AI-driven UI test automation. Today, LLM control of phones and IVI still means: decompose steps, simulate taps on a human UI, read the screen, loop. From early AutoGPT to Zhipu’s open AutoGLM for phones — same pattern. Root cause: most software was never AI-native.

Our CES POC last year — AutoFlow driving Spotify — is the same technical path.

Why is test automation hard and AI control slow and flaky? Most interfaces are built for humans; AI has to pretend to be a user.

The endgame is AI-facing operation surfaces for every product — and the industry is already turning.

On March 28, Feishu shipped Lark CLI so tools like Claude Code can drive the full Feishu stack:

GitHub - larksuite/cli

Chrome also has an open-source CLI path — AI need not drive the browser only by mimicking humans.

Open homework: in AI-efficiency programs, retrofit legacy systems toward AIPI; for new systems and features, design both human and AI interfaces.

I increasingly think AIPI will not remain just an “extra interface for AI.” It will gradually become a new software design default. Today we still ask whether we should expose AI-facing interfaces. In a year or two, the more natural question may be why a system still does not have them.

4.3 What to Watch When Building Skills

A. SAFETY

Security vendors analyzing ClawHub report 800+ risky Skills, spanning:

Malicious delivery and downloaders
Credential theft and phishing
Prompt injection and command hijacking
Data exfiltration and theft
Malicious scripts and generic detection bypass
Remote control and reverse shells
RCE and command injection
Supply-chain and untrusted installs
Spoofing and deception
Exploit kits and abuse tooling
Fraud and financial scams
System hijack and config tampering

Inside a company, Skills should live on a private Skill platform — that cuts most supply-chain risk. You will still pull Skills from the web during development, and internal authors can ship unsafe Skills. You need security review standards and review process.

Some vendors ship Skill-audit plugins with multi-dimensional scoring; we should invest in standards, methods, and tooling of our own.

If code repositories were the key asset layer in the previous software era, Skills may become a new asset layer in the AI-native era. Precisely because they sit closer to execution, permissions, and data, Skill security cannot be treated as a simple plugin problem. It has to be governed as part of the software supply chain.

B. PERFORMANCE

Measure accuracy and repeatability across runs — gate releases on those metrics.

C. COST

Unlike classic software, Skill work needs token awareness. Skill token spend is future R&D spend. Data is the moat; Skills are the AI advantage — halve token use versus a competitor on the same task and you ship an extra project for the same budget.

In implementation, design the shortest path to the outcome. Where RPA or a script can freeze a workflow, prefer scripts over “let the model improvise” — better stability, lower tokens. Example: unzipping files — don’t make the model guess tools or repeatedly self-author scripts; ship a script and document when and how to call it. That is Harness thinking too.

Many teams still evaluate Skills from the angle of “can we make this work?” Once you enter the enterprise, the more important questions become “can we make it work reliably?”, “can we make it work cheaply?”, and “can we make it work at scale?” That is why I increasingly think the real difference between companies will not only come from model selection, but from how quickly they accumulate Skill assets and Harness engineering capability.

V. A Final Take

GDPS made me more certain of one thing: competition in enterprise Agents is shifting from “who connected to a large model first” to “who industrializes AI Native architecture, Skill assets, and Harness engineering first.”

OpenClaw represents the explosion of Agent product form. Harness Engineering represents the maturation of the engineering method. AIPI represents the shift in software interface design. OPC represents the organizational consequence that may follow. They look like separate topics, but they are all pointing to the same trend: AI is not just a new tool. It is rewriting how software is built, invoked, governed, and ultimately how companies themselves operate.

Open Source Project of the Day (Part 29): Open-AutoGLM - A Phone Agent Framework for Controlling Phones with Natural Language

WonderLab — Sat, 04 Apr 2026 01:04:41 +0000

Introduction

"'Open Meituan and search for nearby hot pot restaurants.' 'Send a message to File Transfer Assistant: deployment successful.' — Spoken, and the phone does it automatically."

This is Part 29 of the "Open Source Project of the Day" series. Today we explore Open-AutoGLM (GitHub), open-sourced by zai-org (Zhipu AI ecosystem).

You want to control your phone with natural language: open apps, search, tap, type text — without doing it step by step yourself. Open-AutoGLM delivers two things: a Phone Agent framework (Python code running on your computer) that controls devices via ADB (Android) or HDC (HarmonyOS) in a loop of "screenshot → visual model understands the interface → outputs action (launch app, tap coordinates, type, etc.) → execute"; and the AutoGLM-Phone series of vision-language models (9B parameters) optimized for mobile interfaces, callable via Zhipu BigModel, ModelScope APIs, or your own vLLM/SGLang service. Users simply say something like "open Xiaohongshu and search for food," and the Agent automatically completes the entire flow — with support for sensitive operation confirmation and human takeover during login/CAPTCHA situations. The project supports Android 7.0+ and HarmonyOS NEXT, covering 50+ Android apps and 60+ HarmonyOS apps, and can be integrated with Midscene.js and other UI automation tools.

What You'll Learn

Open-AutoGLM's positioning: Phone Agent framework + AutoGLM-Phone model for "natural language → phone operations"
The working pipeline: screenshot, visual model, action parsing, ADB/HDC execution, remote debugging, and human takeover
Environment setup: Python, ADB/HDC, developer options, ADB Keyboard (Android)
Model acquisition and deployment: Zhipu/ModelScope API and self-hosted vLLM/SGLang
Supported apps, available actions, and secondary development structure

Prerequisites

Familiar with Python 3.10+, pip, and virtual environments
Understanding of basic ADB or HDC concepts (connecting devices, executing commands)
If self-hosting the model service, basic experience with GPU and vLLM/SGLang; using cloud API only requires applying for a key

Project Background

Project Introduction

Open-AutoGLM includes an open-source Phone Agent framework and the AutoGLM-Phone vision-language model, targeting "control phones with natural language": users enter commands on a computer, the Agent controls the phone via ADB (Android) or HDC (HarmonyOS), combining multimodal screen understanding and planning capabilities to automatically complete operations like opening apps, tapping, typing, and swiping. The framework has built-in sensitive operation confirmation and human takeover (e.g., for login, CAPTCHA), supports WiFi/network remote debugging — no need to stay plugged in throughout. The model provides AutoGLM-Phone-9B (Chinese-optimized) and AutoGLM-Phone-9B-Multilingual, downloadable from Hugging Face or ModelScope, or callable via already-deployed Zhipu BigModel or ModelScope APIs. The project states it is for research and learning only — prohibited for illegal use; read the terms of service in the repo before using.

Core problems the project solves:

Want to operate a phone "in natural language," not by memorizing steps or writing scripts
Need a working Agent codebase + a visual model optimized for mobile interfaces for reproduction and secondary development
Need simultaneous support for Android and HarmonyOS, local and remote devices, and Chinese and English commands

Target user groups:

Developers and teams researching or practicing "Phone Agent" and "GUI Agent"
Users needing to automate Android/HarmonyOS device operations for testing, demos, or assistance tasks
Integrators wanting to incorporate "natural language phone control" into their own products (e.g., Midscene.js integration)

Author/Team Introduction

Organization: zai-org (GitHub), related to the Zhipu AI ecosystem; README mentions Zhipu AI Input Method, GLM Coding Plan, AutoGLM Practitioners activities, etc.
Papers: AutoGLM (arXiv:2411.00820), MobileRL (arXiv:2509.18119); model architecture same as GLM-4.1V-9B-Thinking — see GLM-V deployment instructions for reference
Blog and product: autoglm.z.ai/blog

Project Stats

⭐ GitHub Stars: 23.5k+
🍴 Forks: 3.7k+
📦 Version: main branch as trunk; models on Hugging Face / ModelScope
📄 License: Apache-2.0
🌐 Documentation and blog: autoglm.z.ai/blog, repo README and README_en.md, iOS setup guide
💬 Community: WeChat community, Zhipu AI Input Method X account, GitHub Issues

Main Features

Core Purpose

Open-AutoGLM's core purpose is to translate natural language instructions into actual phone operations:

Receive instruction: User inputs something like "open Meituan and search for nearby hot pot restaurants" or "open WeChat and send to File Transfer Assistant: deployment successful"
Screenshot and understand: Agent takes a screenshot of the current screen via ADB/HDC, calls the AutoGLM-Phone visual model to understand the interface content and user goal
Plan and output action: Model outputs structured actions (e.g., Launch, Tap, Type, Swipe, etc.), Agent parses them and sends to device for execution
Loop until complete: After execution, take another screenshot, understand, plan — until the task is done, the maximum steps are reached, or human takeover is triggered
Safety and takeover: Sensitive operations can be configured with a confirmation callback; login, CAPTCHA, and similar scenarios can trigger a human takeover callback, then continue after completion

Use Cases

Automated testing and demos
- Drive app flows with natural language, reducing the need for hand-written UI automation scripts
Personal assistant-style operations
- "Open Taobao and search for wireless earphones," "open Xiaohongshu and search for food guides" — Agent automatically completes multi-step operations
Remote device control and debugging
- Connect via WiFi ADB/HDC, control the phone without a USB connection, convenient for remote demos or development
Integration with Midscene.js and similar tools
- Midscene.js has adapted AutoGLM — automate iOS/Android using YAML or JavaScript workflows paired with AutoGLM
Research and secondary development
- Extend new apps, new actions, or new prompts based on the phone_agent package, or integrate with a self-hosted model service

Quick Start

Environment: Python 3.10+; Android devices need ADB + developer mode + USB debugging (some models need "USB debugging (security settings)") + ADB Keyboard installed and enabled; HarmonyOS devices need HDC + developer options; iOS see docs/ios_setup.

Install the Agent (this repo):

git clone https://github.com/zai-org/Open-AutoGLM.git
cd Open-AutoGLM
pip install -r requirements.txt
pip install -e .

Connect device: After USB connecting the phone, run adb devices (Android) or hdc list targets (HarmonyOS) to confirm the device is listed.

Using third-party model service (no local GPU needed):

# Zhipu BigModel (apply for API key at Zhipu platform)
python main.py --base-url https://open.bigmodel.cn/api/paas/v4 --model "autoglm-phone" --apikey "your-key" "Open Meituan and search for nearby hot pot restaurants"

# ModelScope (apply for API key at ModelScope)
python main.py --base-url https://api-inference.modelscope.cn/v1 --model "ZhipuAI/AutoGLM-Phone-9B" --apikey "your-key" "Open Meituan and search for nearby hot pot restaurants"

Using self-hosted model service: Deploy AutoGLM-Phone-9B with vLLM or SGLang (see README startup parameters) to get an OpenAI-compatible API (e.g., http://localhost:8000/v1), then point --base-url and --model to that service.

Python API example:

from phone_agent import PhoneAgent
from phone_agent.model import ModelConfig

model_config = ModelConfig(
    base_url="http://localhost:8000/v1",
    model_name="autoglm-phone-9b",
)
agent = PhoneAgent(model_config=model_config)
result = agent.run("Open Taobao and search for wireless earphones")
print(result)

Core Features

Multimodal screen understanding: AutoGLM-Phone is optimized for mobile interfaces — understands the current page from screenshots and outputs the next action
Android + HarmonyOS: Android uses ADB, HarmonyOS uses HDC — switch with --device-type adb/hdc in the same Agent
50+ Android apps / 60+ HarmonyOS apps: Social communication, e-commerce, food delivery, transportation, video, music, lifestyle, content communities, etc. — see supported app list with python main.py --list-apps and --device-type hdc --list-apps
Rich operations: Launch, Tap, Type, Swipe, Back, Home, Long Press, Double Tap, Wait, Take_over (human takeover)
Remote debugging: Supports adb connect IP:5555 / hdc tconn IP:5555 for WiFi-based device control
Sensitive operations and human takeover: Configure confirmation_callback and takeover_callback to intervene during payment, login, CAPTCHA, and similar scenarios
Chinese and English prompts: --lang cn (default) and --lang en, corresponding to phone_agent/config/prompts_zh.py and prompts_en.py — customizable
OpenAI-compatible API: Any model service exposing an OpenAI-format interface works — easy to connect to Zhipu, ModelScope, or self-hosted vLLM/SGLang

Project Advantages

Dimension	Open-AutoGLM	Manual UI automation scripts	Cloud-only "phone assistant" products
Input method	Natural language	Coordinates/selectors, code	Natural language but closed-source/uncontrollable
Devices and OS	Android + HarmonyOS, local/remote	Depends on script and tools	Depends on product
Model and deployment	Open-source model + self-hosted or third-party API	No model	Usually cloud-only
Extensibility	Modify prompts, add apps, integrate self-built services	High but requires coding	Low
Research and reproduction	Paper + code + downloadable models	Depends on whether scripts are open-source	Difficult to reproduce

Why choose Open-AutoGLM?

End-to-end open source: From Agent logic to models (including Chinese/multilingual versions) — all accessible for learning and secondary development
Ready-to-use and self-hostable: Use Zhipu/ModelScope for quick experience, or build with vLLM/SGLang for private or customized deployment
Dual platform: Supports both Android and HarmonyOS, with Midscene.js and ecosystem integration for many extension scenarios

Detailed Project Analysis

Architecture Overview

This repo (Agent side): Runs on the computer, responsible for calling model APIs, parsing model-output actions, and sending screenshot and operation commands via ADB/HDC.
Model service: A separate process or remote API, receives "screenshot + conversation/task" input, returns structured actions (e.g., do(action="Launch", app="Meituan")). Can connect to local vLLM/SGLang or Zhipu, ModelScope, etc.
Device side: Phone/tablet with developer mode and USB debugging enabled (plus ADB Keyboard, etc.), communicating with ADB/HDC on the computer via USB or WiFi.

Project Structure (phone_agent)

agent.py: PhoneAgent main class, orchestrates screenshots, model calls, action parsing, operation execution, and callbacks
adb/: ADB connection, screenshots, text input (ADB Keyboard), device control (tap, swipe, etc.)
actions/handler.py: Translates model-output actions into ADB/HDC commands and executes them
config/: Supported app mapping (apps.py), Chinese/English system prompts (prompts_zh.py, prompts_en.py)
model/client.py: OpenAI-compatible model client for requesting the visual model API

HarmonyOS is implemented via HDC-related modules (e.g., hdc/) in the repo; specify with --device-type hdc on the command line.

Models and Deployment

AutoGLM-Phone-9B: Optimized for Chinese mobile app scenarios, Hugging Face, ModelScope
AutoGLM-Phone-9B-Multilingual: Multilingual, suitable for Chinese-English mixed or English interfaces
Deployment: Recommended to use inference services with strong Structured Output capability (e.g., OpenAI, Gemini); when self-hosting, follow README's vLLM/SGLang startup parameters (e.g., --max-model-len 25480, --limit-mm-per-prompt, etc.) — otherwise output format errors or garbled text may occur. Model is ~20GB, requires GPU (recommend 24GB+ VRAM for local deployment).

Important Notes

Compliance and use: Project states it is for research and learning only; strictly prohibited for illegally obtaining information, interfering with systems, or any illegal use; read the terms of service and privacy policy in the repo before using
Permissions and security: Requires enabling developer mode and USB debugging on the device; sensitive operations should use callback confirmation; payment/banking pages may screenshot as black screens and trigger takeover
Chinese input: Android requires ADB Keyboard — not installed or enabled will cause input issues; HarmonyOS uses the system IME

Project Resources

Official Resources

🌟 GitHub: github.com/zai-org/Open-AutoGLM
📄 English README: README_en.md
🌐 Blog: autoglm.z.ai/blog
📱 iOS setup: docs/ios_setup
🤖 Models: Hugging Face, ModelScope
📚 Zhipu API: docs.bigmodel.cn
🐛 Issues: GitHub Issues

Related Resources

Midscene.js AutoGLM integration
GLM-V model deployment
ADB Keyboard (Android text input)
Papers: AutoGLM (arXiv:2411.00820), MobileRL (arXiv:2509.18119)

Who Should Use This

Phone Agent / GUI Agent researchers: Need a reproducible framework and model
Automated testing and demos: Drive Android/HarmonyOS device flows with natural language
Product integrators: Want to incorporate "natural language phone control" (e.g., combined with Midscene.js)
Zhipu/multimodal ecosystem users: Already using Zhipu API or GLM series, want to extend to phone control scenarios

Welcome to visit my personal homepage for more useful knowledge and interesting products

Open Source Project of the Day (Part 28): Graphiti - Building Real-Time Knowledge Graphs for AI Agents

WonderLab — Fri, 03 Apr 2026 10:10:04 +0000

Introduction

"Traditional RAG is batch-oriented and static. When data changes continuously and you need to know 'what happened at that moment,' you need a temporally-aware graph."

This is Part 28 of the "Open Source Project of the Day" series. Today we explore Graphiti (GitHub), open-sourced by getzep.

Knowledge graphs express facts as "entity-relationship-entity" triples, suitable for structured retrieval and reasoning. But most solutions are either batch-processed or have weak temporal semantics, making it difficult to support continuously-updated conversations, business data, and external information. Graphiti targets exactly these scenarios: building and querying temporally-aware knowledge graphs for AI Agents operating in dynamic environments. It supports real-time incremental writes, a dual temporal data model (event time and ingestion time), hybrid retrieval (semantic + keyword BM25 + graph traversal), and custom entities (Pydantic) — all without full graph recomputation for historical queries. It also provides an MCP service (for Claude, Cursor, etc.), a REST API (FastAPI), and supports Neo4j, FalkorDB, Kuzu, and Amazon Neptune graph backends — the core open-source component of Zep's context engineering platform.

What You'll Learn

Graphiti's positioning: a real-time, temporally-aware knowledge graph framework for AI Agents
Differences from traditional RAG and GraphRAG: incremental vs. batch, dual temporal vs. simple timestamps
Core capabilities: Episode writes, hybrid retrieval, custom entities, multi-backend and multi-LLM support
Installation, quick start, and MCP/REST integration
The driver architecture (11 Operations ABC) and its relationship to Zep

Prerequisites

Basic understanding of knowledge graphs (nodes, edges, triples)
Rough familiarity with the differences between RAG, vector retrieval, and graph traversal
Experience with Python 3.10+, pip/uv; setting up your own graph database requires one of Neo4j/FalkorDB/Kuzu/Neptune

Project Background

Project Introduction

Graphiti is a framework for building and querying temporally-aware knowledge graphs, specifically designed for AI Agents operating in dynamic environments. It continuously integrates user interactions, structured and unstructured business data, and external information into a queryable graph, supporting incremental updates and precise historical (point-in-time) queries without full graph recomputation. Unlike traditional RAG, which relies on batch processing and static summaries, Graphiti emphasizes real-time writes, dual temporal modeling, and hybrid retrieval (semantic + keyword + graph), with support for defining custom entity types via Pydantic. Its core capabilities are used by the Zep context engineering and Agent memory platform; Graphiti is provided as an open-source framework for building your own graph storage and retrieval layer.

Core problems the project solves:

With continuously changing data, batch RAG has high latency and difficulty reflecting "current state" and "past state"
Need to explicitly distinguish between "event occurrence time" and "system ingestion time" for auditing and historical queries
Want to combine semantic, keyword, and graph structure for retrieval, not just a single vector or single summary
Need pluggable graph backends (local Neo4j/FalkorDB/Kuzu or cloud Neptune) for flexible deployment based on scale and compliance

Target user groups:

Developers building AI Agent memory, conversation context, and multi-turn reasoning
RAG/knowledge base scenarios requiring "dynamic data + graph structure + temporal queries"
Teams who want to build their own graph layer and connect to Claude/Cursor via MCP
Engineers researching or implementing "graph + time + Agent" architectures

Author/Team Introduction

Organization: getzep (GitHub), provides the Zep context engineering and Agent memory platform; Graphiti is Zep's core graph engine and is open-sourced
Paper: Zep: A Temporal Knowledge Graph Architecture for Agent Memory (arXiv 2501.13956)
Documentation and support: help.getzep.com/graphiti, Discord #Graphiti

Project Stats

⭐ GitHub Stars: 22.9k+
🍴 Forks: 2.3k+
📦 Version: v0.28.x (check Releases for current)
📄 License: Apache-2.0
🌐 Documentation: help.getzep.com/graphiti
💬 Community: Discord, GitHub Issues

Main Features

Core Purpose

Graphiti's core purpose is to provide AI Agents with real-time, queryable, temporally-aware knowledge graph capabilities:

Episode writes: Write text or structured JSON as "episodes" into the graph, automatically extracting entities and relationships — incremental, no full graph reprocessing needed
Dual temporal model: Records both event occurrence time and ingestion time, supporting point-in-time and time-range historical queries
Hybrid retrieval: Semantic embedding + keyword (BM25) + graph traversal, with optional graph-distance reranking, targeting sub-second latency
Custom entities: Define node/edge types via Pydantic to fit domain ontologies
Multiple backends: Neo4j, FalkorDB, Kuzu, Amazon Neptune (including Neptune Analytics + OpenSearch Serverless) with pluggable drivers
Multiple LLMs: Default OpenAI; supports Azure OpenAI, Google Gemini, Anthropic, Groq, Ollama (local), etc. for extraction and embedding
MCP and REST: MCP service for Claude/Cursor calls; REST service (FastAPI) for self-built frontends or service integration

Use Cases

Agent long-term memory
- Write conversations and actions as Episodes to the graph, retrieve by time and topic, supporting multi-turn reasoning and state recovery
Dynamic business knowledge base
- Orders, tickets, documents continuously updated — use graph + time modeling to capture "who was related to what at when," supporting auditing and historical queries
Graph RAG as a replacement for batch RAG
- When data changes frequently, use Graphiti for incremental graph building and hybrid retrieval, replacing "full rerun + pure vector" pipelines
Integration with Claude/Cursor
- Provide "graph memory" to assistants via Graphiti MCP Server: add episodes, manage entities, semantic/hybrid search, grouping and maintenance
Research and reproduction
- Reproduce "temporal knowledge graph + Agent memory" based on the paper and open-source implementation, or extend with new drivers and retrieval strategies

Quick Start

Environment: Python 3.10+; one of Neo4j 5.26 / FalkorDB 1.1.2 / Kuzu 0.11.2 / Amazon Neptune; OpenAI API key (default LLM/embedding). Recommended: models supporting Structured Output (e.g., OpenAI, Gemini) for best extraction quality.

Installation:

pip install graphiti-core
# or
uv add graphiti-core

# For FalkorDB
pip install graphiti-core[falkordb]

# For Kuzu
pip install graphiti-core[kuzu]

# For Neptune
pip install graphiti-core[neptune]

# Optional multi-LLM
pip install graphiti-core[anthropic,google-genai,groq]

Start FalkorDB with Docker:

docker run -p 6379:6379 -p 3000:3000 -it --rm falkordb/falkordb:latest

Minimal example (Neo4j): After setting OPENAI_API_KEY, refer to the repo's examples/quickstart: connect to graph database → initialize indexes and constraints → add Episodes (text or JSON) → hybrid search edges/nodes → rerank by graph distance → use search recipes. See the Quick Start documentation for full steps.

MCP integration: See repo mcp_server/README, supports Episode add/delete/query, entity and relationship management, semantic/hybrid search, grouping and graph maintenance — compatible with Claude, Cursor, and other MCP clients.

Core Features

Real-time incremental updates: New Episodes enter the graph immediately, no batch full recomputation needed
Dual temporal data model: Event time + ingestion time, supports accurate point-in-time/range queries
Hybrid retrieval: Semantic + BM25 + graph traversal, optional graph-distance reranking, low latency (sub-second target)
Pluggable graph drivers: GraphDriver ABC + 11 Operations interfaces, supports Neo4j, FalkorDB, Kuzu, Neptune — build new backends yourself
Custom entities: Pydantic-defined node/edge types for domain ontologies
Multi-LLM/embedding: OpenAI, Azure, Gemini, Anthropic, Groq, Ollama, etc. for cloud and local deployment
MCP and REST: Integration with AI assistants (Claude, Cursor) and self-built services
Telemetry can be disabled: Anonymous usage statistics, disable via GRAPHITI_TELEMETRY_ENABLED=false

Graphiti vs. GraphRAG vs. Zep

Dimension	Traditional GraphRAG	Graphiti	Zep (commercial platform)
Primary use	Static document summarization	Dynamic data and temporal-aware graphs	Managed context and memory
Data updates	Primarily batch	Continuous, incremental	Managed, out-of-the-box
Temporal modeling	Simple timestamps	Dual temporal (occurrence + ingestion)	Platform built-in
Retrieval	LLM summary chain dependent	Semantic + BM25 + graph + rerank	Pre-configured, sub-200ms
Query latency	Seconds to tens of seconds	Typically sub-second	Sub-200ms level
Custom entities	Generally not supported	Supported (Pydantic)	Depends on product capabilities
Deployment	Self-hosted	Self-hosted (multiple backends)	Managed or cloud

Why choose Graphiti?

When you need graph + time + incremental and want to control the graph database and retrieval yourself, Graphiti provides a complete open-source implementation
Same origin as Zep (Zep uses Graphiti underneath) — validate self-hosted first, then consider migrating to Zep managed
MCP and multi-backend, multi-LLM support makes it easy to embed into existing Agents and infrastructure

Detailed Project Analysis

Data Model and Pipeline Overview

Episode: A single input unit (a text passage or structured JSON) — upon writing, entities and relationships are extracted via LLM, written to the graph with time-related edges (e.g., NextEpisode).
Entities and edges: Entity nodes, Episode nodes, Community and Saga nodes, etc.; edge types include inter-entity relationships, Episode-to-entity associations, Episode sequences, etc. Supports temporal edge invalidation to handle contradictions and changes.
Retrieval: Combines semantic retrieval (embeddings), keyword search (FTS/BM25), graph traversal, and communities; results can be reranked by graph distance without relying on long LLM summary chains.

Graph Driver Architecture (11 Operations)

Graphiti uses pluggable drivers to abstract away graph database differences:

GraphDriver: Abstract base class defining connection, session, and index/constraint lifecycle, exposing 11 Operations interfaces (accessed via @property).
11 Operations: Node classes (EntityNode, EpisodeNode, CommunityNode, SagaNode), edge classes (EntityEdge, EpisodicEdge, CommunityEdge, HasEpisode, NextEpisode), search, and graph maintenance. Each backend implements these 11 interfaces; query statements are generated in the appropriate dialect by a shared query builder based on the GraphProvider enum.
Adding new backends: Add enum to GraphProvider → implement GraphDriver subclass and 11 Operations → add dialect for new block in node_db_queries.py / edge_db_queries.py → register optional dependency in pyproject.toml. README documents Neo4j, FalkorDB, Kuzu, and Neptune as reference implementations.

Concurrency and Rate Limiting

The ingestion pipeline supports high concurrency; defaults to limiting concurrency via SEMAPHORE_LIMIT (e.g., 10) to avoid LLM provider 429 errors. Can be raised to improve throughput or lowered to handle rate limits.

Documentation and Roadmap

Documentation: help.getzep.com/graphiti, including Quick Start and building Agents with LangGraph.
Roadmap: Custom graph schema, retrieval enhancement, and MCP Server are live; continuously expanding tests and stability.

Project Resources

Official Resources

🌟 GitHub: github.com/getzep/graphiti
📚 Documentation: help.getzep.com/graphiti
📄 Paper: Zep: A Temporal Knowledge Graph Architecture for Agent Memory (arXiv:2501.13956)
📦 MCP Server: Repo mcp_server/
🌐 Zep platform: getzep.com

Related Resources

Zep Blog: State of the Art in Agent Memory
Quickstart examples
Building Agents with LangGraph + Graphiti
Neo4j / FalkorDB / Kuzu / Amazon Neptune documentation (deployment and version requirements)

Who Should Use This

Agent and memory system developers: Need temporally-aware, incrementally-updatable graph storage and retrieval
Advanced RAG/knowledge base users: Upgrading from pure vector or batch GraphRAG to dynamic graphs + hybrid retrieval
Graph database users: Already using Neo4j/FalkorDB/Kuzu/Neptune, want to integrate LLM extraction and semantic retrieval
Claude/Cursor integration: Providing "graph memory" and retrieval capabilities to assistants via MCP

Welcome to visit my personal homepage for more useful knowledge and interesting products

Open Source Project of the Day (Part 27): Awesome AI Coding - A One-Stop AI Programming Resource Navigator

WonderLab — Thu, 02 Apr 2026 02:47:27 +0000

Introduction

"AI coding tools and resources are scattered everywhere. A topically organized, searchable, contributable list can save enormous amounts of search time."

This is Part 27 of the "Open Source Project of the Day" series. Today we explore Awesome AI Coding (GitHub).

When doing AI-assisted programming, you'll face questions like: which editor or terminal tool should I use? For multi-agent frameworks, should I pick MetaGPT or CrewAI? What RAG frameworks and vector databases are available? Where do I find MCP servers? What ready-made templates are there for Claude Code Rules and Skills? Awesome AI Coding is exactly that kind of curated resource navigator: covering 12 major sections including code generation, Agent development, RAG, LLM applications, code review and testing, prompt engineering, MCP, code understanding, Agent Skills, development acceleration tools, learning resources, and ClaudeCode Rules. Each section lists representative projects with brief descriptions, supports both Chinese and English (README_zh.md), table of contents navigation, and in-browser search. This article focuses on the content structure and what each section can help you with, for easy reference or contribution.

What You'll Learn

Awesome AI Coding's positioning: a one-stop AI programming resource navigator
What each of the 12 categories covers, with typical entries
How to search quickly (table of contents, Ctrl+F), Chinese/English entries, and contribution methods
ClaudeCode Rules section: language/framework/practice rule file structure
Complementary relationship with other Awesome-style lists

Prerequisites

Basic familiarity with AI-assisted programming, LLMs, Agents, RAG, and MCP is sufficient — the list itself is designed as a "where to go next" entry point after getting the basics

Project Background

Project Introduction

Awesome AI Coding is a curated collection of AI coding resources (Awesome-style), aimed at developers and teams who "use AI to write code, build Agents, do RAG, and build LLM applications." Content is divided into 12 major categories, each further broken down into subcategories or directly listing projects — each with a brief description and link for quick navigation to editors, frameworks, vector databases, MCP platforms, Skill collections, spec-driven development tools, and more. The repo provides both an English README and a Chinese README_zh.md, and welcomes continuous additions of quality resources via Issues/PRs.

Core problems the project solves:

AI coding tools, frameworks, Skills, and rules are scattered across GitHub, websites, and communities — hard to browse systematically
Need a "categorized by use case" navigator, not just a generic AI list
Want to cover desktop/terminal editors, Agent frameworks, RAG, MCP, and ClaudeCode Rules all in one place for easy end-to-end reference

Target user groups:

Developers just starting with AI coding who want a quick ecosystem overview
Teams needing to evaluate editors, Agent frameworks, RAG, MCP, and Skills
People using Claude Code/Cursor who are looking for Rules and Skills templates
Contributors and maintainers of Awesome-style lists

Project Stats (Brief)

📦 Content format: Markdown documents (README.md, README_zh.md) + rules/ directory in the repo (ClaudeCode Rules)
📄 License: MIT
🌐 Entry points: English README, Chinese README_zh.md
📝 Updates: README notes continuous updates, Issues/PRs welcome; footer has Last Updated date (e.g., 2026-01-29)

Main Features: Content Structure Overview

Core Purpose

Awesome AI Coding's core purpose is to aggregate AI coding resources by topic and provide a searchable, navigable, contributable entry point:

Clear categories: 12 major categories + subcategories, covering the complete pipeline from "editors/IDEs" to "ClaudeCode Rules"
Each entry has a description: Project name + link + one-line description, easy to decide whether to click
Bilingual: Main README in English, README_zh in Chinese, for different reading preferences
Searchable: README suggests using Ctrl+F / Cmd+F to search by keyword
Extensible: Contributing guide explains how to add resources via Fork + PR

12 Major Categories Overview

1. AI Code Editors & IDEs

Desktop Editors: Cursor, GitHub Copilot, Replit, Bolt, Devin AI, Trae (ByteDance), Windsurf, CodeBuddy, etc. — covering desktop and online AI coding environments.
Terminal Tools: Claude Code, OpenCode, Codex, Gemini CLI, and other CLI/terminal tools.

Ideal for: Quick comparison when choosing an IDE or terminal tool.

2. AI Agent Frameworks

Multi-Agent Systems: MetaGPT, CrewAI, AutoGen, JoyAgent-JDGeni, 500 AI Agents, Agent Design Patterns (Chinese), etc.
Agent Development Frameworks: LangGraph, AgentEvolv, etc.
Coding Agent Tools: Claude Code Plugins, Serena, OpenAutoGLM, SuperClaude Framework, etc.

Ideal for: Framework and tool selection when building multi-agent systems, orchestration, and coding agents.

3. RAG & Knowledge Bases

RAG Frameworks: e.g., RAGFlow.
Vector Databases: Supabase, Pinecone, Weaviate, etc.
Knowledge Graphs: Graphiti (real-time knowledge graph, can be used with code understanding).

Ideal for: Knowledge base Q&A, retrieval augmentation, vector and graph storage selection.

4. LLM Development Frameworks

Frameworks & Tools: LangChain, LlamaIndex, Haystack.
LLM Application Examples: Awesome LLM Apps, Agents Towards Production, etc.

Ideal for: Framework and example reference when building LLM applications and production-grade Agents.

5. Code Review & Testing

Code Review Tools: e.g., CodeRabbit and other AI code review assistants.

Ideal for: Integrating AI code review and quality tools.

6. Prompt Engineering

Prompt Tools: System Prompt Leak, System Prompts and Models of AI Tools (30,000+ lines of tool structure and prompts), etc.
Prompt Resources: Awesome Prompts, Prompt Engineering Guide, etc.

Ideal for: Learning and collecting system prompts and prompt engineering practices.

7. MCP Protocol & Tools

MCP Frameworks: Awesome MCP Servers and similar collections.
MCP Server Platforms: MCP.so, MCP.ad (33,000+ servers), Cursor Directory, Pulse MCP, Glama MCP, etc.

Ideal for: Finding MCP servers and integrating them with Cursor/Claude Code.

8. Code Analysis & Understanding

Code Understanding Tools: DeepWiki (deep GitHub repo understanding, Devin-powered Q&A), etc.
Code Analysis: CodeQL, etc.

Ideal for: Code understanding, static analysis, and security scanning.

9. Agent Skills

Official Skills: Superpowers, Anthropic Skills, OpenAI Skills, Trail of Bits Skills, etc.
Community Skills: Antigravity Awesome Skills (552+), Vercel/AWS/Obsidian/Context Engineering specialized collections, etc.
Resource Collections & Platforms: Claude Code Plugins, SkillsMP, skill0, multiple Awesome Claude Skills collections, NotebookLM Skill, OpenSkills, Skills, etc.

Ideal for: Selecting or referencing Agent Skills, plugins, and marketplaces for Claude Code/Cursor.

10. Development Tools & Acceleration

Documentation Tools: MarkItDown (multi-format to Markdown, LLM-compatible), etc.
Project Management: Spec-Kit (spec-driven development, Copilot integration), OpenSpec, BMAD-METHOD, etc.

Ideal for: Document conversion, spec-driven development, and requirements-to-code collaboration workflows.

11. Learning Resources

Tutorials & Guides: AI Code Guide, Agent Design Patterns CN (with local and Colab), etc.
Community Resources: Awesome AI, Awesome LLM Resources, etc.

Ideal for: Entry-level pathways and advanced learning.

12. ClaudeCode Rules

The rules/ directory in the repo provides ready-to-use development rules and specifications:

Language-Specific: Python, Go, Rust, Node.js, iOS Swift, Android App, Android System, etc.
Framework & Platform: React Frontend, Vue Frontend, Backend, Docker, etc.
Development Practices: Agents, Coding Style, Patterns, Performance, Security, Testing, Git Workflow, Hooks, etc.

Ideal for: Configuring project-level/language-level Rules for Claude Code or similar Agents — unifying style and security policies.

Use Cases

Selection phase: Browse and compare by category when choosing IDEs, Agent frameworks, RAG/vector databases, MCP platforms, and Skill collections.
Learning path: Start from Learning Resources and Prompt/LLM application examples, then jump to Agent, RAG, and MCP as needed.
Configure Claude Code/Cursor: Find ready-made Skills and Rules templates in Agent Skills and ClaudeCode Rules — copy or adapt to local use.
Standards and collaboration: Reference Spec-Kit, OpenSpec, and BMAD-METHOD in Development Tools for spec-driven and multi-agent collaboration workflows.
Contribute and maintain: When discovering quality resources, submit PRs per the Contributing guide to keep the list updated.

Quick Usage

Browse: Open README or README_zh.md, navigate to sections via the top table of contents.
Search: Use Ctrl+F / Cmd+F on the page to search by keyword (e.g., "RAG", "MCP", "Claude", "Skill").
Reference Rules: Clone or download the repo, then configure the corresponding .md paths from rules/ to Claude Code or your Agent rules directory.
Contribute: Fork → new branch → add entry in the corresponding category (format: - **[Name](link)** - Brief description) → submit PR.

Core Features

Comprehensive topic coverage: From editors to Rules, covers the complete AI coding toolchain and learning path.
Consistent structure: Major category → subcategory → list items, each with "name + link + one-liner" — easy to scan.
Bilingual: Main README in English, README_zh in Chinese, accessible to teams and communities.
Includes ClaudeCode Rules: Repo rules can be directly used for project standards and Agent behavior constraints.
Open contribution: Issues/PRs welcome, suitable for community co-maintenance and updates.
Awesome-style: Follows awesome list conventions, easy to use alongside other Awesome lists.

Complementary to Other Resource Lists

Dimension	Awesome AI Coding	Single-topic Awesome (e.g., awesome-claude-skills)	Vendor documentation/navigator
Coverage	12 categories: editors, terminal, Agent, RAG, MCP, Skills, Rules, etc.	Usually focused on Skills or one framework	Primarily their own products
Language	Bilingual (Chinese + English)	Project-dependent	Vendor-dependent
Rules & standards	Includes `rules/` directory, directly usable	Few ready-made Rules collections	Mostly product usage instructions
Positioning	Navigation for the complete "AI coding" pipeline	Deep focus on one sub-domain	Product and ecosystem promotion

Why it's worth bookmarking:

Single entry covering selection, learning, configuration, and standards — reduces repetitive searching.
ClaudeCode Rules and Agent Skills categories are especially useful for developers using Claude Code / Cursor.
Continuous updates and contribution mechanism keeps up with new tools and projects.

Detailed Project Analysis

Document and Directory Structure

README.md: English main document with complete table of contents and 12 major category content.
README_zh.md: Chinese version, same structure as English, for Chinese readers.
rules/: Multiple Markdown rule files, organized by language (python, go, rust, nodejs, ios-swift, android-app, android-system), framework (react-frontend, vue-frontend, backend, docker), and practice (agents, coding-style, patterns, performance, security, testing, git-workflow, hooks) — can be directly loaded by Claude Code or similar Agents.

Content Organization Principles

Categorized by use case: Organized around "what you're doing" (writing code, building Agents, doing RAG, configuring MCP, finding Skills, configuring Rules) — not by company or tech stack name.
Minimal per entry: Only name, link, and one-line description — no long text, easy to quickly scan.
Representative first: Each category lists representative or highly-adopted projects, balancing official and community options.

Contribution and Maintenance

Contribution workflow: Fork → feature branch → add entry per existing format in the appropriate category → submit PR.
README note: Quality resources welcomed via Issue or PR; list will be continuously updated.
Suitable for: Discovering uncatalogued quality projects, fixing links or descriptions, syncing Chinese README_zh updates.

Project Resources

Official Resources

🌟 GitHub: github.com/chendongqi/awesome-ai-coding
📄 Chinese version: README_zh.md
📁 ClaudeCode Rules: Repo rules/ directory
🤝 Contribute: Via Issues and Pull Requests

Who Should Use This

AI coding beginners: Need a topically categorized navigator to quickly understand the editor, framework, RAG, MCP, and Skills ecosystem.
Teams in the selection phase: When comparing Agent frameworks, RAG, vector databases, MCP platforms, and spec-driven tools — use this list as a starting point.
Claude Code / Cursor users: Find ready-made Agent Skills and Rules templates, configure project standards and security policies.
List maintainers and contributors: Want to participate in maintaining or expanding an Awesome list focused on "AI coding."

Welcome to visit my personal homepage for more useful knowledge and interesting products