CN / EN
↑/↓ Vertical details · ←/→ Sections
Dify × AISPEECH · AI Workflow

AI Workflows for
High-Frequency Enterprise Pain Points

Turn cross-team repetitive actions into reusable templates,
and connect LLMs, AISPEECH, and enterprise systems with Dify orchestration

5
Core workflows
8+
Roles covered
4
Weeks to rollout

Speaker: Zheng Li · DevRel @ Dify

01 · One Slide

Let Numbers & Formulas Clash

Value Equation
\( \textbf{Value} = \text{Frequency} \times \text{Time} \times \text{Scale} \times \text{Automation} \)
Turn every repetition into a reusable template; turn every output into a traceable closed loop.
Core thesis: Workflow orchestration + System integration + Governance & ops
Use cases
5
workflow templates
Coverage
8+
roles reusing
Savings
1000+
hours saved / year
Payback
3–6
months
Numbers are not decoration: every use case is bound to input → decision → output → loop and measurable KPIs.
01 · Key Numbers

Put Value Into 6 Numbers

Efficiency 01
1000+
Hours saved / year
Rolling estimate by role × frequency
ROI 02
3–6
Months to payback
Hours saved × labor cost
Reuse 03
8+
Roles reusable
Template-first reuse
Adoption 04
≥90%
Adoption / receipts
Read → confirm → execute
Consistency 05
≥95%
Completeness / consistency
Definitions + field completion
Risk 06
< 5%
Legal false positives
Rules + eval-gated
Next: make KPIs observable dashboards (not slogans)
01 · Community

Community-driven · globally adopted

Open-source first momentum: a GitHub Top-100 repo by stars with compounding reach.

INSTALL
1M+
Powered by Dify
POPULARITY
120K+
GitHub stars
GLOBAL REACH
150+
countries / regions
ENTERPRISE
60+
industries
CONTRIBUTORS
1000+
open-source builders
DOWNLOADS
550M+
total installs
Community gravity compounds workflows, plugins, and success stories.
01 · Pain Map

The Same Actions, Rebuilt by 8+ Roles

Hidden annual cost (example)

Info sync / version alignment
~200h
Data prep / reporting
~300h
Q&A / SOP coaching
~400h
Ticket/Bug triage & routing
~150h
Meetings / action tracking
~100h

Note: illustrative estimates to quantify prioritization.

Condense into 5 reusable workflows

Sync Officer
multi-version summaries · receipts
Auto Analyst
clean → explain → report
Knowledge Q&A
RAG + SOP · traceable answers
Bug Intake
cluster/score · auto routing
Meeting PMO
structured notes · action tracking
For each use case: workflow, key nodes, KPIs
01 · Why Now

Why It Scales Now

Model capability

Summarize, extract, classify, route, and generate structured outputs—now stable and reusable.

ExtractClassifyGenerateEvaluate

Tools & systems

IM, calendars, JIRA, ticketing, and BI all have APIs—turn “manual ops” into “automated chains”.

WebhookHTTPDBPlugins

AISPEECH boost

Speech → text (speaker diarization + timestamps) makes meetings orchestratable and traceable.

ASRDiarizationTimestamp
Prerequisites to scale: observable, auditable, iterable
01 · Method

From Actions to Templates: A Closed Loop

Which one first?

Priority score
\( \textbf{Priority} = \text{Frequency} \times \text{Time} \times \text{Reusability} \times \text{Measurability} \)
Pick “high frequency + high time cost + high reuse + measurable” to earn trust and budget fastest.
Frequency Time Reuse Measurable

Deliver a library, not a one-off

1 Identify actions
2 Orchestrate
3 Integrate
4 Observe KPIs
5 Iterate ops
Deliverables: workflow templates + prompt templates + knowledge assets + eval sets
02 · 5 Workflows

One skeleton: input → processing → output → closed loop

Trigger

event / message / schedule

Context

files / links / data

Transform

extract / classify / summarize

Tools

HTTP / DB / plugins

Output

IM / JIRA / docs

Loop

receipts / metrics / audit

For each use case: pain + KPIs, workflow, and loop + integration
01
02 · Use Case 1

Sync Officer: Version Drift & Slow Confirmations

Pain (who pays the cost)

  • Repeat the same message to execs, operators, and external partners
  • Definitions drift in transit; versions scatter across IM/email/docs
  • No read receipts: hard to confirm “read / understood / executed”
ProductBizHRAdmin

Target KPIs (4 numbers)

Sync time↓70%
Receipt rate≥90%
Alignment disputes↓80%
Traceability100%
Current: 1–2 days feedback cycle (no receipts)
02 · Use Case 1 · Workflow

Multi-version summaries + receipt loop

Trigger

meeting / IM / email

Context

collect files / links

Segment

audience routing

Generate

multi-view summaries

Deliver

IM / email / groups

Receipts

confirm / ask

Archive

versioned log


trigger: webhook(meeting_end) | slash_command(/sync)
steps:
  - collect_context: fetch(attachments, links, participants)
  - segment: classify(management | execution | external)
  - generate: llm.generate(template_by_audience)
  - deliver: send(im/email, read_receipt=true)
  - close_loop: remind_unread + archive(version, confirmations)
02 · Use Case 1 · Loop

Make “did you read it?” an observable metric

Deliverables

  • Role-based summaries: exec / ops / external
  • Version IDs + change diff
  • Receipt list: unread / read / pending-confirm
Integrations: calendar, IM, email, docs

KPI dashboard (example)

Sync time↓70%
Receipt confirmation≥90%
Alignment disputes↓80%
Full trace100%
02
02 · Use Case 2

Auto Analyst: Inconsistent Definitions, Rebuilt Charts

Pain

  • Cleaning, definition alignment, and insights rely on personal experience
  • Rewriting “why up / why down” reports again and again
  • Frequent changes: definition drift makes conclusions non-reproducible
Input: BI / DWH / CSV · Output: charts + insights + definition notes

Target KPIs

Time to report↓80%
Definition consistency≥95%
Anomaly recall≥90%
Error rate↓60%
02 · Use Case 2 · Tension

Who Owns the Narrative: Anomaly Detection + Contribution

Core formula
\( z = \dfrac{x-\mu}{\sigma} \Rightarrow \text{z-score anomaly} \)
Find “what’s abnormal”, then “who caused it” (ranked by contribution), and write the explanation into the report.
The key is not “compute it”, but reproduce it: definition version + lineage + report versioning

Contribution breakdown (illustration)

Channel A
0.68
Region B
0.34
Category C
0.22
Other
0.12

Note: contribution is for illustrating the report structure; actual computation depends on definitions and data sources.

02 · Use Case 2 · Workflow

Clean → Detect → Explain → Report

Data

BI / DWH

Clean

definition alignment

Anomaly

detect / cluster

Attribute

contribution

Report

charts + insights

Distribute

IM / email

Critical loop: definition changes must pass an eval gate (otherwise reports “look right, but are wrong”)
03
02 · Use Case 3

Knowledge Q&A: Expert Time Gets Fragmented

Pain

  • Answering the same basics repeatedly (policies / processes / clauses)
  • SOPs scattered everywhere; search cost is high
  • Inconsistent answers create compliance risk
  • Legal is high-frequency: clause questions, duplicated review notes, inconsistent approval standards
Current: 50+ repeated questions/day

Target KPIs

Self-serve resolution≥60%
Knowledge hit rate≥85%
Satisfaction≥4.0/5
Expert time saved50%+

Legal extensions: review time ↓ 60% · false positives < 5% · first-pass approval ↑

02 · Use Case 3 · Workflow

RAG + SOP: Traceable Answers, No Hallucinations

User question
→
Dify Agent
→
Structured answer (with citations)
↓↑
Policy library
SOP library
FAQ library
Clause library

Intent

classify

Retrieve

Top-K

Compliance

sensitive filter

Respond

cite sources

Legal example: clause questions / review outputs

Input (question / excerpt)

  • “Can the liability cap be written as unlimited liability?”
  • “Is the cross-border data clause missing? What should we add?”
  • “Do the payment terms violate our procurement SOP?”

Output (structured + cited)

  • Red flags: high-risk clauses (reason + suggested replacement)
  • Evidence: templates / policy clauses / checklists (with links)
  • Next: generate redline → request approval → audit trail

Note: this is for illustrating workflow and output format; legal decisions follow your company’s legal policy.

02 · Use Case 3 · Legal Workflow

Contract Review Copilot: Locate → Score → Redline

Workflow (illustration)

Input

contract / PDF / text

Structure

clauses / parties / amounts

Red flags

rules hit

Score

risk 1–5

Redline

replace suggestions

Approve

OA + audit archive

Outputs must include citations: templates / checklists / policy clauses (traceable).

Output (easy to verify)

Review time↓60%
Red-flag recall≥95%
False positives< 5%
First-pass approval↑
Integrations: contract system, OA approvals, seals, archiving
02 · Use Case 3 · Loop

Answer Quality Isn’t a Feeling: Turn Feedback into an Eval Set

Deliverables

  • Structured answers + citations + related SOP links
  • Unanswerable: route to humans + collect unanswered questions
  • Conversation logs for evaluation and knowledge updates
  • Legal extensions: review checklist + risky clause locating + redline suggestions
Integrations: IM bot, ticketing, portal, contract/OA approvals

Quality loop (critical path)

1 User feedback
2 Sampling review
3 Eval set
4 Knowledge/prompt update
5 Regression
The eval set is the moat: it gets better with usage
04
02 · Use Case 4

Bug Intake: Mis-triage, Missing Info, High Rework

Pain

  • Incomplete reports: missing repro info causes back-and-forth
  • Duplicates everywhere: the same bug is filed multiple times
  • Unclear severity: wrong routing drives 30%+ rework
Current: 30%+ rework

Target KPIs

Triage latency↓70%
Info completeness≥95%
Mis-triage↓80%
Rework rate↓60%
02 · Use Case 4 · Tension

Rules × LLM × Similarity Clustering: Make Triage Explainable

Decision formula (example)

\( \textbf{Priority} = \text{RuleScore} + \text{LLMScore} + \text{SimBoost} \)
  • Rules: keywords / blast radius / version matching
  • LLM: severity, module ownership, follow-up questions
  • Clustering: merge duplicates, reduce noise

Not “auto”, but “auto + rollback”

Auto-fill Confidence threshold Human fallback Audit trail
Low confidence → auto handoff to humans; don’t bet critical paths on probability
02 · Use Case 4 · Workflow

Auto triage + completion + routing (write back to JIRA)

Intake

ticket / form

Structure

extract fields

Cluster

merge similar

Score

rules + LLM

Route

owner / team

Write back

JIRA / ticket

Metrics: triage latency, mis-triage rate, completeness, rework (by team/module)
05
02 · Use Case 5

Meeting PMO: Notes Take Forever, Actions Get Lost

Pain

  • Too many meetings: 8+/week, notes are manual
  • Actions are unstructured: owner / due date / dependencies missing
  • No escalation: tracking relies on “people remembering”
Current: 8+ meetings/week

Target KPIs

Note time↓90%
Miss rate↓80%
Completion↑40%
Re-alignment↓50%
02 · Use Case 5 · AISPEECH

Turn Speech into Orchestratable Events: ASR + Diarization + Timestamps

Audio pipeline (traceable)

Audio

meeting recording

Transcribe

ASR

Diarize

speaker

Timestamp

deep-linkable

Output: timestamped transcript + paragraphing (evidence you can trace back)

What meeting text can do (usable today)

Agenda extraction Decisions Action items Risks / open items
Structured output template
Turn notes into data: owner / due date / deps / evidence links (timestamps)
Auditable: every conclusion links back to the original sentence
02 · Use Case 5 · Workflow

Structure notes → Split actions → Remind & escalate

Trigger

meeting ends

ASR

AISPEECH

Structure

topics / decisions

Actions

owner / due date

Write back

JIRA / IM

Remind

overdue escalation

Metrics: note time, miss rate, completion, overdue rate, # follow-up meetings
03 · Platform Base

Dify Workflow: Productize Workflows

Input layer
Calendar events
IM messages
Email
Tickets
Dify Workflow
IF / Switch
Code (JS/Python)
Tools / HTTP / DB
Multi-LLM
RAG / KB
Tracing
Plugin ecosystem: 100+ tool integrations (extensible)
Output layer
IM / Email
JIRA / Tickets
Docs / Reports
Metrics writeback
03 · Integrations

Connect AISPEECH + Enterprise Systems: One Orchestration Layer, Bi-directional Writeback

Calendar
IM
Email
JIRA
Tickets
BI
↓
Dify Workflow orchestration layer
↓
LLM
AISPEECH ASR
Knowledge base
DB / object storage

Event entry

  • Schedules, webhooks, message events, status changes
  • Audio upload / meeting-end triggers ASR

Writeback loop

  • Write back: JIRA/tickets/docs/BI metrics
  • Track: receipts, overdue reminders, SLA
03 · Legal Integrations

Contract / OA Compliance Chain: Review → Approve → Audit

System connections (examples)

Contract system OA approvals Seals/signing Archiving DLP/masking Audit logs
Triggers: contract upload / approval routing / signing complete

Standard outputs (easy to verify)

  • Risk scoring: levels 1–5 + evidence
  • Redline suggestions: replacement text + exact location
  • Approval suggestions: whether legal/executive signoff is required
  • Audit trail: review versions, annotations, signed attachments archived
03 · Legal Template Library

Turn Review Experience into Reusable Templates & Checklists

Contract-type templates

  • Procurement / sales / NDA / outsourcing
  • Clause order + required fields
  • Mandatory approval paths

Red-flag checklist

  • Unlimited liability / caps
  • Cross-border data / subcontracting
  • Non-compete / IP ownership

Evaluation & gates

  • False positive < 5% (example)
  • Changes must pass eval sets
  • Rollbacks are available
Templates + checklists + eval sets = scalable legal ops
03 · Assetization

Turn Experience into a Repeatable Four-Pack

Workflow templates

YAML/visual orchestration: inputs, nodes, outputs, and loops.

Prompt templates

Versioned by role/use case/definitions; supports gradual rollout and rollback.

Knowledge assets

Policies/SOP/FAQ/definitions with governance and access control.

Eval sets

Golden set + production sampling: make quality measurable and verifiable.

A template library is a compounding engine at scale
03 · Observability

Observable + Auditable: Make AI an Engineering System

Suggested metrics

LatencyP95 / peak
Costtokens / call
Retrieval hitRAG hit
Adoptionreceipts/exec
Qualitysample/eval

Governance controls

  • Access control by role, system, and data domain
  • Masking at field-level with rules + model filters
  • Multi-model fallback configurable for critical paths
  • Change gates: templates/definitions must pass eval sets
“It runs” isn’t enough—you need “it’s controllable”
03 · Risks & Mitigations

Make Rollout Safer: Risks → Mitigations

Data security

Private/dedicated deployment; sensitive field masking; audit log retention.

Definition drift

Versioned knowledge + eval gates; every change must be regression-safe.

Model stability

Caching/multi-model fallback; rule-based safeguards on key nodes.

Adoption

Bind every workflow to an owner + KPIs; weekly ops cadence; template marketplace reuse.

04 · 4-week rollout

From One Workflow to a Reusable Template Library

Week 1

Select one scenario · sample data · build the MVP

Flow readyDefine metrics

Week 2

Integrate with systems · pilot in a small cohort · close the loop

WritebackReceipts

Week 3

Expand to 3–5 scenarios · templatize · build evaluation sets

TemplatingEval set

Week 4

Governance & ops · assign owners · publish dashboards

AuditOps
Deliverables: template library + metric dashboards + ops/audit playbook
04 · ROI

Quantify the Payback: ROI Is Not a Slogan

ROI formula
\( ROI = \dfrac{(\text{Hours Saved} \times \text{Labor Cost}) - \text{Platform Cost}}{\text{Platform Cost}} \)
Tie every workflow’s hour-savings to measurable KPIs (receipts/completeness/error rate) to earn trust and reusability.
1000+
Hours saved / year
3–6
Months to payback
8+
Roles covered

Payback curve (illustrative)

Benefit
Break-even: Month 3–6

Illustrative only: plug in team size and labor cost for actual numbers.

04 · Breakdown

Where Payback Comes From: Cost × Output × Adoption

Cost structure (example)

Model callsCap & tune
Storage / retrievalTiered
Integration opsTemplated
Governance & auditNon-negotiable
Cost levers: rate limits, caching, batch ops, fallback strategies

Revenue levers (example)

Hours savedQuantified
Error reductionTraceable
Adoption / receiptsClosed loop
Template reuseScaled
Key: make “is it used?” an instrumented metric, or compounding never happens
04 · Operating model

Who Maintains It? How Does It Get Better?

Owner model

Bind every workflow to an owner + KPIs: adoption, quality, cost.

Weekly cadence

Weekly review: metrics → root cause → template/knowledge updates.

Template marketplace

Reuse beats rebuilding: share templates to avoid duplicated work.

Destination: workflows become the organization’s operating system

Q & A

Don't Panic.

banana@dify.ai

Xiaohongshu QR Xiaohongshu
Bilibili QR Bilibili