Two weeks ago, I needed to build an end-to-end full Policy Change for automobile insurance process with AI agents. My deadline was pretty tight, so I thought, “What if I can use Claude Code to get this done quickly?”
I'd done something similar before on a much smaller scale before. An AI agent with a couple tools. It worked, but it was time consuming with quite a bit of back and forth to get things correct. I had to explain BPMN, FEEL, DMN, give links to documentation, and more to obtain what I needed. In that case, I’m really not sure that using Claude Code really saved me much time in the long run.
But this time, I decided to try something different. I took advantage of Camunda’s AI Skills with Claude Code and it completely changed the experience. I want to walk through what that changed for me using the real process that was built.
The problem with AI that doesn't know your platform
So, why do AI tools fall short when it comes to “building something real”? You need to have a process model that’s structurally correct (for Camunda, in BPMN), decisions that route the right way under the right conditions (using DMN and FEEL with Camunda) and resolve for any inputs. Then, if you are doing anything with AI, you may need an agent that calls tools for the correct reason and possibly hands off to a human or uses another guardrail without dropping context along the way.
Quick primer
Camunda is the enterprise platform for agentic orchestration. We orchestrate agents, people, and systems across end-to-end business processes. Organizations are deploying AI agents at a record pace, but 85% lack the process maturity to coordinate them safely at scale (State of Agentic Orchestration and Automation Report 2026). Here’s the technical foundation that makes that possible:
- BPMN is the open standard for modeling a business process as a diagram.
- DMN is the standard for modeling decisions as tables instead of buried if/else logic.
- FEEL is the expression language that both of them use to write conditions.
But the problem is that without domain knowledge already available in your AI tool, every session starts from zero. You paste in doc links. If your routing logic is wrong, you fix it. If the model doesn’t learn, you fix it again. This week alone, you fixed the same routing error three times. You're training a model that forgets everything the moment the context window closes.
What are the Camunda AI Skills
Camunda has closed that gap with the camunda/skills that are live on GitHub and can be used today. These are 11 official Agent Skills that teach AI coding agents how to build correctly on Camunda 8, following the open Agent Skills standard.
These skills aren't a Camunda-only trick baked into one vendor's assistant. They work with Claude Code, Cursor, GitHub Copilot, Codex, Gemini CLI, and any other compatible AI coding agent. You already picked a coding assistant. You don't have to switch it to work with Camunda skills.
The skills cover the surface area of building on Camunda 8:
- camunda-c8ctl — install and configure the CLI, spin up a local cluster
- camunda-bpmn — create and edit BPMN 2.0 process models
- camunda-feel — write and debug FEEL expressions
- camunda-dmn — author DMN decisions and business rule tasks
- camunda-forms — build Camunda Forms schemas
- camunda-connectors — configure pre-built connectors
- camunda-connectors-development — build custom connectors
- camunda-job-workers — implement job workers in Java, Spring Boot, or TypeScript
- camunda-ai-agents — construct agents inside a BPMN process
- camunda-development — choose the right integration approach before writing code
- camunda-docs — pull accurate answers straight from the official documentation
Each skill is scoped, so your AI agent applies the right knowledge at the right moment instead of dumping everything it knows on you.
The policy change process that I built
I needed to create a process that did the following:
- Takes in an auto insurance policy change request
- Looks up the existing policy for information
- Prechecks the policy holder to confirm they are in good standing without open claims or other issues
- Runs a preliminary risk score
- Executes the policy change, including:
- Validating the identity of new drivers
- Underwriting, including motor vehicle data and comprehensive loss information before any changes are applied
- Flagging an expert (human-in-the-loop) when unsure of steps to take
- Capturing duplicate requests
- Determining whether upselling opportunities exist for other offerings
- Summarizing the policy changes
- Based on the changes, binds the policy and tracks to a second AI agent to build a path for upselling new offerings
I also needed to capture the AI performance and metrics to display in a dashboard so that I could show how Camunda provides detailed agent auditing.
Simple to describe, easy to get wrong: the routing logic has to be right, the review step has to carry the right context, and the whole thing has to actually deploy and run, not just look correct in a diagram.
The resulting Policy Change process
I also had to showcase some specific Camunda features and functions including:
- Message correlation
c8ctlto start a process- REST connector
- Multi-agent orchestration
- RPA for a web application and desktop application
- Parallel routing
- Optimize dashboards
I asked for it in plain language and let the installed skills do the work. What came back wasn't a first draft I had to rebuild. It was close enough to correct that I spent my time reviewing and fine-tuning it, not fixing it. In fact, the results saved me the equivalent to a second engineer. I delivered in days instead of weeks, and that freed-up time let me build some really cool portals, chatbots, and other components on top of the foundation.
What I actually used, and what it did
This is the part that matters more than "it went faster." There were some specific things that I needed to create/build/show in the demonstration and the Camunda AI Skills were there to save the day. Here's exactly which skill did what:
One more, and it's worth calling out on its own: I also wanted a custom dashboard to track how the process was actually performing. That's not one of the 11 skills that ship in the camunda/skills repository. I built that skill myself, on top of the official set. The system is designed to be extended, and that's exactly what I did when I created the optimize-dashboard skill for this.
What actually got built
Here's what came out of it, piece by piece.
The process itself took shape in Modeler exactly the way I described it: submit a change, route by risk, land on a review step before anything's applied. The agent can call a human gate tool when it needs expert input before proceeding. That's orchestration from the inside.
BPMN Diagram for the Policy Change process
Part of the routing runs on a real decision table (DMN), not buried logic. By taking in risk scores, motor vehicle lookup results, comprehensive loss underwriting exchange results, and additional criteria, a decision risk is determined using business rules.
Decide on Risk DMN Table
And the metrics weren't invented for the post. This is Optimize, pulling real numbers off real runs over time.
AI Agent Tool Optimize dashboard showing tool calls made by agents
AI Agent Token Metrics with Optimize
Extra time, extra features
Because fixing the process was the exception when using the Camunda Skills, I wasn't spending my hours fixing gateway conditions or debugging agent tool calls. That time was well spent elsewhere. I was able to build the following:
- A custom portal for submitting (starting) the process and tracking requests
- A Risk & AI Operations dashboard pulling live metrics straight from Optimize
- A chatbot to request a policy change
- A message trigger to handle duplicate requests
That didn’t come from a skill, but it came from having time back because the skill-built foundation didn't need constant repair.
HTML Portal that starts Camunda process instances upon submission
HTML Portal for Risk and AI Operations for token usage and costs
A development pattern, not just a demo
Yes, I did build this process and all its features for a demonstration, but nothing about it is demo-only. What makes a gateway condition correct under deadline pressure is the same thing that makes it correct running in production for a thousand instances a day. What makes an AI agent's tool wiring reliable in a walkthrough is the same wiring you'd want running unattended in production.
The skills didn't know or care whether I was building a demo or something that ran in production. They applied the same BPMN, DMN, FEEL, and agent rules either way. That's the point. The skills enable development acceleration. If you can accelerate your development, weeks of build time turn into days, and that difference compounds across every process after this one.
Try this yourself
Start with Build with Camunda for the full developer journey, including a free-tier cloud cluster. Then follow this checklist:
- Install the skills. Register the camunda/skills marketplace, install the ones you need, or clone the repo directly.
- Start with something you already understand. A process you'd normally model yourself is the best test, because you'll know immediately if the output is right.
- Ask in plain language. Describe the process, the routing logic, and the review step. Let the skills pick the right building blocks.
- Don't expect magic on attempt one. Review what comes back the way you'd review a teammate's pull request. It'll be closer to right than you expect, not perfect by default.
- Push past the diagram. Deploy it. Run an instance. Check the incident if something breaks. That's where camunda-process-mgmt earns its place.
Don't start with something ambitious. Pick the process you already know like an approval chain, a support ticket router, or an onboarding checklist. Ask your AI agent to build it with the skills installed, then compare it against what you would have modeled yourself. That comparison is the real demo.
Camunda has spent years making process orchestration something you can trust at enterprise scale. Now your AI coding agent gets to build on that same foundation, correctly, from the first prompt.
But here’s the thing. The process I built here is structurally no different than the one sitting in your backlog right now. It might be the one you have been putting off because getting the routing logic correct or the agent wiring seemed more trouble than it was worth. Point your AI coding agent at it. Install the skills first. Then go build the process you're actually trying to ship, not just the one you're trying to demo.
The full set of camunda/skills is on GitHub. Build with Camunda is where to start if you're new to the platform.
