# Self-Improvement of Context, Harness, and Model Weights through Reflective Optimization — Lakshya Agrawal — session 2026-07-01T21:25:00.000Z → 2026-07-01T21:45:00.000Z

_56 transcript lines · 38 slides · source: full recording_

## Transcript

And so the contract is what makes that handoff safe. And you know, the best part is that defining the shape forces you to get really clear and specific. Because if you can't say what the output should look like, then you probably don't yet fully understand what you're asking. Hi, everyone. My name is Lakshya a Agrawal, and today I'll be presenting on behalf of a very large effort, the problem of reflective optimization or how can we self improve prompts, agents. And models from textual feedback. The question we start with is how can we teach AI to perform new tasks? The standard way has been to perform weight updates with gradient descent, either during pre training, supervised fine tuning, or reinforcement learning. This has proven to be extremely effective, but it requires a huge number of examples, trillions of tokens for pre training, tens of thousands of labeled examples for supervised fine tuning, or hundreds of thousands of rollouts. For reinforcement learning in domains like math, coding, etcetera. However, most teams do not actually have that much data or compute. And in fact, the problems are that we are trying to tackle with AI now are bottlenecked by sample efficiency. What do we mean by that? Two things. First of all, there is low availability of domain specific knowledge resources, which means there is not enough data to perform offline algorithms. Take SFT. Second, the domains that we are trying to apply AI increasingly are having expensive rollouts where either the LLM workflow pipeline or agentic rollouts are itself, very slow or expensive to do or the task metric is very slow or expensive to execute. We are seeing that agents can now work for hours on end. And if you were to apply an online learning algorithm to this, it would require hundreds of thousands of rollouts and it would not be feasible. So Seeing increasing use of agents for real world product, applications where, these invoke tools, which can also be long running further exacerbating the sample inefficiency issue. The current dominant paradigm is reinforcement learning with verified rewards, where given a model and a task, we perform a number of parallel rollouts and get rewards at the end. Finally, an algorithm like GRPO takes these rewards and converts it into gradients that are applied back to the Model. However, as we can see, there was a lot of information in each of these rollouts, but we only learned an O of one score and propagated that via gradient descent. We can see that there is change of thought, the tool calls made to the environment, the environment's responses to those tool calls, which could potentially contain error messages, which also provide diagnostic value. And we'd learned almost nothing from all of that. So the question we Ask us, can we make use of this other extremely rich information? Our idea is to perform reflective optimization in text space, where instead of only using the zero or one reward signal, we can have a language model or an agent look at the trace of the entire rollout and reflect on what worked in them, what did not work in them. And this reflection could potentially use all intermediate outputs and potentially even make other two. Call such as retrieval from your company's knowledge base or some guide textbook and so on. So that's the first key idea. And the second is that instead of only updating weights with small deltas, we can instead update a prompt where a single natural language update can give a very large behavior change. Let's take a simple example. Let's say you're tasked with writing a text summarization system. And the prompt of that system says generate a one line summary. If I Just go and tweak that prompt to say generate a 10 line summary. We can all agree that the behavior of the system would change quite significantly with that just one word change. And making that one word change is quite quick, and we can reflect on our own behavior and identify what needs to change. If we were to achieve a similar kind of behavior update from our AI system, we would have to have thousands of gradient, very tiny gradient updates sequentially. So with that key idea, we propose Jepa. Which is a reflective prompt optimization technique for agents. It uses an evolutionary loop along with a novel Pareto based candidate selection, which I will come to later. It is akin to doing reinforcement learning in tech space, where instead of just rewarding receiving a reward score, we are actually obtaining score along with textual feedback, which can be very domain specific and learn, all about the domain from it. Let's compare Japa with gRPO, which is one of the leading RL techniques. On the x axis, we have the number of training steps, also proportional to number of data samples seen. And on the y axis, we have the performance on our domain that we are training for. And what we can see is that Jepa, in just one round of reflection using just three data points, is already able to get twice the performance gains that GRPO got after 25,000 rollouts. Continuing to run Jepa for a few more steps further increases that gap. Itself by another two x. I want to note here that the model coen38b is optimizing itself here. There is no external expert teacher involved whatsoever. And what does Jepa learn? Unlike prior prompt optimizers somewhat which would, use model idiosyncrasies like my grandmother will be really angry if you don't generate a good prompt. Here, Jepa is actually giving a very detailed problem specification. Which includes how to make sense of the input, what is the purpose and context of this particular pipe part of the pipeline, what are some key observations and lessons from the data. So the prompt we are seeing here is for the second hop of a multi hop question answering system where, given a question, we need to retrieve some documents that could potentially answer that question, look at those documents, summarize it, and then finally answer the question. And here, what we see is Jepa has found out that first hop documents that often cover one entity or aspect, and the second hop should actually be, Documents that are related to it. We have seen that human engineering teams, whenever a new model comes out, spend weeks of their time manually tweaking one word here and there, trying to discover the problem specification. This entire process is fully automated now with Japa, which takes about half an hour to one hour to run depending on your, pipelines. We can also apply Jepa to leading proprietary models. Just for an example, here, we were able to optimize GPT 4.1 Mini's performance to outperform GPT 4.1 on a math task, and we can see the kind of information distillation Jepa has done in the prompt space itself. Coming back to the problem of sample efficiency, AMD developed a new hardware accelerator called NPU xDNA2, which used a completely new API to program. Which had almost zero available information over on the Internet. And because of this, the leading models at the time, which was GPT four o, was failing miserably to perform this task. We are able to take an existing agent which was getting 4.25% on this task and apply Jepa without any other change to the agent itself, and we got this prompt and push this performance seven x to 30.52%. So what this is, what this goes to say is there can be Lots of domain specific information, which if you include in your AI systems prompts, the models could actually perform much better. And Jepa can help you fully automatically discover that. I want to highlight the sentence saying avoid including ADF dot h. Now the interesting thing is AMD actually ships a library called adf dot h for programming NPUs, but that did not work with this latest, generation of hardware that we were working with, and Jepo was able to discover that in just one step. So how Does it work? It's an extremely simple algorithm, which simply takes your AI pipeline written in any agentic framework or even raw LLM calls that you may have. It simply runs your systems on a few examples and collects domain specific feedback. Whatever information your environment contains is observed. Second, it runs reflection with an LLM or agent that reads the feedback and proposes a better prompt. Finally, and most importantly, it keeps a Pareto pool where it keeps every single candidate That wins on even one training example and not just the top scorer. The question is, but why keep a Pareto pool? And we keep getting asked this question a lot that is JEPRA really better than running the model in a loop? So we went and tested it out. And what happens is a loop keeps only the best and gets stuck in a local optima. So on the left hand side, you see a search tree that was generated by using an LLM in a loop. Starting from a seed prompt at the top left, Where, we asked the LLM to improve the prompt. It improved the prompt, and it generated a prompt that gave us the middle node. However, this prompt got stuck in a local optima. And once again, when we asked the LLM to try and improve it, it proposed something, but that was not actually better. So it went back and it again tried to improve it. And it kept doing this and it exhausted all of the search budget. On the other hand, with Japa's Pareto based candidate selection strategy on the right, we can see that it maintains a much more balanced search process. Eventually converging to a much higher score. Across four benchmarks, we saw that more than half of the gains swing with Japa actually account for this. And it gets almost twice the performance gains that you would get with just applying the model in a loop. JPA can perform really well across diverse benchmarks. Here we see results on question answering, instruction following, claim verification, as well as math, which all the leading frontier model companies are already optimizing their models a lot for. And we are still able to get plus 10% just by optimizing the prompt on it. So we have so far seen Japa only optimizing the prompts, but Japa goes far beyond prompts. And because prompts are just text artifacts that determine AI system behavior, the same algorithm can improve anything that you can express as a piece of text and you can score. For example, your entire agent harness is eventually just a Python or a JavaScript file, and we can apply the same kind of reflective optimization process. To that entire file and we can work with it. So if you can write it as text and score it, Japa can optimize it. So with that insight in mind, we propose optimize anything, which is a universal API for optimizing any text parameter, given any domain like code optimization, where let's say you want to optimize a CUDA kernel code. The input is just that CUDA kernel code where an evaluator looks at this piece of code, maybe compiles it, profiles it, generates a bunch of Related information that we call as actionable side information, which is then provided to an LLM, which proposes a better candidate maintaining this Pareto pool. And it keeps the, repeating this process, till we get convergence. The same thing can be applied to numeric optimization where your numbers can actually be serialized as text or harness optimization where an entire harness can be serialized as text or even cloud scheduling policy optimization where the scheduling policy or heuristic algorithm can be expressed as a piece of Text. And the evaluator can be something like the negative of cost or some function measuring accuracy, efficiency. And the actionable side information can be something like job traces, SLA violations, and so on. The API is dead simple to use. All it requires is you give us the set of problems that you care to be solved along with an evaluator function or a fitness function that returns a score along with any available domain specific site information. If your domain produces expert fee. Feedback, return that. If your domain produces compiler error messages, profiler messages, tool call error messages, return that. If you have maybe a written up documentation, return that. Any kind of it's a very open ended dictionary. You can return literally anything. And all you do is you call optimize anything with this fitness function and the set of problems that you have and optimize anything will sort of take care of it, and give you an optimized solution. Let's see some application. Let's say you were tasked with generating A three d unicorn. This is all the code that you would write or your agent can now write it because we have seen that optimize anything is a very easy to use API for leading agents like plot code. So all you do is write this code which says optimize a Python program to generate a three d unicorn, and the candidate is a Python script that produces a PNG rendering, whatever. And here is the result. On the left hand side, we can see Claude Opus 4.6. If you gave it this task, this is what it generated. And on the right hand side, what we the unicorn that we get with Optimize Anything. This is so fun, but let's say you were tasked with writing an agent to solve a specific task. Typically, teams spend lots and lots of time tweaking their agents, building tools for it, writing tool descriptions, carefully orchestrating the control flow, and so on. Here, we started with a simple four line Python program that was simply calling a model's chain of thought to solve. An RKGI problem. Within just 16 rounds of reflection, JEPA within Optimize Anything was able to find this sophisticated six step agent that took RKGI accuracy on RKGI, that took RKGI accuracy of Gemini flash from 32.5% to 89.5%. And we can see that this agent is automatic like, by itself doing rule hypothesis induction code synthesis. It executes and traces the code automatically debugs this code. Goes back and proposes new versions of that code. And finally, it runs it on the actual test inputs and returns the output. This is a runnable example. You can go to this QR code and you can run this example right now. So, applying the same, like approach of discovering agent harnesses to math 500, we are able to push its accuracy of GPT 4.1 nano by 20% by simply creating a two step agent. And again, I want to emphasize that All we did is we asked optimize anything to optimize an agent file, and it was automatically discovering the sophisticated agent architecture, and we did not have to do anything other than specifying the objective and the task. Finally, every single one of us is using, some coding agent like Cloud Code or Codex or maybe your favorite agent. And agent skills has become a very leading part of the ecosystem where almost all coding agents understand skills. Let's say you want To optimize skills for your specific repository. This is the code that you write, which says learn a skill from the trajectory. When the coding agent is presented with similar problem, the skill should be helpful. We just give it this natural language behavior. And what we see is we started with mini sui agent with GPT five minutei because we were very budget constrained. And we were able to take its performance from 24% to 93%, an almost three x jump on Go repository issue resolution, but more Importantly, the skills that were optimized very cheaply on a GPT five minutei agent, we are able to take that and apply to the latest Claude SONNET. This was done of, about a few months back, but we applied it to Claude SONNET 4.5, pushing its accuracy to 100% issue resolution while, more importantly, cutting down the execution time or issue resolution time by almost 50%. We cut it down into half, which also means it, spent less tokens because skills contain information about how the repository is organized, how to invoke the test cases, where a particular feature is implemented. What are the build system used by this repository and so on. This is a a feature called GSKILL. You can find it in the Japa repository, and it's fully open source as well. So Optimize Anything is a single, interface that provides three optimization modes. If you have just a single problem, like there is a single matrix multiplication kernel that you want to optimize, you can use it that way. If you have any number of related problems, like you want to optimize Matrix multiplication kernel along with the dot product kernel. And you know there might be some information transfer between these two. You can use what we call as the multitask search mode. And finally, build a skill, which is if you want to optimize on a set number of problems, but your, deployment can actually come up with many new problems. So, like, in case of map op like, in case of map prompt optimization, we are training on some examples. But when we deploy it, we can receive a completely new kind of query. So we care about generalization modes. So there you can do Prompt optimization, agent architecture optimization, and so on. So Optimize Anything is can be used for a broad set of domains, including cloud scheduling policy optimization, where we are able to cut costs by almost 40% compared to expert heuristics, write custom solvers to match and exceed Optima even in black box mathematical optimization, create agent skills, prompt optimization, and so on. It is so easy to use that within just twenty hours of releasing Get people at Snorkel had already improved some of their internal benchmarks with it and were tweeting about it. So and Jepa also improves multimodal VLM models performance. Here, we are able to cut OCR error rates for leading models by almost 35%, And this is an externally validated report. Similar similarly, Databricks actually achieved 90 x cost reduction in their deployed agent performance, performance. And here they were able to tune GPT OSS one. 20 b to outperform Claude Opus while being 90 x cheaper. More importantly, the performance delta improvement that you see on top of Claude Opus is actually bigger than the one you see on open source models. Some people have asked me that, oh, as models get better, the importance of prompt optimization will go down. I argue the opposite, which is as models get better, they will get better at instruction following. And the more precise instruction about your task that you have to give to a very smart model, the better that Will be at, solving your task. And this is exactly what we see happening here. The better the instruction was, cloud opus actually jumped much, higher. Some people have this question of, what if we have subjective tasks which are very hard to evaluate? JPA can actually learn evals for your task from production traces. The way to do that is you collect a bunch of production traces from your agent, get a human to annotate just about 50 of those trajectories, giving very detailed feedback. This is a long response. This is a short response. This is a good response. This uses this terminology, whatever. And once you get those human annotations, you can use Japa to optimize an LLM as a judge prompt, and you can use that LLM as a judge prompt then to go back and optimize your agent and deploy that agent.

## Slides

### 00:00:20

**User Interactions:**
- A user's natural language input: "Great place — I'd tour this one."
  - *Comment:* This is "X a dead end

### 00:00:46

# AI Engineer World's Fair
- Amazon AGI Lab
- OpenAI
- together
- TADOG

[Logo for "together" showing three overlapping circles]

### 00:01:19

# How can we teach AI new tasks?

Standard way: **weight updates** with gradient descent: pretraining, supervised fine tuning (SFT), reinforcement learning (RL)

## Engineering the future of AI
[Small logo resembling a four-leaf clover or pinwheel in the bottom right corner of the slide]

### 00:01:48

# How can we teach AI new tasks?

Standard way: **weight updates** with gradient descent: pretraining, supervised fine tuning (SFT), reinforcement learning (RL)

Very effective, but requires huge numbers of examples!
- Trillions of tokens for pretraining
- 10,000s of labeled examples for SFT
- 100,000s of rollouts (trials) for RL (math, coding, etc)

Most teams do not have that much data or compute.

### Engineering the future of AI

### 00:02:15

# Why this is hard in practice

- **Low availability** of domain specific knowledge resources
- **Expensive rollouts**: either the LLM workflow for the task or the task metric is slow/expensive to execute

Engineering the future of AI

[Image of a document titled "AI Engine ML Kernel and Graph Programming Guide"]
[Illustration of a clipboard with "TASK" and a checklist, with a magnifying glass highlighting a green checkmark]

### 00:02:49

# The current dominant paradigm

RL with verified rewards:

[Diagram showing a neural network model branching into three rollouts. Each rollout is a sequence of actions/observations represented by icons (speech bubbles, magnifying glass, black square, wrench) and leads to a reward value (1 or 0). Rollout 1 and 3 yield a reward of 1, while Rollout 2 yields a reward of 0.]

### 00:03:18

# The current dominant paradigm
## RL with verified rewards:

[Diagram illustrating a reinforcement learning process: a 'Model' generates three 'Rollouts' (sequences of actions/observations represented by icons), each leading to a binary 'Reward' (1 or 0), with feedback loops back to the model.]

There was a lot of information in each rollout, but we only took a 0/1 score and propagated that via gradient descent. Can we use the other info?

# Engineering the future of AI

### 00:03:53

# Idea: Reflective Optimization in Text Space

Instead of only using the 0/1 reward signal, have a LM look at the traces of all the rollouts and **reflect** on what worked in them (using **all intermediate outputs**, and potentially even other tools, such as retrieval!)

Agent
- Tool Invocation
- Retrieval
- Guardrails

[Diagram illustrating a system with a central document processing step, multiple model layers, a database, a calculator, and a terminal, all interconnected with arrows indicating data flow and feedback, managed by an Agent with capabilities for Tool Invocation, Retrieval, and Guardrails.]

### 00:04:22

# Idea: Reflective Optimization in Text Space
- Instead of only using the 0/1 reward signal, have a LM look at the traces of all the rollouts and **reflect** on what worked in them (using **all intermediate outputs**, and potentially even other tools, such as retrieval!)
- Instead of only updating weights with small deltas, **update a prompt**: a single natural language update can give a large behavior change

### Engineering the future of AI

[Diagram showing an Agent interacting with a database, document traces, multiple language models, a calculator, and a terminal, with supporting functions for Tool Invocation, Retrieval, and Guardrails.]

### 00:04:49

# Idea: Reflective Optimization in Text Space

Instead of only using the 0/1 reward signal, have a LM look at the traces of all the rollouts and **reflect** on what

### 00:05:17

### RL in text space: Instead of just receiving a reward score, we obtain <score, text feedback>

## GEPA: Reflective Prompt Optimization for Agents

### Genetic
- Leverage text feedback to create good prompts from genetic pool

### Pareto (Multi Objective)
- Discovers test case specific solutions first and aggregate later

### 00:05:46

# GEPA vs GRPO: Multi-Hop QA
[Line graph (a) titled "HotpotQA, Qwen3 8B" shows GEPA and MIPROv2 achieving higher scores than Baseline and GRPO over increasing rollouts.]
[Line graph (b) titled "HoVer, Qwen3 8B" shows GEPA and MIPROv2 achieving higher scores than Baseline and GRPO over increasing rollouts.]

### 00:06:20

# Seed Prompt for Second-Hop of Multi-Hop QA System
Given the fields question, summary_1, produce the fields query.

# GEPA's Optimized Prompt for Second-Hop of

### 00:06:54

# Engineering the future of AI

## Seed Prompt for Second-Hop of Multi-Hop QA System
Given the fields question, summary_1, produce the fields query.

## GEPA

### 00:07:19

# Seed Prompt for Second-Hop of Multi-Hop QA System

Given the fields question, summary_1, produce the fields query.

## GEPA's Optimized Prompt for Second-Hop

### 00:07:51

# GEPA on GPT-4.1-mini: Math

You will be given a mathematical problem to solve. Your task is to provide a detailed, step-by-step solution that clearly

### 00:08:20

# GEPA for Programming a New AMD Accelerator

You are tasked with generating C++ code for a single kernel function that will run on an AI Engine (AIE) tile. The kernel

### 00:09:14

# How GEPA works

## 1. Run
Run your system on a few examples and collect the feedback.

## 2. Reflect
An LLM/Agent reads that feedback and proposes a better prompt.

## 3. Keep a **pareto pool**
Keep every candidate that wins on even one example, not just the top scorer.

Engineering the future of AI

[Flow diagram showing three steps: Run, Reflect, and Keep a pareto pool, connected by arrows]

### 00:09:50

# Is it better than running the model in a loop?
A loop keeps only the best and gets stuck in local optima. GEPA keeps a pool of candidates and explores.

| | Hotpot

### 00:10:48

# GEPA Performance across diverse benchmarks

## Engineering the future of AI

[Four bar charts comparing the performance of Baseline, GRPO, MIPROv2, and GEPA Best-1 methods across HotPotQA, Instruction Following, HoVer, and AIME benchmarks, with GEPA Best-1 consistently showing the highest scores.]

### 00:11:18

# GEPA optimizes more than prompts
- Prompts are text artifacts that determine AI system behaviour.
- The same algorithm improves anything you can write as text and score.
- For example, it can rewrite the entire agent harness instead of just the prompt

> If you can write it as text and score it, GEPA can optimize it.

## Engineering the future of AI
[Logo of a four-leaf clover-like shape in green and blue]

### 00:11:48

# optimize_anything: A Universal API for Optimizing any Text Parameter

### optimize_anything Universal Interface for Text Optimization
Any optimization problem can be expressed as maximizing evaluator **f** over

### 00:12:20

# optimize_anything: A Universal API for Optimizing any Text Parameter

## optimize_anything Universal Interface for Text Optimization

Any optimization problem can be expressed as maximizing evaluator `f` over strings by serial

### 00:12:50

## optimize_anything: A Universal API for Optimizing any Text Parameter

```python
# Dataset: Q&A pairs to optimize for
dataset = [
    {"question": "What is

### 00:13:20

# optimize_anything: A Universal API for Optimizing any Text Parameter

```python
# Dataset: Q&A pairs to optimize for
dataset = [
    {"question": "What is

### 00:13:52

# 3D Modeling

```python
result = optimize_anything(
    seed_candidate=None, # no starting code - the LM writes the first draft
    evaluator=evaluate_3d_render, # 4 aspects: quality, anatomy, mesh, appeal
    objective="Optimize a Python program (build123d + pyrender) to generate a 3D unicorn.",
    background=(
        "The candidate is a complete Python script that produces multi-view PNG renderings. "
        "Use build123d for CSG geometry, export to STL, render with pyrender. "
        "Known working imports:

### 00:14:21

# optimize_anything for Agent Architecture Discovery

[tinyurl.com/gepa-agent-search](tinyurl.com/gepa-agent-search)

### Base ARC Agent (Chain-Of-Thought Input to GEPA)
Inputs -> LLM (Chain-Of-Thought) -> Outputs

- Start
- Inputs
  - Training examples
  - Test inputs
- 1) Single LLM Step
  - LLM: Chain-Of-Thought
- Outputs
  - Test outputs
- End

ARC-AGI: 32.5%

### GEPA-Evolved ARC Agent
Hypothesize -> Synthesize -> Execute -> Debug/Refine -> Apply
LLM-driven solve + self-correction

- Start
- Inputs
  - Training examples
  - Test inputs
- 1) Rule Hypothesis
  - LLM: Chain-Of-Thought
- Artifact
  - NL Rule
- 2) Code Synthesis
  - LLM: Predict
- Artifact
  - Python Function (code)
  - `def transform_matrix()`
- 3) Execute &

### 00:14:51

# optimize_anything for Agent Architecture Discovery

## Base ARC Agent (Chain-of-Thought) Input to GEPA

- Inputs:
    - Training examples
    - Test inputs

### 00:15:23

# optimize_anything for Agent Architecture Discovery

### ARC-AGI, Gemini-3-Flash

### MATH Dataset (500 Questions)

## Engineering the future of AI

[Line graph showing Accuracy (%) versus Total Metric Calls, with a step function increasing from a base of 32.50 to 93.50, and a best test score of 89.50.]
[Bar chart comparing scores for "Chain of Thought" (56) and "GEPA Discovered 2-step agent" (76.2) on the MATH Dataset.]

### 00:15:50

# optimize_anything: Learning Agent Skills to boost Claude Code

The same API can optimize claude-code (or your favourite agent's skills)!

```python
result = optimize_anything(
    seed_candidate=None,
    evaluator=..., # a coding agent (minisweagent)
    objective={
        "Learn a skill from the trajectory. When the coding agent is presented"
        "with similar problems, the skill should be helpful to solve them"
    }
)
```

### 00:16:25

## optimize_anything: Learning Agent Skills to boost Claude Code
- Directly optimize **SKILL.md** with tasks created automatically from existing repository data

### Engineering the future of AI

[Bar chart comparing "Baseline (No Skills)" and "With GEPA Skills" performance for Mini-SWE-Agent on Jinja and Bleve repositories, showing improved test set resolve rates with GEPA Skills]

### 00:16:57

# optimize_anything: Learning Agent Skills to boost Claude Code

Directly optimize **SKILL.md** with tasks created automatically from existing repository data

## Mini-SWE-Agent (gpt-5

### 00:17:20

# optimize_anything: One Interface, Three Optimization Modes

What is the Goal?

-   **I want answers**
    -   Solve Specific Problem(s) (Search Mode)
        -   One Problem (Single-Task Search)
            -   e.g., Blackbox function optimization
        -   Many Related Problems (Multi-Task Search)
            -   e.g., Writing CUDA Kernels for multiple algorithms but same hardware
-   **I want a system**
    -   Build a Skill (Generalization Mode)
        -   e.g., Prompt Optimization, Agentic Architecture Optimization

## Engineering the future of AI

[Flowchart illustrating three optimization modes based on the user's goal]

### 00:17:46

# optimize_anything: One Interface, Three Optimization Modes

[Flowchart illustrating optimization modes]
- **What is the Goal?**
  - **I want answers**
    - **Solve Specific Problem(s) (Search Mode)**
      - **One Problem (Single-Task Search)**
        - e.g., Blackbox function optimization
      - **Many Related Problems (Multi-Task Search)**
        - e.g., Writing CUDA Kernels for multiple algorithms but same hardware
  - **I want a system**
    - **Build a Skill (Generalization Mode)**
      - e.g., Prompt Optimization, Agentic Architecture Optimization

Engineering the future of AI
[Flowchart showing a decision tree for optimization modes, starting with "What is the Goal?" and branching into "Solve Specific Problem(s) (Search Mode)" or "Build a Skill (Generalization Mode)", with further sub-branches and examples.]

### 00:18:17

# optimize_anything for policy discovery, kernel optimization and more!

- optimize cloud scheduling policies that cut costs by 40%, beating expert heuristics
- write custom solvers to match and exceed Optuna in blackbox mathematical optimization
- create agent skills achieving near-perfect Claude Code task completion 47% faster
- find detailed system prompts to boost GPT's math reasoning accuracy

## Engineering the future of AI

### 00:18:51

# GEPA improves Multimodal/VLM Performance (OCR)
## OCR Model Performance — GEPA Optimized vs Original (Intrinsic Labs)
Figure 1: GEPA improved JSON extraction accuracy from baseline

### 00:19:22

# GEPA for Complex Information Extraction
### Building State-of-the-Art Enterprise Agents 90x Cheaper with Automated Prompt Optimization
Source: Databricks Blogpost at [https://

### 00:19:51

# Hard to score (subjective tasks)? GEPA can learn evals from production traces

## Step 1

| Prompt            | LLM Response      | Human Annotation |
| :---------------- |