New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Alpha Evolve Orchestrator

by Google-Cloud-AI in Google-Cloud-AI/alphaevolve-on-googlecloud

End-to-end AlphaEvolve experiment orchestrator. An agent skill from Google-Cloud-AI/alphaevolve-on-googlecloud.

Apache-2.0Auto-check passedResearch & Science

Install Alpha Evolve Orchestrator

skills CLI
$ npx skills add Google-Cloud-AI/alphaevolve-on-googlecloud --skill alpha-evolve-orchestrator -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install Google-Cloud-AI/alphaevolve-on-googlecloud alpha-evolve-orchestrator --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/Google-Cloud-AI/alphaevolve-on-googlecloud.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/alpha_evolve_orchestrator .claude/skills/alpha-evolve-orchestrator && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
alpha-evolve-orchestrator
GitHub stars
118
Token cost
~4.1k tokens
SKILL.md length
1,745 words
Files
3 (incl. references)
Skills in repo
6
Repo updated
First seen
Licence
Apache-2.0

At a glance

End-to-end AlphaEvolve experiment orchestrator. An agent skill from Google-Cloud-AI/alphaevolve-on-googlecloud.

  • Works in 4 steps: Design → Runner → Monitor → …
  • : evolve this function
  • SKILL.md covers Critical Rules, Entry Point Detection, Phase 1: Design and Phase 2: Runner, plus 5 more sections
  • Reaches discoveryengine.googleapis.com

What it does

Alpha Evolve Orchestrator is an agent skill from Google-Cloud-AI/alphaevolve-on-googlecloud. 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".

Its SKILL.md is about 4.1k tokens, which your agent loads only when the skill is triggered. The skill folder holds 3 other files, including reference files (for example `README.md` and `references/handoff_contracts.md`).

It sits in Research & Science, covering End-to-end testing. The licence is Apache-2.0.

When your agent uses it

  • : evolve this function
  • Optimize with AlphaEvolve
  • Set up an AlphaEvolve experiment
  • Make this faster

Example prompts

  • “evolve this function”
  • “optimize with AlphaEvolve”
  • “set up an AlphaEvolve experiment”
  • “/alpha-evolve-orchestrator”

Workflow steps

4 steps, taken from the step headings in SKILL.md.

  1. Design
  2. Runner
  3. Monitor
  4. Post-Experiment

What it can do on your machine

Read from SKILL.md and the folder at commit 674dd5e. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • discoveryengine.googleapis.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Alpha Evolve Orchestrator loads about 4.1k tokens when it runs, and up to ~5.9k if it reads all its reference files. Until then it costs about 129 tokens; SKILL.md has 1,745 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~129
When it runs · the whole SKILL.md, loaded when a task matches
~4.1k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~5.9k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from Google-Cloud-AI/alphaevolve-on-googlecloud at commit 674dd5e, republished under its Apache-2.0 licence (© Google-Cloud-AI). 1,745 words, ~4,128 tokens.

Download SKILL.mdSave it as .claude/skills/alpha-evolve-orchestrator/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
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:

Start at Phase 1 (Design) if:
  • The user describes a problem in natural language ("make this sorting function faster", "optimize this packing algorithm")
  • The user provides source code to optimize but no evaluator
  • The user says "set up an experiment" or "design an experiment"
  • The user says "optimize my code at <path>" — this is a clear request for end-to-end optimization. Do NOT ask "what do you mean by optimize?" — proceed directly to Phase 1 Design.
  • No experiment artifacts exist yet
Start at Phase 2 (Runner) if:
  • The user has a project directory with initial_program.py AND evaluator.py (from a previous Design phase or hand-written)
  • The user says "launch this experiment" or "run this"
  • The user provides both a program file with EVOLVE-BLOCK markers and an evaluator file
Start at Phase 3 (Monitor) if:
  • The user provides an experiment nickname, ID, or resource name (e.g., "monitor exp-brave-otter", "check on my experiment")
  • The user says "how is my experiment doing" or "show results"
  • An experiment is already running
Start at Phase 4 (Post-Experiment) if:
  • The user says "show me results", "analyze the experiment", "integrate the results", or "apply the evolved code"
  • The user has a completed experiment and wants to see the analysis or integrate code
  • The experiment is in a terminal state (COMPLETED, FAILED, CANCELLED) and the user has not yet seen the results report
Ambiguous cases:

If you cannot determine the entry point, ask the user:

I can help you with AlphaEvolve at any stage. Where are you?

  1. Start from scratch -- I have a problem to optimize
  2. Launch an experiment -- I have program and evaluator files ready
  3. Monitor an experiment -- I have a running experiment to check on
  4. Analyze results -- I have a completed experiment to review

Phase 1: Design

Objective: Produce a complete experiment directory with all required files.

Sub-skill: Load the alpha-evolve-experiment-design skill.

How to invoke: Use the Skill tool to load alpha-evolve-experiment-design, then follow its instructions completely. It has two internal phases:

  • Phase 1 (Clarify): Conversation with user to fill ExperimentDescription
  • Phase 2 (Implement): Generate all project files, run tests

Completion gate: The project directory contains all 9 required files and uv run pytest passes.

Record these handoff artifacts before proceeding to Phase 2:

ArtifactDescriptionExample
project_dirPath to the/home/user/my_experiment/
: : experiment : :
: : directory : :
program_dirPath to the<project_dir>/ (must contain
: : experiment : initial_program.py) :
: : directory : :
evaluatorPath to the<project_dir>/evaluator.py
: : evaluator : :
: : file : :
problem_descriptionPath to the<project_dir>/problem_description.md
: : problem : :
: : description : :

Transition: After the gate is satisfied, proceed to Phase 2 immediately.

Do NOT ask "How would you like to proceed?", "Should I launch?", or "Should I create a commit?". Do NOT offer the user a menu of options. Do NOT stop and wait for a new prompt. The user asked you to optimize their code — launching the experiment is the obvious and only next step.

Simply inform the user and continue:

Design phase complete. Proceeding to launch the experiment.

The only exception: if the user specifically said "design an experiment" or "set up an experiment" (where they might want to stop after design), ask before proceeding.

Phase 2: Runner

Objective: Configure the ae CLI, verify the evaluator works, and launch the experiment on the AlphaEvolve backend.

Sub-skill: Load the alpha-evolve-runner skill.

How to invoke: Use the Skill tool to load alpha-evolve-runner, then follow its instructions. Provide the handoff artifacts from Phase 1 (or from the user if they entered at Phase 2 directly).

Environment pre-check. Before diving into the Runner skill's full workflow, quickly verify these prerequisites (they cause the most wasted time if missing):

  1. ae version succeeds (CLI is installed and on PATH)
  2. Network works: verify connectivity to https://discoveryengine.googleapis.com (e.g., via curl or equivalent for your platform)

If any fails, resolve it before loading the Runner skill. The Runner skill's Prerequisites section has a detailed discovery protocol for ae.

If entering at Phase 2 directly (user provided files, not from Design):

  1. Ask the user for the paths to their program file, evaluator file, and problem description.
  2. Validate that the program file has EVOLVE-BLOCK markers.
  3. Validate that the evaluator is a CLI-compatible script (accepts --output-file and --program-dir).
  4. If either is missing, suggest going back to Phase 1 (Design) to create proper artifacts.

Completion gate: The experiment is in ACTIVE state and the user has received the experiment nickname.

Record these handoff artifacts before proceeding to Phase 3:

ArtifactDescriptionExample
experiment_nicknameThe experiment'sexp-brave-otter
: : nickname : :
evaluatorPath to the evaluator<project_dir>/evaluator.py
: : file : :

Transition: After the gate is satisfied, IMMEDIATELY proceed to Phase 3 in the same response. Do NOT stop, do NOT ask "would you like me to monitor?", do NOT suggest manual commands. The user asked you to optimize their code — monitoring is not optional, it is the next required step. Simply inform them:

Experiment <nickname> is now running. Starting the evaluation loop.

Then load the monitor skill and start the control loop. The user should never have to say "yes continue monitoring".

Show full SKILL.md (654 more words)Show less

Phase 3: Monitor

Objective: Run the evaluation control loop and track experiment progress until completion. The control loop (ae experiment run) is the command that actually drives the experiment forward -- it acquires candidates, evaluates them, and submits scores. Without it, the experiment stalls.

Sub-skill: Load the alpha-evolve-monitor skill.

How to invoke: Use the Skill tool to load alpha-evolve-monitor, then follow its instructions. Provide the experiment nickname and evaluator path from Phase 2 (or from the user if they entered at Phase 3 directly). The monitor skill will start the control loop with --dashboard to generate a live progress dashboard.

If entering at Phase 3 directly (user has a running experiment):

  1. Ask for the experiment nickname/ID if not provided.
  2. Ask for the evaluator file path if the control loop is not already running.

Completion gate: The experiment reaches a terminal state (COMPLETED, FAILED, or CANCELLED).

Record these handoff artifacts before proceeding to Phase 4:

ArtifactDescriptionExample
experiment_nicknameThe experiment'sexp-brave-otter
: : nickname : :
project_dirPath to the/home/user/my_experiment/
: : experiment directory : :
original_source_filePath to the user's/home/user/src/solver.py
: : original source file : (may be absent if :
: : (if applicable) : standalone experiment) :

Transition: After the gate is satisfied, IMMEDIATELY proceed to Phase 4 in the same response. Do NOT stop, do NOT suggest manual CLI commands, do NOT offer a menu of options. Simply inform them:

Experiment <nickname> has finished. Analyzing results...

Then load the post-experiment skill and start the analysis.

Phase 4: Post-Experiment

Objective: Analyze experiment results with rich visualizations, review evolved code for correctness, and offer to integrate improvements back into the user's codebase if they choose to.

Sub-skill: Load the alpha-evolve-post-experiment skill.

How to invoke: Use the Skill tool to load alpha-evolve-post-experiment, then follow its instructions. Provide the handoff artifacts from Phase 3.

If entering at Phase 4 directly (user has a completed experiment):

  1. Ask for the experiment nickname if not provided.
  2. Ask for the project directory (where the evaluator and initial program live) if not known.
  3. Ask for the original source file path if the user wants code integration.

Completion gate: The experiment report has been presented and, if applicable, the evolved code has been integrated and validated.

After completion:

The Post-Experiment skill handles everything: visualization, code review, integration, and validation. After it completes, the orchestrator's job is done. If the user wants to run another experiment, they will start a new conversation or say so explicitly.

Phase Diagram

User Request
     |
     v
[Entry Point Detection]
     |
     +---> Problem description / code to optimize
     |         |
     |         v
     |     [Phase 1: Design]
     |     Load: alpha-evolve-experiment-design
     |     Gate: 9 files + pytest passes
     |         |
     |         v (auto-proceed if end-to-end intent, else ask)
     |
     +---> Program + evaluator files ready
     |         |
     |         v
     |     [Phase 2: Runner]
     |     Load: alpha-evolve-runner
     |     Gate: experiment ACTIVE + nickname obtained
     |         |
     |         v (proceed immediately, no confirmation needed)
     |
     +---> Running experiment nickname/ID
     |         |
     |         v
     |     [Phase 3: Monitor]
     |     Load: alpha-evolve-monitor
     |     Gate: terminal state reached
     |         |
     |         v (proceed immediately, no confirmation needed)
     |
     +---> Completed experiment nickname/ID
               |
               v
           [Phase 4: Post-Experiment]
           Load: alpha-evolve-post-experiment
           Gate: report presented + code integrated (if applicable)
               |
               v
           [Done]

Error Recovery

Phase 1 fails (design issues)
  • Tests do not pass: Debug with the user, fix the evaluator or program
  • User wants to change approach: Go back to Phase 1 clarification
Phase 2 fails (launch issues)
  • Connectivity errors: Follow the Runner skill's debugging guide
  • Evaluator baseline fails: Go back and fix the evaluator (may need Phase 1)
  • Quota exceeded: Help the user clean up old experiments or request quota
Phase 3 fails (monitoring issues)
  • Control loop crashes: Check logs, restart the loop
  • Experiment stalls (no evaluations): Debug evaluator, check backend
  • Experiment FAILED state: Diagnose, fix, and optionally relaunch (Phase 2)
Phase 4 fails (post-experiment issues)
  • Results retrieval fails: Verify experiment exists, check connectivity
  • Code integration fails: Syntax error or score mismatch -- follow the Post-Experiment skill's validation and rollback guidance
  • Reward hacking detected: The evolved code exploits the evaluator -- go back to Phase 1 (Design) to improve the evaluator
  • No improvement over baseline: All programs failed or scored equally -- consider adjusting the search space or model
User wants to go back

If the user wants to revisit a previous phase (e.g., "let me fix my evaluator" during monitoring), pause the current phase and load the appropriate sub-skill. When they are done, resume from where you left off.

Quick Reference

PhaseSub-SkillInputOutput
Phase 1: Designalpha-evolve-experiment-designProblem descriptionProject directory (9 files)
Phase 2: Runneralpha-evolve-runnerProgram + evaluator + problem descExperiment nickname
Phase 3: Monitoralpha-evolve-monitorNickname + evaluator pathTerminal state
Phase 4: Post-Experimentalpha-evolve-post-experimentNickname + project dir + source fileReport + integrated code

© Google-Cloud-AI, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files (references) in skills/alpha_evolve_orchestrator of Google-Cloud-AI/alphaevolve-on-googlecloud.

  • SKILL.md
  • README.md
  • references/handoff_contracts.md

Open the folder on GitHubat commit 674dd5e

Compare with similar skills

Alpha Evolve Orchestrator next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Alpha Evolve Orchestrator compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Alpha Evolve Orchestrator this skillGoogle-Cloud-AI/alphaevolve-on-googlecloud118—~4.1kAutomated safety check: PassApache-2.0
Ma End To Endhtlin222/meta-pipe134—~2.3kAutomated safety check: PassCustom licence
Deep Science WriterCYC2002tommy/Deep-Research-Agent311—~8.7kAutomated safety check: WarnMIT
Denariodavila7/claude-code-templates32k9 repos~1.5kAutomated safety check: NotesMIT
FictivK-Dense-AI/scientific-agent-skills48k1 repos~3.6kAutomated safety check: PassMIT
Bio Workflows Clip PipelineGPTomics/bioSkills1.2k2 repos~5.1kAutomated safety check: PassMIT

Similar skills

  • Ma End To End

    htlin222/meta-pipe

    End-to-end AI-assisted meta-analysis pipeline orchestration from TOPIC.txt to final manuscript and reviewer responses.

    134 GitHub stars~2.3k tokensUpdated 15 days ago
    Research & ScienceAuto-check passed

  • Deep Science Writer

    CYC2002tommy/Deep-Research-Agent

    End-to-end scientific research pipeline combining Exa Search, Playwright, deep-research, text-humanization, and iterative Remi peer review.

    311 GitHub stars~8.7k tokensUpdated 1 mo ago
    Research & ScienceAuto-check: warnings

  • Denario

    davila7/claude-code-templates

    Multiagent AI system for scientific research assistance that automates research workflows from data analysis to publication.

    32k GitHub starsUsed in 9 repos~1.5k tokens
    Research & ScienceAuto-check: notes

  • Fictiv

    K-Dense-AI/scientific-agent-skills

    Operates Fictiv (app.fictiv.com), the on-demand manufacturing platform, end to end in the user's browser.

    48k GitHub starsUsed in 1 repo~3.6k tokens
    Research & ScienceAuto-check passed

  • Bio Workflows Clip Pipeline

    GPTomics/bioSkills

    End-to-end CLIP-seq pipeline from FASTQ to ENCODE-compliant binding sites, single-nucleotide crosslink maps, annotation, motifs, and (optionally) differential binding.

    1.2k GitHub starsUsed in 2 repos~5.1k tokens
    Research & ScienceAuto-check passed

  • Bio Workflows Hic Pipeline

    GPTomics/bioSkills

    End-to-end Hi-C analysis workflow from FASTQ to compartments, TADs, and loops, with the decision of WHICH features the sequencing depth can support.

    1.2k GitHub starsUsed in 1 repo~4.2k tokens
    Research & ScienceAuto-check passed

More from Google-Cloud-AI/alphaevolve-on-googlecloud

  • Alpha Evolve Monitor

    Google-Cloud-AI/alphaevolve-on-googlecloud

    Monitor running AlphaEvolve experiments, run the evaluation control loop, and report results using the ae CLI.

    118 GitHub stars~4.4k tokensUpdated 7 days ago
    Auto-check passed

  • Alpha Evolve Post Experiment

    Google-Cloud-AI/alphaevolve-on-googlecloud

    Post-experiment analysis, visualization, and code integration for completed AlphaEvolve experiments.

    118 GitHub stars~9.2k tokensUpdated 7 days ago
    Auto-check passed

  • Alpha Evolve Consultant

    Google-Cloud-AI/alphaevolve-on-googlecloud

    AlphaEvolve expert consultant grounded strictly in the official reference guide.

    118 GitHub stars~3k tokensUpdated 7 days ago
    Auto-check passed

  • Alpha Evolve Runner

    Google-Cloud-AI/alphaevolve-on-googlecloud

    Configure, verify, and launch AlphaEvolve experiments using the ae CLI.

    118 GitHub stars~5.6k tokensUpdated 7 days ago
    Auto-check: warnings

  • Alpha Evolve Experiment Design

    Google-Cloud-AI/alphaevolve-on-googlecloud

    Design AlphaEvolve experiments for the Cloud API. An agent skill from Google-Cloud-AI/alphaevolve-on-googlecloud.

    118 GitHub stars~2.5k tokensUpdated 7 days ago
    Auto-check: warnings

Categories

Questions about Alpha Evolve Orchestrator

What does Alpha Evolve Orchestrator do?

End-to-end AlphaEvolve experiment orchestrator. An agent skill from Google-Cloud-AI/alphaevolve-on-googlecloud. Alpha Evolve Orchestrator is an agent skill from Google-Cloud-AI/alphaevolve-on-googlecloud. End-to-end AlphaEvolve experiment orchestrator.

When should I use Alpha Evolve Orchestrator?

Alpha Evolve Orchestrator fits situations like: : evolve this function; optimize with AlphaEvolve; set up an AlphaEvolve experiment; make this faster.

How do I install Alpha Evolve Orchestrator in Claude Code?

Run `npx skills add Google-Cloud-AI/alphaevolve-on-googlecloud --skill alpha-evolve-orchestrator -a claude-code`. Or copy the skill folder (skills/alpha_evolve_orchestrator in Google-Cloud-AI/alphaevolve-on-googlecloud) into .claude/skills/alpha-evolve-orchestrator in your project. Claude Code loads it when a task matches its description.

How do I install Alpha Evolve Orchestrator in Codex?

Run `npx skills add Google-Cloud-AI/alphaevolve-on-googlecloud --skill alpha-evolve-orchestrator -a codex`. Or copy the skill folder (skills/alpha_evolve_orchestrator in Google-Cloud-AI/alphaevolve-on-googlecloud) into .agents/skills/alpha-evolve-orchestrator in your project. Codex loads it when a task matches its description.

Can I use Alpha Evolve Orchestrator in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add Google-Cloud-AI/alphaevolve-on-googlecloud --skill alpha-evolve-orchestrator -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/alpha-evolve-orchestrator, .gemini/skills/alpha-evolve-orchestrator, .github/skills/alpha-evolve-orchestrator and .opencode/skills/alpha-evolve-orchestrator in your project.

What does Alpha Evolve Orchestrator need to run?

SKILL.md names no scripts, command-line tools or credentials: Alpha Evolve Orchestrator is instructions for the agent only.

Does Alpha Evolve Orchestrator access the network?

SKILL.md names 1 domain. In commands or code: discoveryengine.googleapis.com; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is Alpha Evolve Orchestrator safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Alpha Evolve Orchestrator use?

Alpha Evolve Orchestrator is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Alpha Evolve Orchestrator use?

About 4.1k tokens (SKILL.md is roughly 17k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 1.8k tokens, read only when the agent opens those files.

What are the alternatives to Alpha Evolve Orchestrator?

Skills that share tags, products or a category with Alpha Evolve Orchestrator: Ma End To End (htlin222/meta-pipe, 134 stars), Deep Science Writer (CYC2002tommy/Deep-Research-Agent, 311 stars), Denario (davila7/claude-code-templates, 32k stars) and Fictiv (K-Dense-AI/scientific-agent-skills, 48k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Alpha Evolve Orchestrator?

Google-Cloud-AI (a GitHub organization) maintains it in Google-Cloud-AI/alphaevolve-on-googlecloud, which has 118 GitHub stars. The repository holds 6 skills in this directory. The repository was last updated on October 1, 2026.

Source: Google-Cloud-AI/alphaevolve-on-googlecloud on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.