X-IA Hackathon (25-27 sept. 2026) à Lyon : venir avec un problème, repartir avec un agent testable

Tu veux un agent IA utile, pas une démo qui brille

Un hackathon, ça va vite. Trop vite pour “réinventer l’entreprise agentique”. Mais assez vite pour transformer un vrai irritant métier en agent IA testable, avec une démo reproductible, des métriques et un plan clair pour la suite.

Le X-IA Hackathon se tient à Lyon, avec une phase de hack/coding du 25 au 27 septembre 2026, des inscriptions annoncées du 9 au 22 septembre, et une finale live le 15 octobre 2026 pendant une édition X-IA (avec lot à la clé). Source organisateur : ax.polytechnique.org.

L’édition est orientée “agents”. Donc pas juste un chatbot. Un agent, c’est un système qui enchaîne des étapes, appelle des outils, et produit une action ou une recommandation traçable. Si tu veux remettre les définitions à plat avant de venir, tu peux relire : Qu’est-ce qu’un agent IA, et en quoi il diffère d’un chatbot.

Ce que le format 48-72 h permet vraiment (et ce qu’il ne permet pas)

En 48-72 h, tu peux sortir un agent qui fait une tâche répétable sur un périmètre réduit, avec une entrée et une sortie nettes. C’est là que les équipes gagnent. C’est aussi ce que rappellent plusieurs retours d’expérience sur les hackathons “agents” : tout n’est pas hackathonnable, il faut isoler un cas à enjeu élevé et scope serré (source : arkange.io).

Vise un agent “orienté tâche”, pas un “mini-salarié”

Une règle simple : si tu n’arrives pas à décrire le job de ton agent en une phrase qui commence par un verbe d’action, c’est trop flou.

• Bien : “Trier les demandes entrantes et proposer un routage avec justification.”
• Bien : “Répondre aux questions internes sur 150 pages de procédures, avec citations.”
• Non : “Automatiser tout le support client.”
• Non : “Remplacer l’équipe ADV.”

Ce que tu peux livrer en 48-72 h

• Un pipeline stable de bout en bout sur un jeu de test figé.
• Une interface simple (CLI, mini webapp, Slack/Teams si c’est déjà accessible).
• Des garde-fous minimaux (refus, escalade, validation humaine).
• Des métriques basiques mais honnêtes.

Ce que tu ne dois pas promettre

• Une intégration SI profonde (SSO, IAM complexe, multiples systèmes legacy) si tu n’as pas déjà les accès et les endpoints.
• Un agent qui “agit tout seul” sur des systèmes critiques sans mécanisme de validation.
• Un niveau de conformité ou de sécurité “production-ready” si tu n’as pas prévu logs, permissions, politique de conservation.

5 types de projets “agents IA” réalistes à Lyon en 48-72 h

Voici des formats qui marchent bien en hackathon IA Lyon, parce qu’ils ont des entrées sorties claires, des datasets faisables et une valeur métier facile à tester.

1) Agent de tri et routage (emails, tickets, formulaires)

Objectif : réduire le temps de traitement et les erreurs d’affectation.

• Entrée : un ticket ou un email (texte + quelques métadonnées).
• Sortie : catégorie, priorité, équipe cible, champs extraits, et une action recommandée.
• Garde-fou : validation humaine avant envoi/escalade.

Pour ancrer ça dans le réel, pars d’un flux simple type “demandes entrantes” : Automatiser l’accueil des demandes entrantes : formulaire, tri, affectation.

2) Agent de synthèse opérationnelle (dossiers, incidents, réunions)

Objectif : gagner du temps sur la compréhension et la prise de relais.

• Entrée : un lot de pièces (compte rendu, échanges, incident report, notes).
• Sortie : synthèse structurée + points d’attention + liste d’actions.
• Garde-fou : citations ou renvoi à la source, et “je ne sais pas” quand il manque une info.

Si tu passes par de l’audio, la transcription est souvent le vrai point dur : Outils de transcription audio : précision, langues et coût.

3) Copilote documentaire (RAG) limité mais solide

Objectif : répondre sur une base interne sans halluciner n’importe quoi.

• Entrée : question utilisateur.
• Sortie : réponse + citations + niveau de confiance + refus si hors périmètre.
• Corpus : 30 à 300 documents max pour un hackathon, propres et stables.

Pour comprendre le mécanisme et éviter le RAG “poudre aux yeux” : RAG : comment faire répondre une IA sur vos propres documents.

4) Agent de contrôle qualité (texte, fiches produit, rapports)

Objectif : réduire les retours, incohérences et omissions.

• Entrée : un document ou une fiche.
• Sortie : checklist d’erreurs, incohérences, champs manquants, corrections proposées.
• Garde-fou : ne pas auto-modifier, mais proposer un diff clair et validable.

5) Agent d’automatisation légère (workflow + approbation)

Objectif : automatiser une micro-action qui coûte du temps, sans ouvrir la porte à des dégâts.

• Exemples : créer une tâche Jira, ouvrir un draft d’email, pré-remplir un formulaire, générer une réponse type.
• Garde-fou : permissions minimales, approbation systématique, journaux d’exécution.

Si ton agent touche des outils, pose la question sécurité tout de suite : Sécuriser un agent IA qui a accès à vos outils.

Cadrer ton cas d’usage avant d’arriver : objectif, données, contraintes

Le meilleur hackathon IA Lyon, c’est celui où tu arrives déjà avec un problème “déplié”. Pas besoin d’avoir tout résolu. Besoin d’avoir tranché l’essentiel.

1) L’objectif métier en une phrase, avec un scope explicite

Exemples qui cadrent bien :

• “Réduire de 30 % le temps de tri des tickets N1, sur 5 catégories, avec validation humaine.”
• “Répondre aux questions internes RH sur le processus X, en citant la procédure, et refuser si hors corpus.”

Ajoute une ligne “hors scope” :

• Hors scope : “envoyer des mails au client”, “prendre une décision sur une personne”, “modifier la base clients”.

Si tu as besoin d’une méthode courte pour cadrer, sans te noyer : Cadrer un projet IA : la méthode en quatre étapes.

2) Décider si l’agent recommande ou s’il agit

Deux modes.

• Mode recommandation : l’agent propose, l’humain décide. Idéal en hackathon.
• Mode action : l’agent déclenche une action (création, envoi, modification). Là, tu dois prévoir un contrôle humain significatif et des permissions strictes.

Côté conformité, la CNIL insiste sur une approche par besoins concrets, et sur la maîtrise des risques et limites des IA génératives, notamment selon la sensibilité des usages (source : CNIL).

3) Les données minimales, mais représentatives

Pour un agent testable, tu as besoin d’un “mini-monde” réaliste :

• 20 à 200 cas typiques (tickets, emails, documents), propres, et stables.
• Un golden set : quelques exemples de “bonne sortie” attendue (même si c’est imparfait).
• Des cas difficiles : ambiguïtés, demandes hors scope, données incomplètes.

Si tu dois anonymiser ou pseudonymiser, fais-le avant de venir : Anonymiser ses données avant de les envoyer à un modèle.

4) RGPD : tranche les points qui bloquent toujours au dernier moment

Trois sujets qui font perdre des heures le jour J :

• Données personnelles : est-ce qu’il y en a dans ton dataset ou ton corpus RAG ? Si oui, sur quelle base, et avec quel niveau d’anonymisation ?
• Données sensibles : à éviter pour un hackathon. Sinon, tu as besoin d’un cadre béton.
• Conservation : qu’est-ce qui est loggé, combien de temps, pour quoi faire ?

Deux ressources utiles pour rester sur les rails :

• CNIL sur l’IA générative (Q/R) : cnil.fr
• Conseils CNIL sur les chatbots (notamment mises en garde, conservation) : cnil.fr

Côté Lyon IA, si tu veux une vue d’ensemble “entreprise” sans jargon : RGPD et IA en entreprise : ce que vous pouvez faire, ce que vous ne pouvez pas.

Les livrables à viser pour repartir avec quelque chose de testable

La promesse implicite d’un hackathon “agents IA”, c’est de repartir avec un proto qui tient debout. Pas un slide deck. Pas une vidéo montée. Un truc que tu peux relancer lundi au bureau.

Livrable 1 : une démo reproductible (3 à 5 minutes)

• Démo sur un dataset figé (pas “regarde, je tape une question au hasard”).
• Un scénario simple : 3 cas normaux + 1 cas hors scope + 1 cas ambigu.
• Un bouton “rejouer” ou un script “run_demo.sh”.

Livrable 2 : des métriques minimales, liées au métier

Oublie les métriques vanity du type “ça répond vite”. Vise :

• Taux de tâches réussies sans retouche (ou avec retouche légère).
• Temps moyen gagné par cas (même estimé, mais basé sur un avant/après).
• Taux d’escalade vers humain (normal, et même souhaitable au début).
• Taux d’échec sécurisé : l’agent refuse quand il ne sait pas, au lieu d’inventer.

Attention aux KPI trompeurs type “déflexion” seule : dévier des demandes ne prouve pas qu’elles sont résolues (source : orange-its.ch).

Pour structurer ton avant/après proprement : Mesurer le gain réel d’un usage IA : la méthode avant / après.

Livrable 3 : un plan d’industrialisation en 1 page

Une page. Pas dix. Avec :

• Architecture cible : RAG ou non, outils appelés, où tournent les composants.
• Intégrations SI nécessaires (et lesquelles sont optionnelles).
• Garde-fous : permissions, validation humaine, limites d’action, refus.
• Logs et traçabilité : quoi, où, pour qui, combien de temps.
• Monitoring : qualité, dérive, coûts, sécurité.
• Jalons 30-60-90 jours.

Sur la traçabilité, tu peux t’appuyer sur : Tracer les décisions prises avec l’aide d’une IA.

Checklist “avant de venir” (à copier-coller)

• Problème : une phrase objectif + une phrase hors scope.
• Process actuel : 5 étapes max, avec le point de douleur principal.
• Dataset minimal : 20 à 200 cas représentatifs, nettoyés, exportés (CSV, JSON, PDF).
• Golden set : 10 cas annotés “sortie attendue”.
• Cas pièges : 5 cas hors scope + 5 cas ambigus.
• Accès SI : comptes, clés API, sandbox, tokens, docs d’API, droits validés.
• Contraintes RGPD : données perso oui/non, niveau d’anonymisation, règles de conservation.
• Sécurité : l’agent a-t-il le droit d’écrire quelque part ? Si oui, approbation obligatoire.
• Critères de succès : 2 à 4 métriques (qualité, temps, escalade, refus).
• Format de démo : script ou interface, et scénario de 3 à 5 minutes.

Pièges fréquents (et comment les éviter)

Piège 1 : l’agent trop ambitieux

Symptôme : “Il va gérer tout le cycle, de A à Z”.

Antidote : coupe en une seule tâche avec une sortie claire. Le reste devient “next”.

Piège 2 : pas de garde-fous, donc pas de confiance

Symptôme : l’agent répond toujours, même quand il ne sait pas. Ou il agit sans validation.

Antidote : impose un mode refus, une escalade, et une validation humaine sur toute action. À garder sous la main : Agents IA en production : les cinq garde-fous à poser.

Piège 3 : tu arrives sans données et tu passes 12 heures à “trouver un CSV”

Symptôme : l’équipe bidouille un dataset fictif et la démo ne convainc personne.

Antidote : dataset minimal prêt, anonymisé, et réaliste. Même petit.

Piège 4 : RAG sans citations, donc hallucinations invisibles

Symptôme : réponse fluide, mais invérifiable.

Antidote : citations systématiques, et un bouton “voir la source”.

Pour limiter les hallucinations : Hallucinations des IA génératives : comment les limiter.

Piège 5 : métriques floues, donc débat stérile

Symptôme : “On a l’impression que ça marche.”

Antidote : un jeu de tests figé + scoring simple. Guide utile : Comment évaluer la réponse d’une IA : construire son jeu de tests.

Ce que l’organisation du X-IA Hackathon indique sur l’outillage

L’organisateur mentionne des soutiens et briques d’outillage, dont OpenAI (crédits API et ou Codex), et d’autres composants typiques d’orchestration d’agents, TTS/STT, plateformes d’agents, etc. Pour les détails à jour, réfère-toi à la page officielle : ax.polytechnique.org.

Prends ça comme un bonus, pas comme un plan. Ton plan, c’est : un cas d’usage, un dataset, une démo, des garde-fous.

Plan d’attaque simple si tu viens “avec un problème métier”

Jour 0 (avant de venir)

• Tu écris l’objectif, le hors scope, les métriques.
• Tu prépares le dataset et le golden set.
• Tu sécurises les accès (ou tu assumes un mode offline).

Jour 1 (cadrage dur, puis prototype)

• Tu verrouilles l’entrée et la sortie.
• Tu implémentes un pipeline minimal end to end.
• Tu mets un refus et une escalade dès le début.

Jour 2 (fiabilisation)

• Tu testes sur le golden set et les cas pièges.
• Tu ajustes prompts, formats, règles et citations.
• Tu logges ce qu’il faut pour expliquer les décisions.

Jour 3 (démo + plan de suite)

• Tu figes le dataset de démo.
• Tu produis 1 page d’industrialisation.
• Tu répètes la démo en 5 minutes chrono.

Si tu veux maximiser tes chances de repartir avec un agent IA testable

Ta meilleure stratégie est simple :

• Choisis un cas boring mais rentable : tri, synthèse, QA, RAG, micro-automatisation.
• Arrive avec des données et des critères de succès.
• Fais un agent prudent : refus, escalade, validation.
• Mesure sur un jeu figé. Même petit.
• Documente la suite en une page.

Le X-IA Hackathon à Lyon (25-27 sept. 2026) est une bonne fenêtre pour ça. Pas pour “faire de l’IA” en général. Pour sortir un agent qui fait une tâche, sur tes données, avec un résultat testable, que tu peux défendre en interne dès le lundi.