Projets (études de cas)
Hecklr (2026)
The crash-test lab for AI agents: simulated customers over voice, chat and email, with statistical CI gating.
Problème : Teams ship customer-facing agents on vibes: a prompt tweak can silently break 1 call in 4, and nobody notices until customers do. Agent quality needs the same rigour as code.
Approche : Each scenario × trial resets a sandboxed world (mock backend over MCP/HTTP) and sends a persona-driven simulated customer at the agent through adapters (HTTP/SSE/WS, Twilio, Pipecat, LiveKit, SMTP/IMAP), with real audio, noise, codecs, packet loss and barge-in. Graders combine deterministic checks, tool/state assertions and LLM judges calibrated with Cohen's κ; stats use Wilson and cluster-bootstrap CIs, a paired sign-flip test and Benjamini-Hochberg. Plus a miner (prod logs → scenarios), a fixer (validated prompt patches → PR) and an 8-strategy red-team pack.
Impact : The hecklr gate command comments the PR and fails the build on a real regression: demo catch −27.3 pts [−44.2, −11.2], p = 0.004. 1.8% false alarms over 2,000 A/A runs, 90.6% power for a 10-pt drop, voice timing error ≤ 18 ms, 12/12 seeded faults caught.
Rôle : Sole author — architecture, statistics, voice stack.
Stack : Python, TypeScript, Pipecat / LiveKit / Twilio, DuckDB
Earshot (2026)
Voice supervision for autonomous agents: say "stop, a bit to the left" and the correction becomes a learned rule.
Problème : Robots and agents act faster than humans can type. Operators need to interrupt and correct them by voice, and the same mistake shouldn't happen twice.
Approche : "Stop" is caught on AssemblyAI partial transcripts; the rest of the sentence becomes a skill call (grammar first, LLM fallback). Each correction is logged with 2 s of prior state, then distilled into a new policy version: LLM rules with evidence plus deterministic operator facts. Hierarchical LLM policy over a frozen skill layer, with watchdogs; demo on a simulated gantry gripper.
Impact : Halts in ~250–300 ms; operator interventions drop from 4 to 0 on the next run. 192 unit tests, live demo. Built for the AssemblyAI Voice Agent Hackathon (lablab.ai).
Rôle : Solo build.
Stack : TypeScript, Next.js, AssemblyAI, Gemini
Badge — 🥉 3rd place, Ledger OP3N 2026 (2026)
Turns each employee's Ledger into their company badge for AI agents.
Problème : Your AI agent knows too much; your colleague's knows too little. The most valuable context lives in private conversations and documents, and agents have no safe way to share it with consent.
Approche : A confidential enclave (Intel TDX on Phala, attestation verified by clients) finds the relevant notes in a colleague's memory; the owner approves each excerpt on their Ledger through clear-signed EIP-712 messages. Consent expires, anti-scraping limits stop hijacked agents, and desks behind a Chinese wall answer through Semaphore ZK proofs. Agents plug in over MCP.
Impact : 3rd of 13 student teams at Ledger OP3N ($1,000), built in one week, the only podium project that didn't move money. Open source, live demo.
Rôle : Lead developer (with Alexandre Lemiere).
Stack : TypeScript, Intel TDX, Ledger DMK, MCP
Heureka (2026)
An AI co-scientist: 7 agents that generate, refute and rank hypotheses.
Problème : Research is bottlenecked by how many hypotheses a team can generate and seriously test. How do you surface testable ideas you wouldn't have had?
Approche : 7 specialised agents in an adversarial loop: generation (expert debate) → critique → falsification (red-team) → safety → Elo tournament ranking → evolution. Claim-level verification: each hypothesis is broken into atomic claims checked against open-access literature (OpenAlex, Europe PMC, arXiv); conjunctive scoring — a single contradicted premise collapses the score.
Impact : Ranked hypotheses (lower-confidence-bound Elo) with claim graphs, novelty measured against the nearest prior work, falsification verdicts and proposed experiments. Runs on any OpenAI-compatible model (default NVIDIA Nemotron), with per-role routing, a budget-driven orchestrator and resumable runs. Ships its own eval harness: the scaffold vs. a one-shot call to the same model, judged blind.
Rôle : Sole author — architecture, agents, evals.
Stack : Python, Pydantic, NVIDIA Nemotron, multi-agent
FendForItself — 🏆 Agentic Economy on Arc 2026 (2026)
Autonomous AI-run companies spun up in ~30 seconds.
Problème : Launching a micro-business takes dozens of manual steps. What if agents could own and operate a business end-to-end?
Approche : Each generated company gets its own wallet, USDC funding and a priced API (x402-protected). Agents spawn, pay and coordinate on Arc.
Impact : Winner, Agentic Economy on Arc 2026 (Circle + Arc + Lablab.ai). Demo: 60 buyer agents settling on-chain over real-time SSE. $0.005/call at ~98% margin — viable because USDC is Arc's native gas.
Rôle : Solo build — agents, on-chain integration, frontend.
Stack : Next.js, Gemini, x402, Arc
HyperVest — 🏆 Hack'inDauphine 2026 — Tokenization track (2026)
On-chain equity vesting with Soulbound Tokens.
Problème : Equity vesting stays opaque, off-chain and hard to verify.
Approche : Vesting anchored on non-transferable Soulbound Tokens, with performance-based unlocks (MRR targets, GitHub commits, KPIs) instead of pure time.
Impact : Winner, Tokenization track at Hack'inDauphine 2026 (Kryptosphere). Solidity + OpenZeppelin v5, Foundry, deployed on HyperEVM Testnet.
Rôle : Smart contracts + frontend (with Ariles Hireche).
Stack : Solidity, HyperEVM
Feedforward (2026)
A feed of work your agents already did: approve, edit or dismiss instead of prompting.
Problème : Chat makes you do the thinking: you have to know what to ask. Most useful agent work should arrive ready to approve.
Approche : Miner → parallel Preparers → client-side Ranker → sandboxed Executor, streamed as typed NDJSON. 7 roles on Muse Spark with strict JSON schemas generated from zod, Muse Image and SAM 3.1 segmentation for photo snaps. Rule: the model writes the words, code owns the facts (metrics and calendar slots are computed). A taste memory rewrites the Miner prompt every 3 gestures; an Agent Lens shows every call live.
Impact : Built solo for the Meta Global AI Developer Hackathon 2026 (Indie track). Unit + Playwright E2E tests on 2 viewports, demo video.
Rôle : Solo build.
Stack : Next.js, Muse Spark, SAM 3.1, zod
TokenGo (2026)
Walk Paris. Catch AI. Spend it for real: a location game where the loot is AI inference credits.
Problème : Crypto games bolt tokens onto gameplay nobody wants. What if the reward were something players already value: compute from real models?
Approche : Model shards spawn around OpenStreetMap places, deterministically (HMAC over H3 cell × time window). LLM-driven shopkeepers price from their own stock, so walking between shops is arbitrage; 3v3 Model Arena battles. Items are NEP-245 tokens on a hand-written Rust contract; compiling a recipe burns shards on-chain and credits a NEAR AI Cloud key. The player never sees a wallet.
Impact : 292 unit tests, 36 E2E flows, 1,060 relays and 153 shops across Paris, difficulty tuned over 2,000 simulated battles. Live, built solo for the NEAR Hackathon (games track).
Rôle : Solo build, directing AI coding agents.
Stack : TypeScript, Rust, NEAR, MapLibre
PACT (2026)
Identity & reputation for autonomous agents.
Problème : Agents that transact need to prove who they are and decide who to trust, with no human in the loop.
Approche : Three phases: cryptographic handshake (capabilities + Ed25519-signed bonds), discovery (need/capability matching), and a Web of Trust (referrals via bonded peers).
Impact : 20+ REST endpoints, network visualization dashboard, two demos (one fully LLM-driven, one scripted). Infra brick for trustworthy agent economies.
Rôle : Protocol design + backend + interface.
Stack : FastAPI, React, Ed25519
onchain-lie-detector (2026)
Automated crypto due diligence via fund-flow graphs.
Problème : Evaluating an on-chain protocol is slow, manual and easy to fake (inflated TVL, Sybils).
Approche : Ingests 4 heterogeneous sources (Alchemy RPC, Dune, Etherscan, DefiLlama), builds a fund-flow graph, runs Louvain clustering + Johnson's cycle detection to spot circular flows and Sybil networks.
Impact : 0–98 trust score across 5 weighted dimensions. 108+ tests. Replaces hundreds of hours of manual investigation per protocol.
Rôle : Design + implementation.
Stack : Python, graphs
zkrust (2026)
A Groth16 zk-SNARK built from scratch, zero crypto deps.
Problème : Truly understand zero-knowledge proofs — not just call a library.
Approche : Full Groth16 over BN254: hand-rolled Montgomery field arithmetic (Fp/Fp2/Fp6/Fp12), optimal Ate pairing, Pippenger MSM, KZG commitments, radix-2 NTT. CLI setup → prove → verify.
Impact : ~6,500 lines of Rust, 159 tests, 6-crate workspace. ~1 ms to generate a proof, ~13.5 ms to verify (Apple Silicon).
Rôle : Sole author — maths, implementation, tests.
Stack : Rust
LiquidVest (2026)
Tradeable token vesting on Solana.
Problème : Vesting tokens are locked and illiquid until the cliff ends.
Approche : Each vesting schedule is a transferable Receipt NFT — selling the NFT sells the future token stream. Linear / cliff / step curves.
Impact : Anchor 0.30.1 program, Node.js + better-sqlite3 indexer, Next.js frontend. Property-based tests (Proptest) + 13 integration tests (Bankrun).
Rôle : On-chain program + indexer + frontend.
Stack : Anchor, Solana, Next.js
truth-stamped (2025)
Cryptographic anti-deepfake timestamping.
Problème : Prove a piece of media existed at time T, in the age of AI deepfakes.
Approche : On-chain timestamping: SHA-256 + ECDSA signatures + immutable record on Base.
Impact : Live on Base Sepolia, 12 tests, ~$0.001 per stamp. Defensive content-authentication infrastructure.
Rôle : Design + implementation.
Stack : TypeScript, Solidity, Base