Qu'est-ce qu'un workflow agentique ? Comment en construire un qui planifie, agit et évalue

Un workflow agentique est un système multi-étapes où un modèle de langage ne se contente pas de répondre une fois : il planifie, choisit des outils, exécute des actions, vérifie le résultat et décide de la suite à donner jusqu’à ce que la tâche soit terminée. En pratique, cela signifie combiner une couche de raisonnement LLM avec l’appel d’outils, un environnement d’exécution réel et une boucle d’évaluation. Si vous construisez des agents de codage, des agents de recherche ou une automatisation interne qui doit s’adapter en cours de tâche, c’est généralement l’architecture que vous construisez réellement.

Qu’est-ce qu’un workflow agentique ?

Un workflow agentique est le modèle derrière les systèmes d’IA qui peuvent évoluer dans une tâche au lieu de s’arrêter à la génération de texte. Plutôt que de demander une réponse unique au modèle et de la renvoyer à l’utilisateur, vous laissez le modèle opérer à l’intérieur d’une boucle contrôlée :

1. Lire l’objectif et l’état actuel.
2. Planifier l’étape suivante.
3. Appeler un outil ou exécuter du code.
4. Observer le résultat.
5. Évaluer si la tâche est terminée.
6. Répéter si nécessaire.

Ceci est différent d’un workflow fixe, où chaque étape est pré-écrite dans le code. Dans un workflow fixe, vous décidez du chemin à l’avance. Dans un workflow agentique, le modèle décide quelle action entreprendre ensuite dans les limites que vous fournissez.

Cette distinction est importante car de nombreuses tâches réelles de développement ne sont pas linéaires. Un agent de codage peut avoir besoin d’inspecter des fichiers avant de savoir quel test exécuter. Un agent de recherche peut avoir besoin d’effectuer deux recherches car la première source était incomplète. Un agent de navigation peut avoir besoin de se remettre d’un échec de connexion ou d’une mise en page modifiée. Ce sont des problèmes de workflow, mais ils nécessitent une adaptation.

En quoi un workflow agentique est-il différent d’un agent d’IA ?

Les gens utilisent souvent les deux termes de manière interchangeable, mais il est plus utile de les séparer :

• Un workflow agentique est le modèle d’exécution.
• Un agent d’IA est le produit ou le système construit sur ce modèle.

Vous pouvez avoir un workflow agentique très ciblé qui ne fait que trier les tickets de support, ou un agent d’IA plus large qui coordonne la planification, l’utilisation d’outils, la mémoire et les points de vérification d’approbation sur de nombreuses tâches.

Si vous voulez une règle pratique, utilisez workflow lorsque vous parlez d’architecture et de flux de contrôle, et utilisez agent lorsque vous parlez du système orienté utilisateur.

Quelles sont les parties essentielles d’un workflow agentique ?

La plupart des systèmes de production se retrouvent avec les cinq mêmes parties.

1. Planificateur

Le planificateur transforme une instruction large en l’action concrète suivante. Parfois, c’est une étape de planification explicite qui produit une liste de tâches. Parfois, c’est implicite et se produit à chaque tour d’appel d’outil. Dans les deux cas, le modèle a besoin de suffisamment de contexte pour décider s’il doit lire, écrire, rechercher, exécuter ou s’arrêter.

Une bonne planification ne signifie pas générer un long plan pour chaque requête. Cela signifie rendre la prochaine action compréhensible. Pour les tâches courtes, une planification en une étape suffit. Pour les tâches plus longues telles que les refontes de dépôt, l’automatisation de navigateur ou la révision de documents, un plan explicite réduit les allers-retours inefficaces.

2. Couche d’outils

Les outils sont l’interface du workflow avec le monde. Une couche d’outils solide est généralement étroite et prévisible. Par exemple :

• read_file(path)
• write_file(path, content)
• search_files(query)
• run_command(cmd)
• fetch_url(url)

Les petits outils sont plus faciles à appeler correctement pour le modèle, plus faciles à journaliser et plus faciles à sécuriser. Les grands outils « tout-en-un » semblent pratiques au début mais deviennent difficiles à déboguer car vous ne pouvez pas dire si les échecs proviennent de la décision du modèle, de l’implémentation de l’outil ou du système externe derrière.

3. Environnement d’exécution

Une fois que le modèle décide d’agir, quelque chose doit exécuter l’action. Pour tout workflow qui écrit des fichiers, installe des paquets, exécute du code ou ouvre des sessions de navigateur, cet environnement d’exécution a besoin d’isolation.

C’est là qu’un sandbox entre en jeu. Novita Agent Sandbox est conçu pour cette couche d’exécution : un environnement séparé où les actions de l’agent peuvent s’exécuter sans toucher directement au système hôte. C’est la différence entre « le modèle a suggéré une commande » et « le workflow a exécuté cette commande en toute sécurité ».

4. État et mémoire

Un workflow agentique a besoin d’une mémoire de travail à travers les étapes. Cela inclut généralement :

• l’état de la conversation
• les sorties des outils
• les fichiers intermédiaires
• les journaux d’exécution
• un bloc-notes ou un plan court

Sans état, chaque étape devient une ingénierie de prompt sans état, et le système s’effondre dès que la tâche s’étend sur plus d’une action.

5. Boucle d’évaluation

C’est la partie que de nombreuses équipes ajoutent trop tard. Le workflow a besoin d’un moyen de juger si une étape a réussi et si la tâche est terminée. Dans un workflow de codage, cela peut signifier que les tests passent. Dans un workflow de recherche, cela peut signifier que la réponse cite suffisamment de sources fiables. Dans un workflow de navigateur, cela peut signifier que l’état d’interface utilisateur attendu est visible.

Sans évaluation, « agentique » se transforme souvent en « continue d’appeler des outils jusqu’au délai ».

Pourquoi la planification est importante dans la construction de workows agentiques

La plus grande erreur dans la construction de workows agentiques est de supposer que le modèe doit improviser tout à partr de zéro à chaque tour.

Cela cré d’habitude tros problèmes :

• le modèe revisite les mêmes fichirs ou URLs à plusieurs reprises
• l’utilisation des outils devint bruyante et coûteuse
• le workflow perd une conditon d’arrêt claire

Un meilleur modèe est la planification légère plus l’exécution ancrée. Laissez le modèe décder la prochaine action, mais faites-le en regard d’une tâche explicite, d’un état actuel visible et d’un petit ensemble d’outils autorisés. Cela garde la flexibilité là o elle aide et la supprime là o elle ne le fait pas.

Dans les workows de codage, la planification ressemble souvent à cela :

1. Identifier les fichirs concernés.
2. Lire l’implémentation actuell.
3. Décider du changemen minimal.
4. Effectorer la modifcation.
5. Exécuter la vériication.
6. Soit s’arrêr, soit réparer.

Ceci reste agentique, car le modèe peut bifurquer lorsque le dépôt le surprend. Mais il ne vagabonde pas.

Comment l’utilisation des outils devrit-elle fonctionner dans un workflow agentique ?

L’utilisation des outils doit être explcite, typée et observavle.

Si votre modèe prend en charge l’appel de fucntions, utilisez-le. L’API LLM de Novita exose un point d’terminaison compatible OpenAI et documente directement l’appel de fucntion, ce qui est la manièr la plus propre de laisser le modèe chooisir parmi les outils sans se fier à un ansage de chaîne fragile.

Quelques règs rendent l’utilisation des outils beaucoup plus fiable :

• Gardez les noms d’outils concrts.
• Utilisez des schémas avec des champs obligatoirs.
• Retournez des résulats comlets, y comris les erreurs.
• Journalisez chque app, argumen et sotie.
• Rende les actions strctves rares et facils à verouiler.

La couche d’outils doit aussi reflter les limites rées. Par exmple, ne donnez pas à un agent de codage un méga-outil nommé edit_repo_and_run_tests . Séparez les étapes de lcture, d’écriture et d’xécuton pour que le modèe puise récupr quand qulechose éhoue.

Pourquoi l’xécution de code a-t-elle besoin d’un sandbox ?

Un workflow agentique qui n’xécute jamais rien peut souvent rester à l’intéur d’un serveur d’applicton ordinir. Ds qu’il comence à exécuter des commandes shell, installer des dépenances, gérer des fichirs téléchargés ou naviger sur le web ouvert, vous avez bsoin d’isolaton.

Le sandboxin résout deux probèmes diffrents :

• Sécurité : le code généré et les soties des outils peuvent êtr faux, hostiles ou simpement imprévisibls.
• État : les tâches multi-étapes ont bsoin d’un espac de travail persstant o les fichirs, les paquets et l’historique d’xécution surivvnent à travers les tours.

Pour de nombreuses éqipes, le secod point est tout aussi importnt que le primer. Un workflow qui éite du code, exécute des tests, corrige l’éhec et ré-exécute la vérifction n’est pas possible si chque éape part d’une machine porpe.

C’est pourqoi l’architectur pratique est généraement :

• API LLM pour la planifction et la sélection des outils
• Environnemnt d’xécution sandboxé pour l’xécution et la persitance

Novita s’intègre naturelleent dans cette séparation : l’API LLM agit comme la couche de planifction et d’appel d’outils, tandis que Agent Sandbox gère l’envirnnement d’xécution lui-même.

Comment évaluer un workflow agentique ?

L’évaluation doit avoir liu à deu niveaux.

Évaluation au niveu de l’étape

La dernièr action a-t-ell fonctonné ?

Exmples :

• La commande s’t-ell termnée avec suuccès ?
• L’API a-t-ell retourné un JSON valide ?
• Le fichir attendu a-t-ell été créé ?
• La page du naitgateur contnait-ell l’éément ciblé ?

Évaluation au niveu de la tâche

Le workflow a-t-il résou le probème de l’utilisateur ?

Exmples :

• Les tests sont-ils passes après le changemen de code ?
• Le résumé répon-il à la qustion de recherche avc des preuvs ?
• L’automation a-t-ell compété la trnsacton sans netoyage manuel ?

Les worksflows solides utilient les deu. Si vous n’évalez que la from du résulatt final, vous manquez des signaux d’éhec évidents pendant l’exécution. Si vous n’évalez que les étapes, le workflow peut compléter une longue série d’actions localement valides et échouer ancore à la tâche réelle.

Une architecture pratique pour construire des worksflows agentiques

Voici l’architecture ave laquelle la plupart des équipes devraient commencer :

1. Une requête utilisateur entre dans votre application.
2. Votre contrôleur envoie l’objectif, l’état et les outils disponibles à un LLM.
3. Le LLM retourne soit une répon directe, soit un appel d’outil.
4. Votre contrôleur exécute l’outil à l’intéur d’un sandbox ou d’un autre envionnement contrôlé.
5. Le résulatt de l’outil est ajouté à l’état de la conversation.
6. Un évaluateur vérifie la fin, l’éhec ou les points de contrôe d’approbation.
7. La bouc contunue jusqu’à ce que le worksflow soit termine ou bloqué.

Cette boucle de contrôleur peut être simple. Dans de nombreu cas, un seul processus orchestreur suffit. Vous n’avez pas bsoin d’un système multi-agents dès le premier jour. Commencez avec un planificateur, quleques outls bien définis, un envionnement d’exécution sandboxé et un évaluateur clair.

Exemple : un contrôleur de worksflow agentique en Python

L’exemple ci-dessou montre la forme de la boucle de contrôl. Il utilise l’API compatible OpenAI de Novit pour l’appel d’outils. Les fonctions d’exécution sont à vous d’implémenter par rapport à votre propre envionnement d’exécution ou sandbox.

import json
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.novita.ai/openai",
    api_key=os.environ["NOVITA_API_KEY"],
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Read a file from the workspace",
            "parameters": {
                "type": "object",
                "properties": {"path": {"type": "string"}},
                "required": ["path"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "run_command",
            "description": "Run a shell command in the sandbox",
            "parameters": {
                "type": "object",
                "properties": {"cmd": {"type": "string"}},
                "required": ["cmd"],
            },
        },
    },
]


def read_file(path: str) -> str:
    # Implémentez ceci pour votre propre système de fichiers worksapce ou sandbox.
    raise NotImplementedError


def run_command(cmd: str) -> str:
    # Implémentez ceci pour votre envionnement d'exécution sandbox.
    raise NotImplementedError


dispatch = {
    "read_file": read_file,
    "run_command": run_command,
}


def run_workflow(task: str, model: str) -> str:
    messages = [
        {
            "role": "system",
            "content": (
                "You are a workflow controller. Use tools when needed, "
                "check results after each action, and stop when the task is complete."
            ),
        },
        {"role": "user", "content": task},
    ]

    while True:
        response = client.chat.completions.create(
            model=model,
            messages=messages,
            tools=tools,
            tool_choice="auto",
        )

        message = response.choices[0].message
        messages.append(message)

        if not message.tool_calls:
            return message.content

        for call in message.tool_calls:
            fn = dispatch[call.function.name]
            args = json.loads(call.function.arguments)
            result = fn(**args)
            messages.append(
                {
                    "role": "tool",
                    "tool_call_id": call.id,
                    "content": result,
                }
            )

Ceci est intentionnellement minimal. En production, vous ajouteriez également :

• une politique de réessai pour les erreurs transitoires
• des délais d’attente et des limites de budget
• une approbation humaine pour les actions sensibles
• des journaux d’étape structurés
• un évaluateur au niveau de la tâche avant la complétion finale

Quel modèle utiliser comme planificateur ?

Pour un workflow agentique, le modèle planificateur n’a pas seulement besoin d’intelligence brute. Il a besoin de la bonne forme :

• appel d’outil fiable
• comportement stable sur de longs contextes
• bonne capacité à suivre les instructions
• latence prévisible sur plusieurs tours

Si vous voulez un point de départ open-weight sur Novita, Qwen3 Coder 30B A3B Instruct est une option pratique pour la planification de workflow et l’utilisation d’outils orientés codage. La page actuelle des modèles de Novita répertorie un accès compatible OpenAI, le support des appels de fonction, le support des sorties structurées et une fenêtre de contexte hébergée de 160K. Pour de nombreuses tâches d’automatisation interne et de codage, cela suffit pour construire une première version sérieuse avant de passer à un planificateur plus grand ou plus spécialisé.

Le bon modèle dépend toujours de la tâche. Pour les workflows intensifs en raisonnement, choisissez d’abord la qualité de la planification. Pour l’automatisation à haut volume, la latence et le coût peuvent compter autant que la force des benchmarks.

Modes de défaillance courants dans les workflows agentiques

La plupart des échecs ne sont pas dramatiques. Ils sont répétitifs et coûteux.

Sur-utilisation des outils

Si chaque capacité devient une dépendance distante, le workflow passe plus de temps à coordonner qu’à faire du travail utile.

Règles d’arrêt faibles

Si le système ne sait jamais quand « fini » est vrai, il continue à générer une étape de plus.

Gestion des erreurs insuffisante

Si les outils renvoient des messages vagues comme « échec » au lieu d’une sortie exploitable, le modèle ne peut pas récupérer.

Absence de limite de sandbox

Le workflow peut fonctionner en développement, puis devenir dangereux dès qu’il touche à des fichiers réels, des identifiants ou des systèmes externes.

Pas d’évaluateur

L’agent semble actif mais ne prouve jamais que la tâche a été correctement complétée.

Quand ne pas utiliser un workflow agentique ?

N’en construisez pas un simplement parce que le terme est populaire.

Vous n’avez probablement pas besoin d’un workflow agentique si :

• la tâche est une génération unique
• le chemin est fixe et change rarement
• un programme traditionnel peut décider chaque étape à moindre coût
• il n’y a pas besoin d’utilisation d’outils ou d’exécution

Par exemple, si votre application prend toujours une entrée de formulaire, appelle un prompt et renvoie un email formaté, un workflow LLM ordinaire est plus simple et meilleur.

Les workflows agentiques sont rentables lorsque l’environnement peut surprendre le système et que le système a encore besoin de continuer.

Si vous voulez un point de départ pour un modèle à long contexte, comparez Macaron V1 Tall Quick Start on Novita AI et Qwen3.8-Max on Novita AI.

FAQ

Un workflow agentique est-il la même chose que l’appel de fonction ?

Non. L’appel de fonction est un mécanisme à l’intérieur du workflow. Le workflow complet a également besoin de flux de contrôle, d’état, d’exécution et d’évaluation.

Ai-je besoin de plusieurs agents pour construire des workflows agentiques ?

Non. La plupart des équipes devraient commencer avec une boucle de contrôleur unique et quelques outils. Les conceptions multi-agents sont utiles plus tard, mais elles ne sont pas le point de départ par défaut.

Quel est le contrôle de sécurité le plus important ?

Pour les workflows qui exécutent du code ou touchent à des systèmes externes, le contrôle le plus important est un envionnement d’exécution isolé combiné à des permissions d’outils étroites.

Quel est le stack de production le plus simple prêt à l’emploi ?

Un bon prémier stack est : une API LLM compatible OpenAI, un pétit registre d’outils, un envionnement d’exécution sandboxé et un évaluateur qui peut décider quand la tâche est réellement terminée.

Articles recoméndés

• What Are Coding Agents? How They Work and How to Build One
• What Is an AI Agent Sandbox?
• Agent vs Workflow: Key Différences and Practical Trade-Offs