leafmesh 2.4.30

LeafMesh — YAML-native multi-agent orchestration platform

LeafMesh — Multi-Agent AI Orchestration Platform

YAML-native multi-agent AI platform with self-healing and evolutionary capabilities

LeafMesh transforms multi-agent AI development through declarative YAML configuration that becomes executable intelligence. Built on the MANAGED_MESH architecture with production-ready coordination and persistence.

Core Features

• YAML-Native Intelligence - Zero-code agent creation with AST-parsed configuration
• Built-in Coordination - Manager and Summarizer agents provide automatic oversight
• MANAGED_MESH Architecture - Direct agent communication with conditional routing
• Redis-Powered Persistence - Automatic session management and conversation history
• Enterprise Tool Ecosystem - 15+ built-in tools with OpenAI-compatible function calling
• Advanced Parallel Processing - Multi-session threading with intelligent coordination

Production Features

• Self-Healing Networks - 6 autonomous healing actions with failure detection
• Evolutionary Optimization - Genetic algorithms with real fitness testing
• Adaptive Model Intelligence - ML-powered model selection with performance prediction

---

Quick Start

1. Installation

pip install leafmesh

2. Environment Setup

# Required: OpenAI API key
export OPENAI_API_KEY="your-openai-key"

# Optional: Additional providers
export ANTHROPIC_API_KEY="your-anthropic-key"
export GOOGLE_API_KEY="your-google-key"

3. Redis Setup

Local Redis:

# macOS
brew install redis && brew services start redis

# Ubuntu/Debian
sudo apt install redis-server && sudo systemctl start redis

# Docker
docker run -d -p 6379:6379 redis:alpine

4. Basic Usage

from leafmesh import LeafMesh

# Initialize from YAML configuration
sdk = LeafMesh.from_yaml("config.yaml")

# Start the mesh
await sdk.start()

# Process requests
response = await sdk.process_request(
    session_id="user_session",
    input_data={"message": "Hello, how can you help me?"}
)

print(response)

Example YAML Configuration:

name: "my_mesh"
architecture: "managed_mesh"

# Built-in coordination
manager:
  enabled: true
  model: "gpt-4o"

summarizer:
  enabled: true
  model: "gpt-4o-mini"

# User-defined agents
agents:
  conversation_agent:
    name: "conversation_agent"
    model: "gpt-4o-mini"
    prompt: "You are a helpful AI assistant."
    yields:
      response: "string"
      confidence: "number"
    tools: ["calculator", "current_time"]

---

Architecture Overview

LeafMesh implements a MANAGED_MESH architecture with:

• LLM Agents - YAML-defined with optional Python enhancement
• Manager Agent - Built-in coordination and rule enforcement
• Summarizer Agent - Omnipresent monitoring and analysis
• Redis Persistence - Automatic session and conversation storage
• Event System - All communication flows through events
• Tool System - OpenAI-compatible function calling

For detailed architecture information, see docs/ARCHITECTURE.md

---

Agent Enhancement

Add Python logic to YAML-defined agents:

@sdk.intelligence("conversation_agent")
async def enhance_conversation(llm_response, input_data, context):
    """Add business logic to agent responses"""

    # Access conversation history
    history = context.get("conversation_history", [])

    # Enhance the LLM response
    enhanced_response = add_context(llm_response, history)

    # Trigger other agents conditionally
    if needs_specialist(enhanced_response):
        await sdk.trigger_agents(data={"analysis": enhanced_response})

    return {
        "response": enhanced_response,
        "confidence": calculate_confidence(enhanced_response)
    }

---

Revolutionary Features

Self-Healing Networks

# Enable automatic failure recovery
await sdk.enable_self_healing()

# Monitor agent health
health = await sdk.get_agent_health_status()
stats = await sdk.get_healing_statistics()

Evolutionary Optimization

# Optimize mesh configuration automatically
test_scenarios = [
    {"input": "Test case 1", "agents": ["conversation_agent"]},
    {"input": "Test case 2", "agents": ["technical_agent"]}
]

best_genome = await sdk.evolve_swarm_architecture(test_scenarios)
await sdk.apply_evolved_configuration()

Adaptive Model Selection

# Automatic model selection based on request characteristics
response = await sdk.adaptive_execute(
    prompt="Analyze this complex scenario",
    preferred_models=["gpt-4o", "claude-3.5-sonnet"]
)

---

Documentation

• Architecture Guide - Technical implementation details
• Debugging Guide - Troubleshooting and monitoring
• Getting Started - Run create-leafmesh my-project to scaffold a complete example project

---

Use Cases

LeafMesh excels at:

• Customer Service Systems - Multi-tier workflows with self-healing
• Data Analysis Pipelines - Collaborative analytical workflows
• Content Creation - Coordinated writing and editing
• Decision Support - Complex decision-making with oversight
• Workflow Automation - Business process automation

---

Framework Comparison

Feature	LeafMesh	LangGraph	CrewAI	AutoGen
YAML Configuration	Primary	Code-based	Code-based	Code-based
Built-in Coordination	Manager/Summarizer	Manual	Manual	Manual
Auto-Persistence	Redis	Manual	Manual	Manual
Self-Healing	Production	None	None	None
Evolutionary Optimization	Genetic Algorithm	None	None	None

---

Licensing

LeafMesh is commercial software owned by LeafCraft.

• Evaluation: 30-day free evaluation for research/development
• Commercial: Requires valid commercial license for revenue-generating use
• Enterprise: Custom enterprise licensing available

Licensing: [e-mail]

---

Getting Started

1. Install LeafMesh and set up Redis
2. Create your first YAML configuration with basic agents
3. Add Python enhancements for custom logic
4. Enable revolutionary features for production

LeafMesh: Production-ready multi-agent AI with YAML-driven simplicity

---

Copyright 2025 LeafCraft. All rights reserved.