Agentish AI

The word agent is applied to systems that share little beyond a large language model somewhere in the call graph. A scripted sequence of two prompts and a system that plans, invokes tools, observes results, and revises its own strategy are both marketed as "AI agents," yet they differ in reliability, cost, and failure behaviour by orders of magnitude. This article proposes a technical taxonomy of autonomy—the degree to which a system, rather than its author, decides what happens next—and derives the engineering consequences of each level. The intent is descriptive: to give a system a coordinate on a spectrum, not a verdict.

Why "agentic" resists a binary definition

The difficulty is that agency is not a property of the model but of the control flow wrapped around it. A capable model embedded in a fixed pipeline is not an agent; a modest model given tools and a loop may be. The useful question is therefore not "is this an agent?" but "how much of the control flow is decided at runtime by the model versus fixed at authoring time by the developer?" This mirrors the distinction Anthropic draws between workflows, where LLMs and tools are orchestrated through predefined code paths, and agents, where the model dynamically directs its own process and tool use [1]. We make that axis explicit and graduated.

Five levels of autonomy

Level 0 — Fixed transformation

A single model call with a fixed prompt and no branching. The developer decides everything; the model only fills in text.

Characteristics: deterministic control flow, no tools, no memory. Where it fits: classification, extraction, summarisation. This is not "agentish" in any sense, and calling it an agent is the clearest case of overclaim.

Level 1 — Prompt chain

Several model calls composed in a fixed order, each transforming the previous output—the "prompt chaining" workflow [1]. Control flow is still authored, not inferred.

def draft_and_polish(topic):
    outline = llm(f"Outline an article on {topic}")
    draft = llm(f"Write the article from this outline:\n{outline}")
    return llm(f"Copy-edit for clarity:\n{draft}")

Where the line is: the model never chooses which step runs next. Reliability is high because the space of executions is small and enumerable.

Level 2 — Routed / conditional

The model's output selects among a bounded set of developer-defined paths: routing, classification-driven branching, or a fixed tool chosen per input. The model influences control flow, but only within options the developer enumerated in advance.

Consequence: testing is still tractable—each branch can be exercised—but the number of end-to-end paths grows combinatorially, and evaluation must cover the routing decision itself, not only the leaf outputs.

Level 3 — Tool-using loop

The model runs in a loop, choosing tools and arguments, observing results, and deciding whether to continue—the ReAct pattern of interleaved reasoning and acting [2] and the tool-use / function-calling paradigm [3]. The set of tools is fixed, but the sequence and number of invocations is decided at runtime.

def tool_loop(task, tools, max_steps=8):
    history = [task]
    for _ in range(max_steps):
        step = llm_plan(history, tools)     # model chooses next action
        if step.is_final:
            return step.answer
        result = tools[step.name](**step.args)
        history.append(result)              # observe, then decide again
    raise StepBudgetExceeded()

This is the threshold most people mean by "agentic." The control flow is no longer enumerable: the model may call the same tool repeatedly, in an order the developer never wrote. Two properties become mandatory rather than optional—a step budget, because the loop can fail to terminate, and durability, because a failure at step k must not discard steps 1…k-1. Absent these, the system is agentish in appearance and brittle in practice.

Level 4 — Autonomous / self-directed

The system sets or revises its own sub-goals, may create or acquire new tools, and operates over long horizons with persistent memory—the direction explored by autonomous-agent projects and by memory-augmented, reflective architectures such as Reflexion [4] and generative agents [5]. The developer specifies an objective and constraints, not a procedure.

Consequence: correctness can no longer be defined per output; it must be defined over trajectories. Evaluation shifts from unit-style assertions to trajectory grading, and safety shifts from input validation to bounding what the system is permitted to do at all.

Locating a system on the spectrum

The level is determined by two questions, answered from the implementation rather than the marketing copy:

Question	L0	L1	L2	L3	L4
Does the model choose the next step?	no	no	bounded	yes	yes
Is the number of model/tool calls fixed in advance?	yes	yes	yes	no	no
Is the set of tools fixed in advance?	—	—	yes	yes	no
Are goals fixed by the developer?	yes	yes	yes	yes	no

A system is "as agentic as" its highest honestly-answered yes. A product that advertises Level 4 autonomy but, on inspection, runs a fixed three-step chain is Level 1 with Level 4 copy—the phenomenon of agent-washing. The taxonomy makes the gap measurable rather than rhetorical.

Engineering consequences by level

The value of placing a system precisely is that each level dictates different non-negotiable infrastructure:

• L0–L1: ordinary request/response reliability suffices; retries and idempotency are the whole story.
• L2: branch coverage in evaluation; the routing decision needs its own test set and its own failure metrics.
• L3: a step budget, per-step checkpointing for durable recovery, timeouts on every tool call, and tracing that records why each tool was chosen—concerns covered in the durable-execution and observability literature for agent workloads.
• L4: trajectory-level evaluation, explicit capability sandboxing, and human-in-the-loop or policy gates on irreversible actions.

Choosing infrastructure for a level above the system's true position wastes effort; choosing below it produces the characteristic failures of "agentish" software—non-termination, lost progress on failure, and untestable behaviour.

Conclusion

"Agentish" is not an insult; it is a coordinate. Most useful LLM systems today sit at Levels 1–3, and many should—lower autonomy buys higher reliability and cheaper evaluation. The error is not building a low-autonomy system but mislabelling it, because the label sets the expectation for reliability and the budget for the infrastructure. Stating a system's level plainly aligns the two.

References

1. Anthropic, "Building effective agents," 2024. https://www.anthropic.com/research/building-effective-agents
2. Yao, S. et al., "ReAct: Synergizing Reasoning and Acting in Language Models," arXiv:2210.03629. https://arxiv.org/abs/2210.03629
3. Schick, T. et al., "Toolformer: Language Models Can Teach Themselves to Use Tools," arXiv:2302.04761. https://arxiv.org/abs/2302.04761
4. Shinn, N. et al., "Reflexion: Language Agents with Verbal Reinforcement Learning," arXiv:2303.11366. https://arxiv.org/abs/2303.11366
5. Park, J. S. et al., "Generative Agents: Interactive Simulacra of Human Behavior," arXiv:2304.03442. https://arxiv.org/abs/2304.03442