Agentic AI workflows production : architecture 2026 (Claude, GPT-4, agents)

2026 = année où agentic AI arrive en production. Anthropic Claude 4.7 + Anthropic Computer Use, OpenAI GPT-4 Agent, Operator. Mais déployer agent IA en production exige architecture rigoureuse : observability, safeguards, fallbacks.

TL;DR

- Agents IA = LLM avec capacité d'invoquer outils + boucle de réflexion.

- Stack 2026 : Claude API + tool use + observability LangSmith/Helicone + safeguards.

- Use cases prod : customer support, code review, content generation, data analysis.

Architecture agent IA production

`

[User input]

↓

[Claude Agent SDK]

↓

[Planner : décomposer task]

↓

[Executor : invoquer outils]

├── Search web

├── Query DB

├── Send email

├── Run code

└── Call APIs

↓

[Memory : résultats étapes]

↓

[Reflexion : task done ?]

↓

[Output ou continuer]

`

Étape 1 — Claude Agent SDK setup

`ts

// lib/agent.ts

import Anthropic from '@anthropic-ai/sdk';

const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY! });

const tools = [

{

name: 'search_database',

description: 'Search internal customer database',

input_schema: {

type: 'object',

properties: {

query: { type: 'string', description: 'Search query' },

},

required: ['query'],

},

},

{

name: 'send_email',

description: 'Send email to customer',

input_schema: {

type: 'object',

properties: {

to: { type: 'string', format: 'email' },

subject: { type: 'string' },

body: { type: 'string' },

},

required: ['to', 'subject', 'body'],

},

},

{

name: 'create_ticket',

description: 'Create support ticket in Linear',

input_schema: {

type: 'object',

properties: {

title: { type: 'string' },

description: { type: 'string' },

priority: { type: 'string', enum: ['LOW', 'MEDIUM', 'HIGH', 'URGENT'] },

},

required: ['title', 'description', 'priority'],

},

},

];

async function runAgent(userMessage: string, sessionId: string) {

let messages = [{ role: 'user', content: userMessage }];

let iterations = 0;

const MAX_ITERATIONS = 10;

while (iterations < MAX_ITERATIONS) {

const response = await anthropic.messages.create({

model: 'claude-opus-4-7',

max_tokens: 4096,

tools,

messages,

});

// Si Claude termine sans tool call

if (response.stop_reason === 'end_turn') {

return response.content[0].text;

}

// Tool use : exécuter l'outil

if (response.stop_reason === 'tool_use') {

const toolUse = response.content.find(c => c.type === 'tool_use');

if (!toolUse) break;

const result = await executeTool(toolUse.name, toolUse.input);

messages.push({ role: 'assistant', content: response.content });

messages.push({

role: 'user',

content: [{ type: 'tool_result', tool_use_id: toolUse.id, content: result }],

});

}

iterations++;

}

throw new Error('Max iterations reached');

}

`

Étape 2 — exécuter outils

`ts

async function executeTool(name: string, input: any) {

// Telemetry + audit

await logToolCall(name, input);

switch (name) {

case 'search_database':

return await searchDatabase(input.query);

case 'send_email':

// VALIDATION : anti-spam, content filter

if (containsPII(input.body)) {

return { error: 'Body contains PII, blocked' };

}

return await sendEmail(input);

case 'create_ticket':

return await createLinearTicket(input);

default:

return { error: Unknown tool: ${name} };

}

}

`

Étape 3 — safeguards critiques production

1. Whitelist tools

`ts

// Pas tous les agents ont accès à tous les tools

const AGENT_TOOLS_BY_ROLE = {

customer_support: ['search_database', 'send_email', 'create_ticket'],

code_reviewer: ['search_codebase', 'run_tests', 'create_pr_comment'],

data_analyst: ['query_warehouse', 'generate_chart'],

};

function getToolsForAgent(agentRole: string) {

const allowedNames = AGENT_TOOLS_BY_ROLE[agentRole] ?? [];

return tools.filter(t => allowedNames.includes(t.name));

}

`

2. Validation outputs

`ts

async function executeTool(name: string, input: any) {

// Pre-validation

const validation = validateToolInput(name, input);

if (!validation.ok) {

return { error: validation.reason };

}

// Execute

const result = await runTool(name, input);

// Post-validation

const sanitized = sanitizeOutput(result);

return sanitized;

}

function validateToolInput(name: string, input: any) {

if (name === 'send_email') {

if (input.to.endsWith('@example.com')) {

return { ok: false, reason: 'Test domain not allowed in prod' };

}

if (input.body.length > 10000) {

return { ok: false, reason: 'Body too long' };

}

}

return { ok: true };

}

`

3. Approval requis pour actions critiques

`ts

const CRITICAL_TOOLS = ['send_email', 'transfer_funds', 'delete_user'];

async function executeTool(name: string, input: any) {

if (CRITICAL_TOOLS.includes(name)) {

// Pause + request human approval

const approval = await requestHumanApproval({ tool: name, input, agentSession: sessionId });

if (!approval.approved) {

return { error: 'Human declined approval' };

}

}

return await runTool(name, input);

}

`

4. Rate limiting

`ts

import { Ratelimit } from '@upstash/ratelimit';

const agentLimiter = new Ratelimit({

redis: redisClient,

limiter: Ratelimit.slidingWindow(50, '1 h'),

});

async function runAgent(userMessage: string, sessionId: string) {

const { success } = await agentLimiter.limit(sessionId);

if (!success) {

throw new Error('Rate limit exceeded');

}

// ... rest

}

`

Étape 4 — observability

LangSmith ou Helicone pour observability LLM :

`ts

import { LangChainTracer } from 'langsmith';

const tracer = new LangChainTracer({

apiKey: process.env.LANGSMITH_API_KEY,

projectName: 'kolonell-agent-prod',

});

// Track everything

await tracer.startTrace({

name: 'customer_support_agent',

metadata: { sessionId, userId },

});

const result = await runAgent(userMessage, sessionId);

await tracer.endTrace({ output: result });

`

Visibility :

• Prompt → réponse latency
• Tokens consumed
• Tool call success/failure
• Cost per session
• Error rate
• User satisfaction (thumbs up/down)

Étape 5 — coûts agentic AI

Hypothèse : agent customer support, 1000 conversations/jour.

Tokens moyens par conversation :

• Input : 4K tokens (system prompt + context + history)
• Output : 2K tokens (responses + tool calls)

• Coût Claude Opus 4.7 (2026) :
• Input : $15 / 1M tokens
• Output : $75 / 1M tokens

Par conversation :

• $15 × 4K/1M = $0.06
• $75 × 2K/1M = $0.15
• Total : $0.21

• 1000 conversations/jour × $0.21 = $210/jour = $6.3K/mois

À comparer salaire human support 5-15K USD/mois. ROI rapide si automation > 60-70 %.

Cas d'usage production 2026

Customer support

Agent IA gère 70-80 % tickets niveau 1, escalation human niveau 2.

Code review automatique

Agent reviews PR : security, perf, style. Human merge final.

Content moderation

Agent flag content suspect, human valide.

Data analysis

Agent génère insights, charts, reports automatiquement.

Recruitment screening

Agent scan CV, score, écrit feedback, schedule interviews.

Cas réel — SaaS Dakar agent support

Pièges fréquents

• Agent boucle infinie — toujours MAX_ITERATIONS strict.
• Hallucinations destructrices — pas de DELETE, UPDATE sans approval humain.
• Pas de monitoring coûts — Claude API peut exploser facturation. Alerts critiques.
• Lock-in vendor — abstraire LLM provider (Vercel AI SDK, LangChain).
• Pas de eval framework — tester regressions sur changements prompts.

FAQ

Q : Claude vs GPT-4 vs Gemini pour agents ?

R : Claude Opus 4.7 = state-of-art tool use 2026. GPT-4 close second. Gemini moins fiable.

Q : Open-source alternative ?

R : Llama 3.3 70B + AutoGen. Plus complexe setup mais 10x moins cher.

Q : Quand pas utiliser agent ?

R : Tasks deterministic = traditional code. Agents pour tasks ambiguës nécessitant raisonnement.

Conclusion

Agentic AI en production 2026 = paradigm shift. Coût $0.20/conversation vs $5-20 humain. ROI rapide pour use cases volume > 500/jour. Investissement architecture + safeguards essentiel pour production solide.