A Self-Evolving Agentic Framework for Metasurface Inverse Design

This paper introduces a self-evolving agentic framework that leverages context-level skill evolution to autonomously refine solver-specific strategies for metasurface inverse design, significantly improving task success rates and reducing computational attempts without modifying model weights or physics solvers.

The Gist

Imagine you are trying to build a custom, high-tech lens out of a microscopic grid of tiny structures (called a metasurface). You know exactly what you want this lens to do: "Make light bend exactly 45 degrees and let 90% of it through."

In the past, getting a computer to figure out how to build that grid was like asking a genius architect to design a skyscraper, but you had to hand them a blank piece of paper and say, "Write the code to calculate the physics, then write the code to run the simulation, then write the code to fix the errors." If you didn't know how to speak "computer physics" and "software engineering" fluently, you were stuck.

This paper introduces a new system called a Self-Evolving Agentic Framework. Here is how it works, explained through a simple story.

The Problem: The "One-Time" Genius

Imagine you hire a brilliant but forgetful intern (the AI Coding Agent) to write the code for your lens.

• The Old Way: You give the intern a task. They write code. It crashes. They fix it. It works! You get your lens.
• The Catch: The next day, you ask for a different lens. The intern has to start from scratch. They don't remember that "using a specific type of math library caused a crash yesterday." They make the same mistake again. You have to keep babysitting them, fixing their code over and over.

The Solution: The "Skill Book"

The authors realized the problem wasn't the intern's intelligence; it was that the intern wasn't keeping a notebook of lessons learned.

They built a system with three main characters:

1. The Intern (The Coding Agent): An AI that writes the code to design the lens.
2. The Strict Inspector (The Deterministic Evaluator): A computer program that runs the physics simulation. It doesn't care what the AI thinks is right; it only cares if the math actually works. It gives a simple "Pass" or "Fail" and explains why it failed.
3. The Coach (The Meta-Agent): This is the new, smart part. The Coach watches the Intern try to solve problems. When the Intern fails, the Coach doesn't just say "try again." The Coach updates a Skill Book (a text file called SKILL.md).

How the "Self-Evolving" Part Works

Think of the Skill Book as a recipe card that gets better every time you cook.

• Round 1: The Intern tries to design a lens. They forget to tell the computer to use "double precision" math, and the result is garbage. The Inspector yells, "Error! Precision too low!"
• The Update: The Coach sees this, opens the Skill Book, and writes a new rule: "Always set precision to 'Double' before starting."
• Round 2: The Intern reads the Skill Book, sees the new rule, and writes better code immediately.
• Round 3: The Intern tries a slightly different lens. They forget to check the "wavelength" settings. The Inspector yells again. The Coach adds a new rule: "Always double-check the wavelength list matches the target."

Over time, the Skill Book becomes a massive, perfect guide containing all the tricks, shortcuts, and "don'ts" needed to design these lenses. The AI doesn't need to be retrained (which is expensive and slow); it just gets a better instruction manual.

The Results: From Clumsy to Master

The researchers tested this on a bunch of different lens designs:

• On familiar tasks (The "In-Distribution" test):

  • Before: The system only succeeded 38% of the time. It took about 4 tries to get it right.
  • After: With the evolved Skill Book, success jumped to 74%, and it only took 2.3 tries.
  • Analogy: It's like a student who went from failing math tests to getting A's just by studying a better set of notes.

• On totally new tasks (The "Out-of-Distribution" test):

  • The system didn't become a magic genius that could solve any problem instantly. However, it did get better at avoiding silly mistakes and the "margin of error" improved.
  • Analogy: If you teach a chef how to make a perfect steak, they might not instantly know how to bake a cake. But they will definitely know how to sharpen a knife and check the oven temperature, which helps them try the cake with a better chance of success than before.

Why This Matters

This paper is a big deal because it solves a major bottleneck in science. Usually, to do complex physics simulations, you need a PhD in both physics and coding.

This framework acts like a universal translator and tutor. It allows a researcher to say, "I want a lens that does X," and the system figures out the complex coding and physics rules to make it happen. It turns a difficult, manual coding job into a workflow that gets smarter and more reliable every time it is used.

In short: They didn't make the AI "smarter" by feeding it more data. They made the AI more experienced by giving it a notebook that remembers every mistake and turns it into a rule for the future.

Technical Summary

1. Problem Statement

Metasurface inverse design involves determining the physical structure of a metasurface to achieve a specific target optical response (e.g., transmission/reflection spectra). While deep learning and differentiable solvers have advanced the field, a significant bottleneck remains: converting a target optical response into an executable, optimized computational workflow.

Current challenges include:

• High Expertise Barrier: Designing these workflows requires specialized knowledge in computational electromagnetics (CEM) and software engineering to interface with specific solvers (e.g., RCWA, FDTD).
• Fragility of LLMs: Large Language Models (LLMs) can generate code, but they often fail to produce robust, solver-specific optimization loops without extensive trial-and-error.
• Lack of Retention: Existing agentic frameworks typically treat each task in isolation. They do not retain "solver-specific tactics" or procedural knowledge from previous tasks, forcing the model to re-learn how to interact with the solver for every new design problem.
• Fine-tuning Limitations: Traditional fine-tuning of LLMs is data-intensive, risks catastrophic forgetting, and adapts model weights rather than the explicit workflow logic.

2. Methodology: Self-Evolving Agentic Framework

The authors propose a framework that evolves explicit skill artifacts (workflow guidance) rather than updating the underlying LLM weights. The system operates on a bi-level optimization loop inspired by Meta Context Engineering (MCE).

Core Components

1. Meta-Agent: Analyzes rollout logs and validation summaries from previous design tasks. It identifies failure patterns (e.g., API misuse, gradient errors) and success patterns to revise the Skill Files (explicit Markdown/Python guidance).
2. Coding Agent: An LLM (Claude Sonnet 4.6) that generates candidate optimization programs. It does not learn weights; instead, it consumes the current Skill Set (e.g., SKILL.md) and the task specification to write code.
3. Deterministic Evaluator: A physics-based engine (TorchRDIT backend) that executes the generated code, simulates the electromagnetic response, and scores the design against physical criteria. It provides ground-truth feedback (Success Goal, Criteria Pass Fraction, Best Margin) without relying on the LLM's self-assessment.

The Evolution Loop (Bi-Level Optimization)

• Inner Loop (Task Execution): The Coding Agent attempts to solve a batch of tasks using the current Skill Set. It employs a two-level retry mechanism (Ralph-style):
  • Inner attempts: Revise the same candidate program based on immediate execution errors.
  • Outer rounds: Reset the session but carry forward the best candidate and compact feedback.
• Outer Loop (Skill Evolution):
  • The Meta-Agent reviews the outcomes (errors, margins, success rates) of the inner loop.
  • It updates the Skill Files (e.g., adding rules for tensor handling, specific optimizer heuristics, or solver API contracts).
  • The updated Skill Set is validated on a held-out set. The best-performing skill set is selected for the next iteration.

Key Distinction: The "learning" happens in the text-based skill files (context engineering), keeping the base model and the physics solver fixed. This ensures reproducibility and avoids the data hunger of fine-tuning.

3. Key Contributions

• Skill Evolution over Weight Tuning: Demonstrates that evolving explicit, human-readable workflow guidance is a more effective and efficient path for domain-specific adaptation than fine-tuning LLM weights.
• Deterministic Grounding: The framework relies entirely on a deterministic physics solver for feedback, eliminating hallucination risks associated with LLM self-evaluation.
• Bi-Level Optimization Architecture: Successfully integrates a meta-agent for strategy revision with a coding agent for execution, creating a self-improving loop for scientific workflows.
• First-of-its-Kind Application: This is the first study to apply context-level skill evolution specifically to agentic metasurface inverse design.

4. Experimental Results

The framework was evaluated on a benchmark of 6 metasurface design families (G1–G6) covering reflective, transmissive, and plasmonic regimes.

In-Distribution (IID) Performance

• Success Rate (SG): Increased from 38% (baseline) to 74% after skill evolution.
• Criteria Pass Fraction (CPF): Improved from 0.510 to 0.870, indicating designs met more of the physical constraints.
• Efficiency: Average attempts per task dropped from 4.10 to 2.30.
• Error Reduction: Specific errors like "Tensor Index Out of Bounds" and "API Misuse" were virtually eliminated as the skill files learned to avoid these pitfalls.
• Cost: Interaction costs per task decreased by 61–72% due to fewer retries.

Out-of-Distribution (OOD) Performance

• Binary Success: Remained high but stable (92% baseline $\to$ 90% post-training). The baseline was already strong on these unseen families.
• Quality Transfer: The Best Margin (BM) improved significantly (from -4.626 to -2.092), indicating that while the ability to solve the task didn't change much, the quality of the solution (how well it satisfied constraints) improved.
• Interpretation: The framework demonstrates partial transfer of procedural knowledge (e.g., solver hygiene) but struggles to generalize high-level design strategies to entirely new physical regimes.

5. Significance and Implications

• Lowering the Barrier to Entry: The framework makes complex metasurface design accessible to researchers without deep CEM or software engineering expertise by automating the "boilerplate" of solver interaction.
• Interpretability: Unlike black-box neural networks, the evolved "skills" are explicit text files. Researchers can inspect, audit, and manually refine the rules the agent has learned (e.g., "Always call .with_device(device) early").
• Scalability: The approach is solver-agnostic. While tested on TorchRDIT, the framework can be applied to other electromagnetic solvers by simply updating the reference documentation in the skill files.
• Future Direction: The paper suggests that the future of scientific AI lies not in training larger models, but in building self-evolving agentic workflows that accumulate reusable, domain-specific knowledge artifacts.

Conclusion

The paper presents a practical, self-evolving framework that bridges the gap between high-level design goals and low-level solver implementation. By evolving explicit skill artifacts based on physics-grounded feedback, the system achieves significant gains in task success and efficiency for metasurface inverse design, offering a scalable path toward autonomous scientific discovery.