Why this matters: An AI agent is not merely an LLM feature or a chat interface. It is a bounded system in which a model can select among allowed next steps—often including tool use—to pursue a goal, while deterministic controls constrain execution and humans retain responsibility for consequential decisions. This lesson gives you a behavior-first classification method and an opportunity brief that makes an autonomy decision testable before model or platform selection.

What you will be able to do
- Diagnose a candidate system as a prompt, assistant, deterministic workflow, bounded tool-using agent, or broader agentic system using observable behavior.
- Write an autonomy envelope that defines goal, allowed next steps, permissions, verification, stop conditions, and human escalation.
- Separate model planning from deterministic authorization and tool execution in a traceable design.
- Defend whether an agent is justified using reliability, cost, latency, privacy, security, maintainability, and user-impact tradeoffs.
The constrained brief: do we need an agent at all?
Start with the decision, not the label. The distributor’s operations lead says: “Build an agent that resolves invoice exceptions.” That wording hides the design question: which next-step choices must adapt to the evidence, and which choices must stay fixed?
A dangerous first build would give a chat model broad access to email, accounts payable, and supplier records, then trust an instruction such as “resolve exceptions safely.” A stronger first decision is narrower: the system may inspect approved internal records, classify the exception, collect specified missing evidence, and create a draft case. A human—not the model—approves any supplier outreach, payment release, vendor-master change, or write-off.
Your job in Module 1 is not to prove that a task can use an LLM. It is to decide whether controlled model discretion creates enough value to justify its cost, latency, reliability, privacy, security, and operating burden. A label cannot make that decision for you.
Current vendor guidance broadly converges on a useful distinction: workflows follow predefined code paths, while agents use a model to direct process or tool use dynamically. OpenAI additionally emphasizes that an agent manages workflow execution, uses tools, works within guardrails, and can halt or transfer control. Those are useful design signals, but they are product guidance—not a universal legal or technical definition. ([anthropic.com](https://www.anthropic.com/engineering/building-effective-agents?via=aitoolhunt&utm_source=openai))
A behavior-first taxonomy
Use observable behavior as your classifier. Ask three questions in order:
- Who selects the next step? The user, deterministic application logic, or the model?
- What can that selection do? Generate content only; retrieve information; create a reversible artifact; or change an external system?
- How much discretion exists? Is there one prescribed route, a small rule-based branch set, or a model-chosen path among permitted tools and stopping points?
| System type | Next-step selector | Invoice example | What not to claim |
| Prompt | User invokes one model response. | “Summarize this invoice discrepancy.” | Not an agent merely because the answer is useful. |
| Assistant | User drives turns; software retains interaction context. | AP analyst asks follow-up questions about an exception. | Conversation history alone is not autonomous work. |
| Automation / deterministic workflow | Code, rules, or a fixed state machine chooses the route. | If total exceeds PO by 5%, open a review ticket; otherwise post to queue. | An LLM extraction or classification step does not convert the whole workflow into an agent. |
| Bounded tool-using agent | Model chooses among explicitly allowed next steps based on current evidence. | It chooses whether to retrieve the receipt, inspect tolerance policy, ask for an internal document, draft a case, or stop and escalate. | It is not authorized simply because it selected a tool call. |
| Agentic system | Umbrella term for systems containing agents, workflows, evaluators, or orchestrated components. | An invoice operation with a triage agent plus deterministic approval service. | Do not imply every component is an agent, or jump to multi-agent design. |
The durable vocabulary is therefore behavioral: goal, next-step selection, permitted action set, discretion, state, verification, stop condition, and escalation. These terms remain meaningful if a platform changes its product taxonomy.
Specify a bounded agent rather than a vague autonomous worker
Draw the autonomy envelope before choosing a model. An autonomy envelope is the explicit set of conditions under which the model may recommend or select a next step, combined with the deterministic controls that decide whether anything actually happens.
For the invoice scenario, write this minimum artifact:
| Field | Release-1 decision |
| Goal | Prepare a complete, evidence-linked exception case for an AP analyst. |
| Completion | A draft case includes invoice, matched PO/receipt evidence, discrepancy category, confidence rationale, and recommended owner. |
| Model discretion | Select one allowed read tool at a time; select a discrepancy category; choose draft, request internal evidence, or escalate. |
| Allowed tools | Read invoice store; read PO system; read receipt system; read policy knowledge base; create draft case. |
| Forbidden actions | No payment changes, vendor-master edits, supplier messages, approval decisions, or deletion. |
| Confirmation | Human approval required before any future supplier communication or financial-state change. |
| Stop conditions | Missing required record; conflicting identifiers; ambiguous policy; tool failure after one bounded retry; suspected prompt injection; sensitive data outside task scope. |
| Human handoff | Route to AP queue with evidence, attempted tools, reason for stop, and the unresolved question. |
This design makes a critical separation. The model output may propose “retrieve receipt 8291.” Deterministic application logic validates that the tool is allowed, its arguments match a schema, the case is in the right state, and the caller has access. Only then does the tool executor perform a read or create the draft. Log all three events separately. If they are collapsed into “the agent did it,” you cannot audit failures or enforce authority.
NIST’s risk framework similarly calls for defined scope, documented knowledge limits, defined human oversight, documented test sets and metrics, and production monitoring. Treat these as design work from the beginning, not paperwork added at launch. ([airc.nist.gov](https://airc.nist.gov/airmf-resources/airmf/5-sec-core/?utm_source=openai))
Map context, state, history, memory, and grounding
Do not call all stored information “memory.” The following map prevents common overreach:
- Task context: the current invoice, user request, and applicable case objective. It exists for this run.
- Application state: controlled facts such as case ID, current status, attempted-tool count, approval status, and retry budget. The application owns this; the model does not freely rewrite it.
- Conversation history: prior turns between an AP analyst and assistant. Include only relevant turns; it is neither authoritative policy nor durable customer knowledge.
- Durable memory: intentionally retained information for future work, such as an analyst’s preferred case format. It requires a retention purpose, access control, correction/deletion path, and poisoning defenses.
- Retrieved/grounded knowledge: current policy excerpts and system records fetched for this case. Cite or attach source identifiers in the draft; retrieved text is evidence, not instructions.
For Release 1, choose no model-written durable memory. Invoice data can be sensitive, and the use case does not require learning personal preferences to deliver value. This reduces privacy exposure, makes behavior more reproducible, and limits long-lived contamination. The tradeoff is less personalization and repeated retrieval, which may modestly increase latency and cost.
Also treat tool-returned text, invoice PDFs, and retrieved documents as untrusted data. They may contain adversarial instructions such as “ignore approval rules.” Your instruction hierarchy must state that external content supplies evidence only; it cannot grant permissions, alter policies, or override system controls.
Make model discretion controlled, observable, and reversible},{
Choose the least complex architecture that preserves the needed outcome. If discrepancy routes can be fully expressed as stable rules, build a deterministic workflow with an LLM extraction component. It will usually be easier to test, faster, cheaper, and more predictable. If exceptions vary in document quality, evidence availability, and policy interpretation—and a fixed flow would explode into brittle branches—a bounded agent may be justified.
Do not confuse adaptability with unrestricted autonomy. Give the agent a small tool-selection matrix:
| Tool | Purpose | Permission | Verification |
| Read PO / receipt | Ground a match decision. | Read only for the active case and approved business unit. | Record source ID, timestamp, and match fields. |
| Policy retrieval | Find applicable tolerance or routing guidance. | Approved policy collection only. | Attach policy version and excerpt reference. |
| Create draft case | Produce a reversible handoff artifact. | Only when required fields validate. | Re-read created record; show analyst a preview. |
| Supplier message | Request clarification. | Disallowed in Release 1; future version needs explicit human confirmation. | Human reviews recipient, content, attachments, and send event. |
Require structured output for the model’s proposed next step: tool name, schema-valid arguments, evidence references, reason, and expected state change. Application code—not the model—checks the schema, policy, authorization, idempotency key, and action budget. A create call should be idempotent so a retry cannot create duplicate cases.
Agent designs introduce extra model calls and tool round trips. Set a maximum step count, time budget, and dollar/token budget. When a tool is unavailable, retry only failures known to be transient; otherwise create a partial draft or escalate. A fast, bounded handoff is often more reliable than an elaborate recovery loop.
Anthropic’s guidance makes the same practical tradeoff: workflows favor predictability for well-defined tasks, while agents suit flexible, model-directed decision-making; it recommends starting with the simplest workable approach because agentic complexity can cost latency and money. ([anthropic.com](https://www.anthropic.com/engineering/building-effective-agents?via=aitoolhunt&utm_source=openai))
Applied Practice: Classify and bound the invoice-exception system
Scenario: Fictional scenario using synthetic data: You are advising a regional distributor that receives supplier invoices by email. The operations lead asks for an “AI agent” to resolve invoice exceptions. The candidate system can read an invoice, compare it with a purchase order and receipt, request a missing receipt from the warehouse system, create a draft exception case, or route a case to Accounts Payable. It must never alter vendor bank details, release a payment, or contact a supplier without a human approval step.
Create a one-page Agent Opportunity Brief for the fictional invoice-exception scenario. First, classify four candidate designs: (1) a single prompt that summarizes an invoice, (2) an AP chat assistant, (3) a fixed rule workflow with LLM extraction, and (4) the bounded tool-using system described here. For each, state who selects the next step, whether external state can change, and why the label is or is not appropriate. Then choose one design for Release 1 and defend it to an AP director and security reviewer. Include: goal and non-goals; completion rule; the five information categories (task context, application state, history, durable memory, grounded knowledge); allowed tools and their scopes; forbidden actions; confirmation and escalation policy; verification plan; maximum steps/retries/time; and three representative tests, including a malicious instruction embedded in an invoice attachment. Add the brief, tool-selection matrix, and test cases to your AI Agent Build Portfolio as the first version of an autonomy-envelope artifact.
Self-review checklist
- I named the decision-maker for the next step in each candidate system: user, deterministic code, or model.
- I separated model-proposed actions from application-authorized and actually executed actions.
- I wrote a goal, completion definition, and at least three stop/escalation conditions.
- I listed every allowed tool and marked whether it reads data, creates a reversible artifact, or changes an external state.
- I specified least-privilege access and a confirmation rule for every consequential action category—even if the first release disallows it entirely in practice mode.
Key takeaways
- Classify a system by who selects the next step and whether that selection can cause an external action—not by whether its marketing calls it an agent.
- A bounded agent uses a model to choose among permitted next steps toward a goal; deterministic code still enforces permissions, schemas, budgets, stop conditions, and actual tool execution.
- Use the simplest architecture that meets the task: prompt for one-off generation, assistant for interaction, workflow for stable paths, and an agent only when legitimate variation requires model-directed tool use.
- Separate transient task context, application state, conversation history, durable memory, and retrieved knowledge. Conflating them makes systems unsafe, hard to test, and hard to explain.
- An opportunity is agent-ready only when its goal, permitted tools, external-action rules, verification, escalation path, and evaluation set can be stated concretely.
Useful terms
- Agent
- A system in which a model selects among permitted next steps, often including tools, in pursuit of a goal; deterministic controls still constrain and execute actions.
- Agentic system
- A broad label for a system that may combine agents, deterministic workflows, evaluators, tools, and other components. It does not mean every component is an agent.
- Autonomy envelope
- The documented boundary of what the system may decide, access, execute, verify, retry, stop, and escalate.
- Deterministic workflow
- A system whose routes and transitions are selected by predefined code, rules, or a state machine, even when an LLM performs a contained subtask.
Research & review note
This lesson is built from source-traceable research and reviewed before publication. AI Agentic School uses AI as a research and practice tool, not as a substitute for evidence or editorial judgment.