💬 NLP

optimize_anything: A Universal API for Optimizing any Text Parameter

The paper introduces "optimize_anything," a universal LLM-based optimization framework that achieves state-of-the-art results across six diverse domains—including agent architecture design, cloud cost reduction, and CUDA kernel generation—by unifying text-based search with multi-task transfer and actionable side information to outperform specialized algorithms.

Original authors: Lakshya A Agrawal, Donghyun Lee, Shangyin Tan, Wenjie Ma, Karim Elmaaroufi, Rohit Sandadi, Sanjit A. Seshia, Koushik Sen, Dan Klein, Ion Stoica, Joseph E. Gonzalez, Omar Khattab, Alexandros G. Dimakis

Published 2026-05-20

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Lakshya A Agrawal, Donghyun Lee, Shangyin Tan, Wenjie Ma, Karim Elmaaroufi, Rohit Sandadi, Sanjit A. Seshia, Koushik Sen, Dan Klein, Ion Stoica, Joseph E. Gonzalez, Omar Khattab, Alexandros G. Dimakis, Matei Zaharia

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a master chef (a Large Language Model, or LLM) who is incredibly talented at writing recipes, but they don't know how to cook. Usually, to get a great dish, you have to hire a different specialist for every course: a pastry chef for dessert, a grill master for steak, and a sous-chef for soup.

The paper introduces optimize_anything, a new system that acts like a universal "tasting and coaching" loop. It claims that you don't need a different specialist for every job. Instead, you can use this single system to improve any text-based solution, whether it's a computer program, a set of instructions, a robot's brain, or even a drawing.

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

1. The Core Idea: The "Text Artifact"

The authors realized that almost any problem can be turned into a piece of text.

Code is just text.
A robot's instructions are just text.
A mathematical formula is just text.
A drawing (like an SVG) is just text code.

The Analogy: Think of the "text artifact" as a rough draft of a story. The system's job is to take that draft, read it, see how well it works, and then ask the AI chef to rewrite it to make it better.

2. The Secret Sauce: "Side Information" (The Coach's Notes)

In the past, if you asked an AI to improve something, it would only get a score (e.g., "This code got 60%"). It didn't know why it failed. It was like a student getting a "C" on a test with no feedback on which questions were wrong.

optimize_anything changes the rules. The system doesn't just give a score; it gives Side Information (SI).

The Analogy: Imagine a coach watching an athlete run. Instead of just saying "You ran in 10 seconds," the coach says, "You ran in 10 seconds, but you stumbled on the third hurdle because your shoe lace was loose, and you leaned too far left."
How it helps: The AI uses these specific notes (like error messages, crash logs, or visual descriptions) to fix the exact problem. The paper shows this makes the AI learn 4 to 6 times faster and achieve much higher scores than if it only had a simple score.

3. The Three Ways to Play

The system has three different modes, like different game modes in a video game:

Single-Task Mode (The Solo Player): You give the system one specific problem to solve, like "Pack 26 circles into a square." The AI tries to solve just that one thing.
Multi-Task Mode (The Study Group): You give the system a batch of related problems, like "Write 30 different computer programs to speed up math." The AI solves them all together.
- The Magic: If the AI figures out a trick for Problem #1 (like "use a faster memory trick"), it can instantly apply that same trick to Problem #15. It's like a student who learns a math shortcut in algebra and uses it to ace calculus. The paper found this mode was much better than solving problems one by one.
Generalization Mode (The Master Class): You give the AI a training set and a test set. The goal is to create a solution that works on new, unseen problems.
- Example: The AI learned to write a "skill guide" for a coding robot. It trained on one set of coding tasks and then became so good at the guide that it helped the robot solve brand new coding tasks it had never seen before.

4. What Did They Actually Achieve?

The paper tested this system on six very different types of problems. Here is what happened:

Robot Brains (Agent Architecture): They gave the AI a very simple, 10-line robot brain. The system evolved it into a complex 300+ line brain. The result? The robot's accuracy on a difficult logic puzzle (ARC-AGI) jumped from 32.5% to 89.5%.
Cloud Costs: They asked the AI to write a schedule for cloud servers. The new schedule saved 40% of the money compared to standard methods.
Computer Speed (CUDA Kernels): They asked the AI to write code to make graphics cards faster. 87% of the AI-written code was as fast as or faster than the best human-written code.
Math Puzzles: They improved a math exam prompt, boosting the AI's score from 46.6% to 60%.
Circle Packing: They asked the AI to pack circles as tightly as possible. The AI found a solution that was better than a famous previous AI (AlphaEvolve) and did it with less computing power.
3D Models: In a "seedless" mode (where the AI had to start from scratch with no code), it successfully generated a 3D model of a unicorn.

5. Why This Matters

Before this, if you wanted to optimize a robot, you needed a robot expert. If you wanted to optimize a cloud server, you needed a cloud expert.

optimize_anything claims to be the first "Universal API." It says: "Give me the text, give me the rules for how to score it, and I will handle the rest." It unifies these different worlds under one simple interface.

The Catch (Limitations):

It only works on things that can be written as text.
It needs a "scorer" (an evaluator) to tell it how well the text is doing.
The quality of the result depends on how smart the AI "chef" is.
Sometimes, if you ask it to solve too many totally different problems at once (like packing circles of different sizes), it gets confused. It works best when the problems are related.

Summary

optimize_anything is a tool that lets a single AI system learn to be a master optimizer for almost anything written in text. By giving the AI detailed feedback (not just a score) and letting it learn from multiple problems at once, it can discover solutions that are often better than specialized tools built by human experts for specific jobs.

Technical Summary: optimize_anything

Problem Statement

Current Large Language Model (LLM) optimization systems are largely siloed by artifact type and optimization mode. Existing tools like AlphaEvolve and OpenEvolve specialize in single-task code evolution, while frameworks like GEPA and MIPROv2 focus exclusively on prompt optimization with generalization capabilities. No single system has demonstrated the ability to optimize fundamentally different text artifacts—ranging from code and prompts to agent architectures and image generation parameters—simultaneously. Furthermore, prior systems often lack a unified mechanism for utilizing diagnostic feedback (Side Information) or support for multi-task search where insights transfer across related problems.

The paper posits that a wide range of optimization problems can be unified under a single formulation: optimizing a text artifact $x$ evaluated by a scoring function $f(x)$ that returns a score and optional diagnostic feedback. The goal is to create a universal API that supports single-task search, multi-task search with cross-problem transfer, and generalization to unseen inputs across diverse domains.

Methodology: optimize_anything

The authors present optimize_anything, a declarative API that implements a universal text optimization loop. The system is backend-agnostic but defaults to an extension of the GEPA algorithm, adapted for arbitrary text artifacts.

Core Interface

The system requires three primary inputs:

Seed Artifact: A starting text string (e.g., code, prompt, agent definition). In "seedless mode," the system bootstraps the first candidate from a natural language objective alone.
Evaluator: A function that executes the artifact and returns a tuple of a score (higher is better) and Side Information (SI).
Dataset/Validation Set: Optional inputs to define the optimization mode.

Three Optimization Modes

The system unifies three distinct modes under one interface, determined by the presence of datasets:

Single-Task Search: Optimizes a single artifact for a specific problem (e.g., packing circles). The evaluator scores the artifact directly.
Multi-Task Search: Optimizes a batch of related tasks simultaneously. The system maintains a shared Pareto frontier across tasks, allowing optimization patterns discovered for one task (e.g., a CUDA kernel optimization) to transfer to others.
Generalization: Optimizes an artifact to perform well on a training set while validating on a separate, unseen validation set. This mode extends beyond prompts to agent architectures and scheduling policies.

Key Algorithmic Mechanisms

Side Information (SI) as a First-Class Contract: Unlike traditional gradient-based optimizers that rely on scalar feedback, optimize_anything treats diagnostic feedback (compiler errors, profiler data, execution traces, rendered images) as a primary input. The LLM proposer uses this SI during a "reflection" step to diagnose failures and propose targeted fixes, mimicking an engineer iterating on a prototype.
Pareto-Based Search: Instead of collapsing multi-dimensional scores into a single aggregate, the system tracks scores per task or per metric. It maintains a Pareto frontier of non-dominated candidates. This preserves complementary strengths (e.g., a candidate good at Task A but average at Task B) and prevents premature convergence.
Candidate Selection & Reflection: Candidates are selected for mutation based on their frequency on the Pareto frontier. The proposer is shown a minibatch of examples and their corresponding SI to generate an improved artifact. A "refiner" step catches common generation artifacts (e.g., syntax errors) before evaluation.

Key Contributions

Unified Cross-Domain Optimization: The paper demonstrates that a single LLM-based system can achieve state-of-the-art results across six fundamentally different domains: agent architecture search, cloud scheduling, CUDA kernel generation, prompt optimization, circle packing, and image generation.
First Multi-Task Mode for LLM Evolution: The system introduces a multi-task search mode where solving a batch of related problems enables cross-transfer of optimization patterns, outperforming independent single-task optimization.
Actionable Side Information: The authors formalize diagnostic feedback as a uniform API contract. Ablation studies show that actionable SI yields 4–6 $\times$ faster convergence and substantially higher final scores compared to score-only feedback.
Open-Source Implementation: The system is released as part of the GEPA project, supporting multiple backends and providing a declarative interface that abstracts away mutation prompts, island configurations, and task-specific templates.

Experimental Results

The system was evaluated across six primary domains:

Agent Architecture (ARC-AGI): Optimized an agent system (code + prompts) from a 10-line seed to a 300+ line system, tripling accuracy from 32.5% to 89.5% on the ARC-AGI test set.
Cloud Scheduling: Discovered scheduling algorithms that reduced cloud data egress costs by 40.2% (CloudCast) and improved spot instance utilization (Can't Be Late), outperforming existing benchmarks.
CUDA Kernels: Generated kernels for 31 PyTorch operations where 87% matched or beat PyTorch baselines. Multi-task mode significantly outperformed single-task mode in speedup thresholds.
Prompt Optimization: Improved GPT-4.1-mini's accuracy on AIME 2025 math problems from 46.67% to 60.00%, outperforming MIPROv2.
Circle Packing: Surpassed AlphaEvolve's reported solution for packing 26 circles, achieving a higher sum of radii with fewer evaluations.
Image Generation: Optimized SVG and CAD code, with human evaluators preferring the results over zero-shot baselines.

Ablation Findings:

Side Information: Removing SI reduced final performance significantly (e.g., circle packing score dropped to 94% of optimal; kernel speedups dropped from 40% to 0% exceeding 1.1 $\times$ ).
Multi-Task vs. Single-Task: Multi-task search consistently outperformed single-task search on related tasks (CUDA kernels) due to pattern transfer. However, on unrelated tasks (circle packing with different $N$ ), multi-task search introduced noise and degraded performance.
Proposer Sensitivity: While larger models (GPT-5.1) achieved higher final quality, cheaper models (GPT-5-nano) still provided substantial improvements over seeds at a fraction of the cost.

Significance and Claims

The paper claims to establish text optimization with LLM-based search as a general-purpose problem-solving paradigm. It argues that by treating optimization problems as the improvement of text artifacts evaluated by scoring functions with diagnostic feedback, the need for domain-specific algorithms is reduced.

The significance lies in:

Unification: Unifying tasks traditionally requiring distinct algorithms (code evolution, prompt engineering, agent design) under a single framework.
Scalability of Transfer: Demonstrating that optimization patterns can transfer across related problems, scaling benefits with the number of tasks.
Actionable Feedback: Showing that converting scalar scores into actionable diagnostic signals (SI) is critical for the efficiency and effectiveness of LLM-based optimization.

The authors conclude that optimize_anything provides a declarative interface where users define what to optimize (artifact, evaluator, goal), and the system handles the how (search strategy, reflection, selection), effectively democratizing complex optimization tasks.