Evaluator-Optimizer Loop: Continuous AI Agent Improvement

Here's a dirty secret about AI agents: their first output is rarely good enough. But most agents just ship it anyway.

The Evaluator-Optimizer Loop fixes this. It's a pattern where one component evaluates the output and another component improves it based on that evaluation. Repeat until quality meets the bar.

This is how you build agents that consistently produce high-quality outputs, not just occasionally good ones.

What Is the Evaluator-Optimizer Loop?

The pattern separates evaluation from generation:

text

1	┌─────────────────────────────────────────────────────────────┐
2	│ Evaluator-Optimizer Loop │
3	├─────────────────────────────────────────────────────────────┤
4	│ │
5	│ ┌───────────────┐ │
6	│ │ Generator │──────────────┐ │
7	│ │ │ │ │
8	│ │ Creates │ ▼ │
9	│ │ initial │ ┌───────────────┐ │
10	│ │ output │ │ Evaluator │ │
11	│ └───────────────┘ │ │ │
12	│ ▲ │ Scores output │ │
13	│ │ │ Finds issues │ │
14	│ │ └───────┬───────┘ │
15	│ │ │ │
16	│ │ ▼ │
17	│ │ ┌───────────────┐ │
18	│ │ No │ Good enough? │ │
19	│ │ ┌───────┤ │ │
20	│ │ │ └───────┬───────┘ │
21	│ │ │ │ Yes │
22	│ ┌──────┴─────┐ │ ▼ │
23	│ │ Optimizer │◄──┘ ┌───────────┐ │
24	│ │ │ │ Output │ │
25	│ │ Fixes │ └───────────┘ │
26	│ │ issues │ │
27	│ └────────────┘ │
28	│ │
29	└─────────────────────────────────────────────────────────────┘
30

Three components work together:

Generator: Creates the initial output
Evaluator: Scores the output and identifies issues
Optimizer: Improves the output based on feedback

The loop continues until the evaluator says "good enough" or max iterations are reached.

Why This Pattern Works

1. Separation of Concerns

Generation and evaluation are different cognitive tasks. Separating them lets each component focus:

python

1	# Generator mindset: "Create something that works"
2	# Evaluator mindset: "Find everything wrong with this"
3	# Optimizer mindset: "Fix these specific issues"
4

An LLM trying to do all three at once often compromises on each.

2. Explicit Quality Gates

Instead of hoping output is good, you define what "good" means:

python

quality_criteria = {
    "accuracy": "All facts must be verifiable",
    "completeness": "Must address all parts of the question",
    "clarity": "A non-expert should understand",
    "conciseness": "No unnecessary content"
}
 

The evaluator checks each criterion explicitly.

3. Guaranteed Improvement

Each iteration addresses specific issues. Progress is measurable:

text

Iteration 1: Score 6/10 - Issues: missing examples, too technical
Iteration 2: Score 8/10 - Issues: one factual error
Iteration 3: Score 9/10 - Issues: none critical
→ Output accepted
 

Basic Implementation

Here's a complete evaluator-optimizer loop:

python

import openai
import json
from dataclasses import dataclass
 
@dataclass
class Evaluation:
    score: float  # 0-10
    passed: bool
    issues: list[str]
    suggestions: list[str]
 
class EvaluatorOptimizerAgent:
    def __init__(self, min_score: float = 8.0, max_iterations: int = 5):
        self.client = openai.OpenAI()
        self.min_score = min_score
        self.max_iterations = max_iterations
    
    def run(self, task: str) -> dict:
        """Generate, evaluate, and optimize until quality threshold met"""
        
        # Initial generation
        output = self._generate(task)
        iterations = []
        
        for i in range(self.max_iterations):
            # Evaluate current output
            evaluation = self._evaluate(task, output)
            
            iterations.append({
                "iteration": i + 1,
                "output_preview": output[:200],
                "score": evaluation.score,
                "issues": evaluation.issues
            })
            
            # Check if good enough
            if evaluation.passed:
                return {
                    "success": True,
                    "output": output,
                    "final_score": evaluation.score,
                    "iterations": len(iterations),
                    "history": iterations
                }
            
            # Optimize based on feedback
            output = self._optimize(task, output, evaluation)
        
        # Max iterations reached
        return {
            "success": False,
            "output": output,
            "final_score": evaluation.score,
            "iterations": len(iterations),
            "history": iterations,
            "note": "Max iterations reached"
        }
    
    def _generate(self, task: str) -> str:
        """Initial generation"""
        response = self.client.chat.completions.create(
            model="gpt-4o",
            messages=[{
                "role": "system",
                "content": "Generate a high-quality response to the task."
            }, {
                "role": "user",
                "content": task
            }]
        )
        return response.choices[0].message.content
    
    def _evaluate(self, task: str, output: str) -> Evaluation:
        """Evaluate the output quality"""
        response = self.client.chat.completions.create(
            model="gpt-4o",
            messages=[{
                "role": "system",
                "content": f"""Evaluate this output against the original task.
 
Score from 0-10 based on:
- Accuracy (are facts correct?)
- Completeness (does it fully address the task?)
- Clarity (is it easy to understand?)
- Quality (is it well-written?)
 
Return JSON:
{{
    "score": 7.5,
    "issues": ["issue 1", "issue 2"],
    "suggestions": ["suggestion 1", "suggestion 2"]
}}
 
A score of {self.min_score}+ means it passes."""
            }, {
                "role": "user",
                "content": f"Task: {task}\n\nOutput to evaluate:\n{output}"
            }],
            response_format={"type": "json_object"}
        )
        
        data = json.loads(response.choices[0].message.content)
        
        return Evaluation(
            score=data["score"],
            passed=data["score"] >= self.min_score,
            issues=data.get("issues", []),
            suggestions=data.get("suggestions", [])
        )
    
    def _optimize(self, task: str, output: str, evaluation: Evaluation) -> str:
        """Improve output based on evaluation"""
        response = self.client.chat.completions.create(
            model="gpt-4o",
            messages=[{
                "role": "system",
                "content": """Improve the output by addressing the issues identified.
Keep what's already good. Only fix what's broken."""
            }, {
                "role": "user",
                "content": f"""Original task: {task}
 
Current output:
{output}
 
Issues to fix:
{json.dumps(evaluation.issues, indent=2)}
 
Suggestions:
{json.dumps(evaluation.suggestions, indent=2)}
 
Provide the improved output:"""
            }]
        )
        return response.choices[0].message.content
 
 
# Usage
agent = EvaluatorOptimizerAgent(min_score=8.0, max_iterations=3)
 
result = agent.run(
    "Write a technical explanation of how HTTPS works for a junior developer"
)
 
print(f"Success: {result['success']}")
print(f"Final score: {result['final_score']}")
print(f"Iterations: {result['iterations']}")
print(f"\nOutput:\n{result['output']}")
 

Specialized Evaluators

Code Quality Evaluator

python

from hopx import Sandbox
 
class CodeEvaluator:
    def __init__(self):
        self.client = openai.OpenAI()
    
    def evaluate(self, code: str, requirements: str) -> Evaluation:
        """Evaluate code quality with actual execution"""
        
        # Test 1: Does it run?
        execution_result = self._execute_code(code)
        
        # Test 2: Does it pass tests?
        test_result = self._run_tests(code, requirements)
        
        # Test 3: Code quality analysis
        quality_result = self._analyze_quality(code)
        
        # Combine scores
        score = self._calculate_score(execution_result, test_result, quality_result)
        
        issues = []
        if not execution_result["success"]:
            issues.append(f"Execution error: {execution_result['error']}")
        if not test_result["passed"]:
            issues.extend(test_result["failures"])
        issues.extend(quality_result["issues"])
        
        return Evaluation(
            score=score,
            passed=score >= 8.0 and execution_result["success"],
            issues=issues,
            suggestions=quality_result.get("suggestions", [])
        )
    
    def _execute_code(self, code: str) -> dict:
        """Actually run the code"""
        sandbox = Sandbox.create(template="code-interpreter")
        
        try:
            sandbox.files.write("/app/code.py", code)
            result = sandbox.commands.run("python /app/code.py", timeout=30)
            
            return {
                "success": result.exit_code == 0,
                "output": result.stdout,
                "error": result.stderr if result.exit_code != 0 else None
            }
        finally:
            sandbox.kill()
    
    def _run_tests(self, code: str, requirements: str) -> dict:
        """Generate and run tests"""
        # Generate tests based on requirements
        test_code = self._generate_tests(code, requirements)
        
        sandbox = Sandbox.create(template="code-interpreter")
        
        try:
            sandbox.files.write("/app/solution.py", code)
            sandbox.files.write("/app/test_solution.py", test_code)
            sandbox.commands.run("pip install pytest -q")
            
            result = sandbox.commands.run("python -m pytest /app/test_solution.py -v")
            
            passed = result.exit_code == 0
            failures = self._parse_test_failures(result.stdout) if not passed else []
            
            return {"passed": passed, "failures": failures}
        finally:
            sandbox.kill()
    
    def _analyze_quality(self, code: str) -> dict:
        """LLM-based code quality analysis"""
        response = self.client.chat.completions.create(
            model="gpt-4o",
            messages=[{
                "role": "system",
                "content": """Analyze code quality. Check for:
- Bugs and logic errors
- Security issues
- Performance problems
- Readability issues
- Missing error handling
 
Return JSON: {"score": 0-10, "issues": [...], "suggestions": [...]}"""
            }, {
                "role": "user",
                "content": code
            }],
            response_format={"type": "json_object"}
        )
        
        return json.loads(response.choices[0].message.content)
 

Writing Quality Evaluator

python

class WritingEvaluator:
    def __init__(self):
        self.client = openai.OpenAI()
        self.criteria = {
            "accuracy": {"weight": 0.25, "description": "Facts are correct and verifiable"},
            "clarity": {"weight": 0.25, "description": "Easy to understand"},
            "structure": {"weight": 0.20, "description": "Well-organized with clear flow"},
            "engagement": {"weight": 0.15, "description": "Interesting and holds attention"},
            "grammar": {"weight": 0.15, "description": "No spelling or grammar errors"}
        }
    
    def evaluate(self, text: str, context: str) -> Evaluation:
        """Multi-dimensional writing evaluation"""
        
        scores = {}
        all_issues = []
        all_suggestions = []
        
        # Evaluate each criterion
        for criterion, config in self.criteria.items():
            result = self._evaluate_criterion(text, context, criterion, config["description"])
            scores[criterion] = result["score"]
            all_issues.extend(result.get("issues", []))
            all_suggestions.extend(result.get("suggestions", []))
        
        # Calculate weighted score
        total_score = sum(
            scores[c] * self.criteria[c]["weight"]
            for c in self.criteria
        )
        
        return Evaluation(
            score=total_score,
            passed=total_score >= 8.0 and all(s >= 6.0 for s in scores.values()),
            issues=all_issues,
            suggestions=all_suggestions
        )
    
    def _evaluate_criterion(self, text: str, context: str, criterion: str, description: str) -> dict:
        response = self.client.chat.completions.create(
            model="gpt-4o",
            messages=[{
                "role": "user",
                "content": f"""Evaluate this text for {criterion}: {description}
 
Context: {context}
 
Text:
{text}
 
Return JSON: {{"score": 0-10, "issues": [...], "suggestions": [...]}}"""
            }],
            response_format={"type": "json_object"}
        )
        
        return json.loads(response.choices[0].message.content)
 

Advanced Patterns

Multi-Evaluator Ensemble

Use multiple evaluators and combine their judgments:

python

class EnsembleEvaluator:
    def __init__(self, evaluators: list):
        self.evaluators = evaluators
    
    def evaluate(self, output: str, context: str) -> Evaluation:
        """Combine multiple evaluator opinions"""
        
        all_evaluations = []
        
        for evaluator in self.evaluators:
            eval_result = evaluator.evaluate(output, context)
            all_evaluations.append(eval_result)
        
        # Aggregate scores (weighted average or voting)
        avg_score = sum(e.score for e in all_evaluations) / len(all_evaluations)
        
        # Collect all unique issues
        all_issues = list(set(
            issue for e in all_evaluations for issue in e.issues
        ))
        
        # Consensus on pass/fail
        passes = sum(1 for e in all_evaluations if e.passed)
        majority_pass = passes > len(all_evaluations) / 2
        
        return Evaluation(
            score=avg_score,
            passed=majority_pass,
            issues=all_issues,
            suggestions=[s for e in all_evaluations for s in e.suggestions]
        )
 
 
# Usage
ensemble = EnsembleEvaluator([
    AccuracyEvaluator(),
    ClarityEvaluator(),
    StyleEvaluator()
])
 

Progressive Quality Gates

Different quality bars for different stages:

python

class ProgressiveOptimizer:
    def __init__(self):
        self.quality_gates = [
            {"name": "basic", "min_score": 5.0, "focus": ["correctness"]},
            {"name": "good", "min_score": 7.0, "focus": ["correctness", "clarity"]},
            {"name": "excellent", "min_score": 9.0, "focus": ["correctness", "clarity", "polish"]}
        ]
    
    def run(self, task: str, target_quality: str = "good") -> str:
        """Progressively improve through quality gates"""
        
        output = self._generate(task)
        
        target_gate = next(g for g in self.quality_gates if g["name"] == target_quality)
        target_index = self.quality_gates.index(target_gate)
        
        # Progress through each gate up to target
        for gate in self.quality_gates[:target_index + 1]:
            output = self._optimize_for_gate(task, output, gate)
        
        return output
    
    def _optimize_for_gate(self, task: str, output: str, gate: dict) -> str:
        """Optimize until this gate's criteria are met"""
        
        for _ in range(3):  # Max attempts per gate
            evaluation = self._evaluate_for_gate(output, gate)
            
            if evaluation.score >= gate["min_score"]:
                print(f"✓ Passed {gate['name']} gate ({evaluation.score:.1f})")
                return output
            
            output = self._optimize(task, output, evaluation, gate["focus"])
        
        print(f"⚠ Could not pass {gate['name']} gate")
        return output
 

Optimization with Memory

Remember what works and what doesn't:

python

class LearningOptimizer:
    def __init__(self):
        self.client = openai.OpenAI()
        self.improvement_history = []  # What worked before
        self.failure_patterns = []      # What didn't work
    
    def optimize(self, task: str, output: str, evaluation: Evaluation) -> str:
        # Learn from history
        relevant_successes = self._find_relevant_successes(evaluation.issues)
        patterns_to_avoid = self._find_failure_patterns(evaluation.issues)
        
        response = self.client.chat.completions.create(
            model="gpt-4o",
            messages=[{
                "role": "system",
                "content": f"""Improve this output.
 
Issues to fix:
{json.dumps(evaluation.issues)}
 
Strategies that worked before for similar issues:
{json.dumps(relevant_successes)}
 
Approaches to AVOID (they didn't work):
{json.dumps(patterns_to_avoid)}"""
            }, {
                "role": "user",
                "content": f"Task: {task}\n\nCurrent output:\n{output}"
            }]
        )
        
        improved = response.choices[0].message.content
        
        # Track this attempt
        self._record_attempt(evaluation.issues, improved)
        
        return improved
    
    def record_success(self, issues: list, solution: str):
        """Record a successful optimization for future reference"""
        self.improvement_history.append({
            "issues": issues,
            "solution_approach": self._extract_approach(solution)
        })
    
    def record_failure(self, issues: list, failed_approach: str):
        """Record what didn't work"""
        self.failure_patterns.append({
            "issues": issues,
            "failed_approach": failed_approach
        })
 

Real-World Example: Article Generator

A complete article generator with evaluation and optimization:

python

from hopx import Sandbox
import openai
import json
 
class ArticleGenerator:
    def __init__(self):
        self.client = openai.OpenAI()
        self.min_score = 8.5
        self.max_iterations = 4
    
    def generate(self, topic: str, requirements: dict) -> dict:
        """Generate a high-quality article through iterative improvement"""
        
        # Phase 1: Initial draft
        draft = self._create_draft(topic, requirements)
        
        # Phase 2: Iterative improvement
        for iteration in range(self.max_iterations):
            print(f"\n--- Iteration {iteration + 1} ---")
            
            # Evaluate
            evaluation = self._evaluate_article(draft, topic, requirements)
            print(f"Score: {evaluation.score}/10")
            print(f"Issues: {evaluation.issues}")
            
            if evaluation.passed:
                print("✓ Article meets quality bar")
                break
            
            # Optimize
            draft = self._improve_article(draft, evaluation, requirements)
        
        # Phase 3: Final polish
        final = self._polish(draft)
        
        # Verify code examples if present
        if "```python" in final:
            final = self._verify_code_examples(final)
        
        return {
            "article": final,
            "iterations": iteration + 1,
            "final_score": evaluation.score
        }
    
    def _create_draft(self, topic: str, requirements: dict) -> str:
        response = self.client.chat.completions.create(
            model="gpt-4o",
            messages=[{
                "role": "system",
                "content": f"""Write a technical article.
 
Requirements:
- Length: {requirements.get('length', '1500-2000')} words
- Audience: {requirements.get('audience', 'developers')}
- Style: {requirements.get('style', 'informative but engaging')}
- Include: code examples, practical tips
 
Structure:
1. Hook/Introduction
2. Main content (3-5 sections)
3. Practical examples
4. Conclusion with actionable takeaways"""
            }, {
                "role": "user",
                "content": f"Topic: {topic}"
            }]
        )
        return response.choices[0].message.content
    
    def _evaluate_article(self, article: str, topic: str, requirements: dict) -> Evaluation:
        response = self.client.chat.completions.create(
            model="gpt-4o",
            messages=[{
                "role": "system",
                "content": f"""Evaluate this article rigorously.
 
Criteria (score each 0-10):
1. Technical accuracy - Are all facts and code correct?
2. Completeness - Does it cover the topic adequately?
3. Clarity - Is it easy to follow?
4. Engagement - Is it interesting to read?
5. Actionability - Can readers apply what they learned?
6. SEO - Are headings and structure optimized?
 
Requirements to check:
{json.dumps(requirements)}
 
Return JSON:
{{
    "scores": {{"accuracy": 8, "completeness": 7, ...}},
    "overall_score": 7.5,
    "issues": ["specific issue 1", "specific issue 2"],
    "suggestions": ["specific suggestion 1"]
}}"""
            }, {
                "role": "user",
                "content": f"Topic: {topic}\n\nArticle:\n{article}"
            }],
            response_format={"type": "json_object"}
        )
        
        data = json.loads(response.choices[0].message.content)
        
        return Evaluation(
            score=data["overall_score"],
            passed=data["overall_score"] >= self.min_score,
            issues=data["issues"],
            suggestions=data["suggestions"]
        )
    
    def _improve_article(self, article: str, evaluation: Evaluation, requirements: dict) -> str:
        response = self.client.chat.completions.create(
            model="gpt-4o",
            messages=[{
                "role": "system",
                "content": """Improve the article by fixing the identified issues.
Maintain the overall structure and good parts.
Focus specifically on the issues listed."""
            }, {
                "role": "user",
                "content": f"""Current article:
{article}
 
Issues to fix:
{json.dumps(evaluation.issues, indent=2)}
 
Suggestions to consider:
{json.dumps(evaluation.suggestions, indent=2)}
 
Provide the improved article:"""
            }]
        )
        return response.choices[0].message.content
    
    def _polish(self, article: str) -> str:
        """Final polish pass"""
        response = self.client.chat.completions.create(
            model="gpt-4o",
            messages=[{
                "role": "user",
                "content": f"""Polish this article:
- Fix any remaining typos or grammar issues
- Ensure smooth transitions between sections
- Verify formatting is consistent
 
Article:
{article}"""
            }]
        )
        return response.choices[0].message.content
    
    def _verify_code_examples(self, article: str) -> str:
        """Extract and test all code examples"""
        import re
        
        code_blocks = re.findall(r'```python\n(.*?)```', article, re.DOTALL)
        
        sandbox = Sandbox.create(template="code-interpreter")
        
        try:
            for i, code in enumerate(code_blocks):
                sandbox.files.write(f"/app/example_{i}.py", code)
                result = sandbox.commands.run(f"python /app/example_{i}.py")
                
                if result.exit_code != 0:
                    # Fix the code
                    fixed_code = self._fix_code(code, result.stderr)
                    article = article.replace(f"```python\n{code}```", f"```python\n{fixed_code}```")
            
            return article
        finally:
            sandbox.kill()
 
 
# Usage
generator = ArticleGenerator()
 
result = generator.generate(
    topic="Building RESTful APIs with FastAPI",
    requirements={
        "length": "2000-2500 words",
        "audience": "intermediate Python developers",
        "style": "practical tutorial",
        "must_include": ["authentication", "database integration", "testing"]
    }
)
 
print(f"Generated in {result['iterations']} iterations")
print(f"Final score: {result['final_score']}")
print(result["article"])
 

Best Practices

1. Define Clear Evaluation Criteria

python

# ❌ Vague criteria
criteria = ["make it good", "improve quality"]
 
# ✅ Specific, measurable criteria
criteria = {
    "accuracy": {
        "description": "All facts verifiable, no hallucinations",
        "min_score": 9,
        "examples": ["dates correct", "quotes accurate", "statistics cited"]
    },
    "completeness": {
        "description": "Addresses all aspects of the prompt",
        "min_score": 8,
        "examples": ["all questions answered", "no missing sections"]
    }
}
 

2. Limit Iterations

python

class BoundedOptimizer:
    def __init__(self, max_iterations: int = 5, timeout_seconds: int = 60):
        self.max_iterations = max_iterations
        self.timeout = timeout_seconds
    
    def run(self, task: str) -> str:
        start_time = time.time()
        
        for i in range(self.max_iterations):
            # Check timeout
            if time.time() - start_time > self.timeout:
                print("Timeout reached")
                break
            
            # Check diminishing returns
            if i > 2 and score_improvement < 0.5:
                print("Diminishing returns, stopping")
                break
 

3. Track Optimization History

python

def run_with_tracking(self, task: str) -> dict:
    history = []
    
    for i in range(self.max_iterations):
        evaluation = self._evaluate(output)
        
        history.append({
            "iteration": i,
            "score": evaluation.score,
            "issues_count": len(evaluation.issues),
            "output_length": len(output),
            "timestamp": datetime.now().isoformat()
        })
        
        # Detect if stuck
        if i > 1 and history[-1]["score"] == history[-2]["score"]:
            # Try different optimization strategy
            output = self._alternative_optimize(output, evaluation)
    
    return {"output": output, "history": history}
 

4. Fail Gracefully

python

def run_with_fallback(self, task: str) -> dict:
    try:
        result = self._optimize_loop(task)
        
        if not result["success"]:
            # Return best attempt even if didn't meet threshold
            return {
                "output": result["output"],
                "warning": "Did not meet quality threshold",
                "score": result["final_score"]
            }
        
        return result
    
    except Exception as e:
        # Return initial generation on failure
        return {
            "output": self._generate(task),
            "error": str(e),
            "fallback": True
        }
 

When to Use This Pattern

✅ Use Evaluator-Optimizer when:

Output quality is critical
You can define clear quality criteria
You have token budget for multiple iterations
Task is complex enough to benefit from iteration

❌ Avoid when:

Speed is the priority
Quality criteria are subjective/unclear
Output is simple and usually correct
Token costs are a major concern

Conclusion

The Evaluator-Optimizer Loop transforms inconsistent outputs into consistently high-quality ones:

Explicit evaluation — Define what "good" means
Iterative improvement — Fix issues systematically
Quality guarantees — Meet defined thresholds

Start with simple evaluation criteria. Add specialized evaluators for specific domains. Track optimization history to learn what works.

The agent that evaluates and improves beats the agent that hopes for the best. Every time.

Ready to build self-improving agents? Get started with HopX — sandboxes that let you test and verify outputs in isolation.

Evaluator-Optimizer Loop: Continuous AI Agent Improvement

Evaluator-Optimizer Loop: Continuous AI Agent Improvement

What Is the Evaluator-Optimizer Loop?

Why This Pattern Works

1. Separation of Concerns

2. Explicit Quality Gates

3. Guaranteed Improvement

Basic Implementation

Specialized Evaluators

Code Quality Evaluator

Writing Quality Evaluator

Advanced Patterns

Multi-Evaluator Ensemble

Progressive Quality Gates

Optimization with Memory

Real-World Example: Article Generator

Best Practices

1. Define Clear Evaluation Criteria

2. Limit Iterations

3. Track Optimization History

4. Fail Gracefully

When to Use This Pattern

Conclusion

Further Reading

Related articles

Human-in-the-Loop: Balancing AI Autonomy and Human Control

Memory for AI Agents: Short-term, Long-term, and RAG

The Orchestrator Pattern: Coordinating Complex AI Agent Workflows

1	quality_criteria = {
2	"accuracy": "All facts must be verifiable",
3	"completeness": "Must address all parts of the question",
4	"clarity": "A non-expert should understand",
5	"conciseness": "No unnecessary content"
6	}
7

1	Iteration 1: Score 6/10 - Issues: missing examples, too technical
2	Iteration 2: Score 8/10 - Issues: one factual error
3	Iteration 3: Score 9/10 - Issues: none critical
4	→ Output accepted
5

1	import openai
2	import json
3	from dataclasses import dataclass
4
5	@dataclass
6	class Evaluation:
7	score: float # 0-10
8	passed: bool
9	issues: list[str]
10	suggestions: list[str]
11
12	class EvaluatorOptimizerAgent:
13	def __init__(self, min_score: float = 8.0, max_iterations: int = 5):
14	self.client = openai.OpenAI()
15	self.min_score = min_score
16	self.max_iterations = max_iterations
17
18	def run(self, task: str) -> dict:
19	"""Generate, evaluate, and optimize until quality threshold met"""
20
21	# Initial generation
22	output = self._generate(task)
23	iterations = []
24
25	for i in range(self.max_iterations):
26	# Evaluate current output
27	evaluation = self._evaluate(task, output)
28
29	iterations.append({
30	"iteration": i + 1,
31	"output_preview": output[:200],
32	"score": evaluation.score,
33	"issues": evaluation.issues
34	})
35
36	# Check if good enough
37	if evaluation.passed:
38	return {
39	"success": True,
40	"output": output,
41	"final_score": evaluation.score,
42	"iterations": len(iterations),
43	"history": iterations
44	}
45
46	# Optimize based on feedback
47	output = self._optimize(task, output, evaluation)
48
49	# Max iterations reached
50	return {
51	"success": False,
52	"output": output,
53	"final_score": evaluation.score,
54	"iterations": len(iterations),
55	"history": iterations,
56	"note": "Max iterations reached"
57	}
58
59	def _generate(self, task: str) -> str:
60	"""Initial generation"""
61	response = self.client.chat.completions.create(
62	model="gpt-4o",
63	messages=[{
64	"role": "system",
65	"content": "Generate a high-quality response to the task."
66	}, {
67	"role": "user",
68	"content": task
69	}]
70	)
71	return response.choices[0].message.content
72
73	def _evaluate(self, task: str, output: str) -> Evaluation:
74	"""Evaluate the output quality"""
75	response = self.client.chat.completions.create(
76	model="gpt-4o",
77	messages=[{
78	"role": "system",
79	"content": f"""Evaluate this output against the original task.
80
81	Score from 0-10 based on:
82	- Accuracy (are facts correct?)
83	- Completeness (does it fully address the task?)
84	- Clarity (is it easy to understand?)
85	- Quality (is it well-written?)
86
87	Return JSON:
88	{{
89	"score": 7.5,
90	"issues": ["issue 1", "issue 2"],
91	"suggestions": ["suggestion 1", "suggestion 2"]
92	}}
93
94	A score of {self.min_score}+ means it passes."""
95	}, {
96	"role": "user",
97	"content": f"Task: {task}\n\nOutput to evaluate:\n{output}"
98	}],
99	response_format={"type": "json_object"}
100	)
101
102	data = json.loads(response.choices[0].message.content)
103
104	return Evaluation(
105	score=data["score"],
106	passed=data["score"] >= self.min_score,
107	issues=data.get("issues", []),
108	suggestions=data.get("suggestions", [])
109	)
110
111	def _optimize(self, task: str, output: str, evaluation: Evaluation) -> str:
112	"""Improve output based on evaluation"""
113	response = self.client.chat.completions.create(
114	model="gpt-4o",
115	messages=[{
116	"role": "system",
117	"content": """Improve the output by addressing the issues identified.
118	Keep what's already good. Only fix what's broken."""
119	}, {
120	"role": "user",
121	"content": f"""Original task: {task}
122
123	Current output:
124	{output}
125
126	Issues to fix:
127	{json.dumps(evaluation.issues, indent=2)}
128
129	Suggestions:
130	{json.dumps(evaluation.suggestions, indent=2)}
131
132	Provide the improved output:"""
133	}]
134	)
135	return response.choices[0].message.content
136
137
138	# Usage
139	agent = EvaluatorOptimizerAgent(min_score=8.0, max_iterations=3)
140
141	result = agent.run(
142	"Write a technical explanation of how HTTPS works for a junior developer"
143	)
144
145	print(f"Success: {result['success']}")
146	print(f"Final score: {result['final_score']}")
147	print(f"Iterations: {result['iterations']}")
148	print(f"\nOutput:\n{result['output']}")
149

1	from hopx import Sandbox
2
3	class CodeEvaluator:
4	def __init__(self):
5	self.client = openai.OpenAI()
6
7	def evaluate(self, code: str, requirements: str) -> Evaluation:
8	"""Evaluate code quality with actual execution"""
9
10	# Test 1: Does it run?
11	execution_result = self._execute_code(code)
12
13	# Test 2: Does it pass tests?
14	test_result = self._run_tests(code, requirements)
15
16	# Test 3: Code quality analysis
17	quality_result = self._analyze_quality(code)
18
19	# Combine scores
20	score = self._calculate_score(execution_result, test_result, quality_result)
21
22	issues = []
23	if not execution_result["success"]:
24	issues.append(f"Execution error: {execution_result['error']}")
25	if not test_result["passed"]:
26	issues.extend(test_result["failures"])
27	issues.extend(quality_result["issues"])
28
29	return Evaluation(
30	score=score,
31	passed=score >= 8.0 and execution_result["success"],
32	issues=issues,
33	suggestions=quality_result.get("suggestions", [])
34	)
35
36	def _execute_code(self, code: str) -> dict:
37	"""Actually run the code"""
38	sandbox = Sandbox.create(template="code-interpreter")
39
40	try:
41	sandbox.files.write("/app/code.py", code)
42	result = sandbox.commands.run("python /app/code.py", timeout=30)
43
44	return {
45	"success": result.exit_code == 0,
46	"output": result.stdout,
47	"error": result.stderr if result.exit_code != 0 else None
48	}
49	finally:
50	sandbox.kill()
51
52	def _run_tests(self, code: str, requirements: str) -> dict:
53	"""Generate and run tests"""
54	# Generate tests based on requirements
55	test_code = self._generate_tests(code, requirements)
56
57	sandbox = Sandbox.create(template="code-interpreter")
58
59	try:
60	sandbox.files.write("/app/solution.py", code)
61	sandbox.files.write("/app/test_solution.py", test_code)
62	sandbox.commands.run("pip install pytest -q")
63
64	result = sandbox.commands.run("python -m pytest /app/test_solution.py -v")
65
66	passed = result.exit_code == 0
67	failures = self._parse_test_failures(result.stdout) if not passed else []
68
69	return {"passed": passed, "failures": failures}
70	finally:
71	sandbox.kill()
72
73	def _analyze_quality(self, code: str) -> dict:
74	"""LLM-based code quality analysis"""
75	response = self.client.chat.completions.create(
76	model="gpt-4o",
77	messages=[{
78	"role": "system",
79	"content": """Analyze code quality. Check for:
80	- Bugs and logic errors
81	- Security issues
82	- Performance problems
83	- Readability issues
84	- Missing error handling
85
86	Return JSON: {"score": 0-10, "issues": [...], "suggestions": [...]}"""
87	}, {
88	"role": "user",
89	"content": code
90	}],
91	response_format={"type": "json_object"}
92	)
93
94	return json.loads(response.choices[0].message.content)
95

1	class WritingEvaluator:
2	def __init__(self):
3	self.client = openai.OpenAI()
4	self.criteria = {
5	"accuracy": {"weight": 0.25, "description": "Facts are correct and verifiable"},
6	"clarity": {"weight": 0.25, "description": "Easy to understand"},
7	"structure": {"weight": 0.20, "description": "Well-organized with clear flow"},
8	"engagement": {"weight": 0.15, "description": "Interesting and holds attention"},
9	"grammar": {"weight": 0.15, "description": "No spelling or grammar errors"}
10	}
11
12	def evaluate(self, text: str, context: str) -> Evaluation:
13	"""Multi-dimensional writing evaluation"""
14
15	scores = {}
16	all_issues = []
17	all_suggestions = []
18
19	# Evaluate each criterion
20	for criterion, config in self.criteria.items():
21	result = self._evaluate_criterion(text, context, criterion, config["description"])
22	scores[criterion] = result["score"]
23	all_issues.extend(result.get("issues", []))
24	all_suggestions.extend(result.get("suggestions", []))
25
26	# Calculate weighted score
27	total_score = sum(
28	scores[c] * self.criteria[c]["weight"]
29	for c in self.criteria
30	)
31
32	return Evaluation(
33	score=total_score,
34	passed=total_score >= 8.0 and all(s >= 6.0 for s in scores.values()),
35	issues=all_issues,
36	suggestions=all_suggestions
37	)
38
39	def _evaluate_criterion(self, text: str, context: str, criterion: str, description: str) -> dict:
40	response = self.client.chat.completions.create(
41	model="gpt-4o",
42	messages=[{
43	"role": "user",
44	"content": f"""Evaluate this text for {criterion}: {description}
45
46	Context: {context}
47
48	Text:
49	{text}
50
51	Return JSON: {{"score": 0-10, "issues": [...], "suggestions": [...]}}"""
52	}],
53	response_format={"type": "json_object"}
54	)
55
56	return json.loads(response.choices[0].message.content)
57

1	class EnsembleEvaluator:
2	def __init__(self, evaluators: list):
3	self.evaluators = evaluators
4
5	def evaluate(self, output: str, context: str) -> Evaluation:
6	"""Combine multiple evaluator opinions"""
7
8	all_evaluations = []
9
10	for evaluator in self.evaluators:
11	eval_result = evaluator.evaluate(output, context)
12	all_evaluations.append(eval_result)
13
14	# Aggregate scores (weighted average or voting)
15	avg_score = sum(e.score for e in all_evaluations) / len(all_evaluations)
16
17	# Collect all unique issues
18	all_issues = list(set(
19	issue for e in all_evaluations for issue in e.issues
20	))
21
22	# Consensus on pass/fail
23	passes = sum(1 for e in all_evaluations if e.passed)
24	majority_pass = passes > len(all_evaluations) / 2
25
26	return Evaluation(
27	score=avg_score,
28	passed=majority_pass,
29	issues=all_issues,
30	suggestions=[s for e in all_evaluations for s in e.suggestions]
31	)
32
33
34	# Usage
35	ensemble = EnsembleEvaluator([
36	AccuracyEvaluator(),
37	ClarityEvaluator(),
38	StyleEvaluator()
39	])
40

1	class ProgressiveOptimizer:
2	def __init__(self):
3	self.quality_gates = [
4	{"name": "basic", "min_score": 5.0, "focus": ["correctness"]},
5	{"name": "good", "min_score": 7.0, "focus": ["correctness", "clarity"]},
6	{"name": "excellent", "min_score": 9.0, "focus": ["correctness", "clarity", "polish"]}
7	]
8
9	def run(self, task: str, target_quality: str = "good") -> str:
10	"""Progressively improve through quality gates"""
11
12	output = self._generate(task)
13
14	target_gate = next(g for g in self.quality_gates if g["name"] == target_quality)
15	target_index = self.quality_gates.index(target_gate)
16
17	# Progress through each gate up to target
18	for gate in self.quality_gates[:target_index + 1]:
19	output = self._optimize_for_gate(task, output, gate)
20
21	return output
22
23	def _optimize_for_gate(self, task: str, output: str, gate: dict) -> str:
24	"""Optimize until this gate's criteria are met"""
25
26	for _ in range(3): # Max attempts per gate
27	evaluation = self._evaluate_for_gate(output, gate)
28
29	if evaluation.score >= gate["min_score"]:
30	print(f"✓ Passed {gate['name']} gate ({evaluation.score:.1f})")
31	return output
32
33	output = self._optimize(task, output, evaluation, gate["focus"])
34
35	print(f"⚠ Could not pass {gate['name']} gate")
36	return output
37

1	class LearningOptimizer:
2	def __init__(self):
3	self.client = openai.OpenAI()
4	self.improvement_history = [] # What worked before
5	self.failure_patterns = [] # What didn't work
6
7	def optimize(self, task: str, output: str, evaluation: Evaluation) -> str:
8	# Learn from history
9	relevant_successes = self._find_relevant_successes(evaluation.issues)
10	patterns_to_avoid = self._find_failure_patterns(evaluation.issues)
11
12	response = self.client.chat.completions.create(
13	model="gpt-4o",
14	messages=[{
15	"role": "system",
16	"content": f"""Improve this output.
17
18	Issues to fix:
19	{json.dumps(evaluation.issues)}
20
21	Strategies that worked before for similar issues:
22	{json.dumps(relevant_successes)}
23
24	Approaches to AVOID (they didn't work):
25	{json.dumps(patterns_to_avoid)}"""
26	}, {
27	"role": "user",
28	"content": f"Task: {task}\n\nCurrent output:\n{output}"
29	}]
30	)
31
32	improved = response.choices[0].message.content
33
34	# Track this attempt
35	self._record_attempt(evaluation.issues, improved)
36
37	return improved
38
39	def record_success(self, issues: list, solution: str):
40	"""Record a successful optimization for future reference"""
41	self.improvement_history.append({
42	"issues": issues,
43	"solution_approach": self._extract_approach(solution)
44	})
45
46	def record_failure(self, issues: list, failed_approach: str):
47	"""Record what didn't work"""
48	self.failure_patterns.append({
49	"issues": issues,
50	"failed_approach": failed_approach
51	})
52

1	# ❌ Vague criteria
2	criteria = ["make it good", "improve quality"]
3
4	# ✅ Specific, measurable criteria
5	criteria = {
6	"accuracy": {
7	"description": "All facts verifiable, no hallucinations",
8	"min_score": 9,
9	"examples": ["dates correct", "quotes accurate", "statistics cited"]
10	},
11	"completeness": {
12	"description": "Addresses all aspects of the prompt",
13	"min_score": 8,
14	"examples": ["all questions answered", "no missing sections"]
15	}
16	}
17

1	class BoundedOptimizer:
2	def __init__(self, max_iterations: int = 5, timeout_seconds: int = 60):
3	self.max_iterations = max_iterations
4	self.timeout = timeout_seconds
5
6	def run(self, task: str) -> str:
7	start_time = time.time()
8
9	for i in range(self.max_iterations):
10	# Check timeout
11	if time.time() - start_time > self.timeout:
12	print("Timeout reached")
13	break
14
15	# Check diminishing returns
16	if i > 2 and score_improvement < 0.5:
17	print("Diminishing returns, stopping")
18	break
19

1	def run_with_tracking(self, task: str) -> dict:
2	history = []
3
4	for i in range(self.max_iterations):
5	evaluation = self._evaluate(output)
6
7	history.append({
8	"iteration": i,
9	"score": evaluation.score,
10	"issues_count": len(evaluation.issues),
11	"output_length": len(output),
12	"timestamp": datetime.now().isoformat()
13	})
14
15	# Detect if stuck
16	if i > 1 and history[-1]["score"] == history[-2]["score"]:
17	# Try different optimization strategy
18	output = self._alternative_optimize(output, evaluation)
19
20	return {"output": output, "history": history}
21

1	def run_with_fallback(self, task: str) -> dict:
2	try:
3	result = self._optimize_loop(task)
4
5	if not result["success"]:
6	# Return best attempt even if didn't meet threshold
7	return {
8	"output": result["output"],
9	"warning": "Did not meet quality threshold",
10	"score": result["final_score"]
11	}
12
13	return result
14
15	except Exception as e:
16	# Return initial generation on failure
17	return {
18	"output": self._generate(task),
19	"error": str(e),
20	"fallback": True
21	}
22