The problem How it works Code ↔ Graph Why trust us Early access Roadmap Architecture The language History
V2 in development — Early access open

Your AI agents
break silently.
They don't have to.

Caméléon is a visual workflow orchestrator with a formally-verified execution engine. Every state is observable. Every execution is deterministic. Nothing breaks without a reason you can see.

Get early access → View source

MIT License · Open source since 2012 · Built before LangChain existed · Used in scientific research

agent-pipeline — running
DONE RAG Fetch RUNNING GPT-4 Call ERROR Format JSON ⚠ RuntimeError KeyError: 'choices' — step 3
No connector states visible. Debugging from stack traces only.
The problem

AI pipeline failures are
invisible by default.

You've wired up your agents. It works in dev. In production, something fails, somewhere, silently. You spend hours reading logs. You know this story. LangChain doesn't.

01
🕳
Black box execution
LangChain, AutoGen, CrewAI — they run your agents but don't show you what's actually happening inside each step. When something goes wrong, you're debugging a black box.
02
🎲
Non-deterministic pipelines
Async agents with shared state, race conditions, implicit dependencies. Your pipeline works 9 times out of 10. The 10th time, it fails in a completely different way — and you can't reproduce it.
03
🧩
Impossible to reuse
You rebuild the same retrieval → reasoning → validation pattern in every project. There's no standard way to package, share, or compose agent workflows as reusable components.
04
📉
No observable state
Is my data new or already processed? Was this step executed? Did the output reach the next agent? These questions shouldn't require reading source code to answer.
How Caméléon works

A formal execution engine
behind a visual editor.

Every operator, every connection, every data state follows precise mathematical rules derived from Petri-net theory. There is no ambiguity in what runs, when, and why.

1
🔷
Compose visually
Drag operators onto a canvas, connect their inputs and outputs. Each operator is a pure function — it transforms typed inputs into typed outputs. No hidden side effects.
React Flow editor
2
⚙️
Formal execution
The Caméléon Virtual Machine evaluates each operator's execution condition based on connector states — NEW, OLD, or EMPTY. An operator runs only when its preconditions are formally met. Not probably. Not usually. Always.
Petri-net engine · Go
3
📡
Full observability
Every connector state is visible in real time. You see exactly where your data is, what its status is, and which operator is about to consume it. Debugging becomes a matter of looking, not guessing.
WebSocket · Live states
4
⇆
Code ↔ Graph bijection
Every composition has an exact text equivalent. Write in code, see the graph. Draw the graph, get the code. Let an AI generate the pipeline as text and watch it appear visually.
Dual representation
The engine

Why Petri-nets?
Because math doesn't lie.

Most orchestrators are built on event-driven heuristics — they mostly work. Caméléon's engine is built on a formally-verified Petri-net model. Mostly isn't in our vocabulary.

🔗
Three states. No surprises.
Every connector between operators has exactly one of three states at any moment. An operator fires if and only if its preconditions are formally satisfied. No implicit dependencies. No race conditions. No "it depends."
NEW — triggers exec OLD — consumed EMPTY — no data
Caméléon vs. the alternatives
Criterion n8n / LangFlow Caméléon
Execution model Event-driven Petri-net (formal)
Determinism Best effort Guaranteed
Connector states Implicit / hidden Explicit, observable
AI-readable format GUI-only Bijective text ↔ graph
Nested sub-processes Limited Native
Code ↔ Graph

One workflow.
Two representations.

Write code and see the graph appear. Draw a graph and get the code. Caméléon maintains a perfect bijection between visual and textual representations — they are the same program, in two different forms.

Visual composer Graph
RETRIEVAL RAG Fetch LLM GPT-4 Call VALIDATOR Schema OUTPUT Format JSON NEW OLD EMPTY RUNNING
bijection
⇆
pipeline.cm Text
// Caméléon — v2 syntax   pipeline RAGPipeline:   node rag_fetch : RAGFetch out.chunks → llm_call.in.context   node llm_call : GPT4Call in.context : DataChunks out.response → validator.in.raw   node validator : SchemaCheck in.raw : DataString out.valid → formatter.in.data   node formatter : FormatJSON in.data : DataString out.json
🧑‍💻
For developers who prefer text
Write your pipeline in code, version it in git, diff it in PRs. The visual graph updates live as you type. No lock-in to a GUI format.
🎨
For those who think visually
Drag, connect, explore. The code is always generated as a clean, readable artifact. Share the graph with a designer, the code with a developer.
🤖
For AI-generated pipelines
Because every composition has a clean text form, LLMs can read, generate, and modify Caméléon pipelines directly. Prompt your AI, paste the text, watch the graph appear. Your LLM becomes a pipeline architect.
Why trust the engine

Not a new idea.
A proven one.

Caméléon's execution model has been running complex scientific data pipelines since 2012 — long before AI workflows were a problem anyone was trying to solve.

12
Years in production
The execution engine has been running complex, multi-step data processing compositions since 2012 without a fundamental architecture change.
∞
Formally verified states
Based on a peer-reviewed Petri-net extension. Every execution is mathematically sound. Read the paper →
MIT
Fully open source
The core engine and all operators are MIT licensed. You own your workflows. No vendor lock-in. Self-host forever for free.
Built before the
problem had a name.
In 2008, we started building Caméléon to solve a problem that didn't have a name yet: how do you orchestrate complex data pipelines visually, with mathematical guarantees on execution order?
No-code didn't exist. LangChain was 14 years away. We built a visual dataflow language, a formally-verified virtual machine, and a plugin system — in C++ and Qt, for desktop. We were right about the problem. We were wrong about the medium.
Caméléon v2 is the same engine, rebuilt for the web. The math hasn't changed. The world caught up.
Open Looking for co-founders
Caméléon v2 is an active side project by a solo architect/CTO with 12 years of IP in data and AI orchestration. The engine is proven. The vision is clear.
What's missing: a go-to-market partner who knows B2B SaaS, and a frontend lead who wants to build something that outlasts the current AI hype cycle.
If you've experienced the pain of non-deterministic AI pipelines firsthand and want to fix it structurally — let's talk.
Reach out via early access →
Used in research at
École des Ponts ParisTech · Laboratoire Navier · Geomechanics Research
Early access

Be first when
v2 ships.

We're rebuilding Caméléon from the ground up — Go engine, React Flow editor, cloud-native. No desktop install, no C++ toolchain. Just open your browser and start composing.

✓ You're on the list. We'll reach out when early access opens.
✓ You're on the list. We'll reach out when early access opens.

No spam. No fluff. Just a ping when it's ready.  ·  Follow on Framagit  ·  Explore v1 docs

Caméléon v2 is in active development. The execution model is based on a peer-reviewed Petri-net extension. The v1 C++/Qt implementation has been open source since 2012. Built by shinoe · Learn about the language →