Thèse Vérifier les Agents d'IA Autonomes par les Contraintes Acquisition de Spécifications et Contrôle à l'Exécution des Agents à Base de Grands Modèles de Langage H/F - Doctorat.Gouv.Fr

Établissement : Université Paris-Saclay GS Informatique et sciences du numérique École doctorale : Sciences et Technologies de l'Information et de la Communication Laboratoire de recherche : Laboratoire Interdisciplinaire des Sciences du Numérique Direction de la thèse : Nadjib LAZAAR ORCID 0000000325249462 Début de la thèse : 2027-10-01 Date limite de candidature : 2027-03-09T23:59:59 Les grands modèles de langage sont désormais déployés comme des agents autonomes capables de planifier, d'appeler des outils, d'exécuter des commandes et de modifier des fichiers. Les assistants de programmation agentiques (Claude Code, Codex...) en sont l'exemple le plus visible. Cette autonomie expose à des risques sérieux : suppression ou fuite de données, actions dangereuses, détournement par injection de prompt. Les garde-fous actuels reposent sur des règles écrites à la main ou extraites par des modèles de langage, sans garantie de correction ni de complétude.

Cette thèse propose d'aborder la vérification des agents par la programmation par contraintes et l'acquisition de contraintes. Les politiques de sûreté seront représentées comme des contraintes sur les trajectoires d'actions d'un agent. Elles seront apprises à partir de traces d'exécution et d'interactions avec l'utilisateur, en minimisant le nombre de questions et avec des garanties de convergence. Un solveur les imposera ensuite à l'exécution : il vérifiera avant chaque action que la tâche reste réalisable sans violer la spécification, proposera une correction minimale et expliquera ses refus.

Les contributions attendues sont un langage de spécification aux propriétés théoriques établies, des algorithmes d'acquisition économes en interactions, et un moniteur logiciel libre évalué sur des bancs d'essai publics et sur des scénarios réels d'assistants de programmation. Large language models no longer just produce text. They now act as autonomous agents that plan, call tools, run commands, edit files and interact with external services. Agentic coding assistants (Claude Code, Codex...) are the most visible example: they can chain dozens of actions on a user's machine with limited human oversight. This autonomy raises critical safety questions. An agent may delete data, leak information, run a dangerous command, or be hijacked by malicious instructions hidden in the content it processes (prompt injection). Benchmarks such as SWE-bench (Jimenez et al., 2024) for programming tasks, or AgentDojo (Debenedetti et al., 2024) for robustness to injections, show how hard the problem is.

Current safeguards rely largely on hand-written allowlists, on confirmation requests to the user, or on other language models used as judges. None of these offers formal guarantees. Existing formal approaches, such as shielding in reinforcement learning (Alshiekh et al., 2018) or early rule languages for agents, assume a complete and correct specification. Yet writing that specification is precisely the hard part: acceptable behaviour depends on the context, the user and the task.

Constraint programming and constraint acquisition provide a natural framework to remove this bottleneck. Safety policies can be represented as constraints over an agent's action sequences, learned from traces and interactions, and then enforced at runtime by a solver. The thesis aims to design a neuro-symbolic framework for agent verification, organised around three research directions.

Specification. Define a constraint language suited to agent trajectories: actions, resources accessed, information flows, temporal ordering. The language will build on global constraints (automata, sequences, cardinalities). Its expressiveness and the complexity of verification will be studied.
Specification acquisition. Learn these constraints from labelled execution traces (passive acquisition) and through interaction with the user (active acquisition). In the active setting, partial trajectories are submitted to the user for validation, while minimising the number of queries. Language models may propose candidate constraints from policies written in natural language (security guidelines, project instructions). The symbolic component will guarantee the consistency and convergence of the acquired model.
Runtime enforcement and explanation. Before each action, a solver checks that the current trajectory remains compatible with the specification and that the task can still be completed without violating it. When an action is rejected, it proposes a minimal correction or an alternative, and produces an explanation usable by the user and by the agent itself. The trade-off between safety, task success rate and computational overhead will be measured. The PhD student will combine three strands:

Theory: expressiveness and complexity of the specification language, acquisition guarantees, including with an error-prone user.
Algorithms: active acquisition, incremental satisfiability checking, minimal explanations.
Experiments: instrumentation of open-source agents, CP/SAT solvers, modelling libraries such as MiniZinc.

Étudiant·e normalien·ne titulaire, ou en cours d'obtention, d'un master en informatique ou en mathématiques appliquées à l'informatique.

Fondamentaux attendus : logique, algorithmique, complexité.
Atouts appréciés : connaissances en programmation par contraintes, SAT/SMT ou vérification formelle, et bases en apprentissage automatique.
Programmation : très bonnes compétences, Python en particulier. L'intérêt pour la mise en oeuvre de systèmes réels est essentiel, car la thèse comporte une forte part expérimentale sur des agents existants.
Qualités : goût pour l'articulation entre résultats théoriques et validation expérimentale, curiosité pour la sûreté de l'IA, autonomie et rigueur. Un bon niveau d'anglais écrit et oral est nécessaire pour la rédaction d'articles et les échanges internationaux.

• Python
• Programmation
• Anglais
• Intelligence artificielle
• Autonomie
• Machine learning