SkillFoxx

AlphaEvolve on Google Cloud skill

Six skills and the ae CLI: an agent runs an AlphaEvolve experiment from problem setup to merging the best evolved code

  • 130 ★ on the repository
  • Last commit
  • Apache-2.0
SkillEditors’ pick

Broad access

Why this level

  • Starts paid Gemini calls and compute in your Google Cloud project.
  • The agent gets access to gcloud credentials and edits code.
All reasons and checks

google-cloud-ai/alphaevolve-on-googlecloudAuthor:Google-Cloud-AI

Install

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/alphaevolve-on-google-cloud

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Broad accessThe tool can change data, run commands or handle secrets.

  • Starts paid Gemini calls and compute in your Google Cloud project.
  • The agent gets access to gcloud credentials and edits code.

This is third-party code. Review the repository files before installing.

What it does

AlphaEvolve is Google's Gemini-powered evolutionary coding agent that discovers and improves algorithms: the user supplies a seed program and a scoring function, and the system proposes edits generation after generation, evaluates candidates and moves the population toward better solutions. The repository holds a client library, examples for several Google Cloud environments and a set of skills. Six skills lead an agent through the whole cycle. `alpha_evolve_experiment_design` scaffolds an experiment with a test-driven approach and writes the evaluator, `alpha_evolve_runner` validates connectivity and launches the run through `ae`, `alpha_evolve_monitor` tracks the run and reports progress, and `alpha_evolve_post_experiment` analyzes results, builds reports and merges the best code into the project. `alpha_evolve_orchestrator` chains the stages and `alpha_evolve_consultant` answers questions from a read-only reference guide.

Who it is for. Engineers and researchers with Gemini Enterprise access in their own Google Cloud project who optimize Python code through evolutionary search.

Good fit when

  • An algorithm should be improved against a metric, for example circle packing or kernel speed.
  • The seed program and evaluator are not ready yet and are built with the agent.
  • A running experiment needs tracking with periodic reports.
  • The best code found must be carried back into the codebase carefully.

Not a fit when

  • There is no Google Cloud project with AlphaEvolve and Gemini Enterprise provisioned.
  • You need to evolve code in a language other than Python.
  • Several code locations are optimized at once while this version is tested on one.

Example request

Run alpha_evolve_orchestrator: help me describe the optimization task for my function and prepare an experiment.

Limitations

This version of the skills supports only Python code and is tested on one evolution location at a time. It was tested on Python 3.13.7 and newer and runs on Linux, macOS and Windows. It requires the Google Cloud CLI signed in with `gcloud auth application-default login`, the `uv` package manager, a project with a billing account and a Gemini Enterprise engine with AlphaEvolve provisioned. Experiments spend paid Gemini model calls and project compute, and the Cost section of the docs describes expenses. The authors recommend Gemini 3.5 Flash as the coding assistant.

How to disable. Remove the skills from the coding assistant's directory and the CLI with `uv tool uninstall` for the `ae` package. Stop running experiments in the Google Cloud console.

FAQ

How do I install the AlphaEvolve skills?

First `uv tool install "git+https://github.com/Google-Cloud-AI/alphaevolve-on-googlecloud.git#subdirectory=skills"`, then `ae skills install` and pick an assistant from the menu.

Which assistants are supported?

The install menu shows Gemini CLI, Antigravity, Claude Code and OpenAI Codex, plus a custom path.

How can I confirm the skills loaded?

Ask the assistant to list available skills: six `alpha_evolve_*` entries should appear.

How is the consultant different?

`alpha_evolve_consultant` only answers questions from the expert reference guide and runs nothing.

Can the loop be tried without infrastructure?

The Circle Packing example uses local Python evaluation and needs only AlphaEvolve API access.

Discussion

No questions or reviews yet.

Skills

An open framework where language models and evolutionary selection find and improve code for optimization tasks

CLIBroad access157
Editors’ pick

Google's CLI and skill set that helps a coding agent build, evaluate and deploy agents on Google Cloud with ADK and Gemini Enterprise

CLIBroad access6.3K

Agent memory over MCP: past work trajectories become guidelines for new tasks, with a lite version for Claude Code and Codex

MCP serverExtended access137

An agent evolution framework that edits prompts and skills with parallel workers and keeps only what passes a held-out check.

CLIBroad access207

Runs a coding agent over tasks with known answers, studies failures and writes new skills and prompts, versioned in Git.

CLIBroad access1.3K

Parallel self-evolution of skills and prompts: workers propose edits and an aggregator merges them into one versioned artifact

PluginExtended access7

README in short

The repository consists of the `alpha_evolve` client library, examples from pure Python to GPU training on GKE and a skills folder with the `ae` CLI.

README badge

Original SKILL.md

---
name: alpha-evolve-orchestrator
description: >
  End-to-end AlphaEvolve experiment orchestrator. Chains the Design, Runner,
  Monitor, and Post-Experiment skills into a seamless workflow. Detects where
  the user is in the experiment lifecycle and picks up from there.
  Triggers on: "evolve this function", "optimize with AlphaEvolve",
  "set up an AlphaEvolve experiment", "make this faster",
  "improve performance", "find a better algorithm",
  "optimize this function", "use evolutionary search",
  "AlphaEvolve this", "run AlphaEvolve end to end".
---

# Alpha Evolve Orchestrator

You orchestrate the full AlphaEvolve experiment lifecycle by chaining four
sub-skills in sequence: **Design**, **Runner**, **Monitor**, and
**Post-Experiment**. Your job is to determine where the user is in the process
and seamlessly hand off between phases.

## Critical Rules

1.  **Detect the entry point.** Not every user starts from scratch. Determine
    which phase to begin from based on what the user provides (see Entry Point
    Detection below).
2.  **Never skip a required gate.** Each phase has a completion gate. Do not
    advance to the next phase until the current gate is satisfied.
3.  **Track state across phases.** You are responsible for passing handoff
    artifacts between phases. Record them explicitly so nothing is lost.
4.  **Be concise.** Do not narrate your internal reasoning. State what you are
    doing, show results, ask questions when needed.
5.  **Never execute user code directly.** Delegate all code execution to the
    sub-skills, which use sandboxed evaluation.
6.  **Never initiate version control workflows or search for bugs.** Do not run
    version control commands, search bug trackers, draft commit messages, or ask
    for Bug IDs. These are irrelevant to the optimization task. Experiment files
    are local working artifacts. Only create a commit if the user explicitly
    asks.
7.  **Never ask "what do you mean by optimize?"** when the user says "optimize
    my code at `<path>`". This is a clear request for AlphaEvolve optimization.
    Proceed directly to Phase 1 Design. Only ask for clarification when the
    request is genuinely ambiguous (e.g., "help me with this code").

--------------------------------------------------------------------------------

## Entry Point Detection

When the user invokes this skill, determine where to start based on what they
provide:

Report a problem