Vous pensez à ACE ? Nous pouvons le faire avec moins de tokens.

Vous pensez à l'ACE ? Nous pouvons le faire avec moins de jetons

Quand nous concevons un agent IA, la question qui domine chaque revue est la même : « Va-t-il tenir ? » Le prompt système va-t-il tenir ? Les preuves récupérées vont-elles tenir ? Les douze étapes intermédiaires de raisonnement vont-elles tenir ? En général, la réponse que nous choisissons est d'acheter une fenêtre de contexte plus grande. Mais il existe une alternative plus discrète, souvent meilleure : apprendre à l'agent à dépenser moins de jetons dès le départ.

Cette alternative fait l'objet de « Thinking of ACE? We Can Do It with Fewer Tokens », un billet technique publié par IBM Research sur le blog Hugging Face le 2026-08-11 à l'adresse https://huggingface.co/blog/ibm-research/altk-evolve-sldd. Le billet soutient que l'ingénierie du contexte agentique — la discipline qui consiste à gérer ce qu'un agent lit et écrit — ne doit pas nécessairement être synonyme de budgets de contexte toujours plus grands. Cet article est un compagnon pratique de cette idée. Il explique pourquoi l'efficacité en jetons est le pilier des agents fiables, et il présente une petite boîte à outils concrète pour mesurer et réduire la consommation de jetons de vos propres agents.

Avant d'aller plus loin, une note sur le périmètre. Les faits vérifiés concernant la source sont son titre, sa date de publication et son URL. L'interprétation technique qui suit est la mienne, et les exemples de code sont une configuration générique plutôt que des extraits du billet.

Pourquoi l'ingénierie du contexte est un problème de jetons, pas un problème de mémoire

Un agent est une boucle. Il lit, raisonne, appelle des outils, lit les résultats, raisonne à nouveau, et répète jusqu'à ce qu'il produise une réponse. Chaque passage dans la boucle ajoute des jetons au passage suivant :

• Le prompt système est payé à chaque tour.
• Les documents récupérés sont généralement injectés en intégralité.
• Les sorties d'outils sont souvent renvoyées mot pour mot, quelle que soit leur taille.
• La chaîne de pensée de l'agent est sauvegardée et rejouée afin qu'il puisse rester cohérent.

Il en résulte qu'une tâche simple avec trois appels d'outils peut produire des dizaines de milliers de jetons de contexte, même lorsque les informations utiles pourraient tenir en quelques centaines. Ce n'est pas un problème de mémoire — le modèle peut tout mémoriser. C'est un problème de budget. Chaque jeton supplémentaire ajoute du coût, de la latence et du bruit. Et le bruit n'est pas inoffensif : en pratique, un modèle est souvent bien moins performant pour extraire un fait pertinent unique lorsque ce fait est noyé dans un texte sans rapport. Les ingénieurs appellent parfois cela l'effet « perdu au milieu », et il s'aggrave à mesure que les contextes s'allongent.

L'ingénierie du contexte agentique (ACE), comme son nom l'indique, traite le contexte comme quelque chose que nous concevons et maintenons, et non comme quelque chose qui s'accumule simplement. Un contexte d'agent bien conçu est compact, à jour et suffisant. Il ne contient que ce dont l'étape suivante a besoin, pas tout ce que l'agent a jamais vu. C'est là que le billet d'IBM Research fait valoir son point : avec une ingénierie du contexte disciplinée, vous pouvez exécuter des charges de travail agentiques avec beaucoup moins de jetons — sans sacrifier la qualité de la tâche. Le titre du billet est la thèse : « Nous pouvons le faire avec moins de jetons. »

Le manuel de base : six habitudes pour des agents économes en jetons

Les principes suivants sont une synthèse générique des meilleures pratiques de l'ACE. Ils sont cohérents avec l'orientation du billet source, mais ne constituent pas un résumé de ses détails internes.

1. Privilégier un état structuré plutôt que l'historique brut. Au lieu de rejouer la transcription complète à chaque étape, maintenez un bloc de statut compact : ce que l'agent sait, ce qu'il a essayé, ce qui a échoué et ce qui suit.

1. Réduire les sorties d'outils à la frontière. L'outil renvoie ce qu'il renvoie ; le contexte ne doit pas nécessairement tout contenir. Coupez la charge utile avant qu'elle n'entre dans la conversation.

1. Résumer avant de persister. Chaque fois que l'agent termine une sous-tâche, comprimez le résultat en une entrée de registre d'une ligne. Laissez les détails disparaître après avoir servi leur objectif.

1. Récupérer de manière étroite et fréquente. Au lieu d'injecter un grand corpus au début de la session, récupérez de petits morceaux juste à temps, près du moment où ils sont nécessaires.

1. Budgéter le prompt système. Chaque phrase du prompt concurrence la mémoire de travail. Si une règle peut être raccourcie sans perdre en précision, raccourcissez-la. Si un exemple est redondant, supprimez-le.

1. Tout mesurer. Vous ne pouvez pas gérer une consommation de jetons que vous ne voyez pas. Comptez les jetons par étape, par boucle et par session jusqu'à ce que l'habitude devienne automatique.

Ces habitudes sont peu coûteuses à mettre en œuvre et immédiatement efficaces. Le reste de cet article montre la mécanique concrète.

Prérequis

Pour suivre les exemples de cet article, vous avez besoin de :

• Python 3.10 ou plus récent.
• Un outil d'environnement virtuel tel que venv.
• Les bibliothèques Hugging Face transformers et datasets.
• Facultativement, tiktoken pour le comptage de jetons avec les modèles compatibles OpenAI.
• Une clé API uniquement si vous prévoyez de tester avec un modèle hébergé ; tous les exemples s'exécutent localement.

La configuration utilise délibérément des outils ouverts et locaux. La mesure des jetons ne nécessite pas de GPU, et vous pouvez exécuter chaque exemple sur un ordinateur portable pendant une pause-café.

Installation étape par étape

Tout d'abord, créez un environnement virtuel isolé afin que les paquets que nous installons n'interfèrent pas avec le reste de votre système :

python -m venv ace-env

Cela crée un dossier nommé ace-env contenant son propre binaire Python et son propre répertoire de bibliothèques.

Activez l'environnement. La commande diffère selon le système d'exploitation ; sur Linux et macOS :

source ace-env/bin/activate

Sur Windows :

ace-env\Scripts\activate

Après l'activation, votre invite de shell devrait afficher (ace-env) au début.

Mettez à niveau pip vers la dernière version afin que la résolution des dépendances se comporte bien :

pip install --upgrade pip

Installez les paquets principaux. transformers nous donne les tokeniseurs et les utilitaires de modèles, tandis que datasets est pratique pour charger de petits corpus d'évaluation :

pip install transformers datasets

Si vous travaillez avec des API de style OpenAI et souhaitez compter les jetons en utilisant la même famille de tokeniseurs que celle utilisée par l'API, installez également tiktoken :

pip install tiktoken

Vérifiez l'installation en important les bibliothèques et en affichant leurs versions :

python -c "import transformers; import datasets; print('transformers', transformers.__version__); print('datasets', datasets.__version__)"

Si vous avez installé tiktoken, vérifiez-le de la même manière :

python -c "import tiktoken; print('tiktoken', tiktoken.__version__)"

La configuration est terminée. Il n'y a aucun serveur à démarrer ni aucun modèle à télécharger ; le comptage de jetons fonctionne entièrement hors ligne.

Exemples d'utilisation

1. Compter les jetons avant de concevoir

La première habitude est la mesure. Avant de pouvoir décider si un contexte est enflé, vous avez besoin d'un moyen fiable de compter les jetons dans vos prompts et sorties d'outils. La fonction suivante utilise un tokeniseur Hugging Face :

from transformers import AutoTokenizer

def count_tokens(text: str, model_id: str = "gpt2") -> int:
    tokenizer = AutoTokenizer.from_pretrained(model_id)
    return len(tokenizer.encode(text, add_special_tokens=False))

example = "RESULT: invoice_2024_05_221.pdf contains 4 line items totaling $12,500."
print(count_tokens(example))

Le tokeniseur gpt2 est un substitut local couramment utilisé pour de nombreux modèles modernes, et il fonctionne sans clé API. Si votre modèle cible est connu, remplacez model_id par le nom du tokeniseur de ce modèle.

2. Réduire les sorties d'outils à la frontière

Lorsqu'un outil renvoie un gros blob JSON, il est tentant d'injecter le tout. Une fonction de réduction simple conserve la tête et la queue, où se trouvent généralement les métadonnées importantes, et supprime le milieu :

def trim_tool_output(output: str, keep: int = 400) -> str:
    if len(output) <= keep:
        return output
    half = keep // 2
    return (
        output[:half]
        + f"\n...[trimmed {len(output) - keep} characters]...\n"
        + output[-half:]
    )

large_http_body = '{"status": "ok", "items": [' + ','.join(f'{{"id": {i}}}' for i in range(1000)) + ']}'
print(trim_tool_output(large_http_body, keep=300))

Cela préserve la structure et les limites de la charge utile tout en éliminant la section médiane répétitive. Dans une boucle d'agent, appliquez cette fonction au point où le résultat de l'outil est inséré dans le contexte, pas plus tard. Une fois la sortie brute réduite, ne conservez pas non plus la version non réduite quelque part « au cas où » — cela irait à l'encontre du but recherché.

3. Remplacer l'historique de conversation par un registre de statut

La fuite de jetons la plus courante dans les systèmes agentiques est la transcription complète. Au lieu de stocker chaque message, chaque appel d'outil et chaque réflexion, maintenez un registre court mis à jour après chaque étape :

class AgentLedger:
    def __init__(self, max_entries: int = 5):
        self.entries = []
        self.max_entries = max_entries

    def record(self, step: int, action: str, conclusion: str) -> None:
        self.entries.append(f"step {step}: ran {action} -> {conclusion}")
        self.entries = self.entries[-self.max_entries:]

    def render(self) -> str:
        return "\n".join(self.entries)

ledger = AgentLedger(max_entries=3)
ledger.record(1, "search", "found 3 candidates")
ledger.record(2, "read_doc", "candidate A missing license")
ledger.record(3, "verify", "candidate B is valid")
ledger.record(4, "summarize", "ready to answer")
print(ledger.render())

L'agent perd l'accès au raisonnement brut des trois premières étapes, mais il conserve ce qui compte : ce qu'il a fait et ce qu'il a conclu. Pour de nombreuses tâches, cela suffit pour un comportement cohérent sur un long horizon. Le coût en jetons du registre croît linéairement avec le nombre d'entrées — et non avec la longueur de la transcription complète. C'est le changement le plus efficace que vous puissiez apporter à un agent existant.

4. Construire un prompt système compact

Les prompts système sont payés à chaque tour, donc leur coût en jetons est multiplié par le nombre de boucles que l'agent exécute. Un bon prompt est précis : il énonce le rôle de l'agent, le format de chaque étape et les règles budgétaires. Un mauvais prompt enterre ces instructions dans des exemples et des avertissements. Un modèle minimal démontre le principe :

SYSTEM_PROMPT = """You are a research assistant.
Work in steps. After each step, write a single line:
[step N] <action> -> <conclusion>
Keep the ledger under 10 lines. Do not recap old steps."""

print(count_tokens(SYSTEM_PROMPT))

La formulation exacte différera selon votre tâche, mais la discipline est la même : si une phrase peut être supprimée sans changer le comportement observé, supprimez-la. En cas de doute, effectuez un petit test A/B avec et sans la phrase et comparez les taux de réussite des tâches, pas votre intuition.

Mise en pratique

Lorsque vous combinez ces pratiques, l'effet est cumulatif. Une exécution typique d'agent pourrait ressembler à ceci :

• Le prompt système fait 150 jetons au lieu de 800.
• Les sorties d'outils sont réduites à 400 caractères chacune au lieu de 5 000.
• L'historique de conversation est un registre de cinq lignes au lieu d'une transcription de 40 tours.
• La récupération extrait trois courts extraits au lieu de dix longs documents.

La même tâche s'exécute désormais avec un ordre de grandeur en moins de jetons. La latence diminue car le traitement d'entrée est plus rapide. Le coût diminue car la tarification de l'entrée est multiplicative à travers les tours. Et dans de nombreux cas, la qualité s'améliore, car le modèle n'est plus obligé de chercher un signal dans un océan de bruit.

Il y a des limites. Certaines tâches exigent réellement de longs documents dans le contexte, et une compression agressive peut perdre la formulation exacte dont l'agent a besoin. L'analyse juridique avec de nombreuses citations, par exemple, peut exiger le texte source mot pour mot. L'objectif n'est pas zéro jeton ; c'est le plus petit contexte qui accomplit la tâche de manière fiable. C'est la définition pratique d'une ACE réussie : non pas « combien le modèle peut-il contenir » mais « de combien la tâche a-t-elle réellement besoin ».

Un exercice utile consiste à prendre un de vos agents existants, à l'exécuter sur un cas de test standard et à compter le nombre total de jetons consommés de bout en bout. Ensuite, appliquez les quatre exemples ci-dessus un à un, en réexécutant le cas de test après chaque changement. Vous découvrirez rapidement quelle étape de votre pipeline est le plus gros consommateur — et si elle méritait réellement sa place dans le contexte.

Conclusion

L'ingénierie du contexte agentique est souvent présentée comme un problème d'échelle : modèles plus grands, fenêtres plus grandes, budgets plus grands. Le billet d'IBM Research « Thinking of ACE? We Can Do It with Fewer Tokens » défend le point de vue opposé, et la boîte à outils pratique de cet article suit la même direction. L'efficacité en jetons n'est pas une optimisation de performance que vous appliquez après avoir construit l'agent. C'est une contrainte de conception que vous appliquez dès le premier prompt.

Commencez par mesurer ce que votre agent dépense réellement. Ensuite, réduisez ce dont il n'a pas besoin. Puis remplacez l'historique brut par une structure. Vous découvrirez presque certainement que l'agent portait bien plus qu'il n'en utilisait jamais — et que moins de jetons, utilisés délibérément, suffisent.