GEPA Optimization Guide

GEPA (Graph Enhanced Prompting Algorithm) represents a breakthrough in AI agent optimization, offering reflective prompt evolution that can dramatically improve agent performance with minimal training data. This comprehensive guide covers everything you need to know about using GEPA in SuperOptiX.

What is GEPA?

Plain English Explanation

Imagine you have an AI agent that's pretty good at solving math problems, but sometimes makes mistakes or doesn't explain things clearly. Traditional optimization might try thousands of different examples to make it better. GEPA is smarter - it acts like a thoughtful teacher.

GEPA looks at what the agent did wrong, thinks about why it went wrong, and then writes better instructions for the agent. It's like having an expert tutor who can say "I notice you forgot to check your work in algebra problems, so let me give you better guidance on how to approach these step-by-step."

The "graph" part means GEPA builds a family tree of improved instructions, keeping the best ones and building on them to create even better versions.

Technical Summary

GEPA is a reflective prompt optimizer that uses Large Language Models' ability to analyze and critique their own behavior. Unlike traditional optimizers that rely solely on scalar metrics, GEPA leverages textual feedback to drive targeted improvements through:

Reflective Analysis: A reflection LM analyzes agent trajectories to identify specific failure modes and improvement opportunities
Prompt Evolution: New prompt candidates are generated based on reflective insights and domain-specific feedback
Graph Construction: A tree of evolved prompts is built, with Pareto-aware selection preserving improvements
Iterative Refinement: The process repeats, accumulating improvements over multiple generations

Key Innovation: GEPA can utilize domain-specific textual feedback (compiler errors, medical guidelines, security advisories) rather than just numeric scores, enabling more targeted and effective optimization.

Why GEPA is Useful

Sample Efficiency: GEPA often achieves significant improvements with far fewer training examples than traditional methods. Where other optimizers might need hundreds of examples, GEPA can improve performance with just 3-10 well-chosen scenarios.

Domain Adaptability: GEPA excels at incorporating domain-specific knowledge through textual feedback, making it particularly effective for specialized applications like mathematics, medicine, law, and security.

Interpretable Improvements: Unlike black-box optimization, GEPA generates human-readable prompt improvements that you can understand and validate.

Multi-Objective Optimization: GEPA can simultaneously optimize for multiple criteria (accuracy, safety, compliance) through its feedback system.

Research Foundation

GEPA is based on cutting-edge research in prompt optimization and reflective learning:

Original Paper: GEPA: Reflective Prompt Evolution Can Outperform Reinforcement Learning
DSPy Integration: GEPA Tutorial in DSPy Documentation

The research demonstrates that GEPA can outperform reinforcement learning approaches while requiring significantly less computational resources and training data.

🚀 See GEPA in Action

Interactive Demo Repository

For the best hands-on GEPA experience, visit our dedicated demonstration repository:

🔗 GEPA Evaluation Demo

This repository provides: - Interactive demonstrations of GEPA optimization - Before/after comparisons showing dramatic improvements - Multiple hardware tiers (lightweight for 8GB+ RAM, full demo for 16GB+) - Complete working examples across different domains - Step-by-step optimization walkthrough

Quick Demo Commands

Bash

# Clone the demo repository
git clone https://github.com/SuperagenticAI/gepa-eval.git
cd gepa-eval

# Setup (installs models and dependencies)
./scripts/setup.sh

# Lightweight demo (8GB+ RAM, 2-3 minutes)
./scripts/run_light_demo.sh

# Full demo (16GB+ RAM, 5-10 minutes)  
./scripts/run_demo.sh

What you'll see: Watch a basic math agent transform into a sophisticated problem solver with multiple solution methods, verification steps, and pedagogical explanations - all through GEPA's reflective optimization process.

How to Use GEPA in SuperOptiX

Quick Start in SuperOptiX

Once you've explored the demo, integrate GEPA into your SuperOptiX workflows:

Bash

# 1. Pull a GEPA-enabled agent
super agent pull advanced_math_gepa

# 2. Compile the agent
super agent compile advanced_math_gepa

# 3. Test baseline performance
super agent evaluate advanced_math_gepa

# 4. Optimize with GEPA
super agent optimize advanced_math_gepa

# 5. Measure improvement
super agent evaluate advanced_math_gepa

# 6. Use the optimized agent
super agent run advanced_math_gepa --goal "Solve x² + 5x - 6 = 0"

Basic GEPA Configuration

Add GEPA optimization to any agent playbook:

YAML

spec:
  optimization:
    optimizer:
      name: GEPA
      params:
        metric: answer_exact_match    # Evaluation metric
        auto: light                   # Budget: light, medium, heavy
        reflection_lm: qwen3:8b       # Model for reflection
        reflection_minibatch_size: 3  # Examples per reflection
        skip_perfect_score: true      # Skip if already perfect

Domain-Specific GEPA Setup

Mathematics Agent

YAML

optimization:
  optimizer:
    name: GEPA
    params:
      metric: advanced_math_feedback  # Rich mathematical feedback
      auto: light
      reflection_lm: qwen3:8b
      reflection_minibatch_size: 3

Enterprise Document Analysis

YAML

optimization:
  optimizer:
    name: GEPA
    params:
      metric: multi_component_enterprise_feedback  # Multi-aspect evaluation
      auto: light
      reflection_lm: qwen3:8b
      predictor_level_feedback: true              # Component-specific feedback

Security Analysis

YAML

optimization:
  optimizer:
    name: GEPA
    params:
      metric: vulnerability_detection_feedback     # Security-focused feedback
      auto: medium                                # More thorough for security
      reflection_lm: qwen3:8b
      format_failure_feedback: true              # Handle code format issues

Memory-Efficient Configuration

For local deployment with limited resources:

YAML

spec:
  language_model:
    location: local
    provider: ollama
    model: llama3.1:8b        # Main model (~8GB)
    temperature: 0.1
  optimization:
    optimizer:
      name: GEPA
      params:
        metric: answer_exact_match
        auto: light             # Conservative budget
        reflection_lm: qwen3:8b # Different model (~8GB)
        reflection_minibatch_size: 3

Total Memory Usage: ~16GB for both models, leaving plenty of headroom on a 128GB system.

Best Practices

1. Start with Light Budget

YAML

# Begin conservatively
auto: light  # 3-5 minutes, ~400 metric calls

# Increase if results justify cost
auto: medium  # 8-12 minutes, ~800 metric calls
auto: heavy   # 15-30 minutes, ~1600 metric calls

2. Choose Appropriate Metrics

YAML

# For math problems
metric: advanced_math_feedback

# For document analysis
metric: multi_component_enterprise_feedback

# For privacy-sensitive tasks
metric: privacy_preservation_feedback

# For security analysis
metric: vulnerability_detection_feedback

3. Use Quality Training Scenarios

YAML

feature_specifications:
  scenarios:
    - name: comprehensive_test
      description: Cover main patterns and edge cases
      input:
        problem: "Well-defined, realistic problem"
      expected_output:
        answer: "Complete expected response with reasoning"

4. Diverse Reflection Models

Use different models for main processing and reflection to get diverse perspectives:

YAML

spec:
  language_model:
    model: llama3.1:8b  # Main processing
  optimization:
    optimizer:
      reflection_lm: qwen3:8b  # Different architecture for reflection

GEPA in Action

Case Study 1: Mathematics Problem Solving

Agent: Advanced Math Solver Domain: Quadratic equations and geometric problems Training Data: 5 BDD scenarios

Before GEPA Optimization

Text Only

Input: "Solve x² - 5x + 6 = 0"
Output: "Using the quadratic formula: x = 2 or x = 3"

After GEPA Optimization

Text Only

Input: "Solve x² - 5x + 6 = 0"
Output: "**Method 1: Factoring**
Step 1: Look for two numbers that multiply to 6 and add to -5
These numbers are -2 and -3
Factor: (x - 2)(x - 3) = 0
Solutions: x = 2 or x = 3

**Method 2: Quadratic Formula**
For ax² + bx + c = 0, x = (-b ± √(b²-4ac)) / 2a
Here: a=1, b=-5, c=6
x = (5 ± √(25-24)) / 2 = (5 ± 1) / 2
x = 3 or x = 2

**Verification:**
x = 2: (2)² - 5(2) + 6 = 4 - 10 + 6 = 0 ✓
x = 3: (3)² - 5(3) + 6 = 9 - 15 + 6 = 0 ✓"

Results: - Baseline accuracy: 60% - Post-GEPA accuracy: 95% - Added multiple solution methods - Included verification steps - Better pedagogical structure

GEPA Configuration Used

YAML

optimization:
  optimizer:
    name: GEPA
    params:
      metric: advanced_math_feedback
      auto: light
      reflection_lm: qwen3:8b
      reflection_minibatch_size: 3

Case Study 2: Enterprise Document Analysis

Agent: Enterprise Information Extractor Domain: Business email classification and risk assessment Training Data: 5 multi-component scenarios

Before GEPA Optimization

Text Only

Input: "URGENT: Water leak in server room affecting infrastructure"
Output: "This appears to be urgent. Categories: maintenance"

After GEPA Optimization

Text Only

Input: "URGENT: Water leak in server room affecting infrastructure"
Output: 
"Urgency: Critical - Infrastructure threat requiring immediate response
Sentiment: Negative - Emergency situation with potential damage
Categories: facility_maintenance, infrastructure_emergency, critical_systems
Entities: server room, water leak, infrastructure
Action Items: 1) Contact facilities immediately 2) Assess electrical safety 3) Implement water damage prevention
Risk Assessment: High risk to critical systems, potential for extended outage, electrical safety concerns"

Results: - Component accuracy improved from 45% to 85% - Added comprehensive multi-aspect analysis - Better entity extraction - More detailed risk assessment

Case Study 3: Security Vulnerability Detection

Agent: Security Code Analyzer Domain: Web application security analysis Training Data: 5 vulnerability scenarios

Before GEPA Optimization

Text Only

Input: "query = 'SELECT * FROM users WHERE name = ' + username"
Output: "This code has a security issue with SQL injection"

After GEPA Optimization

Text Only

Input: "query = 'SELECT * FROM users WHERE name = ' + username"
Output:
"Vulnerabilities: Critical - SQL Injection vulnerability in user lookup
Risk Assessment: Critical severity - allows arbitrary database access, data exfiltration, and potential system compromise
Remediation Plan: 
1. Immediate: Replace with parameterized queries using prepared statements
2. Add input validation and sanitization
3. Implement least-privilege database access controls
4. Add SQL injection detection monitoring
Security Score: 2/10 - Critical vulnerability requiring immediate attention
Compliance Status: Fails OWASP Top 10 - Injection (A03:2021)"

Results: - Vulnerability detection improved from 70% to 95% - Added detailed remediation guidance - Included compliance framework references - Better risk severity assessment

Code Example: Custom GEPA Integration

Python

# Custom GEPA configuration in agent pipeline
from superoptix.core.optimizer_factory import DSPyOptimizerFactory

# Create GEPA optimizer with custom feedback
optimizer = DSPyOptimizerFactory.create_optimizer(
    optimizer_name="GEPA",
    params={
        "metric": "advanced_math_feedback",  # Custom feedback metric
        "auto": "light",                     # Conservative budget
        "reflection_lm": "qwen3:8b",        # Reflection model
        "reflection_minibatch_size": 3,
        "skip_perfect_score": True
    },
    lm_config={
        "model": "llama3.1:8b",
        "provider": "ollama",
        "temperature": 0.1
    }
)

# Optimize the agent pipeline
optimized_pipeline = optimizer.compile(
    student=base_pipeline,
    trainset=training_examples
)

GEPA vs. SIMBA

Aspect	GEPA	SIMBA
Approach	Reflective prompt evolution	Stochastic introspective optimization
Feedback Type	Rich textual feedback + metrics	Primarily metric-based
Sample Efficiency	High (3-10 examples often sufficient)	Medium (requires more examples)
Domain Adaptability	Excellent (domain-specific feedback)	Good (general optimization)
Interpretability	High (readable prompt improvements)	Medium (statistical improvements)
Setup Complexity	Medium (requires reflection LM)	Low (standard configuration)
Memory Usage	Higher (two models)	Lower (single model)
Optimization Time	Medium (3-5 min light budget)	Fast (1-2 min)
Multi-Objective	Native support	Limited support
Best For	Specialized domains, quality focus	General optimization, speed focus
Reflection Capability	Built-in	None
Prompt Quality	Often generates sophisticated prompts	Improves existing prompts

When to Choose GEPA

Choose GEPA when: - Working in specialized domains (math, medicine, law, security) - Quality is more important than speed - You have domain-specific feedback requirements - You want interpretable improvements - You need multi-objective optimization - You have limited training data

Choose SIMBA when: - You need fast optimization cycles - Working with general-purpose agents - Memory constraints are tight - You have large amounts of training data - Simple metric optimization is sufficient

Performance Comparison

Based on SuperOptiX benchmarks:

Domain	GEPA (light)	SIMBA	GEPA Advantage
Mathematics	85% → 95%	85% → 90%	+5% accuracy
Document Analysis	45% → 85%	45% → 70%	+15% accuracy
Security Analysis	70% → 95%	70% → 80%	+15% accuracy
General Q&A	80% → 88%	80% → 85%	+3% accuracy

Understanding GEPA Behavior

Normal GEPA Logs

During optimization, you'll see progress indicators:

Text Only

INFO dspy.teleprompt.gepa.gepa: Running GEPA for approx 400 metric calls
INFO dspy.evaluate.evaluate: Average Metric: 2.0 / 5 (40.0%)
INFO dspy.teleprompt.gepa.gepa: Iteration 0: Base program full valset score: 0.4
INFO dspy.teleprompt.gepa.gepa: Iteration 1: Selected program 0 score: 0.4
INFO dspy.evaluate.evaluate: Average Metric: 3.0 / 3 (100.0%)
INFO dspy.teleprompt.gepa.gepa: Iteration 2: Proposed new text for predictor

What this means: - ✅ GEPA allocated 400 metric calls for optimization - ✅ Started with 40% baseline performance - ✅ Making iterative improvements - ✅ Achieved 100% on subset evaluation - ✅ Generating new prompt candidates

GEPA Timeout Behavior

GEPA optimization often exceeds 2-minute command timeouts:

Text Only

Error: Command timed out after 2m 0.0s
INFO dspy.teleprompt.gepa.gepa: Running GEPA for approx 400 metric calls

This is normal behavior because:

Quality Focus: GEPA prioritizes finding better prompts over speed
Reflection Process: Multiple LLM calls for analysis and generation
Iterative Improvement: Several optimization cycles to build prompt tree
Typical Duration: 3-5 minutes for light budget, 8-12 for medium

Solutions:

Bash

# Increase timeout
super agent optimize your_agent --timeout 300  # 5 minutes

# Run in background
super agent optimize your_agent &

# Use lighter budget
# Edit playbook: max_full_evals: 3 instead of auto: light

Signs of Successful GEPA Optimization

Positive Indicators: - Score improvements in logs (40% → 100%) - Multiple iteration cycles - "Proposed new text for predictor" messages - Increasingly sophisticated generated prompts

Warning Signs: - Scores stuck at 0% (metric configuration issue) - No iteration progress - Reflection LM errors - Memory allocation failures

Recommendations and Caveats

Recommendations

1. Start Small and Scale

Bash

# Begin with light budget
super agent optimize your_agent  # auto: light

# If promising, increase investment
# Edit playbook to auto: medium, then recompile and optimize

2. Use Local Models for Cost Control

YAML

spec:
  language_model:
    location: local
    provider: ollama
    model: llama3.1:8b  # Free local optimization

3. Invest in Quality Training Data

YAML

feature_specifications:
  scenarios:
    - name: comprehensive_scenario
      description: Real-world edge cases and common patterns
      input:
        problem: "Complex but realistic problem"
      expected_output:
        answer: "Complete expected response"
        reasoning: "Step-by-step explanation"

4. Monitor and Validate Results

Bash

# Always measure improvement
super agent evaluate your_agent  # Before optimization
super agent optimize your_agent
super agent evaluate your_agent  # After optimization - compare results

5. Use Domain-Appropriate Metrics

YAML

# Mathematics
metric: advanced_math_feedback

# Business documents
metric: multi_component_enterprise_feedback

# Security analysis
metric: vulnerability_detection_feedback

Caveats and Limitations

1. Higher Resource Requirements

Memory: Requires two models (main + reflection)
Time: Longer optimization cycles than traditional methods
Compute: More intensive than simple few-shot optimization

2. Configuration Complexity

Requires choosing appropriate reflection model
Need domain-specific metrics for best results
Budget tuning requires experience

3. Not Always Superior

For simple tasks, traditional optimization may be sufficient
General-purpose agents may not benefit as much
Very large datasets might favor other approaches

4. Model Dependency

Quality depends heavily on reflection model capability
Some local models may not provide good reflection
Cloud models increase costs significantly

5. Debugging Complexity

More complex optimization process to debug
Harder to isolate issues between main and reflection models
Requires understanding of GEPA's iterative process

When NOT to Use GEPA

Avoid GEPA when: - Working with very simple agents that already perform well - Tight memory constraints (< 16GB available) - Need immediate optimization results - Working with very large training datasets (>100 examples) - Budget constraints require minimal resource usage - Traditional optimization already achieves requirements - Using ReAct agents with tool calling (Genies tier and above)

⚠️ GEPA and Tool-Calling Agents

Important Limitation: GEPA is not compatible with ReAct agents that use tool calling (Genies tier and above). This includes:

Genies Tier Agents: ReAct + Tools + Memory
Protocols Tier Agents: Advanced multi-agent systems
Any agent with tool integration

Why GEPA doesn't work with tool-calling agents:

Complex Output Format: ReAct agents produce structured outputs with tool calls, reasoning steps, and observations that don't match GEPA's expected simple text format
Tool Call Parsing: GEPA's evaluation metrics expect simple string outputs, but ReAct produces complex multi-step trajectories
Trajectory Complexity: GEPA analyzes reasoning trajectories, but tool-enhanced ReAct has much more complex multi-step workflows
Format Failure Issues: Tool responses often break GEPA's response parsing expectations

Error Symptoms:

Text Only

WARNING: Failed to unpack prediction and trace. This is likely due to the LLM response not following dspy formatting.
INFO: No trajectories captured. Skipping.
Average Metric: 0.0 / 5 (0.0%)

Better Optimizers for Tool-Calling Agents:

For Genies tier agents with tools, use these optimizers instead:

YAML

# Recommended for tool-calling agents
optimization:
  optimizer:
    name: BootstrapFewShot  # Default, works well with ReAct+tools
    params:
      metric: answer_exact_match
      max_bootstrapped_demos: 4
      max_rounds: 1

YAML

# Alternative: SIMBA for complex reasoning
optimization:
  optimizer:
    name: SIMBA
    params:
      metric: answer_exact_match
      bsize: 4
      num_candidates: 2
      max_steps: 3

YAML

# Alternative: BetterTogether for robust performance
optimization:
  optimizer:
    name: BetterTogether
    params:
      metric: answer_exact_match
      max_bootstrapped_demos: 3
      max_labeled_demos: 12

Agent Tier Compatibility:

Tier	Tool Support	GEPA Compatible	Recommended Optimizer
Oracles	No tools	✅ Yes	GEPA (excellent)
Genies	ReAct + Tools	❌ No	BootstrapFewShot, SIMBA
Protocols	Advanced tools	❌ No	BetterTogether, MIPROv2
Superagents	Complex tools	❌ No	SIMBA, MIPROv2

Summary: Use GEPA for Oracle-tier agents (simple reasoning without tools). For Genies tier and above (with tool calling), use BootstrapFewShot, SIMBA, or BetterTogether optimizers instead.

Cost Considerations

GEPA Resource Usage:

Budget	Time	Memory	Local Cost	Cloud Cost (est.)
Light	3-5 min	~16GB	Free	$2-5
Medium	8-12 min	~16GB	Free	$8-15
Heavy	15-30 min	~16GB	Free	$20-40

Cost Control Strategies: 1. Use local models for optimization 2. Start with light budgets 3. Optimize incrementally 4. Share optimized weights across team (commit *_optimized.json)

Getting Started with GEPA

Prerequisites

SuperOptiX installation with GEPA support
Local models: llama3.1:8b and qwen3:8b
At least 16GB available memory
3-5 quality BDD scenarios for training

Your First GEPA Optimization

Bash

# 1. Create or pull a GEPA-ready agent
super agent pull advanced_math_gepa

# 2. Compile and establish baseline
super agent compile advanced_math_gepa
super agent evaluate advanced_math_gepa

# 3. Run GEPA optimization
super agent optimize advanced_math_gepa

# 4. Validate improvements
super agent evaluate advanced_math_gepa

# 5. Test the optimized agent
super agent run advanced_math_gepa --goal "Solve 2x² + 3x - 5 = 0"

Available GEPA Agents

SuperOptiX provides pre-configured GEPA agents across multiple domains. Each agent is optimized for specific use cases and comes with domain-specific feedback metrics.

🧮 Mathematics & Analytics

Advanced Math GEPA Solver

Agent ID: advanced_math_gepa Domain: Advanced mathematical problem solving Specializes in: Quadratic equations, calculus, geometry, algebraic reasoning

Bash

# Quick start with math problems
super agent pull advanced_math_gepa
super agent compile advanced_math_gepa
super agent optimize advanced_math_gepa
super agent run advanced_math_gepa --goal "Find the derivative of x³ + 2x² - 5x + 1"

Key Features: - Step-by-step solution methodology - Multiple solution approaches - Verification and checking - Mathematical notation support - Educational explanations

Data Science GEPA

Agent ID: data_science_gepa Domain: Statistical analysis and machine learning Specializes in: Data analysis, statistical inference, ML insights, hypothesis testing

Bash

# Start with data science problems
super agent pull data_science_gepa
super agent compile data_science_gepa
super agent optimize data_science_gepa
super agent run data_science_gepa --goal "Analyze correlation between customer age and purchase behavior"

Key Features: - Statistical methodology validation - Data visualization recommendations - Hypothesis testing frameworks - ML model selection guidance - Scientific rigor validation

🏥 Healthcare & Medical

Medical Assistant GEPA

Agent ID: medical_assistant_gepa Domain: Clinical decision support and medical information Specializes in: Medical knowledge synthesis, patient education, clinical reasoning

Bash

# Medical information assistance
super agent pull medical_assistant_gepa
super agent compile medical_assistant_gepa
super agent optimize medical_assistant_gepa
super agent run medical_assistant_gepa --goal "Explain hypertension treatment options"

Key Features: - Safety-focused medical information - Evidence-based recommendations - Patient education materials - Clinical decision support - Medical terminology accuracy

⚖️ Legal & Compliance

Contract Analyzer GEPA

Agent ID: contract_analyzer_gepa Domain: Legal contract analysis and risk assessment Specializes in: Contract review, risk identification, compliance verification

Bash

# Legal contract analysis
super agent pull contract_analyzer_gepa
super agent compile contract_analyzer_gepa
super agent optimize contract_analyzer_gepa
super agent run contract_analyzer_gepa --goal "Review this software license agreement for compliance risks"

Key Features: - Legal risk assessment - Compliance verification - Contract clause analysis - Regulatory framework alignment - Risk mitigation strategies

💼 Enterprise & Finance

Enterprise Extractor GEPA

Agent ID: enterprise_extractor_gepa Domain: Enterprise document processing and information extraction Specializes in: Multi-component analysis, structured data extraction, business intelligence

Bash

# Enterprise document processing
super agent pull enterprise_extractor_gepa
super agent compile enterprise_extractor_gepa
super agent optimize enterprise_extractor_gepa
super agent run enterprise_extractor_gepa --goal "Extract key metrics from this quarterly business report"

Key Features: - Multi-aspect document analysis - Structured information extraction - Business intelligence insights - Risk assessment integration - Executive summary generation

🔒 Security & Privacy

Security Analyzer GEPA

Agent ID: security_analyzer_gepa Domain: Security vulnerability detection and code analysis Specializes in: Vulnerability detection, secure coding practices, security assessment

Bash

# Security code analysis
super agent pull security_analyzer_gepa
super agent compile security_analyzer_gepa
super agent optimize security_analyzer_gepa
super agent run security_analyzer_gepa --goal "Analyze this code for security vulnerabilities"

Key Features: - Vulnerability detection - Security best practices - Remediation guidance - Compliance framework alignment - Risk severity assessment

Privacy Delegate GEPA

Agent ID: privacy_delegate_gepa Domain: Privacy-preserving task delegation and data handling Specializes in: Data anonymization, privacy compliance, secure information handling

Bash

# Privacy-conscious task delegation
super agent pull privacy_delegate_gepa
super agent compile privacy_delegate_gepa
super agent optimize privacy_delegate_gepa
super agent run privacy_delegate_gepa --goal "Process customer data while maintaining GDPR compliance"

Key Features: - Privacy preservation techniques - Data anonymization strategies - Regulatory compliance (GDPR, CCPA) - Secure delegation workflows - Privacy risk assessment

🛠️ Development & Demonstration

GEPA Demo

Agent ID: gepa_demo Domain: GEPA optimizer demonstration and learning Specializes in: Showcasing GEPA capabilities, optimization examples, learning scenarios

Bash

# Learn GEPA optimization
super agent pull gepa_demo
super agent compile gepa_demo
super agent optimize gepa_demo
super agent run gepa_demo --goal "Demonstrate GEPA's reflective optimization capabilities"

Key Features: - GEPA optimization showcase - Before/after comparisons - Learning examples - Optimization metrics demonstration - Best practices illustration

Domain-Specific Quick Start Commands

For Mathematics Problems

Bash

# Advanced mathematical reasoning
super agent pull advanced_math_gepa
super agent compile advanced_math_gepa
super agent optimize advanced_math_gepa --timeout 300
super agent run advanced_math_gepa --goal "Solve the system: 2x + 3y = 12, x - y = 1"

For Business Analysis

Bash

# Enterprise document processing
super agent pull enterprise_extractor_gepa
super agent compile enterprise_extractor_gepa
super agent optimize enterprise_extractor_gepa --timeout 300
super agent run enterprise_extractor_gepa --goal "Analyze quarterly revenue trends and identify growth opportunities"

For Security Assessment

Bash

# Security vulnerability analysis
super agent pull security_analyzer_gepa
super agent compile security_analyzer_gepa
super agent optimize security_analyzer_gepa --timeout 300
super agent run security_analyzer_gepa --goal "Review authentication implementation for security vulnerabilities"

For Medical Information

Bash

# Clinical decision support
super agent pull medical_assistant_gepa
super agent compile medical_assistant_gepa
super agent optimize medical_assistant_gepa --timeout 300
super agent run medical_assistant_gepa --goal "Explain diabetes management strategies for elderly patients"

For Legal Analysis

Bash

# Contract and legal document review
super agent pull contract_analyzer_gepa
super agent compile contract_analyzer_gepa
super agent optimize contract_analyzer_gepa --timeout 300
super agent run contract_analyzer_gepa --goal "Review employment contract for compliance with labor laws"

For Data Science

Bash

# Statistical analysis and ML insights
super agent pull data_science_gepa
super agent compile data_science_gepa
super agent optimize data_science_gepa --timeout 300
super agent run data_science_gepa --goal "Design A/B test for mobile app feature rollout"

For Privacy-Sensitive Tasks

Bash

# Privacy-preserving data processing
super agent pull privacy_delegate_gepa
super agent compile privacy_delegate_gepa
super agent optimize privacy_delegate_gepa --timeout 300
super agent run privacy_delegate_gepa --goal "Process user analytics while maintaining privacy compliance"

Optimization Guide - General optimization techniques and strategies
Agent Development Guide - Complete agent development workflow
Evaluation & Testing Guide - Testing methodologies and metrics
GEPA Integration Examples - Practical implementation examples
Technical Architecture - System architecture and components