Débuter avec les Agents IA On-Chain en 2026 : Créez votre premier Bot Autonome

Arrêtez de parler d’IA. Commencez à coder.En 2024, on avait des bots de trading stupides qui suivaient aveuglément des if/else hardcodés. En 2026, on a des Agents IA autonomes capables de prendre des décisions on-chain sans intervention humaine. La différence ? Ces agents ont un cerveau.

Plus précisément, ils ont accès à des modèles d’apprentissage automatique vérifiables via des preuves zero-knowledge (ZKML). Imaginez un smart contract qui ne se contente pas d’exécuter du code prédéfini, mais qui analyse, prédit et s’adapte aux conditions du marché en temps réel.

💡 Promesse de ce tutoriel : À la fin de cet article, vous aurez déployé un agent IA minimaliste sur le testnet Sepolia. Pas de théorie fumeuse. Du code. Point final.

« Code is law… but AI makes the law dynamic. »

Pré-requis Techniques : Votre Stack 2026

Avant de plonger dans le code, assurez-vous d’avoir les outils suivants. C’est le minimum syndical pour ne pas perdre votre temps.

🛠️ Outils Essentiels

• Un wallet Ethereum : Rabby ou MetaMask (avec quelques ETH de test sur Sepolia)
• Connaissances Solidity : Version 0.8.25 minimum. Si vous ne savez pas ce qu’est un modifier ou un event, revenez quand vous aurez fait vos devoirs.
• Python 3.10+ : Pour le script d’inférence IA côté off-chain
• Foundry : Le framework de développement Solidity le plus rapide. Oubliez Hardhat pour ce tutoriel.
• Un Oracle ZKML : On utilisera Giza ou Oraichain pour connecter notre modèle IA au smart contract

📦 Installation Rapide

# Installation de Foundry
curl -L https://foundry.paradigm.xyz | bash
foundryup

# Vérification
forge --version
cast --version

# Création du projet
forge init ai-agent-tutorial
cd ai-agent-tutorial

⚠️ Mise en garde : Si vous êtes sur Windows, utilisez WSL2. Foundry ne supporte pas nativement PowerShell et vous allez perdre du temps.

Partie 1 : L’Architecture d’un Agent IA On-Chain

Un agent IA on-chain, c’est comme un pilote automatique d’avion. Le smart contract est le cockpit (les commandes), l’oracle ZKML est le cerveau qui analyse les données, et la blockchain est l’avion lui-même.

🧠 Le Schéma Mental

Voici comment les composants interagissent :

1. Modèle IA (off-chain) : Un modèle d’apprentissage automatique entraîné pour prédire des signaux de trading (par exemple, détection de tendances haussières)
2. Oracle ZKML : Génère une preuve cryptographique que le modèle a bien produit cette prédiction, sans révéler les données sensibles
3. Smart Contract (on-chain) : Vérifie la preuve ZK, et si elle est valide, exécute l’action (achat, vente, rebalancement de portefeuille)

🔥 Règle d’or de Mathis : Ne mettez JAMAIS toute la logique métier dans le smart contract. Le coût du gas vous ruinerait. L’IA doit vivre off-chain, et seule la validation de ses décisions doit être on-chain.

📊 Diagramme de Flux

Analogie simple : C’est comme un restaurant. L’IA est le chef qui prépare le plat (off-chain), l’oracle ZKML est le serveur qui apporte le plat avec un certificat d’hygiène, et le smart contract est le client qui vérifie le certificat avant de manger.

Partie 2 : Tutoriel Pas-à-Pas – Le Code

Maintenant, place au concret. On va créer un agent minimaliste qui exécute un trade basé sur une prédiction IA vérifiée.

Étape 1 : Écrire le Smart Contract AIAgent.sol

Voici le contrat le plus simple possible. Il ne fait qu’une seule chose : vérifier qu’une preuve ZK est valide, puis exécuter une transaction.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.25;

/**
 * @title AIAgent
 * @notice Agent IA minimal qui exécute des trades basés sur des preuves ZKML
 * @dev Ce contrat NE DOIT PAS être utilisé en production sans audit
 * @author Mathis Dubois - ActuBlockchain.com
 */
contract AIAgent {
    // Adresse de l'oracle ZKML (Giza ou Oraichain)
    address public immutable zkOracle;
    
    // Limite de dépense par jour (circuit breaker)
    uint256 public constant DAILY_LIMIT = 1 ether;
    uint256 public dailySpent;
    uint256 public lastResetDay;
    
    // Events pour le monitoring
    event TradeExecuted(uint256 amount, string action, uint256 timestamp);
    event CircuitBreakerTriggered(uint256 attemptedAmount, uint256 limit);
    
    /**
     * @param _zkOracle Adresse de l'oracle ZKML vérifié
     */
    constructor(address _zkOracle) {
        require(_zkOracle != address(0), "Oracle address cannot be zero");
        zkOracle = _zkOracle;
        lastResetDay = block.timestamp / 1 days;
    }
    
    /**
     * @notice Exécute un trade si la preuve ZK est valide
     * @param proof Preuve ZKML générée par l'oracle
     * @param amount Montant du trade en wei
     * @param action "buy" ou "sell"
     */
    function executeTrade(
        bytes calldata proof,
        uint256 amount,
        string calldata action
    ) external {
        // Vérification 1 : Seul l'oracle peut appeler cette fonction
        require(msg.sender == zkOracle, "Only oracle can execute trades");
        
        // Vérification 2 : Circuit breaker (limite journalière)
        _checkCircuitBreaker(amount);
        
        // Vérification 3 : La preuve ZK doit être valide
        require(_verifyProof(proof), "Invalid ZK proof");
        
        // Exécution du trade (simulation simple ici)
        if (keccak256(bytes(action)) == keccak256(bytes("buy"))) {
            _executeBuy(amount);
        } else if (keccak256(bytes(action)) == keccak256(bytes("sell"))) {
            _executeSell(amount);
        } else {
            revert("Invalid action: must be 'buy' or 'sell'");
        }
        
        // Mise à jour du compteur de dépenses
        dailySpent += amount;
        
        emit TradeExecuted(amount, action, block.timestamp);
    }
    
    /**
     * @dev Vérifie la preuve ZKML (implémentation simplifiée)
     * En production, utilisez une librairie comme Giza SDK
     */
    function _verifyProof(bytes calldata proof) internal pure returns (bool) {
        // Dans un vrai contrat, on appellerait un vérifieur ZK
        // Pour ce tutoriel, on simule avec un hash simple
        return proof.length > 0 && keccak256(proof) != bytes32(0);
    }
    
    /**
     * @dev Circuit breaker : limite les dépenses journalières
     */
    function _checkCircuitBreaker(uint256 amount) internal {
        uint256 currentDay = block.timestamp / 1 days;
        
        // Reset du compteur si nouveau jour
        if (currentDay > lastResetDay) {
            dailySpent = 0;
            lastResetDay = currentDay;
        }
        
        // Vérification de la limite
        if (dailySpent + amount > DAILY_LIMIT) {
            emit CircuitBreakerTriggered(amount, DAILY_LIMIT);
            revert("Daily spending limit exceeded");
        }
    }
    
    /**
     * @dev Simulation d'un achat (remplacer par vrai DEX en prod)
     */
    function _executeBuy(uint256 amount) internal pure {
        // Ici, intégrer Uniswap, Curve, etc.
        // Pour le tutoriel, on log juste l'action
        require(amount > 0, "Buy amount must be positive");
    }
    
    /**
     * @dev Simulation d'une vente
     */
    function _executeSell(uint256 amount) internal pure {
        require(amount > 0, "Sell amount must be positive");
    }
    
    /**
     * @notice Permet de retirer les fonds (fonction d'urgence)
     */
    function emergencyWithdraw() external {
        // En production, ajouter un modifier onlyOwner ou multisig
        payable(msg.sender).transfer(address(this).balance);
    }
    
    // Permet au contrat de recevoir de l'ETH
    receive() external payable {}
}

📌 Points Clés du Code :

• Circuit Breaker : Limite hardcodée à 1 ETH par jour. Si l’IA « hallucine », elle ne peut pas vider votre wallet.
• Vérification ZK : La fonction _verifyProof() est simplifiée ici. En production, vous utiliseriez les SDK de Giza ou Oraichain.
• Gas Optimization : Utilisation de immutable pour l’oracle et de calldata pour économiser du gas.

Étape 2 : Script Python pour l’Inférence IA

Maintenant, créons le « cerveau » qui tourne off-chain. Ce script Python récupère les données de marché, fait une prédiction, et génère une preuve ZKML.

#!/usr/bin/env python3
"""
Script d'inférence IA pour l'agent on-chain
Utilise un modèle simple de détection de tendance
"""

import requests
import numpy as np
from web3 import Web3
import json

# Configuration
INFURA_URL = "https://sepolia.infura.io/v3/YOUR_API_KEY"
CONTRACT_ADDRESS = "0x..."  # Adresse de votre contrat déployé
ORACLE_PRIVATE_KEY = "0x..."  # Clé privée de l'oracle

w3 = Web3(Web3.HTTPProvider(INFURA_URL))

def fetch_market_data():
    """Récupère le prix ETH/USD des dernières 24h"""
    url = "https://api.coingecko.com/api/v3/coins/ethereum/market_chart"
    params = {"vs_currency": "usd", "days": 1}
    
    response = requests.get(url, params=params)
    prices = [p[1] for p in response.json()["prices"]]
    return np.array(prices)

def predict_trend(prices):
    """
    Modèle ultra-simple : moyenne mobile
    Si prix actuel > moyenne des 12 dernières heures → BUY
    Sinon → SELL
    
    En production, remplacer par un vrai modèle ML (LSTM, Random Forest, etc.)
    """
    current_price = prices[-1]
    moving_avg = np.mean(prices[-12:])
    
    if current_price > moving_avg * 1.02:  # +2% au-dessus de la MA
        return "buy"
    elif current_price < moving_avg * 0.98:  # -2% en-dessous
        return "sell"
    else:
        return "hold"

def generate_zkml_proof(prediction):
    """
    Génère une preuve ZKML (simulation)
    En production : utiliser Giza SDK ou Oraichain API
    
    Exemple avec Giza :
    from giza import GizaProver
    prover = GizaProver(model_id="your_model")
    proof = prover.generate_proof(input_data)
    """
    # Simulation : hash de la prédiction comme "preuve"
    proof_data = f"{prediction}-{np.random.randint(1000000)}"
    return w3.keccak(text=proof_data).hex()

def execute_on_chain(action, proof):
    """Envoie la transaction au smart contract"""
    contract_abi = [...]  # ABI de votre contrat
    contract = w3.eth.contract(address=CONTRACT_ADDRESS, abi=contract_abi)
    
    # Montant du trade (0.1 ETH pour ce test)
    amount = w3.to_wei(0.1, 'ether')
    
    # Construire la transaction
    tx = contract.functions.executeTrade(
        bytes.fromhex(proof[2:]),  # Enlever le "0x"
        amount,
        action
    ).build_transaction({
        'from': w3.eth.account.from_key(ORACLE_PRIVATE_KEY).address,
        'nonce': w3.eth.get_transaction_count(
            w3.eth.account.from_key(ORACLE_PRIVATE_KEY).address
        ),
        'gas': 200000,
        'gasPrice': w3.eth.gas_price
    })
    
    # Signer et envoyer
    signed_tx = w3.eth.account.sign_transaction(tx, ORACLE_PRIVATE_KEY)
    tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)
    
    print(f"✅ Transaction envoyée : {tx_hash.hex()}")
    return tx_hash

def main():
    print("🤖 Agent IA - Démarrage...")
    
    # 1. Récupérer les données
    print("📊 Récupération des données de marché...")
    prices = fetch_market_data()
    
    # 2. Faire la prédiction
    print("🧠 Analyse IA en cours...")
    prediction = predict_trend(prices)
    print(f"📈 Prédiction : {prediction.upper()}")
    
    if prediction == "hold":
        print("⏸️  Aucune action recommandée. Sortie.")
        return
    
    # 3. Générer la preuve ZKML
    print("🔒 Génération de la preuve ZKML...")
    proof = generate_zkml_proof(prediction)
    
    # 4. Exécuter on-chain
    print("⛓️  Exécution on-chain...")
    tx_hash = execute_on_chain(prediction, proof)
    
    print(f"✨ Agent IA terminé avec succès !")

if __name__ == "__main__":
    main()

⚠️ Important : Ce modèle de prédiction est ULTRA-SIMPLIFIÉ. En production, utilisez des modèles ML entraînés sur des données historiques (LSTM, XGBoost, etc.) et testez rigoureusement sur un backtest.

Étape 3 : Connecter les Deux via un Oracle

Pour un vrai déploiement, vous devez intégrer un service ZKML comme :

• Giza : Framework dédié au ZKML sur StarkNet/Ethereum. Permet de déployer des modèles ONNX on-chain.
• Oraichain : Oracle IA avec marketplace de modèles. Supporte plusieurs blockchains.
• Modulus Labs : Spécialisé dans les preuves ZK pour les réseaux de neurones.

🔧 Exemple d’Intégration avec Giza

# Installation du SDK Giza
pip install giza-sdk

# Configuration
from giza import GizaClient, GizaProver

client = GizaClient(api_key="YOUR_API_KEY")

# Déployer un modèle
model_id = client.deploy_model(
    model_path="./model.onnx",
    framework="onnx"
)

# Générer une preuve
prover = GizaProver(model_id=model_id)
proof = prover.generate_proof(
    input_data=np.array([...]),  # Vos données
    output_data=prediction
)

# La preuve peut maintenant être envoyée au smart contract

Partie 3 : Sécuriser Votre Agent – Le « Crash Test »

Un agent IA autonome, c’est puissant. Mais c’est aussi dangereux. Voici les failles classiques et comment les éviter.

 

🔥 Les 5 Failles Mortelles

1. L’Agent Hallucine et Vide Votre Wallet

Problème : Les modèles IA peuvent produire des outputs aberrants (hallucinations). Si l’IA prédit « Vendre 1000 ETH » alors que vous n’en avez que 10…

Solution : Implémenter des Circuit Breakers dans le smart contract :

• Limite de dépenses journalières (déjà dans notre code)
• Vérification de cohérence : refuser les trades > X% du portefeuille
• Pause automatique si pertes > Y% en 24h

// Exemple de circuit breaker avancé
function _checkTradeValidity(uint256 amount) internal view {
    uint256 balance = address(this).balance;
    require(amount <= balance / 10, "Trade exceeds 10% of portfolio");
}

2. Oracle Compromis = Game Over

Problème : Si la clé privée de l’oracle est volée, un attaquant peut générer de fausses preuves.

Solution : Utiliser un multisig ou un DAO pour contrôler l’oracle :

• 3 oracles indépendants doivent signer chaque transaction (quorum 2/3)
• Timelock de 1h sur les trades importants
• Emergency pause activable par un multisig

3. Manipulation du Prix Oracle

Problème : Un attacker peut manipuler les prix (flash loans) pour tromper l’IA.

Solution : Utiliser des TWAP (Time-Weighted Average Price) au lieu de prix spot :

// Utiliser Chainlink ou Uniswap V3 TWAP
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

function getSecurePrice() internal view returns (uint256) {
    AggregatorV3Interface priceFeed = AggregatorV3Interface(CHAINLINK_ETH_USD);
    (, int256 price, , ,) = priceFeed.latestRoundData();
    return uint256(price);
}

4. Gas Attacks et DoS

Problème : Un attaquant spamme des appels à executeTrade() pour consommer tout le gas.

Solution : Rate limiting + gas limit par transaction :

mapping(address => uint256) public lastCallTimestamp;
uint256 public constant MIN_CALL_INTERVAL = 1 hours;

modifier rateLimit() {
    require(
        block.timestamp >= lastCallTimestamp[msg.sender] + MIN_CALL_INTERVAL,
        "Too many calls"
    );
    lastCallTimestamp[msg.sender] = block.timestamp;
    _;
}

5. Modèle IA Non-Déterministe

Problème : Si le modèle IA n’est pas déterministe, deux exécutions avec les mêmes inputs donnent des outputs différents.

Solution : Utiliser ZKML avec des modèles figés (frozen weights) et des seeds fixes pour la génération aléatoire.

🛡️ Checklist de Sécurité

• ✅ Circuit breakers implémentés (limites journalières/par trade)
• ✅ Oracle décentralisé (multisig ou consensus de 3+ oracles)
• ✅ TWAP pour les prix (anti-manipulation)
• ✅ Rate limiting sur les fonctions critiques
• ✅ Emergency pause + withdraw function
• ✅ Audit du code par un tiers (Certora, OpenZeppelin, etc.)
• ✅ Tests fuzz avec Foundry (minimum 10 000 runs)

Étape 4 : Déploiement sur Sepolia

🚀 Déployer le Contrat

# Compiler le contrat
forge build

# Tester (IMPORTANT !)
forge test -vvv

# Déployer sur Sepolia
forge create src/AIAgent.sol:AIAgent \
    --rpc-url https://sepolia.infura.io/v3/YOUR_KEY \
    --private-key YOUR_PRIVATE_KEY \
    --constructor-args "0xYOUR_ORACLE_ADDRESS"

# Note : Remplacer 0xYOUR_ORACLE_ADDRESS par votre propre adresse

✅ Vérifier sur Etherscan

# Vérification automatique
forge verify-contract \
    --chain sepolia \
    --compiler-version v0.8.25 \
    0xYOUR_CONTRACT_ADDRESS \
    src/AIAgent.sol:AIAgent \
    --etherscan-api-key YOUR_ETHERSCAN_KEY

🤖 Lancer l’Agent

# Installer les dépendances Python
pip install web3 requests numpy

# Exécuter l'agent
python ai_agent.py

🎉 Si tout se passe bien, vous devriez voir :

🤖 Agent IA - Démarrage...
📊 Récupération des données de marché...
🧠 Analyse IA en cours...
📈 Prédiction : BUY
🔒 Génération de la preuve ZKML...
⛓️  Exécution on-chain...
✅ Transaction envoyée : 0xabc123...
✨ Agent IA terminé avec succès !

Conclusion : Bienvenue dans le Futur des DAOs Autonomes

Vous venez de créer votre premier agent IA on-chain. C’est une version minimaliste, mais elle contient tous les concepts fondamentaux :

• ✅ Inférence IA off-chain (gas efficiency)
• ✅ Preuves ZKML pour la vérification on-chain
• ✅ Circuit breakers pour la sécurité
• ✅ Architecture modulaire et auditable

🔮 Le Futur : DAOs Gérées par des Agents

Imaginez des DAOs où les décisions de gouvernance ne sont pas prises par des votes humains (lents, biaisés), mais par des agents IA qui analysent :

• Les performances des protocoles DeFi
• Les propositions de gouvernance
• Les risques de marché en temps réel
• Le sentiment de la communauté (analyse de tweets, forums)

C’est vers ça qu’on se dirige. Et vous avez maintenant les bases pour y contribuer.

💻 Challenge Communautaire

🏆 Le Défi : Clonez le repository GitHub de cet article (lien en bas), modifiez la stratégie de trading (par exemple, ajoutez un stop-loss ou un trailing stop), et soumettez votre fork.

🎁 Récompense : Le meilleur fork (le plus sécurisé + le plus rentable sur backtest) gagne un audit gratuit de son code par l’équipe ActuBlockchain.

📚 Pour Aller Plus Loin

• Documentation Giza : https://docs.gizatech.xyz
• Oraichain Developer Hub : https://docs.orai.io
• Foundry Book : https://book.getfoundry.sh
• ZKML Research Papers : Can AI Solve the Oracle Problem?

« Dans la DeFi, le code est roi. Mais l’IA rend le roi dynamique. »
— Mathis Dubois

---

⚠️ Disclaimer : Ce code est fourni à des fins éducatives uniquement. Ne déployez JAMAIS ce contrat en production sans audit professionnel. Les cryptomonnaies sont volatiles, investissez de manière responsable.