Forge

The problem

A Camunda-7 process is not a diagram you sketch — it's an executable contract. Every task, gateway, sequence flow and boundary event has to be well-formed, typed and connected, or the engine refuses to run it. "Describe the process and let the AI draw it" sounds easy until a language model invents an element that doesn't exist, leaves a flow dangling, or emits XML the Designer can't parse.

So the hard part was never getting an LLM to talk fluently about a process. It was getting it to author one the production Designer would accept as its own — element for element, connection for connection — without a human cleaning up after every generation.

That meant the model could not be allowed to freehand the canvas. It had to work through the same operations a human designer uses, against the same model the engine ultimately consumes.

The agentic loop

I architected Forge around a from-scratch NestJS microservice that runs the agent loop server-side and streams every step to the browser over SSE. The model never paints pixels onto the canvas. It calls tools.

Each tool is a typed, function-call mutation on a real bpmn-js Camunda-7 model — create a service task, wire a sequence flow, set a gateway's type, attach a boundary event. The loop applies the call, reads the resulting model back, and hands that state to the next turn. The canvas the user watches build itself is the actual Designer, not a mock preview of one.

RAG grounding keeps the model honest: instead of inventing element types or property names, it retrieves from the real BPMN vocabulary and the existing process library, so it reaches for things that exist. Running the loop server-side keeps credentials, retrieval context and validation off the client, where the canvas only ever receives well-formed operations.

The loop — not the prompt — is the unit of correctness. Every turn is a constrained, validated, observable step, which is what turns "the AI made a diagram" into "the AI authored a process the engine will run."

Honest scope

I'll be exact about what is production-grade and what is a demo, because the two are easy to conflate. The production claim is the NestJS service: a server-side agentic tool-loop, function-calling plus RAG, driving a real bpmn-js Camunda-7 Designer canvas.

The forge-studio surface is something else. It's a "watch-it-build" showcase on React Flow with client-side OpenRouter streaming — a deliberately mocked experience to demonstrate the feel of agentic authoring. It is not bpmn-js, it is not Camunda-validated, and its polish should not be read as engine parity.

Keeping that line bright is the point. Forge as an ADF product is the production agentic loop over a real Camunda-7 canvas; the studio is a demo of the experience around it. Conflating the two would be the exact kind of overclaim this work is built to avoid.