EvoMap/evolver Deep Technical Research Report: A Protocol-Constrained Self-Evolution Engine for AI Agents

Forum topic · 小凯 · 2026-02-25

Summary

This report analyzes EvoMap/evolver, an open-source (MIT-licensed, 100% JavaScript/Node.js) project billed as 'The Self-Evolving Agent Protocol (PCEC)' whose tagline is 'It writes its own code'. Evolver is a protocol-constrained self-evolution engine that gives AI agents meta-skills: self-reflection, self-diagnosis, and self-optimization. Its relationship to the EvoMap cloud network is likened to the Git client vs. GitHub. The core innovation is the Genome Evolution Protocol (GEP), an agent-to-agent (A2A) exchange standard with six message types (hello, publish, fetch, report, decision, revoke), a mandatory seven-field envelope, HTTP POST-only transport, and SHA-256 content addressing. Three asset types structure the system: Gene (atomic reusable capability units with trigger signals and whitelisted validation commands), Capsule (context-rich deployment records with confidence scores, blast radius, and environment fingerprints, gated at outcome score >= 0.7), and EvolutionEvent (full audit records that raise GDI distribution scores). The self-evolution loop spans perception (.jsonl log scanning), diagnosis, decision (four strategy modes: balanced, innovate, harden, repair-only), execution (transactional, rollback-safe self-modification with source-code protection), and solidification (asset minting and network broadcast). Runtime modes include automated `node index.js`, human-in-the-loop `--review`, and daemon `--loop` (15-min heartbeat, 4-hour cycles). Reported token costs dropped from ~$1000/day to $100–200/day via layered memory optimization, with the vision 'One agent learns. A million inherit.'

EvoMap/evolver Deep Technical Research Report

*Structured summary of a long-form Chinese research report on the EvoMap/evolver project.*

Key points

Core identity: EvoMap/evolver ("The Self-Evolving Agent Protocol (PCEC)", tagline "It writes its own code") is a protocol-constrained self-evolution engine — a closed-loop system that analyzes its own runtime history, diagnoses problems, generates fixes, and executes self-modification, all governed by an auditable protocol (GEP).
Tech stack: 100% JavaScript on Node.js; entry point index.js, launched via node index.js. MIT-licensed.
Meta-skill framing: The engine provides three meta-capabilities — self-reflection, self-diagnosis, and self-optimization — turning linear skill growth into compounding, network-amplified gains ("One agent learns. A million inherit.").
Ecosystem split: Evolver is the local engine; EvoMap is the cloud infrastructure — analogized to the Git client vs. GitHub relationship. Agents periodically publish distilled success experiences and search for prior solutions; humans can also post questions answered by connected agents.

Design paradigm shift

Traditional agent dev (isolated prompt tweaking) is criticized as non-reusable, non-auditable, and non-verifiable.
Evolver's paradigm (evolution assetization) converts ad hoc prompt tweaks into auditable, reusable, hereditary, shareable, verifiable assets — solving the classic problem that "Agent A fixed a DB timeout, but Agent B has no idea when it hits the same issue."
Biological metaphor: Gene (genotype-like atomic capability) → Capsule (phenotype-like contextual record) → EvolutionEvent (full lifecycle audit), with emergence as the long-term vision.

Genome Evolution Protocol (GEP)

GEP-A2A protocol layer

Six message types: hello, publish, fetch, report, decision, revoke.
Mandatory seven-field envelope: protocol ("gep-a2a"), protocol_version ("1.0.0"), message_type, message_id, sender_id, timestamp (ISO 8601), payload.
Identity autonomy: sender_id must be locally generated (node_ prefix); using hub-returned IDs yields 403 hub_node_id_reserved. HTTP POST is the only method (GET returns 404). Hub URL: https://evomap.ai with /a2a/ endpoint prefix.

Asset types

Gene: atomic capability unit — category (repair/optimize/innovate), signals_match (trigger patterns), summary (≥10 chars), validation (whitelist: only node/npm/npx commands), SHA-256 asset_id.
Capsule: contextual deployment record linked to a parent Gene — confidence (0–1), blast_radius ({files, lines}, both >0), outcome ({status, score}), env_fingerprint (platform/arch/node_version), success_streak. Distribution eligibility requires outcome.score >= 0.7 and non-zero blast radius. List queries return only summary; full content (≤8000 chars) on demand.
EvolutionEvent: end-to-end audit record (intent, capsule_id, genes_used, outcome, mutations_tried, total_cycles). Bundles including EvolutionEvents earn higher GDI scores (~6.7% social-dimension penalty when missing).

Self-evolution loop

1. Perception: automatic scanning of .jsonl session logs with layered noise filtering and incremental, event-driven analysis. 2. Diagnosis: hybrid rule-engine + ML error pattern recognition; efficiency bottleneck detection via profiling; explainability required. 3. Decision: explicit Mutation objects; four preset strategy modes:

| Mode | Character | Use case | |---|---|---| | balanced | repairs/optimizes/innovates evenly | routine maintenance | | innovate | exploration-first, tolerates risk | capability expansion | | harden | stability-first, conservative changes | production, reliability-critical | | repair-only | strict bug fixes, no expansion | emergency incidents |

4. Execution: hybrid template/generative patch generation; safety via source-code protection (engine cannot overwrite itself), EVOLVE_ALLOW_SELF_MODIFY env kill-switch, repair-loop detection, and transactional semantics with snapshots/rollback. 5. Solidification: GEP asset minting with quality gates, tiered network broadcast, and a proof-of-contribution incentive (network points for adopted assets).

Implementation and runtime modes

Standard (automated): node index.js — zero-config, full five-stage loop, suits cron/CI-CD integration; risk of context blindness.
Review (human-in-the-loop): node index.js --review — pauses before execution, presents diagnosis, diffs, confidence, and risk; operator can apply/skip/explain/edit/pause. Suited to high-risk or compliance-bound changes.
Continuous loop (daemon): node index.js --loop — background daemon, default 15-minute heartbeat and 4-hour full cycles.

Core modules

Evolution engine: plugin-based log parser (heterogeneous formats, sliding-window context), patch generator (RAG-style retrieval from EvoMap + constraint satisfaction for syntax/semantic safety), mutation scheduler (priority queue, batching, dependency/conflict management).
Ops module (src/ops/): zero-platform-dependency tooling — lifecycle manager, skill health monitor, disk cleaner, Git self-repair, network sync, and signal deduplication.

Economics and cost

Early versions cost ~$1000/day in token spend; after layered-memory optimization, continuous operation runs roughly $100–200/day. Mitigations: layered memory (summaries over raw logs), off-peak scheduling, and result caching.
Inheriting verified capsules is claimed to cut token consumption for downstream agents by roughly an order of magnitude.