Demander mon échange gratuit

Expertise technique

Le détail de notre travail, pour ceux qui veulent le vérifier

Architecture, plateforme, produit et systèmes IA: les choix techniques, la méthode et la stack que nous utilisons en production.

Pour CTO et tech leadsStack et méthode détaillées

Architecture agentique

Un agent, ce n’est pas un modèle : ce sont sept couches

Le modèle n’en est qu’une. Les autres décident de ce qu’il voit, de ce qu’il peut faire, et de ce qui doit être validé.

01

Modèle

Produit le texte et les propositions. Il n’agit sur rien seul.

02

Contexte

Référentiels, données du dossier, mémoire et extraits, assemblés à chaque tâche.

03

Outils

Lecture et écriture typées : chaque appel a un contrat d’entrée et de sortie.

04

Boucle

Enchaîne les étapes, sous des bornes de nombre d’étapes, de budget et de délai.

05

Garde-fous

Contrôles par du code, droits de l’utilisateur, escalade vers un humain.

06

Mémoire

Résumé de session et faits validés, compactés au-delà d’un seuil.

07

Observabilité

Journal de chaque exécution : outils appelés, verdicts, sorties.

La boucle, étape par étape

1

Comprend

Planifie : découpe la tâche, identifie le dossier et le livrable attendu.

2

Agit

Appelle les outils typés et observe chaque résultat avant l’étape suivante.

3

Contrôle

Recalcule par du code ce qui peut l’être, applique les garde-fous.

4

Valide

Propose, signale les champs incertains, attend l’accord. Un refus relance la boucle.

Bornes de chaque exécution : nombre d’étapes maximal, budget de contexte, délai, escalade vers un humain en cas de dépassement.

Outils typés

Lecture seule par défaut. Écriture seulement après validation. Le schéma de chaque appel est vérifié avant toute action.

Lecture visuelle de PDF

Plans sans couche texte, lus comme une image.

Lecture géométrique de DXF

Sommets et limites lus depuis le fichier (ezdxf), recoupés avec le plan.

Classeurs Excel

Formules, totaux et contrôles (openpyxl), jamais de valeur figée.

Documents Word

Remplissage sans écraser l’existant, corrections en suivi des modifications.

Garde-fous

Calculs par le code

Tantièmes, cotes et sommes sont recalculés, le modèle ne les estime pas.

Champs incertains signalés

Un doute reste marqué [À VÉRIFIER] tant qu’un humain ne l’a pas tranché.

Validation humaine

Rien n’est envoyé ni enregistré sans l’accord d’un collaborateur.

Trace simulée, exemple illustratif

# Agent contrôle, dossier de démonstration
1  lit      document.docx        → 14 pages, 3 sections
2  appel   read_plan(pdf)       → plan lu (vision)
3  appel   read_dxf(dxf)        → 9 sommets extraits
4  code    recalcule les cotes  → 2 écarts de 1 cm
5  code    vérifie les mentions → 1 mention absente
6  statut  anomalies : 3 · champs [À VÉRIFIER] : 2
7  demande validation → le collaborateur tranche les 2 cas

Évaluation et observabilité

  • Jeu de cas réels anonymisés, rejoué à chaque changement.
  • Shadow mode avant mise en production : le système propose, personne n’envoie.
  • Journal d’exécution : qui a lancé quoi, quels outils, quel verdict.
  • Suivi du coût par tâche : consommation et coût de chaque exécution, par workflow.

01 · Compétences

Quatre piliers d'ingénierie

Des systèmes compréhensibles, livrables et opérables.

01

Architecture logicielle

Architectures cloud-native, event-driven et évolutives, alignées sur les domaines métier.

  • Cartographie des bounded contexts
  • Choix technologiques & ADR
  • Scalabilité, résilience, sécurité
02

DevOps & plateforme

CI/CD, infrastructure as code, observabilité et run fiable.

  • Pipelines GitOps & automatisation
  • Cloud Run / GCP / conteneurs
  • Monitoring, SLO, coût d’exploitation
03

Ingénierie fullstack

Produits web de bout en bout : APIs robustes, interfaces performantes, contrats clairs.

  • Front Angular / écosystème web
  • APIs, data contracts, perf
  • Qualité, tests, maintenabilité
04

Systèmes IA

Systèmes IA prêts pour la production : agents, pipelines, évaluation et serving.

  • Architecture RAG & agents
  • Eval, garde-fous, coût token
  • Intégration dans le SI existant

02 · Méthode

Cadrer · Concevoir · Livrer · Opérer

Un pipeline d'ingénierie clair, adapté aux contraintes des systèmes critiques.

1

Cadrer

Comprendre le terrain, les contraintes et les objectifs avant de poser une brique.

2

Concevoir

Architecture cible, flux de données, seams d’intégration et plan de livraison réaliste.

3

Livrer

Incréments utilisables, automatisation, revue qualité, du prototype au socle durable.

4

Opérer

Observabilité, runbooks, itération continue : un système qui tient quand le trafic monte.

03 · Stack

Outils et pratiques

Des outils choisis pour la clarté des contrats, la vitesse de livraison et la tenue en production.

Architecture

  • Domain-driven design
  • Event-driven
  • Microservices
  • ADR

Plateforme

  • GCP
  • Cloud Run
  • Firebase
  • Terraform
  • GitHub Actions

Produit

  • Angular
  • TypeScript
  • Node
  • APIs
  • Observabilité

IA

  • Agents
  • RAG
  • Eval harness
  • Serving
  • Guardrails

Et après ?

Vous voulez un projet, pas une démonstration ?

Un échange de cadrage gratuit pour identifier ce qui mérite d'être construit, et comment le mesurer.