Building an agent skill optimizer with AlphaEvolve, Harbor and Gemini 4 Argon

Every day, more and more people are using coding agents like Google Antigravity and OpenCode to complete software engineering tasks. But those tools need instructions to operate and their output is only as good as the inputs they get. By utilizing agent skills that direct the agents through building, testing, and deploying code, developers have a powerful way to automate their workflows. 

But most skills are written manually, so it’s hard to know which instructions are effective without assessing their output.

To measure the effectiveness of our skills, we ran OpenCode with Gemini 3.8 Flash on tasks from Terminal-Bench 2.0, a public benchmark. The results were inconclusive: with our baseline skill, the agent passed about two-thirds of its attempts, but the outcome was about the same even without the skill. We needed better results.

To achieve them, we turned to AlphaEvolve, which optimizes skills the way it optimizes code: Gemini proposes a new version, an evaluator scores it, and the search retains the higher-scoring version. And with Harbor, that evaluator can be a real coding agent working on real tasks. We saw improvements of 5% with just a few iterations with alphaevolve

This is how you can build the same loop:

1. Treat the skill as the program: AlphaEvolve can rewrite your skill's text.

2. Let the agent judge: Harbor runs the agent with the skill on real tasks.

3. Make the score trustworthy: Compare each version to the baseline skill and run them both at the same time.

4. Check the winner on unseen tasks: Save some tasks the search never sees for your final check.

Treat the skill as the program

AlphaEvolve is designed to advance the code between two markers in a seed program. Skills are SKILL.md files with names, descriptions, and markdown instructions, so we put their text between the markers and let Gemini rewrite them:

AlphaEvolve operates in Google Cloud and doesn’t run your code. Its feedback is the scores and notes your evaluator sends back about what "better" means.

Let the agent judge

Harbor runs agents on benchmark tasks, with each trial in its own container. We ran it on Google Kubernetes Engine (GKE) with one pod per trial, and a single search ran thousands of agent trials.

For each candidate, the evaluator returns a score for passes and failures, as well as  short notes on tasks that failed or timed-out. AlphaEvolve then sends those notes to Gemini for the next version.

Make the score trustworthy

Agent scores can be noisy. In one of our early runs on the same benchmark, our model’s latency explained much of the variance in candidate scores. With each candidate running next to the baseline skill on the same tasks at the same time,  their scores are the difference.

Check the winner on unseen tasks

The best skills read differently than the baseline, which is a careful checklist: read first, reproduce the failure, and work in small verified steps. AlphaEvolve's version is a protocol built around the time limit:

What we learned

AlphaEvolve focused on the most common failure: running out of time. About a third of the search's trials hit their time limit, as reported in the evaluator's notes, and AlphaEvolve's best skill is built around that limit.

We also found that running the search is harder than building the loop. After about 10 hours, the search scored no new candidate; our latency check held back every evaluation while model responses were slow, and full agent logs filled the controller's disk. It’s important to plan for slow model windows and for log storage before a long search.

In addition, skills paid off when they added what the agent lacks, as advised by the Agent Skills best practices. Our baseline skill made no measurable difference, while the skill holding the answers added 33 points on the dev tasks.

Our hypothesis: today's models and coding agents are already tuned for coding work, so general advice has little left to add. If so, the room is in specifics, which a search can find: AlphaEvolve's best skill is built around the agent's most common failure, running out of time.

What's next

We’re testing AlphaEvolve on enterprise agent harnesses — system prompt, policy instructions, and tools —  where the agent lacks business rules that a search can add. In one small study on customer service test cases for a fictional bank, AlphaEvolve found and fixed a wrong policy rule we had planted, and carried the fix over to cases it never saw.

Other small studies were mixed, and we’ll share our final results when we’ve completed the full study. 

Get started

• AlphaEvolve on Google Cloud: the GitHub repository.

• Benchmark and harness: Terminal-Bench 2.0 and Harbor.

• Agent skills: the format at agentskills.io and the opencode skills docs.

Thanks for reading! Tell us what your own tests show on LinkedIn or X.