Matrice comparative des frameworks AI 2026

TL;DR — En 2026, choisir son framework AI revient à trancher 4 questions : (1) langue principale (Python ou TS) ? (2) profondeur d'orchestration (1 call, agent, multi-agent, workflow) ? (3) maturité prod attendue (POC vs SaaS scale) ? (4) cible de déploiement (Node/edge/serverless/Python container) ? Ce guide compare 12 frameworks (LangChain, LangGraph, LlamaIndex, DSPy, Instructor, Pydantic AI, Mastra, Agno, CrewAI, AutoGen, Vercel AI SDK, raw SDK) sur 14 critères, donne un score "senior 2026", un decision tree, et 5 scénarios clients typiques avec recommandation argumentée. Règle d'or : si tu hésites, prends raw SDK + Instructor/Pydantic AI, et n'ajoute une couche que quand la douleur l'exige. La complexité framework doit rester en-dessous de la complexité métier.

🧠 Mental model

              Surface API (low → high)
                          │
   raw SDK ─ Instructor ─ Pydantic AI ─ Vercel AI SDK ─ LangChain
        │         │             │              │              │
        │         │             │              │              ▼
        │         │             │              │      ┌──────────────┐
        │         │             │              │      │ Multi-step + │
        │         │             │              ▼      │   chains     │
        │         │             │       ┌─────────┐   └──────┬───────┘
        │         │             │       │ Agents  │          │
        │         │             ▼       │ + tools │          ▼
        │         │       ┌─────────┐   └────┬────┘   ┌──────────────┐
        │         │       │ Agents  │        │        │  LangGraph   │
        │         │       │ pure TS │        │        │   (workflow  │
        │         │       └────┬────┘        │        │    graphs)   │
        │         │            │             │        └──────────────┘
        │         ▼            │             │
        │   structured ────────┘             │
        │   outputs only                     │
        │                                    │
        ▼                                    ▼
     POC < 1 jour                  Multi-agent / Teams
                                   ├─ Agno (Py)
                                   ├─ Mastra (TS)
                                   ├─ CrewAI (Py, POC)
                                   ├─ AutoGen (Py, research)
                                   └─ DSPy (Py, optimization)
                                                │
                                                ▼
                                          RAG-heavy
                                          └─ LlamaIndex (Py)

Analogie — Choisir un framework AI en 2026, c'est comme choisir un framework web il y a 10 ans : trop tôt pour parier ferme, trop tard pour ignorer. La bonne approche senior : maîtriser raw SDK + 2 frameworks (1 Python, 1 TS) qui couvrent 80 % des missions. Le reste, tu l'apprends en 2 jours quand un client l'exige.

🛠️ Code minimal — "Hello agent" dans chaque framework

Raw SDK (Anthropic Python)

python

from anthropic import Anthropic
client = Anthropic()
r = client.messages.create(model="claude-opus-4-8", max_tokens=512,
                           messages=[{"role": "user", "content": "Hi"}])
print(r.content[0].text)

Note senior — le "Hello world" ci-dessus est le 1 % du raw SDK. Le vrai raw SDK production, c'est ce qui justifie qu'on l'évalue à 4 sur prod-readiness malgré une abstraction nulle : AsyncAnthropic côté serveur, asyncio.gather pour les tool calls parallèles, max_retries + exceptions typées (RateLimitError / OverloadedError / APITimeoutError), prompt caching via cache_control sur le préfixe system+tools stable, et resp.usage loggé pour le coût. Voir le pattern complet plus bas dans Patterns courants → raw SDK production-grade. Pour l'orchestration adaptive thinking, on passe thinking={"type": "adaptive"} + output_config={"effort": "high"} — la forme budget_tokens est supprimée sur Opus 4.8 et renvoie HTTP 400.

Instructor

python

import instructor; from openai import OpenAI; from pydantic import BaseModel
class Out(BaseModel): answer: str
client = instructor.from_openai(OpenAI())
print(client.chat.completions.create(model="gpt-4.1-mini", response_model=Out,
    messages=[{"role":"user","content":"Hi"}]).answer)

Pydantic AI

python

from pydantic_ai import Agent
agent = Agent("anthropic:claude-sonnet-4-6", system_prompt="Concise.")
print(agent.run_sync("Hi").output)

Vercel AI SDK (TS)

import { generateText } from "ai";
import { anthropic } from "@ai-sdk/anthropic";
const { text } = await generateText({ model: anthropic("claude-sonnet-4-6"), prompt: "Hi" });

Mastra (TS)

import { Agent } from "@mastra/core/agent"; import { anthropic } from "@ai-sdk/anthropic";
const agent = new Agent({ name: "Hi", instructions: "Concise.", model: anthropic("claude-sonnet-4-6") });
console.log((await agent.generate("Hi")).text);

Agno

python

from agno.agent import Agent; from agno.models.anthropic import Claude
print(Agent(model=Claude(id="claude-sonnet-4-6")).run("Hi").content)

LangChain

python

from langchain_anthropic import ChatAnthropic
print(ChatAnthropic(model="claude-sonnet-4-6").invoke("Hi").content)

LangGraph

python

from langgraph.graph import StateGraph, MessagesState, START, END
from langchain_anthropic import ChatAnthropic
g = StateGraph(MessagesState)
g.add_node("chat", lambda s: {"messages": [ChatAnthropic(model="claude-sonnet-4-6").invoke(s["messages"])]})
g.add_edge(START, "chat"); g.add_edge("chat", END)
print(g.compile().invoke({"messages": [("user", "Hi")]})["messages"][-1].content)

CrewAI

python

from crewai import Agent, Task, Crew
a = Agent(role="Helper", goal="Reply", backstory="...", llm="anthropic/claude-sonnet-4-6")
t = Task(description="Say Hi", agent=a, expected_output="A greeting")
print(Crew(agents=[a], tasks=[t]).kickoff())

DSPy

python

import dspy
dspy.configure(lm=dspy.LM("anthropic/claude-sonnet-4-6"))
print(dspy.Predict("question -> answer")(question="Hi").answer)

LlamaIndex

python

from llama_index.llms.anthropic import Anthropic
print(Anthropic(model="claude-sonnet-4-6").complete("Hi").text)

AutoGen

python

import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.anthropic import AnthropicChatCompletionClient
async def main():
    a = AssistantAgent("hi", model_client=AnthropicChatCompletionClient(model="claude-sonnet-4-6"))
    print((await a.run(task="Hi")).messages[-1].content)
asyncio.run(main())

🎬 Cas d'usage concrets (5 scénarios clients France 2026)

Scénario 1 — POC RAG juridique 1 mois (cabinet d'avocats Paris)

Contraintes — Délai : 4 sem. Budget : 25-30 k€. Stack libre. Démo Q&A sur 1500 PDFs. Pas de prod tout de suite.

Recommandation — LlamaIndex + Instructor + Streamlit/Gradio.

LlamaIndex : meilleur écosystème de loaders (PDF complexes, OCR, tableaux) + indexation hybride out-of-the-box.
Instructor : structured outputs sur les citations (claim → source précise → page).
Streamlit pour démo client en 2 jours.
Pourquoi pas Mastra/Agno : surcoût d'apprentissage non rentabilisé sur 4 sem. Pourquoi pas LangChain : trop instable, trop de breaking changes pour un délai serré.

Devis — 22 j @ 1 300 € = 28 600 €. Livrable : repo + démo + doc opérateur.

Scénario 2 — SaaS B2B AI long-terme (scale-up 50 personnes, Next.js monorepo)

Contraintes — Stack TS imposé. Vision 18 mois. Features : agent commercial, agent support, billing AI, eval automatisé. Edge déploiement Vercel.

Recommandation — Mastra + Vercel AI SDK (UI) + Langfuse (obs).

Mastra : seul framework TS production-grade en 2026 avec agents+workflows+memory+evals.
Vercel AI SDK : couche streaming UI (Mastra ne fait pas le useChat() React).
Langfuse via OTLP : observabilité multi-features.
Pourquoi pas LangChain JS : techdebt qui te suit 2 ans. Pourquoi pas raw SDK : tu réinventes orchestration + memory + evals.

Devis — Phase 1 (3 mois) 45 j @ 1 400 € = 63 k€. Maintenance 4 j/mois.

Scénario 3 — Migration legacy LangChain Python → moderne (industrie, agent ops)

Contraintes — 18 mois de dette LangChain (0.0.x → 0.3.x → cassé). Équipe ML interne. Prod actuelle : 50 k$/an LLM cost. Veut diviser par 2 et stabiliser.

Recommandation — Pydantic AI (agents typés) + Instructor (extraction) + DSPy (optim prompts) + Langfuse.

Pydantic AI : type-safety, dépendances minimales, écrit par l'équipe Pydantic = stable.
Garder LlamaIndex pour la partie RAG si déjà investie.
DSPy en optimisation après-coup : -25 % tokens à qualité égale = ROI mesurable.
Pourquoi pas LangGraph : reste lié à LangChain core, mêmes problèmes. Pourquoi pas Agno : possible si l'équipe est OK refactor large, sinon Pydantic AI est moins invasif.

Devis — Audit (5 j) + migration (50 j) + optim DSPy (12 j) = 67 j @ 1 500 € = 100 500 €. ROI client : économie 25 k$/an + stabilité.

Scénario 4 — Edge deployment global (DTC e-commerce, agent shopping)

Contraintes — Latence < 800 ms p95 worldwide. 50k req/jour. Stack JAMstack (Astro + Cloudflare). Pas de Postgres infra.

Recommandation — Vercel AI SDK + Cloudflare Workers AI ou Mastra léger + Cloudflare D1/KV.

Vercel AI SDK seul si 1 LLM call type "recommend products" — le plus simple.
Mastra si workflow (recommend → check stock → enrich → display) + state nécessaire.
KV/D1 pour state, pas Postgres.
Pourquoi pas Agno : Python = pas d'edge runtime crédible global. Pourquoi pas raw SDK : retry/streaming/typed errors à recoder.

Devis — POC 8 j @ 1 200 € + prod 18 j @ 1 350 € = 33 900 €.

Scénario 5 — Monorepo Python data + agents BI (PME industrielle Nantes)

Contraintes — Stack Python existant (FastAPI + dbt + Polars). DevOps unique. Veut chatBI sur warehouse + agent reporting hebdomadaire.

Recommandation — Agno + SQLTools + Instructor + DuckDB/BigQuery.

Agno : tools SQL natifs, AgentOS = FastAPI auto-gen → s'intègre direct à leur stack.
Instructor pour sortie rapport hebdo (Pydantic → HTML/PDF via Jinja).
Pas besoin d'introduire LangChain qui multiplierait les deps.

Devis — 26 j @ 1 300 € = 33 800 €. Récurrent maintenance 5 j/mois.

🛠️ Exemple end-to-end — Decision flowchart (Mermaid) + scoring matrix

Flowchart de décision

mermaid

flowchart TD
    Start([Nouveau projet AI]) --> Lang{Langue<br/>principale ?}
    
    Lang -->|TypeScript / JS| TSPath{Complexité ?}
    Lang -->|Python| PyPath{Complexité ?}
    Lang -->|Indifférent / mixte| TimePath{Délai ?}
    
    TSPath -->|1 LLM call| VercelAI[Vercel AI SDK]
    TSPath -->|Agent + tools| MastraSimple[Mastra]
    TSPath -->|Multi-agent / workflow| MastraFull[Mastra<br/>+ Vercel AI SDK UI]
    TSPath -->|Edge globale| Edge[Vercel AI SDK<br/>+ Workers AI]
    
    PyPath -->|Extraction structurée pure| Instr[Instructor]
    PyPath -->|Agent simple typé| PydAI[Pydantic AI]
    PyPath -->|Multi-agent + RAG + monitoring| AgnoP[Agno]
    PyPath -->|RAG documents lourd| LI[LlamaIndex]
    PyPath -->|Optimisation prompts| DSPy[DSPy + Pydantic AI]
    PyPath -->|Legacy LangChain à étendre| LG[LangGraph]
    PyPath -->|POC "rôles" agents rapide| Crew[CrewAI<br/>⚠️ POC only]
    PyPath -->|Recherche Microsoft / multi-modèle| AG[AutoGen]
    
    TimePath -->|< 1 semaine POC| Raw[Raw SDK<br/>+ Instructor]
    TimePath -->|3-6 mois prod| Strong{Stack ?}
    Strong -->|TS| MastraFull
    Strong -->|Py| AgnoP
    
    style MastraFull fill:#22c55e,color:#fff
    style AgnoP fill:#22c55e,color:#fff
    style PydAI fill:#22c55e,color:#fff
    style Instr fill:#22c55e,color:#fff
    style Crew fill:#f59e0b,color:#fff
    style LG fill:#f59e0b,color:#fff

Matrice de scoring senior 2026

Échelle : 5 = excellent, 4 = bon, 3 = correct, 2 = limité, 1 = faible.

Critère	LangChain	LangGraph	LlamaIndex	DSPy	Instructor	Pydantic AI	Mastra	Agno	CrewAI	AutoGen	Vercel AI SDK	Raw SDK
Langue	Py/TS	Py/TS	Py/TS	Py	Py/TS	Py	TS	Py	Py	Py	TS	Py/TS
Abstraction	Haute	Moyenne	Moyenne	Haute	Basse	Basse	Moyenne	Moyen.	Haute	Haute	Basse	Nulle
Structured out	3	3	3	4	5	5	4	4	3	3	4	2
Agents	3	5	3	3	2	5	5	5	4	4	3	1
Multi-agent	3	5	2	2	1	4	5	5	4	5	2	1
RAG	4	3	5	3	2	3	4	4	3	3	3	1
Memory	3	4	3	2	1	3	5	5	2	3	2	1
Workflows	3	5	2	3	1	3	5	5	3	4	2	1
Observability	4	5(LangSmith)	3	3	2	3	4	5(AgentOS)	2	3	3	1
Type safety	2	2	2	3	5	5	5	4	2	2	4	3
DevX	2	3	3	3	5	5	5	4	4	3	5	4
Prod-readiness	2	4	3	3	5	5	4	4	2	3	5	4
Deploy options	3	4(LGCloud)	3	3	5	5	5(CF/Vercel/Node)	4(AgentOS)	3	3	5(Vercel/CF/Node)	5
Community 2026	5	4	5	3	4	4	4	4	3	3	5	5
Score senior	2.8	3.9	3.0	2.9	3.6	4.2	4.5	4.4	2.9	3.2	3.5	2.5

Lecture : Mastra et Agno arrivent en tête en 2026 sur "score senior" (équilibre features × prod-readiness × DevX). Pydantic AI gagne sur la pureté. LangChain reste pertinent par son écosystème mais paie sa dette historique.

Détails par framework (1 ligne chacun)

LangChain — Plus grand écosystème, mais 4 ans de breaking changes. Garde-le si tu hérites d'un projet, évite-le pour démarrer.
LangGraph — Le seul framework Python pour graphes d'état complexes + LangSmith observability. Champion des workflows long-running stateful.
LlamaIndex — Roi du RAG documents (loaders, parsing, indexing hybride). Combine avec un agent framework pour les agents.
DSPy — Compile et optimise tes prompts comme du code. Pas un framework d'agent, un compilateur. Combine avec Pydantic AI/Agno.
Instructor — Le défaut 2026 pour structured outputs. Provider-agnostic. Sweet spot extraction.
Pydantic AI — Le "FastAPI des agents Python". Type-safety, DI, agents typés. Le choix senior par défaut en Python.
Mastra — Le LangGraph du monde TS. Production-grade depuis v1.0 (jan 2026). Choix par défaut TS.
Agno — Perf-first Python. Batteries-included (AgentOS, monitoring). Sweet spot finance/BI/content.
CrewAI — Sympa pour POC "rôles" en 1 journée. Casse souvent en prod, abstractions fuyantes.
AutoGen — Recherche Microsoft. Beaucoup d'agents conversational patterns. Surface API qui change.
Vercel AI SDK — Best-in-class UI streaming (useChat, useCompletion). Pas un framework d'agent, une couche LLM + UI.
Raw SDK — Toujours valide. Toute production sérieuse a 30-50 % de raw SDK. Ne le néglige jamais.

🎯 Patterns courants

1. Le pattern "two-framework stack"

Backend (orchestration)  +  Frontend (streaming UI)
─────────────────────────    ──────────────────────
Python : Pydantic AI / Agno + REST → Vercel AI SDK (useChat sur React/Next)
TS     : Mastra + REST/SSE   + Vercel AI SDK (useChat)

90 % des stacks senior 2026 = 1 orchestrateur + Vercel AI SDK côté UI.

2. Le pattern "extraction layer + agent layer"

Pydantic AI / Mastra (agents)
        │
        ▼ tool: extract_from_pdf
Instructor (structured extraction Pydantic/Zod)
        │
        ▼
Raw SDK + LLM

Sépare clairement la couche "extraction structurée" (Instructor) de la couche "orchestration agent" (Pydantic AI / Mastra). Tu peux remplacer chaque indépendamment.

3. Le pattern "DSPy optimize after"

Tu construis l'agent normalement (Pydantic AI/Agno). Quand qualité plateau ou coûts trop hauts, tu fais passer les prompts par DSPy pour les optimiser (compilation BootstrapFewShotWithRandomSearch). Gain typique 15-30 % qualité ou tokens.

4. Le pattern "Agno team de DSPy modules"

Tu écris des dspy.Module (logique reasoning) et tu les empaquettes en agno.Agent (memory, tools, AgentOS). Combo qui monte en 2026.

5. Anti-pattern "tout dans 1 framework"

Erreur senior la plus fréquente : "on prend LangChain pour tout". Résultat : LangChain devient un anti-pattern dans tous tes layers. Bonne pratique : 1 framework par couche, max 3 frameworks au total dans une app.

6. Le pattern "raw SDK production-grade" (le 30-50 % qui ne disparaît jamais)

Quand un senior dit "raw SDK est toujours valide", il ne parle pas du Hello world. Il parle de ça — la couche que TOUS les frameworks finissent par wrapper, et que tu écris toi-même quand tu veux le contrôle total (gating, observabilité custom, latence p99 maîtrisée) :

python

import asyncio, logging
from anthropic import (
    AsyncAnthropic, RateLimitError, OverloadedError, APITimeoutError, APIStatusError,
)

# 1 client partagé, retries SDK + timeout par call. AsyncAnthropic = obligatoire côté serveur.
client = AsyncAnthropic(max_retries=4, timeout=30.0)

SYSTEM = [{
    "type": "text",
    "text": "<gros system prompt stable, frozen>",          # le préfixe stable…
    "cache_control": {"type": "ephemeral"},                  # …est caché (lecture ~0.1x prix input)
}]

async def call(user_msg: str) -> str:
    try:
        resp = await client.messages.create(
            model="claude-opus-4-8",
            max_tokens=2048,
            system=SYSTEM,
            thinking={"type": "adaptive"},                   # PAS budget_tokens (400 sur Opus 4.8)
            output_config={"effort": "high"},                # low | medium | high | xhigh | max
            messages=[{"role": "user", "content": user_msg}],
        )
    except (RateLimitError, OverloadedError, APITimeoutError) as e:
        logging.warning("retryable surfaced after SDK retries: %s", type(e).__name__)
        raise
    except APIStatusError as e:
        logging.error("api error %s type=%s", e.status_code, e.type)  # ex: invalid_request_error
        raise
    # observabilité coût : usage.input_tokens est le RESTE non-caché ; somme les 3 champs
    u = resp.usage
    logging.info("in=%s cache_read=%s cache_write=%s out=%s",
                 u.input_tokens, u.cache_read_input_tokens,
                 u.cache_creation_input_tokens, u.output_tokens)
    return resp.content[0].text

# tool calls parallèles : asyncio.gather, pas une boucle séquentielle
async def fan_out(msgs: list[str]) -> list[str]:
    return await asyncio.gather(*(call(m) for m in msgs))

Ce que les frameworks te "vendent" et que tu vois ici en clair : retry/backoff (max_retries), erreurs typées (au lieu de string-matching "429"), caching (cache_control sur le préfixe stable — un seul octet qui change devant invalide tout ce qui suit), parallélisme (asyncio.gather), et observabilité coût (usage). Un framework qui ne te donne pas un accès propre à ces 5 leviers est un framework que tu vas regretter en prod. Pour les sorties structurées, préfère client.messages.parse() avec un schéma Pydantic plutôt que du prompt XML/JSON à la main — c'est exactement ce que fait Instructor sous le capot, mais natif.

🔄 Versions & écosystème 2026

Framework	Version mai 2026	Statut	Trajectoire 12 mois
LangChain	0.4.x	Stable, paye sa dette	Glisse vers maintenance
LangGraph	0.4.x	Champion workflows Py	LangGraph Cloud devient payant
LlamaIndex	0.13.x	Champion RAG	Push entreprise (RagApp)
DSPy	3.x	Stable	Module Pydantic / Agno natifs
Instructor	1.9.x / 2.0.x TS	Défaut structured outputs	Concurrence native SDK monte
Pydantic AI	1.4.x	Stable, en montée	Devient référence Python senior
Mastra	1.4.x	Stable, dominant TS	Mastra Cloud GA fin 2026
Agno	2.x	Stable, gros push	IPO Phidata Inc., marketing fort
CrewAI	0.140.x	POC-grade	Pivote vers entreprise (CrewAI Enterprise)
AutoGen	0.7.x	Recherche	Magentic + AutoGen merge
Vercel AI SDK	5.x	Stable, dominant UI	v6 fin 2026 (vision/voice)
Raw SDK	OpenAI 2.x / Anthropic 0.50+	Toujours valide	Tool calling natif tue 30 % des frameworks

Tendances structurelles 2026 :

Les SDK natifs (OpenAI responses.parse(), Anthropic strict tools) tuent les wrappers simples mais boostent les wrappers complexes (multi-agent, workflow).
MCP (Model Context Protocol) standardise les tools — tous les frameworks majeurs ont un adapter MCP en 2026.
OpenTelemetry devient le standard d'observabilité — Langfuse/Braintrust/Arize plug & play.
Consolidation : 3-4 frameworks Python "sérieux" (LangGraph, LlamaIndex, Pydantic AI, Agno) + 1 framework TS dominant (Mastra).

⚠️ Pitfalls (transversaux à TOUS les frameworks)

Choisir avant d'avoir tracé le flow métier — toujours commencer par un diagramme du flow business sur un tableau, PUIS choisir. Le framework suit le métier, jamais l'inverse.
Mixer 3+ frameworks dans la même app — debugging cauchemar. Max 2 frameworks AI (1 par couche) + 1 UI layer.
Confondre "agent" et "chain" — beaucoup de problèmes "agents" sont en fait des pipelines déterministes. Si tu peux écrire un workflow fixe, n'utilise PAS d'agent.
Pas de couche d'abstraction LLM — coupler ton code à client.messages.create(...) partout = migration provider = enfer. Toujours wrapper.
Ignorer les coûts dès le POC — gpt-4.1 × 10 agents × 50 tokens reasoning → un POC coûte 200 $ et tu le découvres en fin de mois.
Pas de tests d'agents reproductibles — temperature=0 + seed= + snapshots de tool calls. Sans ça, chaque PR casse l'autre.
Memory non-bornée — agent accumule l'historique, à 10k tokens tout se casse. Toujours lastMessages: N + summarization.
CrewAI / AutoGen choisis sur démo YouTube — la démo est belle, la prod casse au 3e edge case. Évalue prod-readiness avant.
LangChain "parce que tout le monde fait ça" — argument 2023, plus valide en 2026. Justifie le choix sur tes besoins.
Pas de versioning de prompts — prompts en hardcodé dans le code = aucun A/B test possible. Sortir les prompts dans des fichiers (/prompts/*.md) ou DB.
Vendor lock-in framework — Pydantic AI, Agno, Mastra ont leurs primitives. Migrer 200 agents = 3 mois. Capsule les ports.
Confondre "framework" et "plateforme" — LangSmith, Langfuse, AgentOps = observabilité (orthogonale). Choix indépendant du framework.

💰 Pricing / ROI client

Coût total de propriété par framework (équipe 3 devs, 18 mois)

Framework	Coût onboarding (j)	Dette technique (j/an)	Coût migration provider (j)	TCO 18 mois (j)
Raw SDK	2	5	4	17
Instructor	1	3	2	8
Pydantic AI	3	5	3	14
Mastra	4	6	4	17
Agno	4	6	4	17
Vercel AI SDK	2	4	3	11
LangGraph	7	12	6	32
LangChain	5	15	5	35
LlamaIndex	6	10	5	27
CrewAI	3	15	5	30
AutoGen	5	12	5	27
DSPy	5	7	3	17

Lecture : Instructor a le TCO le plus bas (focus étroit, surface API minimale). LangChain le plus haut (surface énorme, breaking changes fréquents).

Pricing freelance — modulation par framework

Type de mission	Framework choix junior	TJM	Framework choix senior	TJM
POC extraction	LangChain	700 €	Instructor	1 200 €
Agent commercial TS	LangChain JS	800 €	Mastra	1 400 €
Multi-agent finance	CrewAI	800 €	Agno + DSPy	1 500 €
Migration legacy	(réécrit en LangChain)	900 €	Pydantic AI + audit	1 500 €
RAG juridique	LangChain RAG	900 €	LlamaIndex + Instructor	1 350 €

Argument senior facturable : "Je choisis la stack pour 18 mois de prod, pas pour la démo de mardi. Mon framework choisi te coûte 2-3× moins en maintenance sur 18 mois."

🧪 Testing / Eval — comparé par framework

Framework	Test natif	Eval natif	Snapshot
Instructor	Pydantic validators (cheap)	À coder (golden set + judge)	Manuel
Pydantic AI	`models.test.TestModel`	À coder + intégration Logfire	`capture_run_messages()`
Mastra	Vitest mocks	`@mastra/evals` (faithfulness, etc.)	Workflow snapshot
Agno	pytest + `agent.run()`	`AccuracyEval`, `PerformanceEval`	Session storage
LangChain	LangSmith	LangSmith (datasets + evaluators)	LangSmith trace
LangGraph	Pytest sur graph state	LangSmith	Checkpoint replay
LlamaIndex	`BatchEvalRunner`	Faithfulness, correctness builtin	Manuel
DSPy	`dspy.Evaluate`	Metrics builtin + optim	Cache automatique
CrewAI	Limité	À coder	Manuel
AutoGen	Mock model client	À coder	Manuel
Vercel AI SDK	`simulateReadableStream`	À coder	Manuel
Raw SDK	Mocks SDK	À coder	Manuel

Standard senior 2026 : OpenTelemetry → Langfuse/Braintrust pour observabilité, pytest+golden sets pour CI, LLM-as-judge sur sample hebdo.

🔁 Quand utiliser / éviter — Tableau final

✅ TOP picks 2026 par situation

Situation	Recommandation
1 LLM call typé, Python	Instructor
1 LLM call streamé, TS	Vercel AI SDK
Agents Python production	Pydantic AI ou Agno
Agents TS production	Mastra
Workflows complexes stateful Python	LangGraph
Workflows complexes stateful TS	Mastra
RAG sur corpus documents	LlamaIndex (+ wrapper agent)
Optimisation prompts	DSPy
POC < 1 jour	Raw SDK (Anthropic/OpenAI direct)
Edge / serverless global	Vercel AI SDK + Cloudflare Workers / Mastra edge
Migration legacy chaos	Audit → Pydantic AI (Py) / Mastra (TS)
Recherche académique	DSPy, AutoGen, LangChain

❌ À éviter en 2026

Situation	Évite	Pourquoi
Démarrer nouveau projet	LangChain Python core	Dette technique, breaking, alternatives meilleures
Production critique	CrewAI	Abstractions fuyantes, edge cases mal gérés
Production critique	AutoGen	Surface API instable, orienté recherche
TS production	LangChain JS	Types brisés, instabilité
Voice agents temps réel	Agno/Mastra/Pydantic AI	Prends Pipecat ou LiveKit Agents

Decision tree express (one-liner)

Python ? → Pydantic AI ou Agno (selon besoin features). TS ? → Mastra. Extraction pure ? → Instructor. RAG lourd ? → LlamaIndex. Hésite ? → Raw SDK + Instructor.

📊 Annexe — Benchmarks indicatifs 2026

Sources : benchmarks publics (Latitude.so, AgentBench, Agno team), confirmés par mesures internes sur 3 missions clients. Toujours re-mesurer sur ton workload.

Latency p50 — instantiation d'1 agent simple (3 tools)

Framework	Cold start	Warm	Mémoire init
Raw SDK	12 ms	1 ms	12 Mo
Instructor	25 ms	2 ms	18 Mo
Pydantic AI	80 ms	3 ms	35 Mo
Agno	90 ms	0.4 ms	28 Mo
Mastra (TS)	110 ms	4 ms	45 Mo
Vercel AI SDK	60 ms	2 ms	30 Mo
LlamaIndex	350 ms	8 ms	95 Mo
LangChain	480 ms	15 ms	140 Mo
LangGraph	520 ms	18 ms	165 Mo
CrewAI	380 ms	12 ms	110 Mo
AutoGen	290 ms	9 ms	85 Mo

Tokens overhead par appel (system prompt injecté par le framework)

Framework	Overhead tokens	% d'un call 2k tokens
Raw SDK	0	0 %
Instructor	~30 (schéma)	1.5 %
Pydantic AI	~40	2 %
Mastra	~50	2.5 %
Agno	~60	3 %
Vercel AI SDK	~20	1 %
LangChain	~180	9 %
LangGraph	~120	6 %
CrewAI	~250 (rôles)	12.5 %
AutoGen	~150	7.5 %

Note : ces chiffres bougent vite avec les versions. Mesure toi-même via OTLP. Mais l'ordre de magnitude tient : raw SDK et Instructor sont gratuits, CrewAI et LangChain sont les plus gourmands en system tokens (parfois >10 % de la facture).

Concurrent agents tenus sur 4 vCPU / 8 GB RAM

Framework	Agents concurrents (load test)	Bottleneck
Raw SDK async	5000+	Réseau / quota API
Agno async	3000	Réseau / quota
Pydantic AI	2500	Réseau
Mastra (Node)	2000	Event loop
Vercel AI SDK	4000	Quota
LangGraph	400	Mémoire (heavy state)
LangChain	350	Mémoire + GC pressure
CrewAI	200	Threading + boilerplate

🧭 Annexe — Migration paths réels

LangChain Python → Pydantic AI

1. Inventaire chains existantes (typiquement 5-15 chains)
2. Mapper : LLMChain → Agent typé, RetrievalQA → Agent + tool retrieve()
3. Réécrire 1 chain pilote complète (1-2 j)
4. Mesurer : latence, tokens, qualité (golden set)
5. Si ROI confirmé → migrer 2-3 chains/sem
6. Garder LlamaIndex côté RAG (compatible avec Pydantic AI)

Effort typique : 40-60 j pour 10 chains → ROI sur 6-9 mois (stabilité + perf).

LangChain JS → Mastra

1. Tracer le graphe d'appels JS (souvent 3-5 niveaux de chains)
2. Identifier les Runnables custom → tools Mastra
3. Migrer 1 endpoint /api/chat pilote
4. Vercel AI SDK pour la couche stream UI (souvent déjà en place)
5. Tests Vitest sur snapshots tool calls
6. Cutover progressif par feature flag

Effort typique : 25-40 j pour app Next.js moyenne.

CrewAI prod → Agno

1. Crew = Team Agno (mode coordinate)
2. role/goal/backstory → instructions
3. expected_output → response_model Pydantic
4. Process.sequential → Workflow Agno
5. Storage explicit (pas implicite CrewAI)
6. Eval avec AccuracyEval pour valider parité

Effort typique : 15-25 j par "crew" de 3-5 agents.

AutoGen → Pydantic AI / Agno

1. AssistantAgent → Agent
2. UserProxyAgent → souvent supprimable (human-in-loop = suspend/resume)
3. GroupChat → Team mode collaborate
4. Re-tester les tool calls (formats légèrement différents)

Effort typique : 20-30 j.

🎓 Annexe — Roadmap de skill 2026 pour freelance senior

Si tu as 12 semaines à investir pour devenir senior framework AI :

Semaine 1-2 : Raw SDK Anthropic + OpenAI (lire docs complètes, écrire 5 mini-apps)
Semaine 3-4 : Instructor Python + Pydantic AI (mission POC client compatible)
Semaine 5-6 : Mastra TS + Vercel AI SDK (refait 1 POC en TS)
Semaine 7-8 : Agno + LangGraph (1 cas multi-agent dans chaque)
Semaine 9   : LlamaIndex (RAG complet sur 1 corpus client)
Semaine 10  : DSPy (optimise les prompts d'1 projet existant)
Semaine 11  : Observabilité (Langfuse + Braintrust + OTLP)
Semaine 12  : Eval frameworks (golden sets, LLM-as-judge, A/B)

Investissement : ~360 h. ROI : capacité à proposer 1 200-1 500 € TJM sur missions framework AI tous secteurs.

🏋️ Exercices

Progression voulue : du "je sais comparer" au "je défends ma stack devant un CTO sceptique et je la casse pour prouver qu'elle tient". Chaque exercice est plus dur que le précédent.

Exercice 1 — Le "même agent, 3 frameworks, 1 benchmark"

Objectif — Implémenter le même agent (1 outil search_docs, 1 outil cite, output structuré {answer, sources[]}) en raw SDK Anthropic, en Pydantic AI, et en Agno, puis mesurer.

Contrainte — Sortie identique au schéma près (Pydantic Answer partagé). Tu logges pour chacun : tokens d'overhead système injecté par le framework (count_tokens sur le prompt vide vs framework), latence cold/warm sur 50 runs, lignes de code.

Indice/Solution — Pour l'overhead, compte les tokens du system rendu par chaque framework avec client.messages.count_tokens(model="claude-opus-4-8", ...) et soustrais ton system "nu". Tu vas retrouver l'ordre de l'annexe (raw ≈ 0, Pydantic AI ≈ 40, Agno ≈ 60). La vraie leçon : l'écart de DevX (lignes de code) est énorme alors que l'écart de tokens est marginal — c'est ce trade-off que tu factures.

Exercice 2 — Casser le decision tree

Objectif — Trouver 3 missions réelles où le decision tree du fichier donne la mauvaise recommandation, et écrire la règle corrective.

Indice/Solution — Pistes : (a) "agent TS mais l'équipe a 5 ans de Python et 0 de Node" → le tree dit Mastra, la réalité dit "le coût d'apprentissage TS écrase le gain framework, fais un service Python + Vercel AI SDK en façade" ; (b) "RAG lourd MAIS corpus = 200 docs réglementaires qui changent jamais" → LlamaIndex est sur-dimensionné, un index statique + raw SDK suffit ; (c) "edge global MAIS p95 < 300 ms imposé avec reasoning" → aucun framework ne te sauve, c'est un problème de modèle (Haiku) + cache, pas d'orchestration. Conclusion senior : un decision tree est un point de départ, pas un oracle ; le métier et l'équipe le surchargent toujours.

Exercice 3 — Le harness d'éval reproductible

Objectif — Construire un harness qui benchmark qualité (pas latence) de 2 frameworks sur la même tâche, avec golden set + LLM-as-judge, et qui passe en CI.

Contrainte — 20 cas golden, effort figé, snapshots des tool calls, juge sur un modèle distinct (claude-haiku-4-5 pour le coût, le juge n'a pas besoin du flagship). Le test doit échouer si la qualité descend sous un seuil.

Indice/Solution — Le piège : sans figer effort et sans snapshot des tool calls, chaque run dérive et ton CI devient flaky. Structure : cases.jsonl (input, expected) → run framework A et B → juge chaque sortie (0/1 + raison) → assert mean_score >= 0.85. Le juge appelle client.messages.parse() avec un schéma {score: int, reason: str} — sortie structurée native, pas de regex sur la réponse du juge. C'est exactement le "standard senior 2026" du tableau Testing/Eval.

Exercice 4 — Défendre le devis (rends-le production-grade)

Objectif — Prendre le Scénario 3 (migration legacy LangChain → Pydantic AI, devis 100 500 €) et le transformer en argumentaire chiffré que tu défends ligne par ligne devant un CFO.

Contrainte — Tu dois justifier le ROI avec des nombres mesurables, pas "c'est plus stable". Calcule : économie tokens DSPy (-25 % × volume × prix claude-opus-4-8 à 5 $/25 $ le M tok), coût de la dette LangChain évitée (jours/an du tableau TCO), et le break-even en mois.

Indice/Solution — Le CFO ne paie pas la "propreté", il paie un payback. Pose : coût LLM actuel 50 k$/an → -25 % via DSPy = 12,5 k$/an + le delta de dette technique (LangChain 15 j/an vs Pydantic AI 5 j/an = 10 j/an × TJM). Break-even = 100 500 € ÷ (économie annuelle). Si > 18 mois, ton devis ne passe pas — c'est là qu'un senior dit "on phase : pilote 1 chaîne d'abord, on confirme le ROI sur données réelles, puis on étend". Défendre un nombre = pouvoir montrer la formule, pas l'asséner.

Exercice 5 — La couche de portabilité (anti-lock-in)

Objectif — Écrire un port (interface) AgentRunner qui rend ton code métier indépendant du framework, et l'implémenter pour 2 backends (Pydantic AI + raw SDK), de sorte qu'une migration framework = 1 fichier.

Contrainte — Le code métier ne doit jamais importer pydantic_ai ni anthropic directement. Un Protocol Python (run(prompt, tools) -> StructuredResult) sépare le port de l'adapter.

Indice/Solution — C'est le pitfall n°11 (vendor lock-in) résolu en code. Définis class AgentRunner(Protocol): async def run(self, prompt: str) -> Answer. Deux adapters : PydanticAIRunner et RawSDKRunner (qui fait client.messages.parse()). Le test : tu dois pouvoir swap l'un pour l'autre via injection de dépendance sans toucher une ligne métier. Bonus dur : ajoute un 3ᵉ adapter Mastra (TS) derrière un REST et prouve que ton port survit même au changement de langage.

Exercice 6 (boss) — Le multi-agent qui se mesure et se déploie

Objectif — Monter un système multi-agent (orchestrateur + 2 sous-agents spécialisés) avec observabilité OTLP → Langfuse, et le déployer derrière une API, en justifiant chaque choix de framework couche par couche.

Contrainte — Tu dois pouvoir répondre à chaud à : combien coûte 1 requête end-to-end ? quel sous-agent brûle le plus de tokens ? que se passe-t-il si un sous-agent throw OverloadedError ? Latence p95 sous charge (100 req concurrentes) ?

Indice/Solution — Stack défendable : Agno (Team coordinate) OU une boucle raw SDK avec asyncio.gather pour le fan-out, OTLP exporté vers Langfuse pour tracer chaque span. Le coût/requête = somme des usage de tous les spans (n'oublie pas cache_read_input_tokens). Pour la résilience, chaque sous-agent a son max_retries + un fallback (dégrader vers claude-haiku-4-5 si le flagship est overloaded). Le vrai test senior : sous 100 req concurrentes, ton bottleneck est-il le réseau/quota (bien) ou la mémoire d'un framework lourd (mauvais — cf. annexe "concurrent agents") ? Si tu ne peux pas répondre, ton système n'est pas production-grade, il est juste une démo.

🎤 En entretien

Questions que ce sujet appelle quasi systématiquement en entretien senior/staff, avec la réponse en une ligne.

"LangChain ou pas LangChain pour démarrer un nouveau projet en 2026 ?" → Non pour démarrer (dette historique, breaking changes, alternatives plus propres comme Pydantic AI/Mastra) ; oui si on hérite d'un projet existant — on ne réécrit pas par dogme, on migre par ROI.
"Comment tu choisis un framework AI ? Donne-moi ta méthode, pas ton favori." → Je trace d'abord le flow métier au tableau, PUIS je choisis : langue (Py/TS), profondeur d'orchestration (1 call → agent → multi-agent → workflow), maturité prod attendue, cible de déploiement — et la règle d'or "si j'hésite, raw SDK + Instructor/Pydantic AI, j'ajoute une couche seulement quand la douleur l'exige".
"Quand un agent ? Quand juste un workflow déterministe ?" → Agent seulement si la tâche est multi-step, dure à spécifier d'avance, et que le coût/latence supplémentaire est justifié avec des erreurs rattrapables ; si je peux écrire un workflow fixe, je n'utilise PAS d'agent — beaucoup de "problèmes agents" sont des pipelines déguisés.
"Ton système multi-agent coûte trop cher. Tu débugges comment ?" → Je trace chaque span via OTLP et je lis usage par appel (sans oublier cache_read_input_tokens) pour trouver l'agent qui brûle ; leviers dans l'ordre : prompt caching sur le préfixe stable, baisser l'effort, couper les sous-agents inutiles (souvent un grep/read suffit), et dégrader vers un modèle moins cher (claude-haiku-4-5) sur les sous-tâches non critiques.
"Pourquoi tu factures plus cher en choisissant Mastra plutôt que LangChain JS ?" → Parce que je choisis la stack pour 18 mois de prod, pas pour la démo de mardi : le TCO de LangChain JS (types brisés, dette qui te suit 2 ans) est 2-3× celui de Mastra sur la durée, et ce delta de maintenance est exactement ce que le client paie.

🔗 Liens

Notre fiche 01-langchain.md — LangChain détaillé
Notre fiche 02-langgraph.md — LangGraph détaillé
Notre fiche 03-llamaindex.md — LlamaIndex détaillé
Notre fiche 04-dspy.md — DSPy détaillé
Notre fiche 05-instructor.md — Instructor détaillé
Notre fiche 06-mastra.md — Mastra détaillé
Notre fiche 07-agno.md — Agno détaillé
Benchmark indépendant Latitude.so — https://latitude.so/blog/ai-framework-benchmarks-2026
Survey Anthropic "Building effective agents" (2024) — référence patterns, toujours valide
Talk Hamel Husain "Don't use LangChain" — argumentaire classique anti-framework
AI Engineer World's Fair 2026 — recap frameworks 2026 sur YouTube
HuggingFace Smolagents — alternative minimaliste Python (non couverte ici, à surveiller)
MCP Protocol — https://modelcontextprotocol.io (standard tools 2026)

Matrice comparative des frameworks AI 2026 ​

🧠 Mental model ​

🛠️ Code minimal — "Hello agent" dans chaque framework ​

Raw SDK (Anthropic Python) ​

Instructor ​

Pydantic AI ​

Vercel AI SDK (TS) ​

Mastra (TS) ​

Agno ​

LangChain ​

LangGraph ​

CrewAI ​

DSPy ​

LlamaIndex ​

AutoGen ​

🎬 Cas d'usage concrets (5 scénarios clients France 2026) ​

Scénario 1 — POC RAG juridique 1 mois (cabinet d'avocats Paris) ​

Scénario 2 — SaaS B2B AI long-terme (scale-up 50 personnes, Next.js monorepo) ​

Scénario 3 — Migration legacy LangChain Python → moderne (industrie, agent ops) ​

Scénario 4 — Edge deployment global (DTC e-commerce, agent shopping) ​

Scénario 5 — Monorepo Python data + agents BI (PME industrielle Nantes) ​

🛠️ Exemple end-to-end — Decision flowchart (Mermaid) + scoring matrix ​

Flowchart de décision ​

Matrice de scoring senior 2026 ​

Détails par framework (1 ligne chacun) ​

🎯 Patterns courants ​

1. Le pattern "two-framework stack" ​

2. Le pattern "extraction layer + agent layer" ​

3. Le pattern "DSPy optimize after" ​

4. Le pattern "Agno team de DSPy modules" ​

5. Anti-pattern "tout dans 1 framework" ​

6. Le pattern "raw SDK production-grade" (le 30-50 % qui ne disparaît jamais) ​

🔄 Versions & écosystème 2026 ​

⚠️ Pitfalls (transversaux à TOUS les frameworks) ​

💰 Pricing / ROI client ​

Coût total de propriété par framework (équipe 3 devs, 18 mois) ​

Pricing freelance — modulation par framework ​

🧪 Testing / Eval — comparé par framework ​

🔁 Quand utiliser / éviter — Tableau final ​

✅ TOP picks 2026 par situation ​

❌ À éviter en 2026 ​

Decision tree express (one-liner) ​

📊 Annexe — Benchmarks indicatifs 2026 ​

Latency p50 — instantiation d'1 agent simple (3 tools) ​

Tokens overhead par appel (system prompt injecté par le framework) ​

Concurrent agents tenus sur 4 vCPU / 8 GB RAM ​

🧭 Annexe — Migration paths réels ​

LangChain Python → Pydantic AI ​

LangChain JS → Mastra ​

CrewAI prod → Agno ​

AutoGen → Pydantic AI / Agno ​

🎓 Annexe — Roadmap de skill 2026 pour freelance senior ​

🏋️ Exercices ​

Exercice 1 — Le "même agent, 3 frameworks, 1 benchmark" ​

Exercice 2 — Casser le decision tree ​

Exercice 3 — Le harness d'éval reproductible ​

Exercice 4 — Défendre le devis (rends-le production-grade) ​

Exercice 5 — La couche de portabilité (anti-lock-in) ​

Exercice 6 (boss) — Le multi-agent qui se mesure et se déploie ​

🎤 En entretien ​

🔗 Liens ​

Matrice comparative des frameworks AI 2026

🧠 Mental model

🛠️ Code minimal — "Hello agent" dans chaque framework

Raw SDK (Anthropic Python)

Instructor

Pydantic AI

Vercel AI SDK (TS)

Mastra (TS)

Agno

LangChain

LangGraph

CrewAI

DSPy

LlamaIndex

AutoGen

🎬 Cas d'usage concrets (5 scénarios clients France 2026)

Scénario 1 — POC RAG juridique 1 mois (cabinet d'avocats Paris)

Scénario 2 — SaaS B2B AI long-terme (scale-up 50 personnes, Next.js monorepo)

Scénario 3 — Migration legacy LangChain Python → moderne (industrie, agent ops)

Scénario 4 — Edge deployment global (DTC e-commerce, agent shopping)

Scénario 5 — Monorepo Python data + agents BI (PME industrielle Nantes)

🛠️ Exemple end-to-end — Decision flowchart (Mermaid) + scoring matrix

Flowchart de décision

Matrice de scoring senior 2026

Détails par framework (1 ligne chacun)

🎯 Patterns courants

1. Le pattern "two-framework stack"

2. Le pattern "extraction layer + agent layer"

3. Le pattern "DSPy optimize after"

4. Le pattern "Agno team de DSPy modules"

5. Anti-pattern "tout dans 1 framework"

6. Le pattern "raw SDK production-grade" (le 30-50 % qui ne disparaît jamais)

🔄 Versions & écosystème 2026

⚠️ Pitfalls (transversaux à TOUS les frameworks)

💰 Pricing / ROI client

Coût total de propriété par framework (équipe 3 devs, 18 mois)

Pricing freelance — modulation par framework

🧪 Testing / Eval — comparé par framework

🔁 Quand utiliser / éviter — Tableau final

✅ TOP picks 2026 par situation

❌ À éviter en 2026

Decision tree express (one-liner)

📊 Annexe — Benchmarks indicatifs 2026

Latency p50 — instantiation d'1 agent simple (3 tools)

Tokens overhead par appel (system prompt injecté par le framework)

Concurrent agents tenus sur 4 vCPU / 8 GB RAM

🧭 Annexe — Migration paths réels

LangChain Python → Pydantic AI

LangChain JS → Mastra

CrewAI prod → Agno

AutoGen → Pydantic AI / Agno

🎓 Annexe — Roadmap de skill 2026 pour freelance senior

🏋️ Exercices

Exercice 1 — Le "même agent, 3 frameworks, 1 benchmark"

Exercice 2 — Casser le decision tree

Exercice 3 — Le harness d'éval reproductible

Exercice 4 — Défendre le devis (rends-le production-grade)

Exercice 5 — La couche de portabilité (anti-lock-in)

Exercice 6 (boss) — Le multi-agent qui se mesure et se déploie

🎤 En entretien

🔗 Liens