I turn AI prototypes into reliable systems your team can use.
Hands-on delivery of AI agents, document workflows and internal tools.
Connected to your data, integrated with your software, measured against a real business outcome.
Paris · Remote collaboration · English / French · Consulting & embedded delivery
Architecture illustration, not live telemetry. View the static version.
| What is blocking you? | What we work on |
|---|---|
| The AI prototype works. It is not ready to ship. | Build a production workflow around your agents, RAG or document processing: API and data integration, evaluation, access controls, human review and deployment. |
| The AI system is unreliable, expensive or hard to debug. | Diagnose failures. Add structured outputs, tracing, bounded retries, recovery and regression tests. Measure quality, latency and cost per completed task. |
| You need someone to own delivery, not just recommend tools. | Embed with your product and engineering team: scope the workflow, design the architecture, write the code, support rollout and hand over an operable system. |
Start with one valuable workflow. Agree on what success means, ship a narrow slice, and expand based on evidence. The deliverable is working software, evaluation evidence and an operational handover.
I am CTO at Remolab. Previously, I led product and technology at Welcome Account, working on payments and AI-assisted KYC in a regulated environment.
That background shapes how I build: understand the user's job, integrate with the systems already in place, and make it clear what happens when something fails. I work with the team using the system, not only the team commissioning it.
Start here: Production AI Systems Architecture — my book on evaluation, typed workflows, human oversight, observability, security and AI economics.
| Project | What you can inspect |
|---|---|
| Reliable AI Agents | Book and Rust / Rig / Postgres reference implementation covering durable jobs, explicit state, recovery and operational gates. |
| LLM Observability Guide | OpenTelemetry + SigNoz guide and examples for tracing model calls, tool execution and multi-agent workflows. |
| Typed LLM Boundaries | Guide and examples for turning natural-language inputs into typed, validated data before downstream software acts on it. |
| AIMX | Safe Rust bindings for Apple's on-device Foundation Models, with typed sessions, structured outputs and tool-call results. |
| fair-eval | Rust audit harness for testing output differences across otherwise equivalent hiring cases with controlled identity-linked cue changes. |
| Agentic Workstation | Repeatable Ubuntu environments for coding agents, with profiles, health checks, a Rust planning CLI and Nix-based validation. |
These are books, reference implementations and tools, not a list of client deployments. Each repository has its own scope and license.
I am interested in the shift from chat interfaces to useful, tool-using systems—and in making those systems dependable, inspectable and useful to the people they serve:
- Agentic software engineering: bounded coding-agent changes, executable verification gates and recoverable delivery workflows—not code generation without review.
- Production agents: durable, tool-using workflows with typed boundaries, policy controls, evaluation and operational visibility.
- On-device and local inference: exploring the trade-offs of running models close to the user—from Ollama-powered agent labs to safe Rust bindings for Apple's on-device models.
- Human-centered AI: context-aware support, with product learning grounded in whether it genuinely helps the people using it.
Dayeh — an early-stage, proactive AI parenting companion. Building context-aware support and learning which behaviours genuinely help parents. TypeScript + Mastra.
Agent delivery infrastructure — developing a Rust execution graph for coding agents, with typed evidence, assurance and path optimization. The focus: making agent-assisted engineering reviewable and recoverable, not just fast once.
Stack & engineering approach
| Layer | Tools and practices |
|---|---|
| Application & agents | Rust · TypeScript · Python · Rig · Mastra · RAG · Tool calling · Structured outputs |
| Backend & state | Axum · Tokio · PostgreSQL · Background workers · Idempotency · Durable jobs |
| Operations | OpenTelemetry · SigNoz · Sentry · Docker · NixOS · GitHub Actions |
| Controls | Evaluation suites · Scoped permissions · Human review · Audit events · Recovery paths |
Rust is a strong part of my toolkit, not a requirement for your project. I work with the stack your product and team need.
Teaching & learning in public
Agentic Rust: Core Labs 101 — 20 hands-on labs for building Rust agents, from typed outputs and tool policies to local models, RAG and durable runs.
AI Reading Club — foundational AI papers and the engineering questions behind them.
Phippy Gaming Workshop — an AI-assisted game-building starter workshop for young and first-time creators, taught at AI Engineer, AGNTCon and CNCF Kids Day.
rust-ml.com · Category Theory for Tiny ML in Rust — learning machine learning through small, inspectable systems.
Send me what happens today, what is blocked, and what a useful result would look like. Add your timeline. No pitch deck required.
Discuss a project by email · Message me on LinkedIn
The model can be probabilistic. The system still needs clear responsibilities.