Feishu Evolver Wrapper: Self-Improving AI Agents with Enterprise Reporting
16,570 downloads, 66 installs, 4 stars. The Feishu Evolver Wrapper by @autogame-17 is a purpose-built integration that connects two distinct worlds: the capability-evolver self-improvement protocol for AI agents, and Feishu — ByteDance's enterprise collaboration platform (known internationally as Lark). The result is an AI agent that can diagnose its own failures, generate fixes, run through evolution cycles, and report all of it back to your team as rich, interactive Feishu cards.
The Problem It Solves
The capability-evolver skill (19,383 downloads, the parent skill) handles self-improvement logic admirably — it scans execution history, extracts failure signals, generates Gene mutations, and applies the GEP (Genome Evolution Protocol). But in a team environment, "the agent improved itself" needs to be observable. Engineers need to know what changed, why, and whether it worked.
In organizations running on Feishu/Lark, the natural reporting surface is the Feishu card — the rich interactive message format that Feishu bots use to deliver structured data. The Feishu Evolver Wrapper bridges this gap: it runs the same evolution loop but pipes all output through the Feishu reporting layer, making agent evolution visible in the same tool the team uses for everything else.
Architecture
The wrapper is deliberately minimal — it doesn't reimplement the evolution logic. Instead, it injects the EVOLVE_REPORT_TOOL environment variable that tells capability-evolver to use Feishu as its output channel, then provides three additional utilities:
┌─────────────────────────────────────────────────────────┐
│ Feishu Evolver Wrapper │
├──────────────────────────────────────┬──────────────────┤
│ Evolution Loop │ lifecycle.js │
│ (capability-evolver + Feishu output)│ (start/stop/ │
│ │ ensure/status) │
├──────────────────────────────────────┴──────────────────┤
│ Dashboard (visualize_dashboard.js) │
│ (Markdown dashboard from events.jsonl) │
├──────────────────────────────────────────────────────────┤
│ OpenClaw Cron Watchdog │
│ (lifecycle.js ensure — runs every 10 min) │
└──────────────────────────────────────────────────────────┘
Core Commands
Run the Evolution Loop
# Run the Feishu-reporting evolution loop
node skills/feishu-evolver-wrapper/index.jsThis executes the full GEP cycle — scan logs, extract repair signals, generate mutations, apply Genes — and sends rich card reports to the configured Feishu channel at each stage.
Lifecycle Management
# Check current daemon status
node skills/feishu-evolver-wrapper/lifecycle.js status
# Start the evolution daemon
node skills/feishu-evolver-wrapper/lifecycle.js start
# Stop the daemon
node skills/feishu-evolver-wrapper/lifecycle.js stop
# Ensure daemon is running (start if not)
node skills/feishu-evolver-wrapper/lifecycle.js ensureThe ensure command is what the watchdog cron calls — it's idempotent, starting the daemon only if it's not already running. This makes the system self-healing: if the evolution daemon crashes, the next watchdog run will restart it automatically.
Dashboard Visualization
# Generate evolution history dashboard as Markdown
node skills/feishu-evolver-wrapper/visualize_dashboard.jsReads from assets/gep/events.jsonl — the evolution event log — and generates a Markdown summary of all evolution cycles, mutations applied, outcomes, and current agent state. Useful for reviewing what the agent has changed about itself over time.
The Feishu Context
Feishu (飞书) is ByteDance's enterprise collaboration suite, dominant in Chinese technology companies and expanding internationally as Lark. Its bot/card system is one of the most feature-rich in the enterprise messaging space — Feishu cards can include structured data tables, approval buttons, collapsible sections, and real-time data binding.
When the evolver sends a cycle report to Feishu, it's not a plain text message — it's an interactive card showing:
- Which failure signals were detected
- What mutation was generated (the Gene)
- Whether the mutation passed validation
- The current evolution score
For teams where Feishu is the communication hub, this means agent health is visible in the same interface where the team reviews PRs, manages approvals, and coordinates deployments.
The Watchdog Pattern
One of the more interesting architectural choices: the wrapper integrates with OpenClaw's cron system to maintain daemon reliability.
The cron job evolver_watchdog_robust runs lifecycle.js ensure every 10 minutes. If the evolution daemon is running normally, ensure exits immediately with no action. If the daemon has crashed (due to a bug in a generated mutation, network failure, or anything else), ensure restarts it.
This means the self-improving agent is itself protected by an independent watchdog — a meta-reliability layer that keeps the improvement engine running even when the agent's own generated code contains errors.
Use Cases
Chinese enterprise AI deployments. For teams already on Feishu, this is the natural path to running self-improving agents with team-visible telemetry. No new tooling required.
Continuous agent improvement cycles. Deploy a long-running agent, let the evolution loop run in the background, receive Feishu cards when meaningful mutations are applied. The team gets visibility into improvement without manually reviewing logs.
International teams using Lark. ByteDance has been expanding Feishu internationally as Lark, particularly in Southeast Asia and globally expanding Chinese tech companies. Teams on Lark get the same rich card reporting.
Game AI and simulation. The parent skill's author (autogame-17) focuses on game-playing agents — the evolution wrapper fits naturally into setups where game bots adapt their strategies and need to report results to a monitoring dashboard.
How to Install
clawhub install feishu-evolver-wrapperPrerequisites:
capability-evolverskill installed (the parent dependency)- Feishu bot configured with an active webhook or API token
- Node.js 18+
Considerations
- Data flows to Feishu (ByteDance servers). Evolution logs, agent history, and reported events are sent to Feishu's API, which is operated by ByteDance and stored on Beijing-based servers (or Singapore for Lark international). For organizations with data residency requirements, verify this aligns with your compliance posture before deploying.
- Feishu/Lark dependency. This skill has limited utility outside of Feishu/Lark deployments. If your team uses Slack, Discord, or no messaging platform, the parent
capability-evolverskill is the better starting point. - Requires the parent skill. The
package.jsonhas"evolver": "file:../evolver"as a dependency — capability-evolver must be installed at the expected path. Install both skills in the same environment. - Stars vs downloads gap. 16,570 downloads vs 4 stars reflects a specialized audience: the people running it are primarily from Chinese enterprise environments where GitHub star culture is less prominent. The download count is the more meaningful signal here.
- Cron watchdog requires OpenClaw cron integration. The self-healing watchdog pattern requires that your OpenClaw environment has cron capabilities configured. Verify this before relying on automatic restarts.
The Bigger Picture
The Feishu Evolver Wrapper represents a specific and important direction for AI agent infrastructure: making agent behavior observable by human teams in their existing tools. Self-improving agents are only useful if the humans responsible for them can understand and trust what they're doing.
The Feishu integration isn't an aesthetic choice — it's a trust architecture decision. By surfacing evolution events in the same tool where engineers do their day-to-day work, it keeps agent self-modification within the team's observability perimeter rather than happening silently in the background.
As autonomous agents become more capable, the tools that make their behavior legible to human teams will be as important as the agents themselves.
View the skill on ClawHub: feishu-evolver-wrapper