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

Google Cloud engineers Ivan Nardini and Anant Nawalgaria detailed an automated system optimizing coding agent instructions with AlphaEvolve, Harbor, and Gemini models, as documented in Google Cloud Blog's report. The team addressed a common issue: manual agent skills rarely outperform bare models. Testing OpenCode with Gemini 3.8 Flash on Terminal-Bench 2.0 showed a human baseline skill matched the pass rate without any skill. By evolving markdown instructions in AlphaEvolve and testing trials in Harbor, the team achieved a five percent performance improvement across a few iterations.

This report details the technical architecture, execution mechanics, and operational constraints uncovered during Google Cloud's trials. Developers and machine learning engineers directing tools like Google Antigravity can examine how prompt evolution replaces manual prompt writing. The analysis explores how Harbor collects test notes across Google Kubernetes Engine, how concurrent baseline runs isolate model latency noise, and how storage bottlenecks emerge during extended runs. Readers will discover how evolutionary search produces practical survival rules that prompt checklists overlook when guiding agents through containerized Linux environments.

Building an agent skill optimizer: what actually changed

The experimental framework replaces manual prompt crafting with an automated evolutionary loop treating agent skill files as modifiable code. Developers write SKILL.md documents with descriptions and markdown instructions to steer coding assistants like Google Antigravity and OpenCode through building and fixing software. Because human instructions lack systematic testing, Google Cloud wrapped skill text inside EVOLVE-BLOCK markers within a Python seed program. AlphaEvolve updates the text using Gemini, while Harbor runs instructions on Terminal-Bench 2.0 tasks, shifting agent guidance from guesswork to measurable optimization.

The resulting performance data showed clear advantages over standard human instructions. In initial Terminal-Bench 2.0 evaluations, OpenCode paired with Gemini 3.8 Flash solved two-thirds of tasks, showing identical results with or without the baseline skill. Introducing AlphaEvolve's evolutionary search improved task success rates by five percent across a few iterations. On specialized developer tasks where the skill supplied domain answers, the score increased by thirty-three points, confirming that agent skills add value only when providing specific operational knowledge missing from the foundation model.

Building an agent skill optimizer: how it works

The optimization pipeline connects AlphaEvolve to Harbor's execution environment in a continuous feedback loop. AlphaEvolve operates in Google Cloud without executing target code directly, using Gemini to generate revised skill descriptions and markdown bodies. Harbor deploys each evaluation trial into an isolated container pod on Google Kubernetes Engine, running thousands of agent trials during a search. The evaluator tracks completions, failures, and notes, returning them to AlphaEvolve. AlphaEvolve feeds failure summaries into Gemini 4 Argon to generate refined instruction variants for subsequent rounds.

To prevent model latency swings from skewing results, Harbor evaluates candidate skills concurrently alongside the baseline skill on identical benchmark problems. Early trials revealed that fluctuating Gemini response times created significant score variance, which side-by-side relative scoring resolved. When an agent fails or runs out of time, Harbor captures diagnostic logs for AlphaEvolve to review. Once the evolutionary search completes candidate iterations, the top-performing skill is tested against reserved unseen Terminal-Bench 2.0 tasks to verify performance gains generalize beyond the training environment.

Building an agent skill optimizer: why it matters

Automated optimization revealed that traditional prompt engineering advice fails to enhance modern coding agents. Google Cloud's human baseline skill emphasized conventional practices: inspect repositories first, reproduce bugs locally, and execute changes in small, verified steps. However, evaluation demonstrated contemporary models already incorporate general programming principles, making generic instructions redundant. Evaluator data showed that roughly one-third of failed runs occurred because agents hit container time limits. Consequently, AlphaEvolve abandoned polite checklists to construct an aggressive operational protocol focused directly on runtime efficiency and timeout avoidance.

The evolved skill introduced defensive coding rules protecting solutions from sudden container timeouts. AlphaEvolve directed agents to write a functional baseline artifact to disk immediately, preserving working code for files like gpt2.c, eigen.py, or my_warrior.red before attempting further optimizations. The evolved instructions mandated an immediate hard stop whenever acceptance checks or eval.py passed. Discarding conversational guidance for strict termination conditions confirmed prompt optimization succeeds when resolving concrete agent failure modes like timeout expiration, rather than repeating basic programming principles foundation models already understand.

Building an agent skill optimizer: who is affected

Developers configuring coding agents like OpenCode and Google Antigravity must re-evaluate how they manage skill repositories. Platform teams relying on static SKILL.md files formatted under agentskills.io specifications should establish objective benchmarking pipelines rather than assuming detailed prompts improve agent accuracy. Research demonstrates that unverified instructions consume context window space without improving task completion over base models. Engineering organizations automating software workflows must adopt containerized harnesses like Harbor on Google Kubernetes Engine to test whether customized agent skills provide measurable gains on production repositories.

Enterprise architects designing agent harnesses, system prompts, and tool policies gain practical methods for validating business rules. Google Cloud applied AlphaEvolve to customer service scenarios for a fictional bank, where the optimizer detected a planted policy error and corrected it across unseen evaluation cases. Although additional enterprise trials produced mixed results, the experiment provides a framework for auditing regulatory guardrails and automated workflows. Teams building corporate agents can utilize evolutionary search to identify contradictory instructions, refine operational policies, and ensure autonomous systems adhere to verified enterprise guidelines.

Building an agent skill optimizer: what to watch

Infrastructure teams must anticipate operational hurdles before deploying multi-hour evolutionary search loops. During Google Cloud's testing, the optimization search stalled after roughly ten hours without evaluating new candidate versions. Elevated model response latency activated automated safeguards that delayed evaluations, while detailed agent logs overwhelmed controller disk storage on Google Kubernetes Engine. Organizations running similar pipelines must implement proactive log rotation, dedicated storage volumes, and resilient evaluation monitors to handle slow model response windows without halting large-scale evolutionary search operations across thousands of container trials.

Practitioners should monitor Google Cloud's forthcoming research as the team concludes wider testing across enterprise agent harnesses. While policy tests on the fictional banking dataset demonstrated automated rule correction, mixed results across other domains highlight the need for further validation. Developers should follow updates in the public AlphaEvolve repository, Harbor testing harness, and Terminal-Bench 2.0 evaluation suite. As models transition from Gemini 3.8 Flash to Gemini 4 Argon, observing whether automated skill evolution consistently unlocks performance gains will determine its viability for mainstream software engineering workflows.