Performance et limites des agents

# En CLI : limiter à 15 tours
claude --print --max-turns 15 "Refactore le module auth"

# En SDK TypeScript
const result = await claude({
  prompt: "Refactore le module auth",
  options: { maxTurns: 15 },
});

Agent principal (30 tours max)
  └── Subagent review (10 tours max)
  └── Subagent tests (15 tours max)
       └── Sub-subagent? Non recommandé.

# En CLI : timeout global de la session
claude --max-turns 20 "Lance les tests E2E"

# En SDK : le timeout se gère au niveau application
const result = await claude({
  prompt: "Lance les tests E2E complets",
  options: {
    maxTurns: 20,
    // Le SDK attend la fin de l'agent
    // Gérez le timeout côté application si nécessaire
  },
});

## Critères d'arrêt
- Si tu as essayé 3 approches différentes sans succès, arrête-toi
  et explique ce qui bloque
- Si tu relis le même fichier plus de 2 fois, change de stratégie
- Si le même test échoue 3 fois, signale-le comme problème bloquant

async function withRetry<T>(
  fn: () => Promise<T>,
  maxRetries: number = 3,
  delayMs: number = 2000,
): Promise<T> {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      if (attempt === maxRetries) throw error;
      console.log(`Tentative ${attempt}/${maxRetries} échouée, retry...`);
      await new Promise((r) => setTimeout(r, delayMs * attempt));
    }
  }
  throw new Error("Unreachable");
}

// Utilisation
const result = await withRetry(() =>
  claude({
    prompt: "Analyse les logs des dernières 24h",
    options: { maxTurns: 10 },
  })
);

async function smartRetry(originalPrompt: string): Promise<string> {
  // Première tentative avec le prompt original
  const first = await claude({
    prompt: originalPrompt,
    options: { maxTurns: 10 },
  });

  // Vérifier le résultat
  if (isValidResult(first.text)) {
    return first.text;
  }

  // Deuxième tentative avec un prompt plus détaillé
  const second = await claude({
    prompt: `Le résultat précédent n'était pas satisfaisant.
      Voici ce qui manquait : ${identifyGaps(first.text)}.
      Reprends depuis le début avec plus de rigueur.
      Mission originale : ${originalPrompt}`,
    options: { maxTurns: 15 },
  });

  return second.text;
}

import asyncio
import random
from claude_code_sdk import claude, ClaudeOptions

async def with_backoff(prompt: str, max_retries: int = 5) -> str:
    """Retry avec backoff exponentiel et jitter."""
    for attempt in range(max_retries):
        try:
            result = await claude(
                prompt=prompt,
                options=ClaudeOptions(max_turns=10),
            )
            return result.text
        except Exception as e:
            if "rate_limit" not in str(e) or attempt == max_retries - 1:
                raise
            delay = (2 ** attempt) + random.uniform(0, 1)
            print(f"Rate limit, retry dans {delay:.1f}s...")
            await asyncio.sleep(delay)
    raise RuntimeError("Nombre maximum de tentatives atteint")

import pLimit from "p-limit";

// Maximum 3 agents en parallèle
const limit = pLimit(3);

const issues = await getOpenIssues();
const results = await Promise.all(
  issues.map((issue) =>
    limit(() =>
      claude({
        prompt: `Triage l'issue #${issue.number}: ${issue.title}`,
        options: { maxTurns: 5 },
      })
    )
  )
);

// Budget par exécution d'agent
const MAX_TOKENS_PER_AGENT = 100_000; // ~0.50$ en Sonnet

// Budget quotidien
const DAILY_TOKEN_BUDGET = 1_000_000; // ~5.00$ en Sonnet

let dailyTokensUsed = 0;

async function budgetedAgent(prompt: string): Promise<string> {
  if (dailyTokensUsed >= DAILY_TOKEN_BUDGET) {
    throw new Error("Budget quotidien épuisé");
  }

  const result = await claude({
    prompt,
    options: { maxTurns: 10 },
  });

  dailyTokensUsed += result.tokensUsed ?? 0;
  return result.text;
}

interface AgentLog {
  readonly id: string;
  readonly prompt: string;
  readonly startedAt: Date;
  readonly completedAt: Date;
  readonly tokensUsed: number;
  readonly turnsUsed: number;
  readonly result: "success" | "error" | "timeout";
  readonly output: string;
}

async function loggedAgent(prompt: string): Promise<string> {
  const startedAt = new Date();
  const id = crypto.randomUUID();

  try {
    const result = await claude({
      prompt,
      options: { maxTurns: 15 },
    });

    const log: AgentLog = {
      id,
      prompt,
      startedAt,
      completedAt: new Date(),
      tokensUsed: result.tokensUsed ?? 0,
      turnsUsed: result.turnsUsed ?? 0,
      result: "success",
      output: result.text,
    };

    await saveLog(log); // Votre système de logging
    return result.text;
  } catch (error) {
    const log: AgentLog = {
      id,
      prompt,
      startedAt,
      completedAt: new Date(),
      tokensUsed: 0,
      turnsUsed: 0,
      result: "error",
      output: String(error),
    };
    await saveLog(log);
    throw error;
  }
}

// Alerter si un agent coûte plus de 2$
if ((result.tokensUsed ?? 0) > 200_000) {
  await notifySlack(
    "#alerts",
    `Agent coûteux détecté : ${result.tokensUsed} tokens `
    + `pour "${prompt.substring(0, 50)}..."`
  );
}

// Alerter si plus de 3 échecs en 1 heure
const recentErrors = await getRecentErrors(60 * 60 * 1000);
if (recentErrors.length > 3) {
  await notifySlack(
    "#alerts",
    `${recentErrors.length} erreurs d'agents en 1h. Vérifiez les logs.`
  );
}