Inside ProcessOS

The Day One keynote announced ProcessOS. The Day Two keynote actually ran it. Bernd Rücker, Co-founder and Chief Technologist, and Bastian Körber, VP Product Management, took a process from a one-paragraph brief to a deployed and running instance in under thirty minutes. They were upfront that this was lab conditions, not a production rollout. I think that honesty mattered, because the thirty-minute number is not the real point of the session.

The more hands-on half of the keynote was what sits underneath the demo. ProcessOS is not just “AI writes a BPMN file”. It is a pipeline that goes from intent to executable artifacts, plus a stack of capabilities that Camunda is building so the output actually holds up in production. The framing was direct. Generation is the easy half. Trust is the half most teams underestimate.

This article walks both halves. The demo first, because the phase model is the easiest way to understand how ProcessOS thinks. Then the Four Pillars of Trust and the roadmap to Camunda 8.10 in October 2026, where the trust half lives. If you want the announcement framing, read the Day One write-up first. This one assumes you have it.

The interesting part of the demo was not the domain. It was the sequence of phases ProcessOS runs through.

There are several phases, and each one has a clear input, an agent step, and a user review:

• Brief and goals. A plain-English brief, picked KPIs (cycle time, manual effort, quality, compliance, cost, throughput), free-text constraints, and a single sentence describing the desired outcome. The brief on stage was short, a few lines pointing at the company wiki for policy and naming the backend services the process should wire up to.

• Discovery. The Discovery agent reads the wiki, OpenAPI specs, policies, and runbooks that are in scope. It builds a Markdown decomposition of the as-is process and a draft BPMN. A live event stream showed the discovery phase running through to phase complete.

• Calibrate as-is. ProcessOS does not pretend its findings are ground truth. It surfaces open questions, risks, and confirmations against specific BPMN elements, and asks you to answer per element to lock down the as-is.

• Design and review to-be. The agent proposes the redesign with concrete before-and-after items per step, each tied back to a KPI you picked. One step in the demo replaced a gut-feel decision with a DMN business rule producing a routing class. The BPMN diff that followed showed 47 additions, 28 removals, and 3 changes. Feedback can be left on individual steps and goes back to the agent.

• Generate artifacts. The Build agent produces real Camunda 8 artifacts, not pseudocode. Four artifact types: BPMN, DMN, forms, and Java workers, sitting as files in the project repository, ready to compile.

The last phase was deploy and test. ProcessOS lints the artifacts, deploys all the BPMN, DMN, and form files to a Camunda 8 cluster, generates synthetic test variables, and starts one process instance via the Zeebe REST API. About thirty seconds. Bernd then switched to Operate and walked a live instance through its happy path. If you skip the deploy step, the artifacts stay in the project folder and you can run the generated worker scaffold yourself.

To make the openness point, Bernd also opened a coding agent in the same project folder and asked it to extend the generated Java application with a small web form. Same repo, same artifacts, different agent. The point is that ProcessOS is not a closed surface. The output is a normal Camunda 8 project that any coding agent or human can pick up from.

Thirty minutes from brief to running instance is a strong headline. It is also the kind of headline that gets teams in trouble. I have seen enough demos that looked good in the room and stalled in production to be careful here, and the speakers were careful too. They put it directly: “Trust is structural, not aspirational. Governance lives in the engine, the diagram, and the deploy path. Not in a policy doc.”

The strategic framing on the slide stacked three goals:

• Build solutions quicker. That is what ProcessOS is for.

• Build solutions that hold. That is what agentic orchestration plus the Four Pillars of Trust is for.

• Scale adoption. That only works if the first two are real.

The middle goal is where most of the engineering investment is going. Generating BPMN was never going to be the hard part. Operating, evolving, and trusting agent-driven processes in production is.

This is the framework Bernd walked through on stage. The pillars sit on top of agentic orchestration as the foundation. That foundation gives you durable state, governance, auditability, and operational control. The pillars cover what comes after a process is in production, when you have to operate it, debug it, and evolve it. Each pillar in his slide was split into what is shipping today and what is coming with 8.10.

Testing. Non-determinism breaks the usual test pyramid. You cannot assert on exact strings when the LLM is in the loop.

• Today: mock the LLM with Camunda Process Test, when(agent calls tool X).then(complete with Y). Assert output quality in natural language using an LLM as judge.

• 8.10: Test Studio for no-code acceptance tests written by business analysts.

Analytics. Problems at scale are invisible without dedicated signals. Aggregate process metrics are not enough once an agent is making decisions inside the flow.

• Today: bottleneck detection across the fleet in Optimize, plus process monitoring and incident tracking in Operate.

• 8.10: full agent visibility per instance, with conversation history, system prompt, tool calls, and token usage. An Agentic Control Plane for fleet-wide averages and outliers across tokens, durations, failure rates, and tool call distribution.

Instance Operations. Production problems need surgical fixes, not restarts. If your only remediation is to redeploy, you will keep redeploying.

• Today: see the incident and fix it in place. Retry, modify, migrate. Every action goes to the audit trail. Drill into individual agent runs to see the complete memory, including every tool call and reasoning step.

• 8.10: waiting state visibility, variable trace, and instance priority. Know what the process is waiting for without guessing.

Evolution. Everything changes. Models, prompts, business rules. The platform needs to make change cheap and traceable.

• Today: every change versioned, every instance traceable, running cases stay on their version, and you know which model ran when. Promote a proven agent pattern to a deterministic step without rewriting the process.

• 8.10: swap model or credentials without touching the process via environment handling and a connection manager. Optimize from production data, with token trends, tool frequency, and prompt versioning.

Read across the pillars and the pattern is consistent. The “today” rows already give you a working production setup. The “8.10” rows close the visibility and operational gaps that agentic systems specifically introduce.

The roadmap puts the trust half on a calendar. The slide split it into three layers, each on a different clock:

• The Foundation. Camunda 8 as it is today. The event-streaming engine, the SDKs, BPMN as an open standard, Process Test for self-validating agents, the Docs MCP server. Most readers are running on it already.

• The Connective Tissue. Arrives with 8.10 in October 2026. One Camunda Hub workspace, AI Coding Assistant reaches full release, Test Studio, Agentic Control Plane, and processes exposed as MCP tools. This is where the Four Pillars deliverables show up.

• The Compounding Loop. Beyond 8.10. Platform-generated Solution Packs, agents that tune from production signals, and overnight experiments that surface improvements with a diff. The long bet and the one with the most execution risk.

There is also a people side. ProcessOS is being positioned as a transformation offering, with forward-deployed engineers running discovery engagements at the customer site. Design partners are open now. If you are in a real re-engineering program, that is the program to ask about.

The Day Two keynote did three things well. It showed the pipeline end to end on something that looked like a real process. It admitted the demo was lab conditions and pointed at what is harder than generation. And it tied the roadmap to a clear date, October 2026 with 8.10, instead of a vague future.

• The demo phase model is the right mental shortcut for ProcessOS. Brief, Discovery, Calibrate, Design, Artifacts, Deploy and test. Each phase is reviewable.

• The artifacts are normal Camunda 8 artifacts. BPMN, DMN, forms, and Java workers in a project repo. Coding agents and humans can pick it up from there.

• Bernd’s Four Pillars of Trust frame where the production story lives. Roughly half of each pillar is available today. The other half ships with 8.10.

• The roadmap names three paces. Foundation today, Connective Tissue in October 2026, Compounding Loop beyond. Plan for the right one for your team.

• ProcessOS is also a transformation offering. The design partner program is the way in if you have a real re-engineering program lined up.

What I will be watching over the next months: the closed beta opening up, the 8.10 release notes for the Four Pillars deliverables, and the first platform-generated Solution Pack reaching full release. If you saw the keynote and want to compare notes, reach out. I will follow up once 8.10 is out.