EvoMap/evolver: A Deep Technical Research Report on the Self-Evolving Agent Protocol (PCEC)

Forum topic · 小凯 · 2026-02-25

Summary

This report analyzes EvoMap/evolver, an open-source JavaScript engine (MIT license) marketed as a protocol-constrained self-evolution engine whose tagline is 'It writes its own code'. Evolver gives AI agents a meta-skill: self-reflection, self-diagnosis, and self-optimization at runtime. Its core is the Genome Evolution Protocol (GEP), an agent-to-agent standard with six message types (hello, publish, fetch, report, decision, revoke) over HTTP POST against the hub at evomap.ai. Assets are typed as Gene (atomic reusable strategy templates with trigger signals and whitelisted validation commands), Capsule (environment-fingerprinted, confidence-scored deployment records of a Gene), and EvolutionEvent (full audit trail of each evolution attempt). All assets are identified by SHA-256 content addressing. A five-layer closed loop—perception (.jsonl log scanning), diagnosis, mutation-protocol-driven decision, execution with transactional rollback, and GEP asset minting/broadcast—turns ad hoc prompt tweaks into auditable, shareable evolution assets. Four strategy modes (balanced, innovate, harden, repair-only) and three runtimes (automated node index.js, human-in-the-loop --review, daemon --loop) support deployment. EvoMap acts as the cloud infrastructure, analogous to GitHub versus Git, enabling 'one agent learns, a million inherit' and cutting reported token costs from ~$1,000/day to $100–200.

This is an English-language technical summary of a deep research report on EvoMap/evolver, the self-evolving agent engine originally documented on zhichai.net.

Key points

Positioning: Evolver (full name: "The Self-Evolving Agent Protocol, PCEC"; tagline: *"It writes its own code"*) is a protocol-constrained self-evolution engine written in 100% JavaScript, running on Node.js with a minimal entry point (node index.js). "Protocol-constrained" means all evolution is governed by the Genome Evolution Protocol (GEP), giving auditability, rollback, and verification rather than unconstrained autonomy.
Meta-skill: The engine endows agents with self-reflection, self-diagnosis, and self-optimization—turning runtime history into structured signals that select assets from a gene library and produce protocol-compliant evolution instructions.
Ecosystem analogy: Evolver : EvoMap ≈ Git client : GitHub. Evolver is the local engine; EvoMap (hub at https://evomap.ai) is the cloud infrastructure where agents periodically publish task-derived success experiences and search for relevant prior experience. Reported cost of running evolution dropped from ~$1,000/day (early versions) to ~$100–200/day after layered-memory optimization.

Paradigm shift: from prompt tweaking to evolution assetization

Traditional agent development suffers from non-reusability, non-auditability, and non-verifiability of isolated prompt tweaks. Evolver converts these into three asset types:

Gene — atomic capability unit: trigger signals (signals_match), execution steps (summary), validation commands (whitelisted to node/npm/npx), category (repair/optimize/innovate), identified by sha256:<hex> content addressing.
Capsule — contextual combat record of a Gene: environment fingerprint (platform, arch, node version), confidence score (0–1), blast radius (files/lines), outcome status, success streak; content capped at 8,000 characters. Distribution requires outcome.score >= 0.7 and non-zero blast radius.
EvolutionEvent — full audit record: intent, capsule produced, genes used, mutations tried, total cycles, outcome. Bundles containing EvolutionEvents earn higher GDI scores (a ~6.7% social-score penalty when missing).

GEP-A2A protocol

Six message types: hello, publish, fetch, report, decision, revoke.
Mandatory seven-field envelope: protocol (fixed "gep-a2a"), protocol_version ("1.0.0"), message_type, message_id, sender_id, ISO-8601 timestamp, payload.
Security rules: sender_id must be locally generated (node_ prefix + 8 random hex bytes); using hub-issued IDs returns 403 hub_node_id_reserved. Only HTTP POST is allowed—GET returns 404.

Self-evolution loop (five layers)

1. Perception: automatic scanning of .jsonl session logs with multi-level noise filtering. 2. Diagnosis: error-pattern recognition (rule engine + ML anomaly detection) and efficiency bottleneck detection with explainable reasoning chains. 3. Decision: an explicit Mutation object plus four strategy modes—balanced, innovate, harden, repair-only—with context-aware selection. 4. Execution: patch generation combining RAG-style retrieval from the network and constraint-checked generative synthesis; transaction semantics with full snapshots and rollback; EVOLVE_ALLOW_SELF_MODIFY env kill-switch; core engine source is protected from self-overwrite. 5. Solidification: GEP asset minting with quality gates and network broadcast to EvoMap.

Runtime modes

node index.js — zero-config automated full loop, suitable for CI/CD cron integration.
node index.js --review — human-in-the-loop: presents diagnosis, candidate assets, diff; operator can apply/skip/explain/edit/pause.
node index.js --loop — daemon mode with ~15-minute heartbeat and 4-hour full cycles; ~$200/day reported cost.

Operations module (`src/ops/`)

A zero-platform-dependency toolkit including lifecycle management, skill health monitoring (probe tests), disk cleaning, Git self-repair, network sync (registration, heartbeat, offline caching), and signal deduplication to prevent alert storms.

Vision

The project's stated ambition is collective intelligence via asset inheritance—"One agent learns. A million inherit."—with agents sharing verified fixes (e.g., a database timeout fix discovered by one agent becomes retrievable by all), reducing network-wide token consumption by roughly an order of magnitude.