Paste, upload, or photograph
Text SOPs, BPMN/XML files, PDFs, Visio drawings, or images of process diagrams — vision extraction converts them to structured ProcessFlow with steps, decisions, and swimlanes you preview before running.
Workflow Transformation ProtocolSource-grounded
From process evidence to code you own.
Paste an SOP, upload a BPMN file, or drop in a photo of the whiteboard — vision extraction turns process diagrams into structured flows. The protocol builds your workflow as a deterministic state machine, quantifies the friction, models the automation ROI honestly, and ships the redesign as runnable LangGraph code plus a deployable Google ADK agent wired to Sentinel governance. A consulting firm hands you a target-operating-model deck you then pay someone else to build. MCOS ships the build.
Process transformation
Live68%
Automation
potential
$540K
Annual savings
01Map process evidenceDone
02Redesign for automationDone
03Scaffold the agentActive
04Deploy under governanceNext
Scaffolds generated
API stubsState machineTest harnessOwner map
68%
Automation
4
Steps
4
Scaffolds
$540K
Savings
Operating flow
Evidence becomes operating state.
The protocol structures source evidence, applies its method, records management actions, and updates the resulting operating state.
Deterministic graph construction
Steps, actors, and handoffs become a connected state machine — prose decisions become real conditional edges with labeled branches, and every node is reachable by construction.
Honest automation economics
Friction points carry annual-cost quantification. The ROI model declares its basis: grounded when your document states step durations, clearly labeled ILLUSTRATIVE when modeled from defaults.
The five-module workspace
Executive Dashboard, Workflow Graph, Friction Points, ROI Model, and Code Output — plus a live analysis chat grounded in your run.
Export and deploy
Copy the LangGraph code, download the Studio bundle, or generate a Google ADK agent scaffold with a Vertex deploy script, a smoke test, and Sentinel governance wiring — then provision it in Agent Fleet.
Vudu Copilot
A live analysis chat grounded in your specific run. Answers stay tied to your deterministic workflow graph and friction analysis, not a generic best-practices response.
Workspace modules
The durable asset is the working system behind the report.
Dashboards and exports matter. The deeper value is the structured evidence, operating state, decision logic, and management workflow that can be revisited and updated.
Executive Dashboard
01Automation rate, annual savings, ROI, and the top friction costs — every figure marked grounded or illustrative.
Automation %SavingsROI basis
Workflow Graph
02Your process as an inspectable state machine — decision diamonds, conditional branches, human-in-the-loop nodes.
D3 graphDecision diamondsClick-to-inspect
Friction Points
03Bottlenecks, manual handoffs, and rework with annual-cost quantification and severity.
BottlenecksAnnual costSeverity
ROI Model
04CapEx and OpEx savings with payback math — and an explicit basis declaration, never silent assumptions.
PaybackGrounded vs illustrativeAssumptions listed
Code Output
05The generated LangGraph implementation with conditional routers, parallel splits, and interrupt-before human gates.
PythonConditional routersHuman gates
Management actions
A correction should change the operating record.
Validations, owner assignments, risk decisions, and approved changes are operating events. They should update the underlying state rather than remain comments beside a static report.
Management action → state update → recalculated dashboard → revised output.
Set Your ROI Parameters
Recalculates state
annual volumeshourly ratesCapEx per nodethe whole ROI model
Run the Transformation
Recalculates state
workflow graphfriction mapautomation splitgenerated code
Tag Into an Engagement
Recalculates state
suite aggregatesgrounded vs illustrative savings split
Generate the ADK Scaffold
Recalculates state
deployable agent packageSentinel governance wiringAgent Fleet handoff
Operating view
The redesign ships as artifacts, not slides.
Every run produces implementation-ready outputs you own — constructed deterministically from your process, with no model generating the graph or the code.
Artifact
What it is
Construction
LangGraph code
The workflow as runnable Python
Deterministic — no model in the loop
Studio bundle
workflow.py + langgraph.json + requirements + env template, zipped
Deterministic
Google ADK scaffold
Vertex AI agent package with deploy script, smoke test, Sentinel wiring
Deterministic
Slide prompt
A grounded ten-slide executive brief prompt, copied to your clipboard
Grounded template
Inside the dashboard
Five modules, from friction map to running code.
Every workflow run opens as a redesign workspace. The graph and the code are constructed deterministically from your process, and the ROI model declares its basis — grounded in your document's stated durations, or clearly labeled illustrative.
Executive Dashboard
01Automation rate, annual savings, ROI, and the top friction costs.
Large-metric grid with synthesis
Workflow Graph
02The process as a state machine you can inspect node by node.
D3 process graph, click-to-inspect
Friction Points
03Bottlenecks with annual-cost quantification and severity.
Ranked friction list
ROI Model
04CapEx and OpEx savings, with the payback math.
Financial waterfall
Code Output
05The generated implementation, ready to run.
Python LangGraph code panel
Generate from the redesign
Implementation-ready scaffolds you own.
The redesign ships as artifacts you run, not slides about them. The graph and the code are built without a model in the loop, so they are accountable by construction.
Generative: grounded copilot outputPrompt: grounded handoff to another toolExport: structured file or scoped document
Slide Prompt
PromptA grounded ten-slide executive brief for the redesign, copied to your clipboard.
LangGraph Code
ExportThe workflow as runnable Python, built with no model in the loop.
Studio Bundle
Exportworkflow.py plus langgraph.json, requirements, and an env template, zipped.
Google ADK Scaffold
ExportAn ADK agent package for Vertex AI Agent Engine, wired to Sentinel governance.
The ADK scaffold deploys to Google Vertex AI Agent Engine and ships with a Vertex deploy script and a smoke test.
Why it holds up
The redesign ships as code, not a recommendation.
Deterministic construction
The workflow graph and the code are built from structural analysis of your process, with no model generating them.
The artifact, not a slide about it
The redesign ships as code you own and run, accountable by construction rather than by assertion.
The ROI model declares its basis
Grounded when your document states step durations; clearly labeled ILLUSTRATIVE when modeled from defaults — never silent assumptions.
Governed by Sentinel
The agent you scaffold is wired to the MCOS Sentinel governance server, so every action is checked against the contract at machine speed. Sentinel runs the same deterministic engine on Google Cloud Run and as an Amazon Bedrock AgentCore runtime.
These mechanisms are engineered to enforce accuracy by construction, but the system is under continuous improvement, and defects are corrected as they surface.
Governed workflow deployment
From verified process to software you can inspect and operate.
The protocol can produce a deployment package containing decision logic, human approvals, governance wiring, implementation assets, and verification scaffolds. The seams stay visible so engineering teams can review what is complete, what is configured, and what still needs work.
01
Documents & diagrams
SOPs, PDFs, Visio, whiteboard photos
02
Verified process graph
Steps, actors, decisions, loops
03
Decision logic & gates
Routers, approvals, holds
04
Executable LangGraph
Runnable code with labeled functions
05
Agent + governance
ADK scaffold wired to Sentinel
06
Deployment package
Deploy script, smoke test, environment seams
07
Customer-owned logic
Inspect it, run it, retain it
Inspect locally
LangGraph Studio Bundle
A runnable local project for opening the graph visually, stepping through nodes, exercising human-gate interrupts, and reviewing the dependency manifest and integration configuration.
Prepare for deployment
Agent Scaffold + Governance
An agent scaffold, workflow package, deployment seam, smoke-test scaffold, and Sentinel governance integration that engineering teams can validate in their own environment.
Governance properties
What “governed” means in the package.
These are implementation properties that can be inspected in the generated artifacts rather than branding claims layered on top of them.
Human gates the graph cannot skip
Payment decisions and review steps compile as LangGraph interrupts. The workflow pauses at an approval checkpoint until an authorized human resumes it.
Every function declares its provenance
Generated functions identify whether their logic came from a curated library pattern, a source-grounded suggestion requiring review, or an explicit TODO where the source did not define the rule.
Business rules come from the source
Thresholds, timeframes, and classification criteria must come from the process evidence, workflow state, or configuration. Unsupported policy constants are not treated as verified rules.
External integrations stay explicit
Generated code avoids hidden model calls, hardcoded URLs, and embedded credentials. External I/O runs through named configuration seams that can be inspected and tested.
Sentinel governance wiring
The agent scaffold can route consequential actions through Sentinel policy checks so approvals, holds, and governance outcomes remain part of the execution record.
Package contents
Files the build team can inspect.
The exact package varies by workflow and deployment target. The point is to hand off implementation artifacts, not only a process diagram.
| workflow.py | Executable LangGraph state machine with nodes, routers, loops, and human-gate interrupts |
| agent.py | Agent scaffold that routes work through the workflow and governance checks |
| deploy.py | Deployment script with explicit environment and infrastructure seams |
| smoke_test.py | Post-deployment verification scaffold |
| requirements.txt | Authoritative dependency manifest for the shipped files |
| .env.example | Documented integration variables and configuration seams |
| langgraph.json | LangGraph Studio configuration for local inspection and iteration |
Implementation boundary
Generated packages are reviewable implementation starting points, not automatic claims of production readiness. Rules the source does not define should remain explicit TODOs or configuration requirements. Financial assumptions should be labeled as grounded or illustrative so technical and finance reviewers can see the boundary.
Governed output layer
A workspace, running code, and a deployable agent.
Workflow Transformation produces the friction analysis, the honest ROI model, and the redesigned workflow as code you own and run — accountable by construction, so the result is the artifact, not a slide describing it. Group runs by engagement and the suite view splits grounded savings from illustrative ones.
Output package
Five-module analysis workspace
Workflow graph with conditional branches
Friction points with annual costs
ROI model with declared basis
Runnable LangGraph code
Studio bundle (zip)
Google ADK agent scaffold (zip)
Ten-slide executive brief prompt
Engagement suite comparison view