agency-agents-zh

Converts unified Markdown-based agent definitions (with YAML frontmatter) into tool-specific formats via a two-stage bash/PowerShell pipeline (convert.sh → install.sh). The convert stage parses raw agent files and transforms them into 14+ target formats (.mdc for Cursor, .json for Kiro, aggregated files for Aider/Windsurf, rules for Claude Code/Copilot). The install stage auto-detects local tool installations and deploys converted agents to the correct configuration directories (~/.claude/agents/, .cursor/rules/, etc.), eliminating manual file placement.

Organizes 211 pre-built AI agent personas across 18 professional departments (Engineering, Design, Marketing, Sales, Support, Testing, Finance, Legal, HR, Academic, Game Development, Supply Chain, etc.) with 46 agents specifically designed for Chinese platforms (Xiaohongshu, Douyin, WeChat, Feishu, DingTalk). Each agent is defined as a Markdown file containing YAML metadata (name, department, tools, version) and a structured body (identity/mission/rules/deliverables). The library is indexed and linted via CI/CD to ensure consistency and completeness.

Integrates with OpenClaw (a workspace management tool) to enable unified deployment and management of agents across multiple tools and projects. OpenClaw provides a centralized interface for selecting, configuring, and deploying agents to local development environments. The integration leverages the conversion pipeline to automatically deploy agents to the correct tool-specific formats and directories. This reduces friction for teams that use multiple tools and want a single point of control for agent deployment.

Provides pre-defined scenario runbooks (e.g., 'xiaohongshu-launch', 'product-development', 'infrastructure-deployment') that orchestrate multiple agents through a complete workflow. Each runbook specifies the sequence of agents, handoff protocols, validation checkpoints, and expected outputs. Runbooks are defined in Markdown and can be executed via the NEXUS orchestration framework or manually. This enables teams to standardize on repeatable workflows without building orchestration logic from scratch.

Provides standardized templates and contribution guidelines for adding new agents to the library. Contributors create a Markdown file with YAML frontmatter (metadata) and a structured body (identity, mission, rules, deliverables) following the template. The contribution process includes validation via the linter, peer review, and integration into the appropriate department. The framework ensures consistency across all 211 agents and makes it easy for community members to contribute without understanding the entire codebase.

Implements a 7-phase orchestration framework (Phases 0–6) for coordinating multiple agents on complex tasks. Each phase defines entry conditions, agent responsibilities, handoff protocols, and validation checkpoints. Agents communicate via standardized handoff templates that specify context, constraints, and expected outputs. The framework includes scenario runbooks (pre-defined workflows for common patterns like 'product launch', 'content creation', 'infrastructure deployment') and agent coordination templates that define who hands off to whom and under what conditions. Implemented via the agency-orchestrator NPM package for programmatic control.

Converts agent definitions into .mdc (Markdown with Code) rule files for Cursor, Trae, and OpenCode, which use a rules-based system to inject agent personas into the IDE's code completion and suggestion engine. The conversion process extracts the agent's identity, mission, and rules from the Markdown definition and formats them as a .cursor/rules/ file that the IDE loads at startup. Rules are applied contextually — the IDE evaluates them against the current file, selection, and command to determine which agent persona should influence suggestions. This enables IDE-native agent switching without leaving the editor.

Provides agent definitions formatted as copy-paste system prompts for Claude Code and GitHub Copilot, which do not support external rule files or configuration. The conversion process extracts the agent's identity, mission, and rules from the Markdown definition and formats them as a plain-text system prompt that can be pasted directly into Claude Code's system prompt field or GitHub Copilot's settings. This is the simplest integration path but requires manual copy-paste and does not support dynamic agent switching within a session.

Converts multiple agent definitions into a single aggregated file (e.g., agents.md or agents.json) that Aider and Windsurf can load as a unified agent catalog. The aggregation process concatenates agent definitions while preserving metadata and ensuring no conflicts. Aider and Windsurf then parse this file to populate their agent selection UI, allowing users to switch between agents without restarting the tool. This approach balances automation (single file deployment) with simplicity (no complex configuration).

Converts agent definitions into skill definitions for Antigravity and Gemini CLI, which use a skill-based system to extend their capabilities. Each agent is mapped to a skill (e.g., 'Senior Developer' → 'advanced-coding-skill', 'Content Strategist' → 'content-creation-skill') with associated metadata (description, parameters, examples). The conversion process extracts the agent's mission and rules and formats them as skill definitions that Antigravity/Gemini CLI can invoke. This enables agents to be used as reusable skills that can be chained or composed.

Implements a bash-based linter (lint-agents.sh) that validates agent definitions against a schema (YAML frontmatter structure, required fields, formatting consistency). The linter checks for missing metadata (name, department, version), malformed YAML, incomplete rules sections, and inconsistent formatting. It outputs validation errors and warnings that can be integrated into GitHub Actions workflows, preventing invalid agents from being merged into the repository. This ensures library quality and consistency without manual review.

Provides 46 agents specifically designed for Chinese platforms (Xiaohongshu, Douyin, WeChat, Feishu, DingTalk) with localized workflows, content strategies, and platform-specific best practices. Each agent understands platform-specific features (e.g., Xiaohongshu's hashtag system, Douyin's algorithm, WeChat's group dynamics) and provides guidance tailored to that platform. Agents include 'Xiaohongshu Content Strategist', 'Douyin Trend Analyzer', 'WeChat Community Manager', 'Feishu Workflow Optimizer', and 'DingTalk HR Specialist'. These agents are integrated into the same deployment pipeline as generic agents, enabling seamless use across tools.

Integrates with the Model Context Protocol (MCP) to enable agents to maintain persistent memory across sessions. Agents can store and retrieve context (e.g., project state, user preferences, conversation history) via MCP memory servers, allowing them to pick up where they left off in subsequent sessions. The integration is optional and tool-dependent — agents can function without MCP, but with MCP they gain stateful capabilities. This is particularly useful for long-running projects or multi-session workflows where context preservation is critical.