Deloitte: The Rise of Autonomous Agents by 2027

Introduction

Deloitte predicts that by 2027, half of the companies using generative artificial intelligence will have implemented pilot projects or proofs of concept around agentic AI. This rapid and widespread adoption has led to the frequent use of the term "agentic" to refer to almost anything involving a call to a large language model (LLM). This can range from a five-step process with GPT intervention for summarization to a fully autonomous system that plans its own path without a predefined script.

However, these concepts are not equivalent. Confusing them can lead to two major errors: either over-engineering a simple process with unnecessary autonomy, or underestimating a complex problem by confining it within a rigid framework that fails as soon as reality diverges from the initial plan.

Anthropic, in its influential paper "Building Effective Agents," makes a clear distinction: workflows are systems where LLMs and tools are orchestrated by predefined code paths, while agents are systems where LLMs dynamically direct their own process and tool usage, maintaining control over how they accomplish a task. This article explores the full spectrum of deterministic workflows, orchestrated systems, unique reactive agents, and fully autonomous multi-agent systems, with code at each step to make the distinction of flow control concrete rather than abstract.

The Real Axis is Not "AI vs. No AI": It's Predictability vs. Autonomy

Before comparing architectures, it is crucial to reframe the question. The question is not whether a system uses an LLM, as practically all do today. The real questions are: does this process need to be repeatable, auditable, and explainable step by step? And: is the correct path known in advance, or does the system need to discover it in real-time?

A system can rely heavily on an LLM while remaining entirely deterministic in its structure: a fixed pipeline where one step calls a model for text generation, but the next step is hard-coded, regardless of what is returned. A system can also be "agentic" with very little real autonomy: a strictly scripted loop with only two allowed actions and a step limit. The presence of a call to an LLM is not the signal. The ownership of flow control is.

Google Cloud's design patterns documentation operationalizes this line: deterministic workflows include tasks with a clearly defined path known in advance, where the steps do not change much from one execution to another. Workflows requiring dynamic orchestration involve problems where the agent must determine the best way to proceed, without a predefined script. This is the spectrum that this article explores, step by step.

Deterministic Workflows

This is the foundation. A deterministic workflow has a known sequence of steps decided at design time by a human in the code. An LLM can be integrated at any step—generating text, classifying inputs, drafting a summary—but it does not choose what happens after executing its own step. The orchestration code takes care of that, regardless of what the model returns.

# deterministic_pipeline.py
# Prerequisites: none beyond the standard Python library
# Run: python deterministic_pipeline.py
def mock_llm_classify(text: str) -> str:
    """
    Simulated call to an LLM -- replaces a real API call to make this example
    executable without an API key. The point is structural: whatever it
    returns, the next function to execute is already decided below.
    """
    if "refund" in text.lower() or "invoice" in text.lower():
        return "billing"
    return "general"

def extract(raw_input: str) -> str:
    """Step 1 -- always executes, always leads to Step 2. No branching here."""
    return raw_input.strip()

def classify(cleaned_text: str) -> str:
    """
    Step 2 -- calls an LLM to produce a label, but the label has no effect
    on the function that executes next. This is the deterministic part: the model
    fills in a data point, it does not influence the path.
    """
    label = mock_llm_classify(cleaned_text)
    print(f"  [classify] LLM returned label='{label}' (information only)")
    return cleaned_text

def summarize(cleaned_text: str) -> str:
    """Step 3 -- always executes after Step 2, regardless of the label from Step 2."""
    return f"Summary: {cleaned_text[:40]}..."

def notify(summary: str) -> str:
    """Step 4 -- always executes last. The path is fixed at design time."""
    return f"Notification sent: {summary}"

def run_deterministic_pipeline(raw_input: str) -> str:
    """
    The flow control here is entirely written by a human, in advance.
    Each execution follows the same path: extract -> classify -> summarize -> notify.
    The call to the LLM inside classify() produces a label, but this label is never
    used to decide which function executes next -- it is a data point circulating in a fixed pipeline.
    """
    step1 = extract(raw_input)
    step2 = classify(step1)
    step3 = summarize(step2)
    step4 = notify(step3)
    return step4

if __name__ == "__main__":
    # Two inputs that the LLM would classify completely differently
    result_1 = run_deterministic_pipeline("I want a refund for my last invoice")
    result_2 = run_deterministic_pipeline("What are your opening hours?")
    print(f"\nResult 1: {result_1}")
    print(f"Result 2: {result_2}")

Orchestrated Workflows

This is the intermediate ground that is often mislabelled as "agentic," and it is worth slowing down here because this is the line that most people actually cross when they start using this term loosely.

An orchestrated workflow always has a graph of possible paths defined entirely in advance, but the path taken now depends on a real-time decision, often made by a call to an LLM. It is still a workflow. Every branch that could be taken has been anticipated.