DEV Community: Dinesh Singh Panwar

The Agentic AI Juggernaut Stalled at the Enterprise Gate

Dinesh Singh Panwar — Sun, 28 Jun 2026 09:07:31 +0000

To make this concrete, we walk through a real enterprise workflow: sales document ingestion with PII redaction. The problem it illustrates is not specific to sales teams or an industry. It shows up in every agentic workflow that has ever been proposed and never made it past a governance review for enterprise scale implementation.

Condensed version. Full article at apmn.kshetra.studio/articles

The Gap Nobody Talks About

AI engineers are building sophisticated agentic workflows. Greenfield orchestration blueprints in LangGraph. Brownfield migration plans that wrap existing CRM and ECM systems with intelligent retrieval layers. The execution frameworks are mature. LangChain, LangGraph, Orkes Conductor are production-ready. The capability exists.

And then it hits the enterprise boundary.

Not because the technology is wrong. Because the artefact is wrong.

A board does not approve Python. A risk committee does not approve LangGraph node definitions. A Chief Compliance Officer does not approve YAML. Enterprise decision makers approve process flows. Structured abstractions that show sequencing, decision points, human oversight, and risk controls at a level they can read, question, and put their name to.

The AI engineer has a detailed execution blueprint. The board has a governance requirement. There is no shared language between them. So the agentic workflow sits in a proof of concept. It demonstrates well in a sandbox. It never reaches production.

That is why the agentic AI juggernaut has stalled at the enterprise boundary. Not capability. Not cost. Not risk appetite. A missing artefact.

APMN is that artefact.

The Business Problem

Your sales team generates documents constantly. Proposals, contracts, email threads, Salesforce attachments, shared drive files. Some contain customer PII: names, email addresses, phone numbers, financial account numbers, government IDs. Your organisation wants to vectorise that content for AI-powered knowledge retrieval so sales reps can search the entire document history and get relevant answers instantly.

The compliance question has to be answered before a single document is vectorised: how do you guarantee that PII never reaches the vector store unredacted?

This is not a question the AI engineer needs answered. They know how to write a redaction function. The question is for the board, the risk committee, and the data governance officer. They need to see, in a form they can evaluate and sign off, that the ordering is correct. Redact first. Vectorise second. Always. With no path through the workflow that bypasses that sequence.

If that ordering is enforced in code but invisible to the people who must approve it, the approval never happens. Or it happens on the basis of a PowerPoint that drifted from the implementation three sprints ago.

APMN solves this by making the ordering visible, structured, and executable from the same source.

What the Board Needs to See

Before any technical discussion, consider what a Chief Risk Officer or data governance committee needs in order to approve this workflow for production.

They need to know:

What triggers the workflow and what data enters it
At what point is PII detected and by what mechanism
What happens when detection is uncertain, and who decides
What is the guaranteed ordering between detection, redaction, and vectorisation
What happens when any step fails
Who is notified when the system cannot proceed automatically
How is every exception logged and tracked A LangGraph Python file answers all of these. Not in a form a risk committee can read in a governance meeting. Not in a form where a compliance officer can point to a specific node and say: this is the gate I required, and this is where it sits in the sequence.

APMN answers the same questions in a visual process notation enterprise decision makers already understand. The same source compiles directly to LangGraph scaffolding. The diagram the board approves and the code that runs in production are the same artefact at different altitudes.

The APMN Workflow

Export from APMN Modeler:bpmn2ai.kshetra.studio

View APMN YAML source and interactive build

The flow reads left to right. Every node type is drawn from the APMN v0.1 specification. The visual notation is BPMN-compatible, meaning any enterprise architect, BA, or process owner who has worked with Appian, IBM BPM, Pega, or Camunda can read this diagram without training.

What they will see that they have never seen in a standard BPMN diagram are the AI-native constructs: the confidenceGate, the escapeGate, and the humanInLoopTask. These are not cosmetic additions. They are the notation that makes probabilistic AI steps visible and governable at design time.

Walking the Board Through the Flow

Document detection. An mcpToolTask (task_crawl_source) pulls the raw document from CRM, email, or shared drive. The raw document has one outgoing path: to PII detection. Not to storage. Not to retrieval.

PII detection. task_detect_pii runs a language model and returns two things: detected PII spans and a confidence score for detection completeness. Not a binary yes or no. A probability. Detection might be 94% confident. Or 71%. Or 45%. Each outcome requires a different response.

The confidence gate. gw_pii_confidence routes on the confidence score:

Above 0.9: proceed to redaction
0.6 to 0.9: route to a human data governance reviewer before proceeding
Below 0.6: raise a ServiceNow exception ticket, document does not proceed A risk committee reading this diagram can see three defined responses to probabilistic output. No silent paths. No ambiguous routing. The thresholds are visible. The routing is explicit.

The board can negotiate these thresholds. Is 0.9 the right cutoff for financial documents or should it be 0.95? Is four hours the right human review window? These are governance decisions. They belong in the APMN source, set by the people accountable for them, enforced in the compiled output.

Human review with time boundary. task_human_review_pii is a humanInLoopTask with a four-hour timeout and escalate_to: gw_escape. If the reviewer does not respond within four hours, the document does not proceed. Human oversight is not optional and not open-ended.

Redaction. task_redact_pii produces a PII-clean copy. The original is never passed to any downstream node.

Parallel processing. After redaction, the workflow splits: the clean copy is embedded into the vector store and simultaneously filed in ECM with a retention policy. The split comes after redaction. There is no flow connection from any pre-redaction node to the vector store. The graph topology is the enforcement mechanism, not a comment in a Python file.

Quality grading. task_grade_quality verifies chunk coherence and ECM metadata completeness before the workflow declares success.

Escape gate. gw_escape watches five nodes throughout: task_detect_pii, task_redact_pii, task_vectorise, task_file_ecm, task_grade_quality. Any failure, timeout, or sub-threshold result raises a ServiceNow ticket. No silent failure mode.

The Executive Conversation This Diagram Enables

The APMN diagram is not just a technical specification. It is a negotiation surface.

A Chief Data Officer can point to gw_pii_confidence and ask: who set the 0.9 threshold, and on what basis? The answer belongs in the APMN source as a documented annotation, not in a developer's memory.

A General Counsel can point to task_human_review_pii and ask: what happens if the reviewer is on leave and nobody picks up the ticket in four hours? The answer is visible in the diagram: escape gate fires, ServiceNow ticket raised, document does not proceed. That satisfies a legal question without a conversation with the engineering team.

A risk committee can ask: show me every node where AI makes a probabilistic decision. The answer: one. task_detect_pii. Every other gate is either a deterministic condition or an external tool call. The scope of AI judgment is clearly bounded.

These conversations happen before a line of production code is written. When decisions change, they change in one place and the compiled output reflects them automatically.

From Diagram to Execution

The same APMN source compiles directly to LangGraph Python scaffolding via TwinTrack.

The confidenceGate becomes a conditional routing function evaluating task_detect_pii.output.confidence. The escapeGate becomes a supervisor node watching for failures across five monitored nodes. The humanInLoopTask becomes an interrupt point with a timeout escalation handler. The parallel split becomes a LangGraph fork with a synchronisation barrier at the join.

The developer receives a working scaffold. They do not re-derive intent from a requirements document. They implement detail inside nodes the diagram has already positioned, connected, and bounded.

When the compliance officer asks to see the production workflow, they see the same diagram. It did not become a fiction the moment development started.

What This Changes for Enterprise Agentic Adoption

The agentic AI juggernaut has not stalled because enterprises are slow or risk-averse. It has stalled because the artefact that enterprise governance requires has not existed for agentic workflows.

LangGraph is a brilliant execution framework. It is not a governance artefact. Orkes Conductor is a powerful orchestration engine. It is not a board-level sign-off document.

APMN is the missing layer. It speaks the visual language enterprise decision makers trust. It carries the AI-native constructs that make probabilistic steps explicit and governable. And it compiles to the execution frameworks developers are already using.

The gates open when the board can see what they are approving.

Full article: apmn.kshetra.studio/articles
APMN spec (Apache 2.0): apmn.kshetra.studio/spec/apmn-v0.1
Visual modeller: apmn-modeler.kshetra.studio
TwinTrack: bpmn2ai.kshetra.studio

Agentic AI in Mortgage Origination

Dinesh Singh Panwar — Mon, 22 Jun 2026 08:23:20 +0000

The Mortgage Process Already Knows Where AI Belongs

A technical guide to converting existing BPMN mortgage workflows to APMN for agentic AI

The Australian mortgage industry has significant AI investment and limited AI production deployment.

Most programmes are piloting document tools or building chatbots alongside existing processes. Few are asking the more productive question: what is already encoded in our existing process diagrams, and where does AI fit inside that?

Every lender running Appian, IBM BPM, Pega, or a comparable platform has BPMN diagrams for mortgage origination. Serviceability rules encoded. APRA CPS 234 requirements mapped. Exception paths tested against real borrowers over years.

Those diagrams are the starting point, not an obstacle to work around.

Where BPMN Falls Short for Mortgage AI

Income verification is probabilistic.

A human assessor reviews payslips, tax returns, and bank statements and returns a verified income figure. An AI model does the same work but returns a confidence-weighted output. BPMN cannot express "proceed if confidence above 90%, flag for assessor review if 70-90%, request additional documents if below 70%". Every implementation hacks this into service task variables and exclusive gateways -- obscuring the business logic and making the decision trail difficult to audit.

Document intelligence output is not a system event.

BPMN handles document receipt as a message event. AI document intelligence is different -- the model reads, extracts, validates, and returns a structured output that can be wrong. There is no BPMN boundary event for "the AI extracted an income figure that is implausible for the declared employment type". Catching this requires custom code that sits outside the process diagram and outside the audit trail.

APRA requires explainability. BPMN does not enforce it.

When AI is embedded inside a BPMN service task, the decision logic is invisible to the process diagram. The diagram shows "credit decision service task" and says nothing about which model ran, what version, what confidence it returned, or what the assessor was shown before approving. This is a governance gap regulators are focused on.

What APMN Adds

APMN -- AI Process Model and Notation -- is an open extension of BPMN 2.0 that makes AI a first-class citizen of the process diagram. Fully backwards compatible with existing BPMN tools.

Key constructs for mortgage:

ragTask -- retrieve financial context before assessment. Credit bureau data, ATO income data via CDR, previous application history, property records. The retrieval step is explicit in the diagram and in the audit trail.

agentTask -- AI performs the assessment. Specifies model, version, prompt context, and expected output schema. When a compliance officer asks what the AI assessed and why, the answer is in the process record.

confidenceGate -- route based on confidence score. Above threshold: straight-through processing. Mid-range: assessor review of AI output. Below threshold: full manual assessment. Thresholds are configurable by loan type, borrower segment, and regulatory requirement.

humanInLoopTask -- structured assessor review of AI output. The assessor sees the AI recommendation, the confidence score, the documents referenced, and the key factors driving the output. Every decision is recorded against the process instance.

escapeGate -- automatic fallback. If confidence drops below minimum, if the model times out, or if output fails structural validation, the escapeGate routes to the manual assessor queue. No application stalls because an AI component failed.

modelVersionGate -- run a new model version on a percentage of applications alongside the current model. Compare outputs. Validate before full deployment. This is how you upgrade your income verification model without a big-bang release.

Full spec at apmn.kshetra.studio/spec/apmn-v0.1

The TwinTrack Architecture for Mortgage

Foundational separation between AI infrastructure and deterministic infrastructure, joined by lightweight orchestration ramps.

Your existing mortgage process -- the one that passes APRA audits, that assessors know, that compliance has signed off -- runs on the reliable track. It does not change.

AI runs on the innovation track in parallel. On-ramps divert selected applications based on routing criteria: standard residential, PAYG borrower, complete documentation. Low-risk, high-volume, high AI confidence. Start here.

Off-ramp triggers: confidence below threshold, document anomaly, borrower segment outside training distribution, escapeGate fires. Any of these returns the application to the assessor queue on the reliable track.

As evidence accumulates -- comparing AI outcomes to assessor decisions on the same applications -- the routing criteria widen at a pace your risk committee controls. Self-employed borrowers added when confidence on that segment is validated. Complex income structures added later.

The governance surface is reduced because AI decisions are isolated from deterministic decisions. Each has its own audit trail, its own escalation path. Frictionless innovation on the AI track. Unconditional reliability on the deterministic track.

A Worked Example: Income Verification

Standard BPMN: assessor reviews payslips and tax returns, calculates verified income, records in origination system. One human task. High volume. Time-consuming.

In APMN with TwinTrack:

ragTask retrieves all income documents from document management, plus ATO tax return via CDR integration where available, plus any previous income assessments from prior applications.

agentTask extracts structured income figures from each document, reconciles across sources, identifies discrepancies, flags anomalies, calculates verified income per APRA serviceability guidelines. Output includes confidence score, extracted figures, and structured explanation of the calculation.

confidenceGate routes: above 92% on a standard PAYG borrower proceeds to serviceability calculation automatically; 75-92% presents AI assessment to assessor for review and confirmation; below 75% routes to full manual assessment with AI output available as reference only.

humanInLoopTask for mid-confidence cases presents the assessor with AI-calculated income, documents referenced, figures extracted, and plain-language explanation of discrepancies. Assessor confirms, adjusts, or overrides. Decision and reason recorded.

escapeGate catches document read failures, model timeouts, output validation failures, figures outside plausible range. All return to manual track.

The compliance record shows: model, version, confidence, documents referenced, what the assessor saw, what decision they made. The audit trail APRA expects.

Getting Started

Upload your existing mortgage origination BPMN to TwinTrack. It identifies every human task where AI can act, scores conversion confidence, and generates APMN output plus deployment-ready Orkes Conductor JSON.

You control the confidence thresholds, routing criteria, and pace of adoption.

APMN spec v0.1 (Apache 2.0): apmn.kshetra.studio/spec/apmn-v0.1
APMN visual modeller (MIT): apmn-modeler.kshetra.studio
TwinTrack, free to try: bpmn2ai.kshetra.studio

Full article with APRA governance framework: apmn.kshetra.studio

Dinesh Singh Panwar, founder of Kshetra Studio. Creator of APMN and TwinTrack. Former Head of Technology, Westpac Group. Founder of askmybank.ai, AI-native mortgage document intelligence for Australian brokers and lenders.

Agentic AI in Clinical Processes

Dinesh Singh Panwar — Mon, 22 Jun 2026 07:54:34 +0000

Your Clinical Processes Already Know Where AI Belongs

A technical guide to converting existing BPMN healthcare workflows to APMN for agentic AI

Most healthcare AI programmes start by asking the wrong question.

"Which AI platform should we adopt?" "What should we pilot?" "Let's build something new and see what sticks."

Meanwhile, sitting in a process repository, is a BPMN diagram for patient preadmission. Another for prior authorisation. Another for clinical triage. Each one represents years of institutional knowledge -- every compliance requirement codified, every exception path tested against real patients.

That knowledge gets ignored. Teams reinvent from scratch. Pilots stay as pilots.

There is a better starting point.

What BPMN Cannot Express

BPMN 2.0 handles deterministic healthcare processes well. Sequential care steps, parallel workstreams, human tasks, service calls, exception handling -- it covers all of this.

The problem is that AI agents are not deterministic. Three specific gaps matter for health:

Probabilistic outputs. A radiologist returns a diagnosis. An AI model returns a probability distribution. BPMN has no way to say "proceed if confidence exceeds 90%, escalate to clinician if below". Teams hack this into service task variables and exclusive gateways. It works but makes the decision trail hard to audit.

AI-specific failure modes. BPMN handles system failures well. It handles AI failures badly. There is no boundary event for hallucination, no error handler for model drift, no standard catch for "the model was confident but the output was clinically implausible".

Transition states. A hospital cannot flip a switch and hand clinical decisions to AI. BPMN has no concept of "run AI alongside human for six months, compare outcomes, then decide". A task is either human or automated. Nothing in between.

What APMN Adds

APMN -- AI Process Model and Notation -- is an open extension of BPMN 2.0 that addresses these gaps while remaining fully backwards compatible with existing BPMN tools and diagrams.

It uses BPMN 2.0's official extension mechanism. Your existing diagrams remain valid.

The key constructs for healthcare:

agentTask -- an AI model performs clinical reasoning, document analysis, or administrative processing. The model, version, prompt context, and output schema are explicit in the diagram.

ragTask -- retrieve clinical context before reasoning. Patient history, previous imaging, medication records, clinical guidelines. The retrieval step is a first-class process node, not hidden inside a service call.

confidenceGate -- route based on AI confidence score. Thresholds are configurable per process and per risk appetite. High confidence proceeds. Mid-range flags for clinician review. Low confidence falls back to the human task.

humanInLoopTask -- structured clinician review of AI output before the process continues. Designed specifically for AI oversight -- the clinician sees the AI recommendation, the confidence score, the source documents, and the key factors driving the output.

escapeGate -- automatic safety net. If AI confidence drops below a minimum floor, if the model times out, or if output fails structural validation, the escapeGate catches it and routes to the deterministic fallback. The reliable process that was running before AI was introduced.

modelVersionGate -- run two model versions in parallel on a percentage of cases and compare outcomes before committing to an upgrade across the full patient population.

Full spec at apmn.kshetra.studio/spec/apmn-v0.1

The TwinTrack Architecture

The architectural principle behind APMN adoption is foundational separation between AI infrastructure and deterministic infrastructure, joined by lightweight orchestration ramps.

Your existing clinical process -- the one that passes audits, that clinicians trust -- runs on the reliable track. It does not change.

AI runs on the innovation track in parallel. On-ramps divert selected cases to the AI track based on routing criteria you define. Off-ramps return cases to the reliable track if confidence drops or an escapeGate fires.

The separation means a failure in the AI track cannot propagate to the reliable track. Governance of AI decisions is isolated from governance of deterministic decisions. Clinicians trust the reliable track unconditionally -- which is the prerequisite for AI adoption in clinical settings.

As evidence accumulates, the routing criteria widen at a pace determined by your risk appetite.

A Worked Example: Patient Preadmission

Standard BPMN: receive referral, verify insurance, review medical history, assess clinical priority, schedule, confirm. Steps 2, 3, 4 are human tasks.

In APMN with TwinTrack:

Verify insurance: ragTask retrieves policy documents. agentTask verifies eligibility. confidenceGate routes on confidence score. escapeGate catches failures and returns to human task.

Review medical history: ragTask retrieves EHR records and clinical guidelines. agentTask summarises and flags risk factors. escapeGate validates output before it reaches the clinician. humanInLoopTask presents the AI summary alongside source documents for clinician sign-off.

Assess clinical priority: agentTask applies urgency scoring. confidenceGate routes high-confidence scores to expedited scheduling, borderline scores to consultant review, low confidence to the human task on the reliable track.

Steps 1, 5, 6 are unchanged. The business logic and compliance requirements are unchanged. Three bottlenecks now have AI handling preparation work, with human oversight calibrated to confidence level and clinical risk.

Full worked example with before/after diagrams at apmn.kshetra.studio/examples/patient_preadmission

Getting Started

Upload your existing BPMN to TwinTrack. It identifies every human task where AI can act, scores conversion confidence, and generates APMN output plus deployment-ready Orkes Conductor JSON.

You control the confidence thresholds, the routing criteria, and the pace of adoption.

APMN spec v0.1 (Apache 2.0): apmn.kshetra.studio/spec/apmn-v0.1
APMN visual modeller (MIT): apmn-modeler.kshetra.studio
TwinTrack, free to try: bpmn2ai.kshetra.studio

Full article with regulatory context and governance framework: apmn.kshetra.studio

Dinesh Singh Panwar, founder of Kshetra Studio. Creator of APMN and TwinTrack.Former Head of Technology, Westpac Group.