From data mining to machine learning to autonomous systems — perhaps our process models need to evolve again.

There is a question I have been thinking about for a while:

Do we need a new CRISP-like process model for the Agentic AI era?

Maybe something like CRISP-Agentic AI.

I don’t mean this as a finished framework, a new methodology, or a proposed standard.

Not yet.

I mean it as a question worth investigating.

Because when we look at the history of data and machine-learning projects, an interesting pattern appears:

When the nature of the problem changes, eventually the process used to solve that problem changes too.

CRISP-DM emerged to give data-mining practitioners a common, cross-industry way of structuring their work.

CRISP-ML(Q) later responded to challenges that became important when machine-learning applications moved beyond traditional data-mining projects.

Today, Agentic AI is introducing another set of problems.

And I think the first thing we should ask is not whether we can fit agents into our existing processes.

It is whether the object we are engineering has changed enough to require a new process model.

What CRISP-DM Actually Gave Us

CRISP-DM was valuable not simply because it created a diagram with six phases.

It created a shared language for a class of problems.

The familiar lifecycle was:

Business Understanding → Data Understanding → Data Preparation → Modeling → Evaluation → Deployment

But CRISP-DM was never intended to be a rigid waterfall.

The process was iterative. Teams could return to previous phases when new findings changed their understanding of the problem or the data.¹

More importantly, CRISP-DM was designed to be largely independent of a particular industry, tool, or application.

That is what made the Cross-Industry part meaningful.

A telecommunications company and a retailer might have completely different business problems, datasets, and models.

But they could still share a common process language.

CRISP-DM also started with something that remains surprisingly easy to forget:

the business problem.

The objective was not to build a model.

The objective was to understand a business objective and translate it into a data-mining problem that could eventually create value.

This distinction matters for what comes next.

Then the Problem Changed

Machine-learning applications introduced new concerns.

A model was no longer necessarily an analysis artifact used once and forgotten.

It could live in production.

The environment could change.

Data distributions could shift.

Model performance could degrade.

Quality assurance had to extend beyond checking whether a model produced a good result during development.

Monitoring and maintenance became part of the lifecycle.

CRISP-ML(Q) was proposed to address these and other machine-learning-specific requirements while preserving the idea of an industry-neutral process model.²

Its contribution was not:

“CRISP-DM was wrong.”

It was closer to:

“The problem domain has evolved, and the existing process model does not explicitly address several important characteristics of ML applications.”

That is the pattern I find interesting.

The process evolved because the engineering object evolved.

And I believe Agentic AI is creating the same situation again.

The Thing We Are Building Has Changed Again

A traditional machine-learning system can be simplified as:

Input → Model → Prediction

Of course, real ML systems are much more complicated.

But the primary role of the model is generally to produce some form of prediction, classification, recommendation, ranking, or generated output.

An agentic system introduces a different loop:

Goal → Context → Plan → Tool → Action → Observation → Evaluation → Adaptation

And then the process can continue.

The important difference is not simply that the underlying model is more capable.

The difference is that the system can increasingly decide and act.

An agent can:

retrieve information,

choose between tools,

interact with external systems,

maintain state,

change its plan,

execute actions,

observe their consequences,

collaborate with other agents,

and decide whether to continue, escalate, or stop.

AgentOps research already treats LLM agents as compound systems involving models, goals, plans, tools, knowledge sources, workflows, and runtime interactions rather than as isolated models.³

This changes the process problem.

A model can make an incorrect prediction.

An agent can make an incorrect prediction and then act on it.

That action might be harmless.

Or it might change production code.

Issue a refund.

Modify a CRM record.

Send a customer communication.

Trigger an ERP workflow.

Access sensitive information.

Spend money.

The primary engineering object is therefore no longer only the model.

It is becoming a decision-and-action system.

And I think that is where a CRISP-like process model may need to evolve again.

The First Question May Need to Change

CRISP-DM begins with Business Understanding.

That principle should absolutely remain.

But Agentic AI introduces another question very early in the process:

Should this problem have agency at all?

Today it is easy to start with:

“We could build an agent for this.”

But technical feasibility should not automatically imply that agency is appropriate.

Perhaps deterministic software is enough.

Perhaps a traditional workflow is enough.

Perhaps RAG is enough.

Perhaps AI should recommend while a human decides.

Perhaps the system should execute only low-risk actions.

Perhaps no autonomous action should be allowed at all.

So Business Understanding may need to expand toward something like:

Business & Agency Understanding

What business outcome are we trying to create?

Why does this problem require an agent?

What value does autonomy actually create?

Which decisions can be delegated?

Which actions can be delegated?

What is the consequence of a wrong action?

Is that action reversible?

Where must human authority remain?

Who owns the final outcome?

These are not model-selection questions.

They are process-design questions.

We are no longer only deciding how intelligence should work. We are deciding what authority intelligence should receive.

Why This Is a Cross-Industry Problem

This is also why I don’t think Agentic AI can be treated only as a Software Engineering problem.

The underlying technical implementation may be similar across many domains.

But delegated agency immediately creates process questions across the organization.

Consider a few examples.

Software Engineering

An agent can inspect a repository and suggest code.

But can it modify code?

Merge a pull request?

Deploy to production?

Run a database migration?

Respond to an incident?

CRM and Sales

An agent can recommend that a salesperson contact a customer.

But can it create an offer?

Change a discount?

Update the CRM?

Send the customer a message?

Finance

An agent can analyze a financial scenario.

But can it modify a forecast?

Initiate a payment?

Move a budget?

Approve a transaction?

HR

An agent can summarize applications.

But can it rank candidates?

Reject one?

Generate performance feedback?

Take an action that affects an employee?

Marketing

An agent can generate campaign ideas.

But can it publish them?

Change campaign budgets?

Communicate publicly on behalf of the organization?

ERP and Operations

An agent can identify an inventory problem.

But can it place an order?

Change a production plan?

Modify a supply-chain workflow?

These are very different business domains.

But underneath them is the same process question:

How should we design, evaluate, deploy, and govern a software system that has been delegated some degree of authority to make decisions and take actions?

That commonality is precisely why a cross-industry model may be useful.

Data Understanding May Need to Become Context & Environment Understanding

Another difference appears when we look at data.

CRISP-DM emphasizes Data Understanding.

That remains essential.

But an agent operates on more than a dataset.

Its behavior may depend on:

data,

retrieved context,

organizational knowledge,

system state,

memory,

tools,

permissions,

policies,

APIs,

and the environment it is allowed to affect.

So perhaps Data Understanding needs to expand into:

Context & Environment Understanding

What does the agent need to know?

What is the source of truth?

Where does context come from?

How current is it?

Who owns it?

Which systems can the agent access?

Which actions do those systems expose?

Which credentials does the agent use?

What happens when a tool fails?

What state persists between actions?

What should the system remember?

What should it forget?

A model may be highly capable and still fail because the surrounding context is wrong.

Or because an available tool behaves differently than expected.

Or because the organizational policy changed while the agent’s context did not.

This means the quality of an Agentic AI system depends not only on the quality of its model.

It depends on the quality of the environment in which agency is exercised.

Model Engineering May Need to Become Agent System Engineering

CRISP-ML(Q) naturally places significant emphasis on ML Model Engineering.

For Agentic AI, the model remains important.

But the model is only one component.

The system may include:

Model

+

Instructions

+

Context

+

Tools

+

Memory

+

State

+

Planning

+

Retrieval

+

Human interaction

+

Other agents

The engineering question therefore becomes broader.

Should there be one agent or several?

Which decisions should use which models?

When should the agent retrieve information?

When should it use a deterministic workflow?

When should it ask a human?

What information should persist in memory?

What happens when one component fails?

How does the system recover?

This suggests another possible process area:

Agent System Engineering

The point is not to invent a new label for every ML activity.

It is to acknowledge that the unit we are designing has expanded beyond the model itself.

Evaluation Must Include Behavior, Not Only Outcomes

Agentic systems also complicate evaluation.

Suppose an agent successfully completes a task.

Is that enough?

Maybe not.

It may have reached the right answer while:

using the wrong tool,

accessing unnecessary information,

retrying excessively,

violating a policy,

spending an unreasonable amount of money,

or failing to escalate when it should have.

A successful final output can hide a problematic execution path.

This is why emerging work on Evaluation-Driven Development and Operations treats evaluation as a continuous concern across both development and operation of LLM agents.⁴

For Agentic AI, evaluation may need to answer two questions:

Did it achieve the right outcome?

and:

Did it behave appropriately while achieving it?

That implies a broader evaluation surface:

outcomes,

tool selection,

tool parameters,

context usage,

decision paths,

escalations,

retries,

cost,

policy compliance,

and recovery behavior.

In other words:

Agentic evaluation is partly evaluation of action, not just output.

Deployment Is No Longer the End

CRISP-DM included Deployment.

CRISP-ML(Q) explicitly added Monitoring & Maintenance.

Agentic systems may require an even more active operational loop.

Once deployed, an agent encounters a changing environment.

Models change.

Tools change.

APIs change.

Policies change.

Business rules change.

Context changes.

Permissions change.

Users behave in unexpected ways.

New failure modes appear.

And an autonomous system can discover combinations of actions that its designers never explicitly anticipated.

That means production operations need visibility into more than CPU, latency, and error rates.

We may need visibility into:

which context was used,

which decisions were made,

which tools were called,

which actions were taken,

how often the agent retried,

when it escalated,

when it failed to escalate,

what the outcome cost,

and what happened after the action.

AgentOps research highlights exactly this observability challenge for autonomous and non-deterministic LLM agents.³

Traditional observability asks:

What happened to the system?

Agentic observability increasingly needs to ask:

What did the system decide, what did it do, and what happened as a result?

So What Would a CRISP-Agentic AI Process Need to Cover?

I don’t think the answer is simply another seven-box diagram.

And I don’t think we yet have enough evidence to declare a finished methodology.

But the process requirements are beginning to become visible.

A first exploration might include areas such as:

Business & Agency Understanding

What business problem are we solving, and why does it require delegated agency?

Context & Environment Understanding

What information, tools, systems, permissions, and constraints define the environment?

Agent System Engineering

How should models, tools, context, workflows, memory, and humans work together?

Evaluation & Verification

How do we evaluate both outcomes and behavior?

Deployment & Operations

How do we safely release the capability and observe decisions and actions in production?

Continuous Adaptation

How do we improve, restrict, roll back, or eventually retire the system as the environment changes?

And some concerns may need to cut across every phase rather than exist as individual steps:

Safety

Governance

Security

Human oversight

Cost

Accountability

This is something that further research needs to clarify.

The important point is not the exact number of phases.

The important point is whether Agentic AI introduces enough new cross-industry requirements that our existing process models no longer make those requirements explicit.

What CRISP-Agentic AI Should Not Be

If this idea develops further, I believe a few principles should remain important.

It should be cross-industry.

A Finance agent and a Software Engineering agent may perform completely different work, but the underlying process should still provide a common language.

It should be model- and vendor-neutral.

The process should not depend on OpenAI, Anthropic, Gemini, LangGraph, CrewAI, or whichever technology becomes popular next.

It should be iterative.

Like CRISP-DM, learning in later stages must be able to change earlier assumptions.

A production failure may change the autonomy boundary.

An evaluation result may change the architecture.

A new risk may change the business case.

And it should describe more than phases.

CRISP-DM itself distinguishes between phases, generic tasks, specialized tasks, and concrete process instances.¹

If CRISP-Agentic AI is going to become genuinely useful, it may eventually need the same depth:

phases,

tasks,

expected outputs,

decision points,

artifacts,

and guidance for adapting the process to specific industries and use cases.

That work has not been done yet.

But that is exactly why I think the question is interesting.

Do We Need CRISP-Agentic AI?

I don’t have the answer yet.

And I don’t think we should create a new methodology simply because Agentic AI is currently popular.

A new process model should exist only if the problem has materially changed.

But I think there are reasons to investigate that possibility seriously.

CRISP-DM helped structure cross-industry data-mining work.

CRISP-ML(Q) responded to machine-learning-specific lifecycle and quality requirements.

Today, Agentic AI introduces another set of concerns:

delegated agency,

decision rights,

context,

environment interaction,

tool use,

behavioral evaluation,

action verification,

human escalation,

decision observability,

and continuous adaptation.

And these concerns are not isolated to AI engineering.

They appear wherever autonomous systems begin to participate in business processes.

So perhaps the question is not:

“How do we fit agents into CRISP-ML?”

Maybe it is:

“What should a cross-industry process model look like when software can make decisions and take actions?”

For now, I am using CRISP-Agentic AI as a working name for that question.

Not as a standard.

Not as a completed methodology.

But as a hypothesis worth testing.

Because when the object we engineer changes, eventually the process used to engineer it may need to change as well.

Let’s Explore This Together

This article is the beginning of an exploration around CRISP-Agentic AI.

The next step is not to declare a methodology.

It is to understand the problem better.

That means studying existing lifecycle models, AgentOps, evaluation approaches, governance practices, real Agentic AI projects, and the needs of practitioners across different industries.

It also means challenging the assumptions in this article.

If you work in AI Engineering, Software Engineering, MLOps, AgentOps, Data, Product, Finance, HR, Marketing, CRM, ERP, Operations, Security, Governance, or another area where autonomous systems are beginning to participate in real work, I would be very interested in your perspective.

If you know related work I should read, have a practical use case that challenges these ideas, or would like to contribute to this exploration, please feel free to contact me:

mebilgin@mebilgin.com

The original CRISP-DM idea became valuable because it aimed to provide practitioners across industries with a common process language.

If Agentic AI needs something similar, it should be shaped in the same spirit:

cross-industry, technology-neutral, practical, and open to being challenged by real-world experience.

References

@misc{bilgin2026crisp-agentic-ai,
  title   = {From CRISP-DM to CRISP-Agentic AI},
  author  = {M. Emre Bilgin},
  year    = {2026},
  url     = {https://mebilgin.com/posts/2026/08/crisp-agentic-ai/}
}