Two quotes land on your desk for what sounds like the same problem. One says ₹45,000 for "workflow automation". The other says ₹4,50,000 for an "AI agent". The scope paragraph on both describes chasing documents and updating a CRM.
Neither is necessarily wrong. They are describing different machines, and the difference between them is not how clever they are. It is who decides what happens next.
That one question sorts almost every system you will be offered, and it determines the cost, the failure modes, and whether you need a human watching. This post is about answering it properly.
Three tiers, not two
Most articles present this as a binary. It is really three, and the middle one is where most useful business software lives.
Tier 1 — Deterministic automation
No model involved. Rules you wrote, executing exactly as written. A cron job, a Zapier zap, an n8n flow, a database trigger, a CRM workflow rule.
When this form arrives, create a record, assign it to the South region queue, send template 4, and set a reminder for 48 hours.
Every branch is one you anticipated. Given the same input, you get the same output, today and next March. This is the overwhelming majority of what gets called "automation", and it is excellent — fast, cheap, auditable, and it fails loudly rather than quietly.
Tier 2 — Workflows
A model is now involved, but your code still decides the route. Anthropic's engineering team, in the clearest published writing on this distinction, defines workflows as "systems where LLMs and tools are orchestrated through predefined code paths."
The model does the bit that needs comprehension — read this email, classify this enquiry, extract these fields, draft this reply — and your code does everything else: what runs, in what order, what happens on failure.
Read the inbound email. Classify it as sales, support or spam. If sales, extract company, budget signal and timeline. Create the record. Route by region. If classification confidence is low, put it in the human queue.
The intelligence sits inside the steps. The sequence is fixed.
Tier 3 — Agents
The model owns the route. Same source: agents are systems where "LLMs dynamically direct their own processes and tool usage," keeping control over how they accomplish a task.
You give it a goal and a set of tools, and it decides which tools to use, in what order, and when it is finished.
Here is the goal: get this client onboarded. Here are your tools — email, the CRM, the document store, the KYC checker. Work out what is missing and go and get it.
That is a genuinely different machine. It can handle situations you did not anticipate. It can also do things you did not anticipate, which is the same sentence read from the other side.
The question that classifies anything
When a vendor describes a system, ask: if something unexpected happens, who decides what to do?
- "It follows the rules we configured" → Tier 1
- "The AI reads it and then our system routes it" → Tier 2
- "The agent works out what to do" → Tier 3
One phrasing that cuts through the marketing, borrowed from a talk by one of that paper's authors: with a workflow, you own the plumbing; with an agent, the model owns the plumbing.
Most things sold as "AI agents" in 2026 are Tier 2 workflows. That is not a criticism — Tier 2 is usually the right answer — but it should be reflected in the price.
How they compare
| Deterministic automation | Workflow | Agent | |
|---|---|---|---|
| Who picks the next step | Your rules | Your code | The model |
| Handles cases you did not foresee | No | Only inside a step | Yes, for better or worse |
| Same input, same output | Always | Usually | Not guaranteed |
| Cost per run | Negligible | Low, predictable | Variable, can spike |
| Latency | Milliseconds | Seconds | Seconds to minutes |
| Auditability | Complete | Good | Needs deliberate work |
| Fails | Loudly | Mostly loudly | Quietly and confidently |
| Needs a human in the loop | Rarely | At low confidence | Yes, at checkpoints |
The row that costs people money is the last-but-one. Deterministic automation breaks visibly: the zap errors, the queue backs up, someone notices. An agent that misunderstands the goal produces plausible output and nobody notices until a client does.
Why most problems are workflows
Anthropic's own guidance is to find "the simplest solution possible, and only increasing complexity when needed," and notes that "agentic systems often trade latency and cost for better task performance." Workflows, they say, offer "predictability and consistency for well-defined tasks"; agents suit cases where "flexibility and model-driven decision-making are needed at scale."
That maps cleanly onto business reality. Most operational problems are well-defined. You are not asking for open-ended problem solving — you are asking for a known sequence to happen reliably, with one or two steps that need reading comprehension.
There is also an arithmetic reason to prefer fewer autonomous steps. If each step in a chain is 95% reliable, five steps end up around 77% and ten around 60%. That is simple compounding, and it is why a long autonomous chain with no checkpoints disappoints: not because any step is bad, but because they multiply. Fixed code paths let you put a check between steps rather than hoping the chain holds.
The workflow patterns worth knowing
If you are being quoted for Tier 2, these are the shapes the work actually takes, and a competent vendor will recognise the names:
- Prompt chaining — break the task into ordered steps, each feeding the next. Good when the task decomposes cleanly.
- Routing — classify the input first, then send it down a specialised path. This is the single most useful pattern for inbound enquiries.
- Parallelisation — run several calls at once, either splitting the work into sections or asking the same question several times and voting on the answer. Voting is a cheap reliability upgrade for decisions that matter.
- Orchestrator-workers — a central step breaks work into subtasks and delegates them. Getting closer to agentic territory.
- Evaluator-optimiser — one pass produces, a second critiques, loop until it passes. Expensive, and genuinely effective for drafting.
If a proposal for an "AI agent" cannot be described in those terms, either it is a real Tier 3 agent — which is a much bigger commitment — or nobody has thought about the architecture yet.
How each one fails
This is the part worth dwelling on, because the failure modes are what you are really buying or avoiding.
Deterministic automation fails on change. A supplier alters an invoice layout and the parser silently takes the wrong column. A field gets renamed and records stop syncing. Nothing is wrong with the logic — the world moved. The mitigation is monitoring, not intelligence.
Workflows fail at the edge of their steps. The classifier meets an enquiry that is genuinely two enquiries. The extractor meets a form with the date in words. These fail well if — and only if — there is an explicit low-confidence path. Without one, the model guesses, because guessing is what it does. Ask to see that path. It is the single most revealing question you can put to a vendor.
Agents fail in ways that need naming:
- Confident wrongness. It misreads the goal and executes beautifully against the wrong objective.
- Unbounded loops. It gets stuck retrying, and the cost is metered.
- Cost variance. The same task might cost ₹2 or ₹200 depending on how many steps it decides to take. Budget for a distribution, not an average.
- Unexplainability. Six weeks later a client asks why a decision was made. "The agent decided" is not an answer anyone accepts, which matters more in regulated work.
None of this makes agents a bad idea. It makes them a thing you deploy deliberately, with sandboxed testing and guardrails — Anthropic recommends exactly that, along with having agents "pause for human feedback at checkpoints or when encountering blockers."
What each costs
Indicative ranges for the Indian market, and they track the tiers closely:
| Scope | Range | Usually |
|---|---|---|
| Starter automations | ₹25,000 – ₹60,000 | Tier 1, one or two flows |
| Growth automation stack | ₹75,000 – ₹2,00,000 | Tier 1 and 2 across channels |
| Custom CRM and automation | ₹2,00,000 – ₹10,00,000+ | Tier 2 embedded in a real system |
Full ranges sit on the marketing automation pricing page, and the deeper end overlaps with custom CRM work.
Two cost notes people miss. First, Tier 1 has essentially no running cost, Tier 2 has a small and predictable one, and Tier 3's running cost is a distribution with a long tail. Second, the build cost difference between Tier 2 and Tier 3 is not mostly the model — it is the guardrails, the audit logging, the sandbox testing and the human-checkpoint design. That is why the quotes differ by an order of magnitude: you are buying the safety apparatus.
Choosing, concretely
Use deterministic automation when the inputs are structured and the rules are stable. Order confirmations. Appointment reminders. Payment follow-ups. Stage changes in a pipeline. If you can write the rule down without using the word "usually", you do not need a model.
Use a workflow when one or two steps need comprehension and the rest is a known sequence. Reading inbound enquiries and routing them. Extracting fields from supplier invoices. Summarising a thread onto a record. Drafting a first-pass reply for someone to edit. This is where most of the value is, and it is the cheapest tier that uses AI at all.
Use an agent when the path genuinely cannot be known in advance and the work is valuable enough to justify supervision. Multi-step research. Reconciling across systems where the next check depends on what the last one found. Onboarding flows with many conditional document requirements.
For Aieraa's admissions platform the automation runs across five-plus user roles, and almost all of it is Tier 1 and 2 by design: admissions has a known sequence, so the win came from removing the waiting between steps, not from giving a model discretion over a student's application. That is the typical shape of a good outcome.
The same process, built three ways
Abstractions only go so far. Here is one real process — a new enquiry arriving for a service business — built at each tier, with what you get and what it costs you.
Tier 1: rules only
A form submission creates a CRM record, assigns it round-robin to the sales team, sends an acknowledgement, and sets a 48-hour reminder.
What works: it never forgets, it runs in milliseconds, and it costs nothing per run. For a business getting twenty broadly similar enquiries a week, this is genuinely sufficient and anything more is overspending.
What breaks: round-robin ignores who is best placed to answer. A supplier enquiry, a job application and a serious buyer all get the same acknowledgement. Someone still reads every message to work out what it is, which is the actual bottleneck.
Tier 2: a workflow
The same flow, with two model-powered steps inserted. On arrival, the enquiry is classified — sales, support, supplier, recruitment, spam — and for sales enquiries, company, service interest, budget signal and timeline are extracted into fields. Your code then routes by service and region, writes a three-line summary to the top of the record, and notifies the right owner. Anything the classifier is not confident about goes to a human queue flagged as unclassified, not guessed.
What works: the reading is done before a person opens it. First response time drops, because the right person gets it with context attached. The sequence is still yours, so you can reason about it and test it.
What breaks: an enquiry that is genuinely two things at once will be filed as one. The extractor will occasionally read "next quarter" as a date. Both land in the human queue if the confidence path exists, and both get silently mis-filed if it does not.
Cost shape: a few rupees per enquiry in model usage, and a build in the ₹75,000–₹2,00,000 band once it is wired into a CRM properly.
Tier 3: an agent
The agent is given the goal — qualify this enquiry — and tools: the CRM, the email thread, the website analytics, an enrichment API, the calendar. It decides to look the company up, read their site, check whether they have visited pricing pages before, draft a tailored reply, and propose three meeting slots. If something is missing it goes and finds it.
What works: it handles the enquiry that does not fit any category, and it can assemble context nobody thought to ask for.
What breaks: it might enrich from the wrong company with a similar name and write a confidently personalised reply about the wrong business. It might loop on an enrichment API that is rate-limiting. The same enquiry might cost ₹2 or ₹200. And when a prospect asks why they were told something, you need a log that explains it.
Cost shape: the build is several times Tier 2, and most of the difference is guardrails, logging, sandbox testing and the human checkpoint — not the model.
For most service businesses, Tier 2 captures the large majority of the available value, and the honest recommendation is to build that, run it for a quarter, and only then look at what it could not handle.
Moving up a tier without wasting the last one
The tiers compose, which is the useful thing about them. You do not throw Tier 1 away to get Tier 2.
Start deterministic. Get the sequence right, get the notifications right, get the record structure right. That work survives every later change, because it is the plumbing.
Then insert model steps where a human is currently reading something to make a simple decision. That is Tier 2, and it is a small change to a working system rather than a rebuild.
Only reach for Tier 3 when you have evidence from running Tier 2 — a documented category of case it could not route, happening often enough to matter. That evidence is also the specification, which is why the order matters: teams that start at Tier 3 end up discovering their requirements in production.
How to tell whether it is working
Agree the measure before anything is built, because the obvious one is usually wrong. "Number of tasks automated" tells you nothing. The measures that mean something:
- Elapsed time from enquiry to first human response, or from request to resolution. This is usually where the money is, and automation moves it most.
- The escalation rate — what proportion goes to the human queue. If it is near zero, the confidence threshold is probably too loose and errors are being hidden rather than caught.
- Error cost, not error rate. One mis-routed supplier enquiry is free. One confidently wrong reply to a client is not.
- Cost per run, and the 95th percentile of it. Averages hide the loops.
Instrument those four before launch. Retrofitting measurement onto a system that is already live is how teams end up arguing about whether it worked.
What to ask before you sign
- Which tier is this, in your own words?
- If the model is unsure, what happens? Show me that path.
- What does a run cost, and what does the worst case cost?
- How do we see what it did and why, six months from now?
- Where is the human approval, and can we move it later without a rebuild?
- What breaks if the model provider changes, deprecates a version, or has an outage?
A vendor who answers the second and fourth clearly is probably worth working with, whatever tier they are proposing.
The honest summary
"AI agent" has become the term for anything with a model in it, which makes it almost useless as a specification. The useful question is who owns the control flow. If your code owns it, you have a workflow — predictable, cheaper, easier to audit, and right for the overwhelming majority of business processes. If the model owns it, you have an agent, which is more capable and needs more care than most proposals admit.
We write about what agents genuinely automate well separately. If you are holding two quotes that differ by a factor of ten, describe the process and we will tell you which tier it actually needs — including when the answer is a ₹45,000 workflow rather than the expensive thing.
Bharat Vasireddy
Founder & Digital Marketing Strategist8+ years of experience in performance marketing and web development. I help businesses scale through data-driven SEO, Google Ads, and high-performance websites.