Documentation de référence de l'API AlphaEvolve

Ce document sert de référence d'API et de spécification système faisant autorité et de qualité pour la production pour l'API AlphaEvolve Cloud sous les couches conversationnelles du moteur de découverte Google Cloud. Il définit les hiérarchies de ressources imbriquées précises, les points de terminaison REST et gRPC, les contraintes au niveau des champs, les machines à états du cycle de vie, les matrices de diagnostic des erreurs, les règles de bac à sable de sécurité et les workflows d'intégration nécessaires pour concevoir une boucle de contrôleur et d'évaluation entièrement automatisée côté client.

Machines à états du cycle de vie unifiées

L'agent AlphaEvolve coordonne deux machines à états indépendantes pour surveiller la progression des campagnes de test et gérer la diffusion et l'exécution des mutations de programme individuelles.

États du cycle de vie des tests

Un test représente la campagne d'optimisation globale. Il est traité comme une ressource persistante côté serveur et passe par les états suivants :

  • CREATED : état de l'initialisation. La ressource est déclarée et configurée, mais n'a pas encore généré de générations initiales ni distribué d'appels d'API.

  • RUNNING : état actif de l'évaluation. Le moteur échantillonne simultanément les candidats parents, génère des mutations de code via le mélange LLM et transmet les tâches aux évaluateurs.

  • PAUSED : état de suspension temporaire déclenché manuellement ou par le biais d'une idle_timeout de protection automatisée. La génération de code s'arrête et les workers existants mettent en pause la diffusion des métriques.

  • COMPLETED : état final indiquant que la recherche a atteint avec succès son allocation cible max_programs ou sa limite de génération structurelle.

  • FAILED : état d'erreur terminal indiquant que des problèmes d'environnement systémiques (tels que des exceptions d'identifiants API non détectées, une corruption du data store ou des paniques consécutives du runner) ont interrompu l'exécution du traitement.

États du programme

La séquence de validation de l'exécution est appliquée à chaque variante candidate.

Chaque mutation de code générée se comporte comme une entité de programme isolée qui passe par une séquence d'états opérationnels précis dans la base de données de la population.

  1. INITIALIZED : l'entrée du programme est créée dans la base de données, ce qui permet de suivre son pedigree ancestral et les liens vers le programme parent.

  2. GENERATING : une tâche est activement envoyée au backend du mélange de modèles de langage pour rédiger ou modifier les blocs de code fonctionnel spécifiques.

  3. EVALUATING : la charge utile du code est verrouillée par un processus de worker d'évaluation et exécutée dans un environnement de harnais de test isolé.

  4. COMPLETED : les scores d'exécution et les informations structurelles descriptives sont enregistrés de manière sécurisée dans la base de données évolutive, et le programme est ajouté au pool de sélection.

Mécanismes de concurrence et de verrouillage

Les programmes sont acquis par les boucles de nœuds de calcul à l'aide d'un mécanisme de jeton de verrouillage atomique pour éviter les conditions de course ou les frais généraux de scoring en double dans les topologies distribuées. L'évaluateur doit envoyer le schéma de notation finalisé avec le jeton de verrouillage correspondant exactement pour pouvoir renvoyer les résultats à la base de données.

Schémas de configuration et de paramètres

Présentation des configurations, des paramètres et des valeurs par défaut du schéma de base utilisés par le moteur d'exécution AlphaEvolve.

AlphaEvolveExperimentConfig

Définit les paramètres structurels de base et les contraintes de programmation de l'exécution de l'expérience évolutive.

Nom du champ Type Par défaut Contraintes / Limites de valeurs Description technique
title string Obligatoire 256 caractères maximum Nom à afficher unique du test.
problemDescription string Obligatoire 5 000 caractères maximum Spécification formelle du problème. Il est injecté directement dans les contextes d'invite pour établir des règles.
programmingLanguage string Obligatoire Valeur de forme libre Langue cible du codebase évolué (par exemple, "python", "cpp", "verilog", "cuda", "julia", "java").
runSettings objet Obligatoire Correspond au schéma RunSettings Paramètres de rythme et de délai avant expiration.
generationSettings objet Obligatoire Correspond au schéma GenerationSettings Paramètres de sélection et de contexte du modèle.
evolutionSettings objet Obligatoire Correspond au schéma EvolutionSettings Paramètres de sélection des parents et de diversité.
notes string Obligatoire 1 000 caractères maximum Annotations facultatives pour la documentation d'exécution.

RunSettings

Régit le rythme du débit, les limites de parallélisation et les délais d'expiration automatiques du système.

Nom du champ Type Par défaut Contraintes / Limites de valeurs Description technique
maxPrograms int32 100 Min : 1, Max : 100 000 Budget d'exécution total (programmes à générer et à évaluer).
concurrency int32 1 Min : 1, Max : 30 Nombre de mutations de programme parallèles actives dans la file d'attente. Les valeurs supérieures à 30 ne sont pas autorisées.
maxDuration string null Chaîne ISO 8601 dayTimeDuration
Min: >=0, Max: 7 Days		 Temps total écoulé autorisé avant l'arrêt du test.
idleTimeout string null Chaîne ISO 8601 dayTimeDuration
Min : >=0, Max : 24 heures		 Durée d'inactivité avant le passage automatique à l'état "PAUSED".

Paramètres de génération

Le schéma GenerationSettings contrôle l'assemblage des requêtes, les fenêtres de contexte et les configurations de modèle pour les mutations :

  • context (chaîne) : documentation de référence, API supplémentaires ou règles facultatives fournies par l'utilisateur. Il est fortement recommandé de ne pas dépasser 200 000 jetons. Les tailles de contexte supérieures à 200 000 jetons diluent l'attention du modèle et dégradent la qualité de la mutation.

  • includeFullProgramInPrompt (bool) : false par défaut.

    • true : l'invite de mutation inclut le # EVOLVE-BLOCK mutable et le boilerplate immuable environnant (vivement recommandé pour le raisonnement structurel complexe).

    • false : seul le bloc mutable est visible, ce qui permet d'enregistrer le contexte du jeton.

Paramètres d'évolution

Le schéma EvolutionSettings contrôle les probabilités de réensemencement du modèle insulaire et d'échantillonnage des parents :

  • parentSamplingConfig → paretoSamplingConfig → paretoSamplingProbability (float) : probabilité (de 0,0 à 1,0) d'échantillonner les programmes parents directement à partir de la frontière de Pareto active plutôt que d'utiliser la sélection standard basée sur la forme physique. Ce paramètre doit être défini sur 0.0 (désactivé) si les métriques optimisées ne renvoient qu'une seule métrique scalaire.

Modèles de données des programmes candidats

Cette section décrit les schémas et les représentations de données utilisés pour définir et organiser les structures de code candidates dans la base de données de population.

AlphaEvolveProgramContent

Définit les fichiers et la structure du programme candidat.

  • files (tableau de AlphaEvolveSourceFile) : liste de tous les fichiers composant la codebase candidate. Cette collection est strictement limitée à 50 fichiers maximum par programme candidat.

  • description (string) : résumé généré automatiquement décrivant les modifications programmatiques suggérées par le modèle de génération (1 000 caractères maximum).

AlphaEvolveSourceFile

Représente un fichier de code source individuel dans le codebase.

  • path (chaîne) : chemin de destination relatif à l'espace de travail (256 caractères maximum). Si vous configurez un espace de travail Python, le point d'entrée du fichier exécutable principal doit être nommé exactement "initial_program.py".

  • content (chaîne) : chaîne de code source brut comprenant les blocs d'implémentation fonctionnelle. L'empreinte totale et cumulée de la base de code combinée à tous les fichiers doit être inférieure à 4 000 à 5 000 lignes de code.

  • programLanguage (chaîne) : tag de mappage du parseur de langue. Cette chaîne doit correspondre explicitement à la langue désignée dans la configuration du test parent.

  • description (chaîne) : résumé facultatif décrivant l'architecture ou l'objectif du fichier, qui est exposé au LLM lors des passes de mutation (500 caractères maximum).

AlphaEvolveProgramEvaluation

Charge utile structurée renvoyée par les instances de l'exécuteur client à la base de données évolutionnaire après l'exécution du runtime.

  • scores (AlphaEvolveScores) : valeurs numériques objectives et standardisées. Les bonnes pratiques recommandent de limiter ce nombre à trois ou cinq métriques flottantes distinctes. Un nombre excessif de dimensions cibles dégrade les performances du comparateur Pareto multi-objectif.

  • insights (tableau de AlphaEvolveEvaluationInsight) : étiquettes sémantiques de diagnostic et traces d'exécution en langage naturel renvoyées pour aider le LLM lors de ses tentatives de génération de mutations ultérieures (10 éléments maximum recommandés).

Formulation du score et formats d'ingestion

Règle de maximisation

AlphaEvolve fonctionne fondamentalement comme un algorithme d'escalade monotone et maximise strictement toutes les métriques numériques. Si votre pipeline d'évaluation suit une cible de minimisation (par exemple, la minimisation de la latence d'application en millisecondes ou la réduction de l'utilisation de la mémoire), vous devez nier la valeur avant de la renvoyer à la base de données : submitted_score = -latency_ms.

Idéalement, les scores doivent être continus. Les métriques booléennes ou très discrètes ne fournissent pas un signal de gradient suffisant pour une exploration efficace de l'escalade de colline.

Schéma d'ingestion à objectif unique

Utilisez le JSON suivant lorsque votre harness d'évaluation est optimisé par rapport à une fonction objectif scalaire unique.

```json
{
  "scores": {
    "scores": [
      {
        "metric": "accuracy",
        "score": 0.95
      }
    ]
  },
  "insights": {
    "insights": [
      {
        "label": "validation",
        "text": "Passed syntax and basic compilation."
      }
    ]
  }
}
```

Schéma d'ingestion multi-objectifs

Utilisez le code JSON suivant lorsque vous transmettez des paramètres de suivi multi-objectifs indépendants pour activer les routines d'optimisation de la frontière de Pareto côté serveur.

{
  "scores": {
    "scores": [
      {
        "metric": "accuracy",
        "score": 0.95
      },
      {
        "metric": "latency",
        "score": -42.5
      }
    ]
  },
  "insights": {
    "insights": [
      {
        "label": "verification",
        "text": "Passed 5 out of 5 unit tests."
      },
      {
        "label": "latency_warning",
        "text": "Latency regression of 3% observed on large dataset."
      }
    ]
  }
}

Récupérer et interroger les données du programme

Le système AlphaEvolve enregistre la télémétrie, les métriques d'exécution et le code source complet de chaque mutation générée, ce qui permet aux développeurs d'interroger ce datastore historique à l'aide de l'API ou de la CLI pour suivre la progression de l'optimisation et extraire les candidats de code les plus performants.

Récupérer des programmes à l'aide de l'API REST

Les ressources de programme évaluées peuvent être interrogées à partir de la base de données à l'aide du point de terminaison ListAlphaEvolvePrograms standard avec des paramètres de requête de filtrage et de tri :

  • Filtrage par état : interrogez les programmes correspondant à un état de cycle de vie spécifique :

    GET /v1alpha/{parent}/alphaEvolvePrograms?state_filter=COMPLETED

  • Tri basé sur les métriques : récupérez les candidats triés en fonction des métriques optimisées :

    GET /v1alpha/{parent}/alphaEvolvePrograms?order_by=accuracy desc,latency&page_size=5

Récupérer des programmes à l'aide de la CLI

Pour extraire les candidats les plus performants directement depuis votre terminal, exécutez la commande suivante :

ae results best <experiment-nickname> --top 5

Exemples complets d'utilisation de la CLI

L'interface de ligne de commande AlphaEvolve permet aux développeurs de contrôler et de surveiller rapidement les campagnes directement depuis le shell :

  • Lister tous les tests d'une session conversationnelle :

    ae experiment list

  • Lister tous les programmes candidats mutés pour un test spécifique :

    ae program list EXPERIMENT_NICKNAME \
  --state=COMPLETED \
  --order_by="accuracy desc"

    Remplacez EXPERIMENT_NICKNAME par le nom de votre expérience.

  • Récupérez les candidats de code complété les plus performants :

    ae results best EXPERIMENT_NICKNAME --top 5

    Remplacez EXPERIMENT_NICKNAME par le nom de votre expérience.

  • Réactiver une campagne mise en veille :

    ae experiment resume EXPERIMENT_NICKNAME

    Remplacez EXPERIMENT_NICKNAME par le nom de votre expérience.

Répertoire des points de terminaison de l'API REST principale

Tous les points de terminaison sont versionnés sous v1alpha de l'API Discovery Engine. Google Cloud

Format du chemin d'accès à la ressource parente

L'URI de la ressource parente imbriquée est structuré comme suit : projects/{project}/locations/{location}/collections/{collection}/ engines/{engine}/sessions/{session}

Créer un test (POST)

  • Chemin d'accès : POST v1alpha/{parent=projects/*/locations/*/collections/*/engines/*/ sessions/*}/alphaEvolveExperiments

  • Corps de la requête : AlphaEvolveExperimentConfig (voir la section 2.1)

  • Réponse : ressource AlphaEvolveExperiment contenant la campagne initialisée.

  • État HTTP : 200 OK

Exemples de charge utile de l'API

  1. Exemple de corps de requête (POST /alphaEvolveExperiments)

    {
  "config": {
    "title": "Sorting Optimization Campaign",
    "problemDescription": "Optimize the custom_heuristic function.",
    "programLanguage": "python",
    "notes": "Exploring convergence with Gemini 3.5 Flash.",
    "runSettings": {
      "maxPrograms": 250,
      "concurrency": 8,
      "maxDuration": "86400s",
      "idleTimeout": "1800s"
    },
    "generationSettings": {
      "context": "Ensure custom_heuristic is in-place.",
      "includeFullProgramInPrompt": true,
      "models": [
        {
          "name": "gemini-3.5-flash",
          "weight": 1.0
        }
      ]
    },
    "evolutionSettings": {
      "parentSamplingConfig": {
        "paretoSamplingConfig": {
          "paretoSamplingProbability": 0.0
        }
      }
    }
  }
}

  2. Exemple de corps de réponse (200 OK)

    {
  "name": "projects/.../sort-opt-01",
  "state": "CREATED",
  "createTime": "2026-06-23T13:30:00Z",
  "config": {
    "title": "Sorting Optimization Campaign",
    "problemDescription": "Optimize the custom_heuristic function.",
    "programLanguage": "python",
    "notes": "Exploring convergence with Gemini 3.5 Flash.",
    "runSettings": {
      "maxPrograms": 250,
      "concurrency": 8,
      "maxDuration": "86400s",
      "idleTimeout": "1800s"
    },
    "generationSettings": {
      "context": "Ensure custom_heuristic is in-place.",
      "includeFullProgramInPrompt": true,
      "models": [
        {
          "name": "gemini-3.5-flash",
          "weight": 1.0
        }
      ]
    },
    "evolutionSettings": {
      "parentSamplingConfig": {
        "paretoSamplingConfig": {
          "paretoSamplingProbability": 0.0
        }
      }
    }
  }
}

Démarrer le test (POST)

  • Chemin d'accès : POST v1alpha/{name=projects/*/locations/*/collections/*/engines/*/ sessions/*/alphaEvolveExperiments/*}:start

  • Corps de la requête : StartExperimentRequest

  • Avertissement d'obsolescence : Le champ de corps initialProgram est obsolète et ignoré.

  • Réponse : GoogleLongrunningOperation (opération de longue durée).

  • État HTTP : 200 OK (l'état passe de CREATED à RUNNING)

Exemples de charge utile de l'API

  1. Exemple de corps de la requête

    {
  "desiredProgramsCount": 1
}

  2. Exemple de corps de réponse (200 OK – opération de longue durée)

    {
  "name": "projects/.../operations/start-op-7788",
  "metadata": {
    "@type": "type.googleapis.com/.../AlphaEvolveStartExperimentMetadata",
    "createTime": "2026-06-23T13:31:00Z"
  },
  "done": false
}

Acquérir des programmes (POST)

  • Chemin d'accès : POST v1alpha/{parent=projects/*/locations/*/collections/*/engines/*/ sessions/*/alphaEvolveExperiments/*}:acquirePrograms

  • Corps de la requête : AcquireProgramsRequest

    • desiredProgramsCount (int32) : nombre facultatif de programmes mutés à récupérer (par défaut, la valeur est 1 si elle n'est pas définie).

  • États de réponse :

    • 200 OK : renvoie une réponse contenant des ressources AlphaEvolveProgram verrouillées.

    • 204 No Content : la file d'attente est vide ou la campagne est mise en veille. Les runners doivent se mettre en veille (pendant 15 secondes, par exemple) et réessayer.

Exemples de charge utile de l'API

  1. Exemple de corps de la requête

    {
  "desiredProgramsCount": 1
}

  2. Exemple de corps de réponse (200 OK)

    {
  "programs": [
    {
      "name": "projects/.../alphaEvolvePrograms/prog-102",
      "lockToken": "token_uuid_8877_x99",
      "state": "EVALUATING",
      "createTime": "2026-06-23T13:32:00Z",
      "content": {
        "description": "Mutated candidate program.",
        "files": [
          {
            "path": "initial_program.py",
            "programLanguage": "python",
            "description": "Primary sorting executable.",
            "content": "def custom_heuristic(arr, _):\n    ..."
          }
        ]
      }
    }
  ]
}

  3. Exemple de corps de réponse (204 Aucun contenu)

État HTTP 204 renvoyé avec un contexte de charge utile vide.

Envoyer des évaluations de programmes (POST)

  • Chemin d'accès : POST v1alpha/{parent=projects/*/locations/*/collections/*/engines/*/ sessions/*/alphaEvolveExperiments/*}:submitProgramsEvaluations

  • Corps de la requête : SubmitProgramsEvaluationsRequest

    • evaluationSubmissions (tableau) : contient les lockToken correspondants, le chemin d'accès qualifié à la ressource du programme et la charge utile d'évaluation (scores et insights).

  • Réponse : SubmitProgramsEvaluationsResponse (vide).

  • État HTTP : 200 OK (enregistre les scores, déverrouille la serrure active et enregistre les insights)

Exemples de charge utile de l'API

  1. Exemple de corps de la requête

    {
  "evaluationSubmissions": [
    {
      "lockToken": "token_uuid_8877_x99",
      "program": "projects/.../alphaEvolvePrograms/prog-102",
      "evaluation": {
        "scores": {
          "scores": [
            {
              "metric": "latency_performance",
              "score": evaluation_payload["score"]
            }
          ]
        },
        "insights": {
          "insights": [
            {
              "label": "benchmark",
              "text": "Completed test case in 12.45ms."
            }
          ]
        }
      }
    }
  ]
}

  2. Exemple de corps de réponse (200 OK)

    {}

Reprendre le test (POST)

  • Chemin d'accès : POST v1alpha/{name=projects/*/locations/*/collections/*/engines/*/ sessions/*/alphaEvolveExperiments/*}:resume

  • Corps de la requête : ResumeExperimentRequest

  • Réponse : GoogleLongrunningOperation (opération de longue durée).

  • État HTTP : 200 OK (l'état passe de PAUSED à RUNNING)

Exemples de charge utile de l'API

  1. Exemple de corps de la requête

    {}

  2. Exemple de corps de réponse (200 OK – opération de longue durée)

{
  "name": "projects/.../operations/resume-op-9900",
  "metadata": {
    "@type": "type.googleapis.com/.../AlphaEvolveResumeExperimentMetadata",
    "createTime": "2026-06-23T13:45:00Z"
  },
  "done": false
}

Lister les programmes (GET)

  • Chemin d'accès : GET v1alpha/{parent=projects/*/locations/*/collections/*/engines/*/ sessions/*/alphaEvolveExperiments/*}/alphaEvolvePrograms

  • Paramètres de requête :

    • stateFilter (chaîne) : facultatif. Filtre de liste standard, par exemple stateFilter = 'COMPLETED'.

    • orderBy (chaîne) : facultatif. Tri basé sur une métrique, par exemple accuracy desc.

  • Réponse : ListAlphaEvolveProgramsResponse.

  • État HTTP : 200 OK

Exemples de charge utile de l'API

  1. Exemple d'URL de requête

    GET v1alpha/projects/.../alphaEvolveExperiments/sort-opt-01/
  alphaEvolvePrograms?stateFilter=COMPLETED&orderBy=latency_performance%20desc
  &pageSize=1

  2. Exemple de corps de réponse (200 OK)

    {
  "alphaEvolvePrograms": [
    {
      "name": "projects/.../alphaEvolvePrograms/prog-102",
      "state": "COMPLETED",
      "createTime": "2026-06-23T13:32:00Z",
      "evaluation": {
        "scores": {
          "scores": [
            {
              "metric": "latency_performance",
              "score": -12.45
            }
          ]
        },
        "insights": {
          "insights": [
            {
              "label": "benchmark",
              "text": "Completed test case in 12.45ms."
            }
          ]
        }
      }
    }
  ],
  "nextPageToken": "token_page_1_next"
}

Code de diagnostic et informations de dépannage

Matrice des codes de diagnostic de l'API

État HTTP Type d'erreur Cause liée au système Solution ou mesure d'atténuation
400 INVALID_ARGUMENT Balises de commentaire # EVOLVE-BLOCK-START/# EVOLVE-BLOCK-END manquantes, syntaxe de schéma JSON non valide, limites de fichier ou de nombre de lignes dépassées. Vérifiez que les commentaires de bloc sont placés dans les corps de fonction à l'aide d'une syntaxe de langage cible valide. Vérifiez que le nombre de fichiers et les limites de LOC sont respectés.
403 PERMISSION_DENIED L'utilisateur ou le compte de service ne dispose pas du rôle "Utilisateur Discovery Engine" ni d'une licence Gemini Enterprise attribuée. Vérifiez les licences Gemini Enterprise actives. Assurez-vous que les identifiants par défaut de l'application sont correctement configurés pour l'utilisateur et le projet en exécutant la commande suivante :

gcloud auth application-default login --project=<<PROJECT_ID>>

Remarque : Model Armor n'est pas compatible avec les configurations AlphaEvolve.
408 LOCK_TIMEOUT Le programme d'exécution du client a dépassé sa durée d'exécution. Le verrouillage du programme a expiré dans la file d'attente. Appliquez des délais d'expiration stricts côté client de 30 minutes. Si la limite est dépassée, envoyez immédiatement les scores de pénalité pour échec afin de déverrouiller la file d'attente.
429 RESOURCE_EXHAUSTED Vous avez dépassé les limites d'exécution simultanée active ou les quotas de modèles. Implémentez un intervalle exponentiel entre les tentatives côté client et configurez des paramètres de concurrence prudents dans RunSettings.
503 SERVICE_UNAVAILABLE Le service de backend est surchargé ou en cours de maintenance. Implémentez une boucle de nouvelle tentative avec un intervalle exponentiel entre les tentatives aléatoire côté client.

Remédier aux "abandons silencieux"

Une interception par un filtre de sécurité (suppression silencieuse) se produit lorsque des modèles de langage côté serveur signalent et suppriment des requêtes candidates mutées en raison d'une formulation sensible ou de déclencheurs de règles de sécurité. Le serveur désactive la sortie, ce qui entraîne le renvoi de réponses vides par la file d'attente, et les exécutants clients peuvent attendre indéfiniment.

Solution de contournement :

  • Nettoyer le contexte : supprimez les expressions à forte charge émotionnelle ou sensibles en termes de sécurité de problemDescription.

  • Filtrer les insights : analysez et tronquez les traces d'exception brutes ou les journaux stderr du terminal dans la charge utile insights pour éviter l'écho de contenu système non sécurisé qui déclenche des filtres en aval.

  • Localisez les ensembles de données : ne placez pas d'enregistrements d'entraînement ni de grands corpus de texte dans les requêtes. Chargez-les localement dans l'environnement client lors de l'exécution de la boucle d'évaluation.

Bonnes pratiques pour l'évaluation côté client

Le goulot d'étranglement du "code spaghetti"

Une mise en forme de la source sous-optimale dégrade la qualité de l'optimisation : "Code spaghetti ==> Espace de recherche bruyant". Avant de placer des repères EVOLVE-BLOCK :

  • Refactorisez les blocs de code afin que les variables et les signatures de fonction soient clairement nommées.

  • Ajoutez des docstrings descriptives et concises expliquant ce que font chaque fonction ou variable et pourquoi.

  • Assurez-vous que toutes les dépendances externes et immuables (comme l'importation de modules d'assistance ou le chargement de données statiques) se trouvent en dehors de # EVOLVE-BLOCK.

Allocation de la fenêtre de contexte

Pour maximiser la créativité des mutations, limitez la charge utile du code envoyée à l'API. Le contexte total du programme doit rester inférieur à 150 000 à 200 000 jetons. Les grands blocs de code réutilisable statique et immuable consomment l'attention du modèle et dégradent les performances. Déplacez entièrement les scripts utilitaires, les pipelines d'ingestion de données et les bibliothèques de validation lourdes vers l'évaluateur côté client.

Amorcez d'abord le programme initial.

Avant d'exécuter AlphaEvolve, utilisez un agent de codage standard pour déboguer à la fois votre codebase de départ et votre évaluateur :

  • Préparer le seed : corrigez les bugs de syntaxe évidents, les problèmes de compilation et les cas extrêmes.

  • Vérifiez le score de départ : assurez-vous que le score de référence est raisonnable et que l'évaluateur est entièrement déterministe (même code + même entrée = même score).

  • Tester avec des entrées non valides : exécutez l'évaluateur avec des fonctions volontairement défectueuses pour vérifier qu'il détecte les problèmes de compilation, gère correctement les boucles infinies et renvoie des scores de pénalité négatifs élevés.

Éviter les références trop optimisées

Ne transmettez pas un programme de référence déjà fortement optimisé en tant que seed. Si votre programme initial est déjà presque optimal, AlphaEvolve aura du mal à effectuer l'escalade, car il y a très peu de marge d'amélioration. Commencez par une base raisonnable, mais pas encore optimisée au maximum. Cela donne à AlphaEvolve l'espace nécessaire pour explorer et effectuer une recherche du meilleur voisin.

Mesures de protection du programme d'exécution côté client

Les évaluateurs côté client doivent appliquer des mesures de protection strictes pour empêcher les candidats malveillants, gourmands en ressources ou non réactifs de bloquer les workers parallèles :

  • Délai d'exécution strict : appliquez un délai d'exécution strict de 30 minutes (ou moins, selon la structure de l'espace de recherche).

  • Envoi d'une pénalité de délai d'attente : si une variante du programme candidat dépasse la limite de délai d'attente, mettez fin immédiatement à son thread d'exécution. Ne pas autoriser l'échec du processus candidat. Au lieu de cela, compilez et envoyez instantanément un score de pénalité pour échec grave (par exemple, -100000.0) ainsi qu'un insight de débogage descriptif au serveur pour déverrouiller la file d'attente du programme.

  • Filtres de sécurité AST : exécutez toujours une vérification d'inspection de l'arbre syntaxique abstrait (AST) sur la charge utile du code source entrant avant la compilation. Interrompez immédiatement l'exécution et appliquez une pénalité en cas d'échec grave si des primitives d'exécution ou de réflexion restreintes (telles que eval, exec, getattr ou setattr) sont détectées.

Autres ressources

Pour en savoir plus, consultez les ressources suivantes :