Before no-code had a name
A week ago, I didn't really believe in AI. Not in a militant way — not the kind to write alarming op-eds. More a quiet skepticism, fed by years of watching technological promises evaporate on contact with reality.
Today I'm one of its strongest advocates. And one of its most attentive critics. Both at the same time — because nothing is black or white.
Here's what happened.
2008. The right problem, the wrong medium.
It was supposed to take a week.
Vincent Tariel — computer scientist, PhD researcher at École Polytechnique — had a simple need: interact live with his image analysis algorithms for materials science. Change a parameter, see the result immediately. Without recalculating everything from scratch.
That need, precise and concrete, is the DNA of everything Caméléon became. Incremental execution. Connector states. The fact that synchronization is a property of the model, not a problem to solve.
We started building Caméléon together at Laboratoire Navier, École des Ponts ParisTech. Four years of intense work, the two of us. Then years alone, evenings after work, until 2020.
The objective crystallized: a visual orchestration language for complex scientific data pipelines, with an execution engine based on a formally verifiable model. The engine runs on Petri nets — a mathematical theory from 1962 that models concurrent systems with formal guarantees. Not gadget drag-and-drop. Real rigor: the model's properties (liveness, boundedness, determinism) are mathematically verifiable.
Synchronization isn't a problem to solve — it's a property of the model. If the tokens aren't in the right places, the transition doesn't fire. Period. No timeout, no polling, no workaround.
No-code doesn't exist yet. LangChain is 18 years away. We're solving a problem that doesn't have a name yet.
In 2010, the execution model is submitted to arXiv. In 2012, Caméléon enters production in geomechanics research pipelines at École des Ponts. The same engine still runs today.
But it's C++/Qt. Desktop. And the world is going web.
In 2020, I put down the keyboard. 63,000 lines of code. An MIT license. A buried conviction — and a sentence I can't yet formulate clearly.
What we understood before everyone else
Zapier arrives in 2011. Make in 2012. Apache Airflow in 2014. n8n in 2019. LangFlow and Flowise in 2022, riding the LLM wave.
All these tools are visual. None inherits a formally guaranteed execution model. In demos, they work. In production with real volumes, timeouts, LLMs hallucinating unexpected formats — they break in non-reproducible ways. Nobody has solved this.
Caméléon had solved this problem in 2008. With a property nobody else can claim: synchronization isn't a feature bolted on top of an event-driven engine. The state is the execution model. It's not monitoring. It's ontology.
"A Petri-net doesn't guess. It fires, or it doesn't."
We just had the wrong medium.
Saturday evening. The sentence.
February 2026. I submit the Caméléon repository to Claude. Not for reassurance. To test. This was the test that AIs couldn't pass: understand a real project, complex, undocumented, with its implicit decisions and its history hidden in 63,000 lines of C++.
Fifteen minutes later: a complete presentation. Layered architecture, positive/negative code review, comparison with current competitors, recommended stack for a rewrite, 3-phase roadmap.
But what stops me cold is a sentence in the "Positive points" section:
"The execution via executionCondition() on the NEW/OLD/EMPTY connector states is elegant and mathematically founded. It's the equivalent of a modern reactive engine, before its time."
That's exactly what Vincent and I told each other in 2008. Not from reading documentation — the code barely had any. From reading the code.
And then, in the comparison with n8n and Node-RED:
"Caméléon had the right execution model but the wrong medium."
The sentence I'd been carrying for 18 years without being able to formulate it that clearly.
No dependency, just standards
The rewrite starts. And immediately, the old reflexes kick in. I think big: Go for the engine, Kafka for messaging, React for the UI. Distributed architecture, modern stack.
Claude puts a file on the table: demo/cvm-poc-petrilike.html.
A single HTML file. The CVM engine, SVG rendering, interaction — everything inside. Runs in the browser. Nothing behind it. No server, no build, no node_modules.
"Wait. It runs in the browser? What's behind it?"
HTML/JS/SVG. W3C standards. Period.
And everything came flooding back. Caméléon v1 depended on Qt. Qt3 → Qt4 → Qt5, each migration a construction site. By 2012-2016, no time to keep up. Qt killed the project. Not a bug, not a missing feature — a dependency that moves while you can't keep up.
Eighteen years later, same formal engine, same creator. But this time: if I build on HTML/JS/SVG, nobody will ask me to migrate. The W3C doesn't ship breaking changes. The browser is the most stable and universal runtime that exists.
No dependency, just standards.
It's not a technical choice. It's a scar turned into discipline.
It's going to work.
The seven-day bet is ending. The rewrite is underway. The engine runs. A team of AI agents deliberates on its architecture. The code is in git.
Is everything finished? No. Is the trajectory clear? Yes.
And while I'm writing these lines, Vincent is doing the same thing. On another project. Without coordinating. In 7 days of vacation, we each built a structured AI agent team — roles, ADRs, governance. Independently. In parallel.
This is not a feat. It's a signal.
We've changed worlds.
— O. Cugnon de Sévricourt Project Katen — March 2026