Skip to content

agentralabs/agentic-evolve

AgenticEvolve hero

crates.io Tests Multi-client

cargo install MCP Server MIT License 22 Capabilities .evolve format

The Library That Remembers How to Build

Pattern crystallization for AI agents -- verified code patterns stored, matched, and composed so the hundredth build takes seconds, not minutes.

Quickstart · Problems Solved · How It Works · Capabilities · MCP Tools · Benchmarks · Install · API · Concepts


Sister in the Agentra ecosystem | .evolve format | 22 Capabilities | 14 MCP Tools | 38 CLI Commands

AgenticEvolve terminal demo

Why AgenticEvolve

Every AI agent writes the same code from scratch every time. It generates a REST handler for the tenth time as if it has never seen one before. It writes the same error handling boilerplate, the same pagination logic, the same auth middleware -- from zero, every time, with no memory of what worked before.

The current fixes do not work. Template engines produce rigid output that breaks when requirements deviate. Snippet libraries store text, not patterns -- they cannot adapt to new variable names, types, or structures. Fine-tuning is expensive, slow, and locked to one model.

Current AI: Cold start on every build. No reuse. No learning. No acceleration. AgenticEvolve: Crystallizes verified patterns from successful builds and matches them to new contexts, so the first build takes a minute and the hundredth takes fifteen seconds.

Quickstart

cargo install agentic-evolve-cli
evolve --help

Problems Solved (Read This First)

  • Problem: AI agents regenerate identical patterns from scratch on every project. Solved: pattern crystallization extracts reusable patterns from verified code, indexed by signature, domain, and context -- the agent remembers what worked.
  • Problem: there is no confidence signal for generated code quality. Solved: every pattern tracks success rate, usage frequency, and decay score -- the agent knows which patterns are battle-tested and which are speculative.
  • Problem: code reuse requires exact matches, which rarely happen across projects. Solved: four matching strategies (signature, context, semantic, fuzzy) find applicable patterns even when variable names, types, and structures differ.
  • Problem: combining multiple patterns into coherent code is manual and error-prone. Solved: pattern composition with gap filling and adapter generation assembles multiple patterns into working code with consistent types and interfaces.
  • Problem: pattern libraries grow stale as languages and frameworks evolve. Solved: decay management and promotion engines automatically deprecate unused patterns and elevate frequently successful ones.
# Crystallize what works, reuse what is proven -- three commands
evolve crystallize --file src/handlers/user.rs --function create_user
evolve match signature "pub async fn create_user(input: CreateUserInput) -> Result<User>"
evolve compose --patterns p1,p2,p3 --output src/handlers/task.rs

How It Works

AgenticEvolve architecture

Architecture Overview

+-------------------------------------------------------------+
|                     YOUR AI AGENT                           |
|           (Claude, Cursor, Windsurf, Cody)                  |
+----------------------------+--------------------------------+
                             |
                  +----------v----------+
                  |      MCP LAYER      |
                  |   14 Tools + stdio  |
                  +----------+----------+
                             |
+----------------------------v--------------------------------+
|                   EVOLVE ENGINE                              |
+-----------+-----------+------------+-----------+------------+
| Matching  | Crystal-  | Composition| Collective| Token      |
| (4 types) | lization  | Engine     | Learning  | Conservation|
+-----------+-----------+------------+-----------+------------+
                             |
                  +----------v----------+
                  |    .evolve FILE     |
                  | (pattern library)   |
                  +---------------------+

22 Capabilities

Tier Capabilities Focus
T1: Storage Pattern Store, Pattern Index, Pattern Versioner, Pattern Validator How are patterns stored?
T2: Matching Signature Matcher, Context Matcher, Semantic Matcher, Fuzzy Matcher How are patterns found?
T3: Crystallization Pattern Extractor, Variable Detector, Template Generator, Confidence Calculator How are patterns created?
T4: Composition Pattern Composer, Gap Filler, Adapter Generator, Integration Weaver How are patterns combined?
T5: Collective Usage Tracker, Success Tracker, Decay Manager, Promotion Engine How do patterns evolve?
T6: Optimization Pattern Optimizer, Cache Manager How is performance maintained?

Benchmarks

AgenticEvolve benchmarks


Install

git clone https://github.com/agentralabs/agentic-evolve.git
cd agentic-evolve
cargo install --path crates/agentic-evolve-cli
curl -fsSL https://agentralabs.tech/install/evolve | bash
cargo install agentic-evolve-cli
cargo install agentic-evolve-mcp
pip install aevolve-installer && aevolve-install install --auto
npm install @agenticamem/evolve

Standalone guarantee: AgenticEvolve operates fully standalone. No other sister, external service, or orchestrator is required.


License

MIT -- see LICENSE.

About

Pattern library engine for AI agents — crystallizes verified code patterns for instant rebuilds, 15-second subsequent builds. Rust core + MCP server.

Topics

Resources

License

Code of conduct

Contributing

Security policy

Stars

Watchers

Forks

Releases

No releases published

Packages

 
 
 

Contributors

Languages