EPOCH: An Agentic Protocol for Multi-Round System Optimization

The paper introduces EPOCH, a unified engineering protocol that structures multi-round autonomous system optimization into baseline construction and iterative self-improvement phases with role-constrained stages to ensure stability, reproducibility, and traceability across heterogeneous environments.

The Gist

Imagine you are trying to build the perfect recipe for a cake.

In the old way of doing things with AI, you might ask a smart chef (the AI) to "make a better cake." The chef tries a new ingredient, tastes it, and if it's slightly better, they keep it. Then they try another change. But here's the problem: the chef is also the one tasting the cake, the one writing down the notes, and the one deciding if the cake is good enough. They might get tired, forget what they changed, or accidentally taste the cake while it's still in the oven (cheating). Every time you want to try a new type of cake, you have to build a whole new kitchen from scratch.

EPOCH is like a new, ultra-organized kitchen management system that changes how we let AI chefs improve things. Instead of just asking for a better cake, EPOCH sets up a strict, professional workflow that works for any kind of cooking, whether it's baking, grilling, or making cocktails.

Here is how EPOCH works, broken down into simple concepts:

1. The Two-Phase Plan: "Start Strong, Then Polish"

EPOCH doesn't just jump into tweaking. It splits the job into two distinct phases:

• Phase 1: The Foundation (Baseline Construction). Before trying to make the cake "perfect," the system first makes sure there is a cake that actually works. It takes a messy idea (like "I want a cake") and turns it into a solid, working recipe that can be tested. If you already have a working cake, it just checks that it's valid.
• Phase 2: The Polish (Iterative Self-Improvement). Now that the cake exists, the system starts making small, controlled changes to make it better.

2. The "Kitchen Crew" (Role Separation)

This is the most important part. In a normal kitchen, one person might do everything. In EPOCH's kitchen, the roles are strictly separated so no one can cheat or get confused. Think of it like a high-end restaurant with four specific jobs:

• The Architect (Orchestrator): The manager. They say, "Okay, we have 5 rounds of changes. Let's start." They keep the whole process on track.
• The Detective (Investigator): They look at the current cake and say, "Hmm, the frosting is too sweet. Let's try using less sugar." They come up with the idea for a change.
• The Chef (Executor): They are the hands-on worker. They actually go into the kitchen and change the recipe based on the Detective's idea. They don't decide if the idea is good; they just do the work.
• The Food Critic (Reviewer): This is the most important role. The Critic never cooks or comes up with ideas. They only taste the final result. They compare the new cake against the old one using a strict scorecard. If the new cake isn't significantly better, they say, "Nope, throw it out."

Why separate them? Because if the Chef tastes their own cooking, they might think it's delicious even if it's salty. By having a separate Critic, the system ensures the changes are actually good, not just felt to be good.

3. The "Round" System (Tracking Everything)

Every time the team tries a change, it's called a "Round."

• Round 1: We tried less sugar. The Critic tasted it. It was better. Keep it.
• Round 2: We tried adding lemon. The Critic tasted it. It was worse. Discard it.
• Round 3: We tried a retry with a different lemon. Keep it.

EPOCH writes down everything: who suggested the change, who made it, what the score was, and why it was accepted or rejected. This means if the cake tastes weird later, you can look back at the notes and say, "Ah, we added lemon in Round 3, that's the problem." It makes the whole process traceable.

4. It Works for Everything (Not Just Cakes)

The paper shows that this system isn't just for cooking (or prompts). It works for:

• Writing Code: Like fixing a calculator to run faster. The system first makes sure the math is right, then tries to make it faster, then stops when it can't get any faster.
• Tuning Models: Like adjusting the temperature and time on an oven (hyperparameters) to get the perfect bake without burning the cake.
• Fixing Rules: Like changing the rules of a game to make it fairer.

The Big Picture

Before EPOCH, AI optimization was like a chaotic kitchen where everyone shouted instructions, forgot what they did, and sometimes cheated.

EPOCH is the project manager who brings order. It says:

1. Let's build a solid base first.
2. Let's separate the idea-generators from the testers.
3. Let's write down every single step so we know exactly how we got here.
4. Let's stop when we've reached the limit, so we don't waste time.

It turns the messy, unpredictable process of "AI trying to get better" into a reliable, repeatable engineering process that companies can actually trust to run their businesses.

Technical Summary

Technical Summary: EPOCH - An Agentic Protocol for Multi-Round System Optimization

1. Problem Statement

Current autonomous agent systems for improving prompts, code, and machine learning models are typically designed as task-specific optimization loops (e.g., specific frameworks for prompt engineering like DSPy or hyperparameter search like AgentHPO). These approaches lack a unified protocol that can:

• Establish a reproducible executable baseline from a raw problem specification.
• Manage multi-round self-improvement across heterogeneous system components (prompts, code, configurations, rules).
• Ensure evaluation integrity, traceability, and stability across rounds.

Existing systems often fail to provide a shared abstraction with explicit role separation, canonical execution interfaces, and round-level state tracking. This gap hinders the deployment of reliable, auditable, and production-ready autonomous improvement workflows where system performance depends on the interplay of multiple artifacts rather than a single component.

2. Methodology: The EPOCH Protocol

EPOCH (Engineering Protocol for Multi-Round System Optimization) is an agentic protocol designed to treat iterative improvement as a structured, reproducible engineering process rather than a monolithic optimizer. It operates on a two-phase framework guided by an OODA (Observe-Orient-Decide-Act) loop, adapted with strict role separation and canonical interfaces.

Core Architecture

The protocol organizes optimization into two distinct phases:

Phase I: Baseline Construction

• Goal: Transform a problem specification (natural language or structured config) into an accepted, executable baseline.
• Roles:
  • Seed Planner: Analyzes the task, designs the initial system architecture, and defines the evaluation interface (inputs, outputs, entry points).
  • Baseline Executor: Converts the design into a runnable implementation, instantiates configurations, and generates the first set of accepted metrics.
• Flexibility: If a validated baseline already exists, this phase reduces to a validation step.

Phase II: Multi-Round Self-Improvement

• Goal: Perform structured, tracked iterations to improve the system.
• Roles (Strictly Separated):
  • Orchestrator: Manages round-level control flow, budgets, and state transitions.
  • Investigator: Analyzes current system state and evidence to generate hypotheses for improvement (constrained by task rules, e.g., train-only access).
  • Executor: Implements the proposed changes within the admissible action space (e.g., editing prompts, adjusting hyperparameters, modifying code).
  • Reviewer: Evaluates the candidate state using a canonical evaluation interface and decides whether to accept or reject the change.
• Key Mechanism: The separation of hypothesis generation/implementation from evaluation prevents data leakage and ensures evaluation integrity.

Key Design Principles

1. Role-Constrained Stages: Planning, implementation, and evaluation are performed by distinct logical agents.
2. Canonical Execution Interfaces: Standardized commands ensure that improvements are measured under a shared interface, reducing evaluation drift.
3. Round-Level Tracking: Every round produces structured artifacts (metrics, deltas, decisions, logs), creating a traceable history of optimization rather than an unstructured sequence of edits.
4. Configurability: The protocol supports different variants (e.g., deterministic vs. stochastic evaluation, LLM-based vs. metric-based reviewers) via a meta-level skill construction mechanism.

3. Key Contributions

1. EPOCH Protocol: A unified agentic protocol for transforming problem specifications into executable baselines and managing tracked multi-round self-optimization across heterogeneous modalities (prompts, code, rules, hyperparameters).
2. Two-Phase Orchestration Framework: A novel structure separating baseline establishment from iterative refinement, and further decomposing rounds into role-constrained stages (hypothesis, implementation, evaluation).
3. Unified Abstraction for Industry Workflows: Provides canonical execution interfaces, configurable evaluation pipelines, and rigorous round-level tracking to ensure stability, reproducibility, and traceability.
4. Empirical Validation: Demonstrates the protocol's effectiveness across four distinct task instantiations, showing that a shared protocol can coordinate diverse optimization workflows without altering its core control structure.

4. Empirical Results

The authors evaluated EPOCH across four distinct skill instantiations, maintaining the same underlying protocol logic for each:

Task	Optimization Target	Key Findings
Code Improvement (Fibonacci Calculator)	Program Logic	Successfully managed staged optimization: first achieving 100% correctness (replacing naive loops with fast-doubling), then optimizing performance (using gmpy2). The system self-terminated when further gains were negligible.
Hyperparameter Tuning (MNIST)	Learning Rate & Optimizer	Demonstrated strict train/eval separation and rejection/retry behavior. It rejected an aggressive learning rate increase that caused instability and successfully retried with a different strategy (SGD) to recover performance.
Prompt Tuning (SST-2 Sentiment)	Prompt Artifacts	Achieved perfect held-out accuracy in 3 rounds by refining system prompts and adding few-shot examples. Crucially, it maintained leakage checks, ensuring no evaluation data influenced the prompt generation.
Rule-Based Optimization (Iris Classification)	Symbolic Rules	Optimized decision rules for Iris classification. The protocol correctly rejected modifications that improved training metrics but failed to yield gains on the held-out evaluation set, preventing overfitting.

Cross-Skill Observations:

• State Transitions: Optimization was consistently converted into explicit, auditable state transitions.
• Robustness: The protocol handled rejection and retries without breaking the control flow.
• Self-Termination: The system effectively stopped optimization when performance ceilings were reached or metrics were saturated.

5. Significance and Future Work

Significance:
EPOCH shifts the paradigm from building isolated, task-specific optimizers to establishing a protocolized engineering process for autonomous improvement. It addresses a critical gap in production environments where system behavior is defined by the interaction of code, data, and models. By enforcing role separation and canonical interfaces, EPOCH ensures that autonomous optimization is reproducible, auditable, and safe for integration into existing workflows.

Future Work:
The authors propose extending EPOCH from single-target optimization to multi-agent coordination for complex systems. Future iterations aim to handle scenarios where multiple specialized agents operate in parallel or hierarchically across different subsystems (e.g., training pipelines, inference strategies, monitoring layers), coordinated by the protocol through shared evaluation checkpoints.

Availability:
To support reproducibility, all code, configurations, and task-specific protocol instantiations used in the study are planned for public release.