Agent marketing contenu avec OpenClaw

Introduction

Produire du contenu marketing de qualité prend du temps : recherche de mots-clés, brief éditorial, rédaction, relecture SEO, publication. Pour une équipe réduite, c'est souvent 2 à 3 heures par article. Avec un agent IA construit sur OpenClaw, ce pipeline tombe à 20 minutes. L'agent reçoit un mot-clé, génère un brief structuré, rédige l'article, l'évalue selon des critères SEO, puis le prépare pour la publication. Dans ce cas d'usage, vous apprenez à construire ce pipeline complet, skill par skill.

Résumé rapide

Le pipeline agent marketing OpenClaw fonctionne en cinq étapes :

Input : l'utilisateur fournit un mot-clé cible (ex. : "crewai vs langgraph")
Research : le skill web_research collecte les sources et la SERP
Brief : le skill brief_generator produit un plan structuré (H2, mots-clés secondaires, longueur cible)
Rédaction : le skill content_writer génère l'article complet en markdown
QA + Publication : le skill qa_checker score l'article (SEO, longueur, maillage) et déclenche la publication si le score dépasse le seuil

Qu'est-ce qu'un agent contenu et pourquoi OpenClaw est adapté

Un agent marketing IA n'est pas un simple appel LLM. C'est un système orchestré qui enchaîne des tâches avec état, prend des décisions conditionnelles et peut appeler des outils externes (moteur de recherche, CMS, base de données interne). La différence avec un script GPT classique : l'agent sait ce qu'il a déjà fait, peut recommencer une étape si le résultat est insuffisant, et délègue chaque sous-tâche à un composant spécialisé.

OpenClaw est particulièrement adapté à ce cas d'usage pour trois raisons.

Orchestration multi-skills native. OpenClaw structure chaque capacité de l'agent en "skill" indépendant, testable et remplaçable. Un skill de rédaction peut être swappé sans toucher au skill de QA. Cette modularité est critique quand on fait évoluer les prompts ou qu'on intègre de nouveaux modèles.

Gestion d'état entre les étapes. Le pipeline contenu est séquentiel mais conditionnel : si le score QA est insuffisant, l'agent relance la rédaction avec un feedback ciblé. OpenClaw expose un contexte partagé (AgentContext) accessible à chaque skill, ce qui évite de passer des données manuellement entre les fonctions.

Intégrations prêtes à l'emploi. OpenClaw propose des connecteurs natifs pour les API de recherche (Serper, Brave), les LLMs (OpenAI, Anthropic, Mistral) et les outils de publication (Notion, WordPress, fichiers markdown). Pour un pipeline contenu, c'est l'essentiel sans code de glue.

Les quatre composants du pipeline sont :

Skill brief : analyse le mot-clé, scrape la SERP, génère un plan H2/H3 avec intention de recherche
Skill rédaction : prend le brief en input, rédige l'article avec les consignes de style et de longueur
Skill QA : évalue le contenu produit (densité du mot-clé primaire, nombre de mots, présence de liens internes, lisibilité)
Skill publication : formate l'output en MDX avec frontmatter, écrit le fichier ou appelle l'API du CMS

Pipeline complet : de l'idée à la publication

Besoin métier concret

Trois profils bénéficient directement de ce pipeline :

L'agence de contenu qui gère 20 clients et doit produire 40 à 60 articles par mois. Sans automatisation, chaque article mobilise un rédacteur senior pour le brief et la relecture, un junior pour la rédaction.
Le solopreneur SEO qui veut scaler son blog sans embaucher. Il a le plan de site, les mots-clés, mais pas le temps de tout écrire.
L'e-commerce qui doit alimenter son blog produit en contenu de longue traîne sur des centaines de références.

Dans chacun de ces cas, le goulot d'étranglement est le même : la rédaction est chronophage, la relecture SEO est répétitive, et la publication est manuelle. C'est exactement ce que l'agent OpenClaw pour le business est conçu à adresser.

Code du pipeline OpenClaw

Voici la structure complète du pipeline en pseudocode Python avec l'API OpenClaw.

Initialisation de l'agent et du contexte :

from openclaw import Agent, AgentContext, Skill

# Contexte partagé entre tous les skills
context = AgentContext()
context.set("keyword", "crewai vs langgraph")
context.set("target_length", 1500)
context.set("internal_links", [
    "/frameworks/crewai",
    "/frameworks/langgraph",
    "/comparaisons/crewai-vs-langgraph"
])

Skill 1 — Recherche web :

class WebResearchSkill(Skill):
    name = "web_research"

    def run(self, context: AgentContext) -> AgentContext:
        keyword = context.get("keyword")
        # Appel Serper API pour récupérer les 10 premiers résultats
        results = self.tools.search(keyword, num_results=10)
        # Extraction des titres, métas, H2 des pages top SERP
        serp_data = self.tools.scrape_serp(results)
        context.set("serp_data", serp_data)
        return context

Skill 2 — Génération du brief :

class BriefGeneratorSkill(Skill):
    name = "brief_generator"

    def run(self, context: AgentContext) -> AgentContext:
        keyword = context.get("keyword")
        serp_data = context.get("serp_data")

        prompt = f"""
        Génère un brief éditorial pour le mot-clé : {keyword}
        Données SERP : {serp_data}
        Format : intention de recherche, plan H2/H3, mots-clés secondaires, longueur cible, angle éditorial.
        """
        brief = self.llm.complete(prompt)
        context.set("brief", brief)
        return context

Skill 3 — Rédaction de l'article :

class ContentWriterSkill(Skill):
    name = "content_writer"

    def run(self, context: AgentContext) -> AgentContext:
        brief = context.get("brief")
        length = context.get("target_length")
        links = context.get("internal_links")

        prompt = f"""
        Rédige un article SEO en français basé sur ce brief :
        {brief}

        Contraintes :
        - Longueur : {length} mots minimum
        - Intègre ces liens internes de manière contextuelle : {links}
        - Style : concret, pragmatique, sans hype
        - Format : Markdown avec H2 et H3
        """
        article = self.llm.complete(prompt, max_tokens=3000)
        context.set("article_draft", article)
        return context

Skill 4 — QA et scoring SEO :

class QACheckerSkill(Skill):
    name = "qa_checker"
    SCORE_THRESHOLD = 75  # score minimum pour passer en publication

    def run(self, context: AgentContext) -> AgentContext:
        article = context.get("article_draft")
        keyword = context.get("keyword")
        target_length = context.get("target_length")

        score = 0
        word_count = len(article.split())

        # Critère 1 : longueur (30 points)
        if word_count >= target_length:
            score += 30
        elif word_count >= target_length * 0.8:
            score += 15

        # Critère 2 : présence du mot-clé (30 points)
        keyword_density = article.lower().count(keyword.lower()) / word_count
        if 0.005 <= keyword_density <= 0.02:
            score += 30
        elif keyword_density > 0:
            score += 15

        # Critère 3 : liens internes présents (20 points)
        links = context.get("internal_links", [])
        links_found = sum(1 for link in links if link in article)
        if links_found >= 2:
            score += 20
        elif links_found == 1:
            score += 10

        # Critère 4 : structure H2 présente (20 points)
        if article.count("## ") >= 4:
            score += 20

        context.set("qa_score", score)
        context.set("qa_passed", score >= self.SCORE_THRESHOLD)
        context.set("word_count", word_count)
        return context

Skill 5 — Publication :

class PublisherSkill(Skill):
    name = "publisher"

    def run(self, context: AgentContext) -> AgentContext:
        if not context.get("qa_passed"):
            raise ValueError(f"QA score insuffisant : {context.get('qa_score')}/100")

        article = context.get("article_draft")
        keyword = context.get("keyword")
        slug = keyword.lower().replace(" ", "-")

        frontmatter = f"""---
title: "{keyword.title()}"
slug: /{slug}
publishedAt: "2026-03-09"
---

"""
        mdx_content = frontmatter + article
        # Écriture du fichier MDX
        self.tools.write_file(f"content/articles/{slug}.mdx", mdx_content)
        context.set("published", True)
        context.set("output_path", f"content/articles/{slug}.mdx")
        return context

Assemblage et exécution de l'agent :

agent = Agent(
    name="marketing-content-agent",
    skills=[
        WebResearchSkill(),
        BriefGeneratorSkill(),
        ContentWriterSkill(),
        QACheckerSkill(),
        PublisherSkill(),
    ],
    context=context,
    retry_on_failure=True,
    max_retries=2
)

result = agent.run()
print(f"Article publié : {result.get('output_path')}")
print(f"Score QA : {result.get('qa_score')}/100")
print(f"Nombre de mots : {result.get('word_count')}")

Gains mesurables

Tâche	Manuel	Avec l'agent
Recherche + brief	45 min	3 min
Rédaction	90 min	8 min
Relecture SEO	30 min	2 min
Mise en forme + publication	15 min	2 min
Total	~3h	~15–20 min

En termes de volume : un rédacteur produit 1 article par jour en qualité correcte. Avec ce pipeline, la même personne peut valider et affiner 8 à 10 articles par jour, en se concentrant sur la relecture et l'ajout de la voix de marque.

Limites à connaître

Le pipeline automatisé ne remplace pas tout. Trois limites importantes :

Qualité brute du premier jet : le contenu généré est structurellement correct mais manque souvent de profondeur factuelle. Un expert métier doit valider les données et ajouter des insights originaux.
Fact-checking humain obligatoire : les LLMs hallucinent. Les chiffres, dates, comparaisons techniques doivent être vérifiés avant publication. Ce n'est pas optionnel.
Voix de marque : sans guidelines précises dans le prompt, l'agent produit un style générique. Intégrez un document de brand voice dans le contexte du skill rédaction pour corriger cela.

Pour aller plus loin sur l'automatisation SEO avec des agents, le pipeline décrit ici est une bonne base de départ.

Exemple concret : blog tech, "crewai vs langgraph"

Input : le mot-clé crewai vs langgraph, longueur cible 1500 mots, 3 liens internes obligatoires.

context.set("keyword", "crewai vs langgraph")
context.set("target_length", 1500)
context.set("internal_links", [
    "/frameworks/crewai",
    "/frameworks/langgraph",
    "/comparaisons"
])

result = agent.run()
# Output :
# - content/articles/crewai-vs-langgraph.mdx (1612 mots)
# - QA score : 87/100
# - Temps total : 18 minutes

L'agent a produit un article structuré en 7 sections H2, avec une table de comparaison, 3 liens internes intégrés dans le corps du texte, et un frontmatter MDX complet. Le score QA de 87/100 dépasse le seuil de 75, la publication est déclenchée automatiquement.

La seule intervention humaine : relire l'article, corriger deux approximations sur les versions des librairies, et ajouter un paragraphe d'opinion personnelle. Temps passé : 12 minutes supplémentaires. Total : 30 minutes contre 3h en mode manuel.

Ce type d'agent OpenClaw est reproductible sur n'importe quel sujet technique, à condition d'adapter les guidelines de style et les critères QA à votre secteur.

Bonnes pratiques

Erreur 1 — Supprimer la relecture humaine. L'automatisation réduit le temps de travail, elle ne l'élimine pas. Le contenu publié sans relecture humaine génère des erreurs factuelles et dilue la crédibilité du site. Gardez toujours une étape de validation, même courte.

Erreur 2 — Utiliser des prompts trop génériques. "Rédige un article SEO sur X" produit un résultat médiocre. Le skill rédaction doit recevoir : l'intention de recherche précise, le persona lecteur, le ton attendu, les sections obligatoires, les éléments à éviter. Plus le prompt est spécifique, plus l'output est directement utilisable.

Erreur 3 — Ignorer les guidelines de marque. Un agent sans brand voice produit un contenu interchangeable. Créez un fichier brand_voice.md et injectez-le dans le contexte du skill rédaction à chaque exécution.

Erreur 4 — Ne pas versionner les prompts. Les prompts évoluent. Sans versioning, vous ne pouvez pas comparer les outputs entre deux versions d'un skill ni revenir en arrière si une mise à jour dégrade la qualité.

Questions fréquentes

OpenClaw peut-il publier automatiquement sur WordPress ou Webflow ?

Oui. OpenClaw dispose de connecteurs natifs pour les APIs REST des principaux CMS. Le skill de publication peut appeler l'API WordPress pour créer un post en statut "draft", prêt pour validation manuelle. La même logique s'applique à Notion, Webflow ou tout CMS disposant d'une API.

Quel modèle LLM utiliser pour la rédaction en français ?

GPT-4o et Claude 3.5 Sonnet produisent les meilleurs résultats en français avec un prompt structuré. Mistral Large est une option plus économique pour les pipelines à fort volume. Le choix dépend du ratio coût/qualité acceptable pour votre use case.

Comment gérer les contenus dupliqués si l'agent produit des articles similaires ?

Intégrez une étape de vérification dans le skill QA : comparer le nouvel article avec les contenus existants via une similarité cosinus sur les embeddings. Si le score de similarité dépasse 0.85, l'agent rejette l'article et remonte une alerte.

Le pipeline fonctionne-t-il pour des contenus non techniques ?

Oui, à condition d'adapter les critères QA et les sources de recherche. Pour un blog e-commerce ou lifestyle, remplacez les sources tech (GitHub, documentation) par des sources sectorielles, et ajustez le scoring pour prioriser la lisibilité plutôt que la densité technique.