Agentic AI

Foundations Of Agentic AI

What Makes a System Agentic

There is no boundary at which a system becomes "an agent." There is a dial, and the useful question is how far along it you need to be.

JrCodex·7 min read

Jr Codex Agentic AI Notes

Level: Beginner Prerequisites: Chapter 1: From Traditional AI to Agentic AI Time to complete: ~20 minutes

Table of Contents

  1. Agentic Is a Spectrum, Not a Label
  2. The Six Properties
  3. The Spectrum in Code
  4. Who Decides the Control Flow
  5. Choosing the Right Point on the Spectrum
  6. Summary & Next Steps

1. Agentic Is a Spectrum, Not a Label

There is no boundary at which a system becomes "an agent." There is a dial, and the useful question is how far along it you need to be.

The Spectrum
─────────────────────────────────────────
  1. SINGLE CALL       prompt in, answer out

  2. CHAIN             fixed sequence of calls, each
                       feeding the next

  3. ROUTER            a model picks which fixed
                       branch to take

  4. TOOL-USING LOOP   the model chooses actions
                       until done

  5. PLANNING AGENT    the model decomposes the goal
                       first, then executes

  6. MULTI-AGENT       several agents coordinate

  ◄── more predictable        more capable ──►
  ◄── cheaper, testable       costlier, harder ──►
─────────────────────────────────────────

The Rule Worth Internalising Now
─────────────────────────────────────────
  Use the LEAST agentic system that solves the
  problem.

  Every step rightward costs predictability,
  testability, latency and money — and buys
  flexibility you may not need. Most production
  "agents" would be better as level 2 or 3.
─────────────────────────────────────────

2. The Six Properties

What people mean by "agentic" decomposes into six properties that a system can have independently.

1. AUTONOMY
─────────────────────────────────────────
  Acts without step-by-step human instruction.
  Measured by: how many steps between human inputs.

2. GOAL-DIRECTEDNESS
─────────────────────────────────────────
  Pursues an OUTCOME, not a procedure. You specify
  what "done" looks like, not how to get there.
  This is what separates level 4 from level 2.

3. TOOL USE
─────────────────────────────────────────
  Can affect or observe the world beyond generating
  text. Without this, autonomy is meaningless —
  there is nothing to be autonomous ABOUT.

4. MEMORY
─────────────────────────────────────────
  Retains state across steps and, sometimes, across
  sessions. Module 3 is devoted to this.

5. ADAPTABILITY
─────────────────────────────────────────
  Changes approach in response to results. An agent
  that retries the identical failing action is
  looping, not adapting (Module 4, Chapter 4).

6. REFLECTION
─────────────────────────────────────────
  Evaluates its own output and revises. The
  distinguishing property of the more capable
  patterns — Module 4, Chapter 3.
─────────────────────────────────────────

Using These as a Checklist
─────────────────────────────────────────
  When someone describes a system as "agentic",
  ask which of the six it actually has.

  Most commercial "AI agents" have tool use and
  nothing else — which makes them level 3 or 4, and
  that is often exactly right. The problem is not
  being at level 3; it is not KNOWING you are.
─────────────────────────────────────────

3. The Spectrum in Code

The distinction is clearest when the same task is written at three levels.

# LEVEL 2 — A CHAIN. You wrote the control flow. It runs the same way every time.
def summarize_ticket(client, ticket):
    category = classify(client, ticket)                 # step 1, always
    context  = retrieve(category)                       # step 2, always
    return draft_reply(client, ticket, context)         # step 3, always
# LEVEL 3 — A ROUTER. The model picks a BRANCH; you still wrote every branch.
def handle_ticket(client, ticket):
    route = classify(client, ticket, options=["billing", "technical", "refund"])
    return {                                            # the set of outcomes is FIXED
        "billing":   handle_billing,
        "technical": handle_technical,
        "refund":    handle_refund,
    }[route](client, ticket)
# LEVEL 4 — A TOOL-USING LOOP. The model decides the sequence AND its length.
def resolve_ticket(client, ticket, tools, max_steps=10):
    messages = [{"role": "system", "content": "Resolve the ticket. Use tools to gather "
                                              "what you need before replying."},
                {"role": "user", "content": ticket}]
    for _ in range(max_steps):
        reply = client.chat.completions.create(
            model="gpt-4o", messages=messages, tools=tools.schemas).choices[0].message
        if not reply.tool_calls:
            return reply.content
        messages.append(reply)
        for call in reply.tool_calls:
            messages.append({"role": "tool", "tool_call_id": call.id,
                             "content": str(tools.run(call))})
    raise StepLimitExceeded()                           # the loop MUST be bounded
Read the Difference Structurally
─────────────────────────────────────────
  Level 2: no branching. Fully testable.
  Level 3: branching, but a FINITE, enumerable set
           of paths. Still testable — test each branch.
  Level 4: an unbounded set of possible paths. You
           can no longer enumerate them, which is why
           Module 7 evaluates TRAJECTORIES rather
           than outputs.
─────────────────────────────────────────

4. Who Decides the Control Flow

There is one question that places any system on the spectrum, and it cuts through all the marketing.

The Question
─────────────────────────────────────────
  "At runtime, does the MODEL decide what happens
   next — or did the DEVELOPER already decide?"

  DEVELOPER decides  ──►  a workflow (levels 1-3)
  MODEL decides      ──►  an agent (levels 4-6)
─────────────────────────────────────────

Why This Is the Right Question
─────────────────────────────────────────
  It predicts everything else about the system:

  If the DEVELOPER decides:
    - execution paths are enumerable and testable
    - cost and latency are bounded and known
    - failures are reproducible
    - debugging is ordinary software debugging

  If the MODEL decides:
    - the path is non-deterministic
    - cost varies per run and can spike
    - failures may not reproduce
    - you need TRACING to know what happened at all
─────────────────────────────────────────

Note that a system can be highly capable and still be a workflow. A five-stage pipeline with retrieval, an LLM at each stage, and structured handoffs is sophisticated engineering — and entirely deterministic in its control flow. That is a feature.

5. Choosing the Right Point on the Spectrum

Decision Guide
─────────────────────────────────────────
  Can you write down the steps in advance?
      ──► LEVEL 2. Do that. It is cheaper, faster
          and testable, and it will not surprise you.

  Are there a handful of known paths?
      ──► LEVEL 3. A router plus fixed branches.

  Does the necessary sequence genuinely depend on
  what is discovered along the way?
      ──► LEVEL 4. This is the real threshold.

  Does the task need decomposition before any work
  can start?
      ──► LEVEL 5 (Module 4).

  Do genuinely separate specialisations need to
  work in parallel, with separate contexts?
      ──► LEVEL 6 (Module 6) — and read Module 6,
          Chapter 5 first, on why this usually
          makes things worse.
─────────────────────────────────────────

The Test for Level 4
─────────────────────────────────────────
  "Could I have written this sequence of steps
   before seeing the input?"

  If yes, you do not need an agent — you need the
  function you just described.

  Investigating a fraud alert genuinely fails this
  test: whether to check the merchant depends on
  what the customer history turned up. Summarising
  a document does not fail it at all.
─────────────────────────────────────────

6. Summary & Next Steps

Key Takeaways

  • Agentic is a six-level spectrum from single call to multi-agent; each step right trades predictability, testability and cost for flexibility.
  • "Agentic" decomposes into six independent properties — autonomy, goal-directedness, tool use, memory, adaptability, reflection — and most systems have only some.
  • The defining question is who decides control flow at runtime: developer means workflow and testable paths, model means agent and non-deterministic trajectories.
  • Use the least agentic system that solves the problem, and apply the level-4 test: if you could have written the steps in advance, write them.

Concept Check

  1. A colleague calls their five-stage retrieval pipeline "an agentic system." Using this chapter's question, what is it actually, and does that matter?
  2. Why does level 4 require trajectory evaluation while level 3 does not?
  3. Apply the level-4 test to "generate a weekly sales summary from our database." What level does it need, and why?

Next Chapter

→ Chapter 3: Classical Agent Types, Reframed

Jr Codex — 1-on-1 Personalized Coaching | Back to Module Index | Back to Agentic AI Index