The Excitement Around Agentic Workflows

I am excited about agentic workflows.

But I also believe something I learned years ago at Singularity University still applies:

Only use AI when it is absolutely necessary.

That may sound strange in 2026, when everyone wants to build agents. But I think it matters even more now.

As AI tools become more powerful, the temptation is to use them everywhere. If a task can be made more autonomous, people often assume it should be.

I do not believe that.

An agentic workflow is not automatically better than a deterministic workflow.

Sometimes the best system is boring.

And boring systems are often underrated.

Not Every Workflow Needs an AI Agent

There is a difference between what is possible and what is necessary.

If a task has a fixed sequence, stable rules, clear inputs, and predictable outputs, then you may not need an agent at all.

You may need a checklist.

You may need a script.

You may need a scheduled job.

You may need a simple automation.

You may need a workflow where AI assists at one step, but does not control the entire process.

That is an important distinction.

Because in practice, many operational workflows do not need reasoning at every step. They need consistency.

A recurring report does not necessarily need an autonomous agent.

A structured data cleanup task may not need an autonomous agent.

A well-defined email send workflow may not need an autonomous agent.

A CRM enrichment step may not need an autonomous agent.

In many cases, the more intelligent-looking solution is not the better solution.

The better solution is the one that is reliable, understandable, and appropriately scoped to the problem.

What AI Agents Are Actually Good At

Agents become useful when the system needs to make decisions under uncertainty.

They are useful when the next step depends on interpretation.

They are useful when the workflow needs to read, reason, choose, and adapt.

That is where agency starts to matter.

An agent can be valuable when the environment is dynamic, when the inputs vary, when the rules are not fully stable, or when multiple possible actions depend on context.

For example, an agent may be useful when:

• a workflow needs to read unstructured documents and decide what matters
• the next step depends on interpreting the content of an email or message
• the system has to choose between multiple possible actions
• the workflow needs to adapt based on prior outcomes
• the process is exploratory rather than fixed
• human review is needed at changing points in the sequence

This is the kind of work where rigid automation may be too brittle.

In those cases, autonomy can create real value.

But even then, autonomy should be introduced carefully.

Autonomy Comes With Risk

This is the part people often skip.

Autonomy comes with risk.

An agent can misunderstand the goal.

It can overreach.

It can take the wrong action.

It can optimize for the wrong signal.

It can create complexity where none was needed.

And yes, it can apparently wipe a database unexpectedly.

That is the problem with giving decision-making freedom to a system that can still make reasoning mistakes. The more autonomy you give it, the more careful you need to be about boundaries, permissions, review, rollback, and testing.

A system that merely drafts a recommendation is very different from a system that sends communications, updates records, changes states, or triggers downstream actions automatically.

The question is not only whether the agent can do the task.

The question is what happens when it does the wrong thing.

That is why I do not think of autonomy as a status symbol.

I think of it as a risk decision.

Agentic Workflows Exist on a Spectrum

I find it more useful to think about agentic systems on a spectrum.

On one side, you have deterministic automation.

Every step is predefined. The rules are stable. Inputs and outputs are clear. The system follows a fixed path. AI may not be involved at all, or it may only assist in a narrowly bounded way.

On the other side, you have full autonomy.

The agent decides what to do, when to do it, and how to respond. It can reason across options, choose actions, and adapt dynamically.

Most useful systems live somewhere in the middle.

That middle zone is where a lot of good design happens.

You can have:

• deterministic workflows with one AI-assisted step
• structured workflows with human approval gates
• semi-agentic workflows that suggest actions but do not execute them
• agents that operate inside narrow constraints
• systems that escalate uncertain cases to humans

That middle ground is usually where intelligence and reliability can coexist.

It is also where cost and risk can stay manageable.

The Real Goal Is Not to Prove You Built an Agent

This became very clear to me when I started building a marketing lab.

At first, I wanted an agentic system.

I wanted the experience of building one. I wanted the system to create content, send campaigns, track responses, and improve itself. I wanted the machine to feel intelligent and alive.

But wanting an agentic workflow is not the same as needing one.

That distinction changed everything.

The real goal was not to prove I could build agents.

The real goal was to solve a marketing problem at low cost.

That is a very different design brief.

Once I looked at it that way, the question was no longer:

How agentic can I make this?

The question became:

What is the simplest system that reliably solves the problem?

That is a much better question.

Because sometimes the smartest build is not the most autonomous one.

Sometimes the smartest build is the one with fewer moving parts.

The Best System Is Often the Least Dramatic One

There is a tendency in AI to overdesign.

People want the workflow to sound advanced.

They want multiple agents.

They want orchestration.

They want memory.

They want tools calling tools.

They want self-improving loops.

They want the system to feel like a breakthrough.

But operationally, that can become noise.

Every new layer creates more failure points.

More ambiguity.

More debugging.

More places where the system can misunderstand what success actually means.

This is why I believe the best system is often the least dramatic one that still gets the job done.

If a checklist solves the problem, use a checklist.

If a script solves the problem, use a script.

If a deterministic automation solves the problem, use deterministic automation.

If one AI-assisted step inside a structured process solves the problem, that may be enough.

You do not get extra points for adding autonomy.

You only get extra risk.

A Good Workflow Design Question to Ask

I think one of the best design questions you can ask is:

Where is uncertainty actually happening?

That question reveals whether you need an agent or not.

If the workflow is fixed, structured, and repetitive, you may not need autonomy.

If the uncertainty only exists in one step, then maybe only that step should use AI.

If the uncertainty is real and the next action genuinely depends on interpretation, then a more agentic design may make sense.

But even then, the right answer is rarely “give the system full control.”

More often, the right answer is:

• narrow the scope
• constrain the actions
• add checkpoints
• keep humans in the loop where necessary
• separate recommendation from execution
• make review easy
• make rollback possible

That is mature design.

Agentic systems should earn their autonomy.

What This Means for Real Estate and Operational Workflows

This matters even more in real estate, where workflows are often messy, expensive, and high-stakes.

A real estate system can touch deals, parcels, zoning, outreach, financial analysis, site selection, approvals, content, and client communication. In that environment, complexity can become dangerous quickly.

Some parts of a real estate workflow may benefit from AI reasoning.

Other parts should remain structured and deterministic.

For example:

• summarizing unstructured zoning text may benefit from AI
• deciding whether to overwrite parcel data automatically may not
• drafting outreach variants may benefit from AI
• sending campaigns without checks may not
• interpreting complex property descriptions may benefit from AI
• updating records across systems without safeguards may not

That is the discipline.

Do not ask, “Where can I add AI?”

Ask, “Where is intelligence actually needed, and where is reliability more important?”

That one shift can save enormous time and cost.

The Most Useful Systems Usually Live in the Middle

I do not think the future belongs only to fully autonomous systems.

I think the future belongs to thoughtfully designed systems.

Systems that combine deterministic structure with selective intelligence.

Systems that know when to use AI and when not to.

Systems that are built around the actual problem, not around the desire to sound advanced.

Most useful systems live somewhere in the middle.

That is not less ambitious.

It is more mature.

Because in the real world, good systems are not judged by how futuristic they sound.

They are judged by whether they work.

Conclusion: Use Autonomy Only Where It Earns Its Place

I am excited about agentic workflows.

But I do not believe autonomy is a goal in itself.

Autonomy is a tool.

And like any tool, it should be used where it creates clear value.

If a task is fixed, predictable, and well structured, a checklist, script, or deterministic automation may be the better answer.

If the workflow truly requires interpretation, adaptation, and decision-making under uncertainty, then agentic behavior may be worth the added complexity.

But the standard should stay the same:

Do not build the most autonomous system you can.

Build the simplest system that solves the problem well.

That distinction changed the way I think about building with AI.

And I think it is one of the most important design disciplines we can develop right now.