Why this matters: Professional agent design begins by refusing an architecture label until the task has earned it. Classify the work by who controls the path and who can cause consequential change. Then preserve deterministic controls, bound any model-selected loop, and demand evidence that increased autonomy improves outcomes enough to justify its cost and risk.

What you will be able to do
- Classify a proposed AI capability as a prompt, assistant, deterministic workflow, bounded tool-using agent, or broader agentic system based on control of workflow execution and action authority.
- Identify task characteristics that justify model-selected steps and distinguish them from work that should remain predefined and deterministic.
- Produce an opportunity brief and bounded-autonomy contract that specifies permissions, confirmation gates, state, retrieval, stop conditions, verification, fallback, escalation, and observability.
- Design comparative evidence and evaluation criteria that can support or reject an agent proposal.
1. Start with the consequential decision, not a definition
Decision brief: HarborDesk’s sponsor says, “Let the AI handle maintenance end to end.” That sentence hides at least five different systems. A tenant might only need a drafted acknowledgement. A coordinator might need an assistant that summarizes the request and recommends a category. The organization might need a deterministic workflow that maps a known category to a known queue. Or it may need a bounded tool-using agent that chooses whether to ask a clarifying question, retrieve building rules, inspect vendor availability, or escalate an ambiguous case. Those are not interchangeable risk profiles.
Your first certification habit is to turn the slogan into a decision: What uncertainty must the system resolve, what authority would it receive, and which outcomes would be materially worse if it chose wrongly? Do not call an LLM integration an agent merely because it uses a prompt, retrieval, or a tool. An agent controls some portion of workflow execution by selecting next steps and tools within a loop; a fixed workflow controls the sequence in code. OpenAI similarly distinguishes tool-using systems that let the model manage workflow execution from chatbots, single-turn calls, and classifiers that do not. ([openai.com](https://openai.com/business/guides-and-resources/a-practical-guide-to-building-ai-agents/?utm_source=openai))
Artifact to create: one-sentence opportunity claim. “For non-emergency, text-heavy maintenance requests with incomplete descriptions, a bounded system may reduce coordinator triage effort by producing grounded classifications and collecting missing information; it will not dispatch vendors or close tickets without deterministic eligibility checks and human approval.” This is deliberately narrower than the sponsor’s request. A narrower claim can be tested and defended.
2. Choose the least-complex architecture that meets the outcome
| Architecture | Who determines the path? | HarborDesk example | Appropriate boundary |
|---|---|---|---|
| Prompt | User or application asks for one model output. | Draft a polite acknowledgement from supplied ticket text. | No external action; output is reviewed or presented as a draft. |
| Assistant | User remains in control of consequential next steps. | Coordinator asks for a summary, suggested category, and missing facts. | Recommendations and drafts; user chooses whether to act. |
| Deterministic workflow / automation | Predefined code, rules, and states determine the path. | If a request contains a verified unit ID and selected category, route to that queue; calculate SLA from the service policy. | Known paths, stable policies, structured inputs, repeatable decisions. |
| Bounded tool-using agent | Model selects among allowed next steps based on current evidence. | Choose whether to retrieve building-specific guidance, ask one approved clarifying question, or escalate because the request may be an emergency. | Variable paths; limited tools; explicit stop limits and approval gates. |
| Broader agentic system | Model-driven decisions operate alongside application services, state, retrieval, controls, interfaces, and monitoring. | Triage capability plus ticket service, policy retrieval, identity/role controls, audit trail, evaluator, and human queue. | A system description—not proof that broad autonomy is warranted. |
A workflow can contain LLM calls without becoming an agent. For example: extract fields → validate a unit ID → route based on a policy table → generate a response. The LLM may interpret unstructured text, while deterministic code owns the sequence and all control points. This is often stronger when steps are known. Anthropic draws the same useful distinction: workflows use predefined code paths, whereas agents dynamically direct their process and tool use; it recommends adding complexity only where it demonstrably improves outcomes. ([anthropic.com](https://www.anthropic.com/engineering/building-effective-agents?utm_source=openai))
Classification test: Write the happy path and ten plausible exception paths. If the set is finite, stable, and economically maintainable, prefer a deterministic workflow. If material cases require context-sensitive judgment over unstructured evidence, the next step cannot be reliably pre-specified, and action can remain safely bounded, investigate an agent. “The input is text” alone does not justify one.
3. Decompose the proposal: model judgment surrounded by deterministic controls
Build an uncertainty-and-authority map before proposing tools. Score each task component qualitatively: low, medium, or high for path variability, ambiguity, action authority, reversibility, verification burden, and harm if wrong. Then split the task into components instead of granting the entire request to an agent.
| Component | Best controller | Reason | Control |
|---|---|---|---|
| Extract symptoms, location, and stated urgency from free text | Model output | Unstructured language; uncertainty is acceptable if labeled. | Structured schema; confidence/insufficient-evidence field; no action. |
| Determine emergency routing | Deterministic policy plus human escalation | High consequence; policy conditions must be auditable. | Conservative trigger rules; immediate escalation; never rely on a model’s reassurance alone. |
| Retrieve building access and service policy | Deterministic retrieval service, optionally model-selected query | Knowledge must be current and attributable. | Tenant/building authorization filter; source/version returned with results. |
| Decide whether a clarification is needed | Bounded agent candidate | Evidence gaps vary by request. | One approved question; no sensitive-question categories; then stop or escalate. |
| Create work order, choose vendor, schedule visit | Deterministic service with human approval | Creates commitments and may involve cost and privacy. | Approved-vendor list, budget rule, availability check, explicit approval, idempotency key. |
The model may propose a structured classification or next step. Application logic must validate it against a schema and policy. The tool service, not the model, performs a call after authorization. For example, create_work_order should accept only a validated ticket ID, approved vendor ID, service code, and approval token. The model never receives general database credentials and cannot invent a permission.
Do not confuse information stores. Task context is the current request and authorized facts supplied for this run. Application state is authoritative operational data, such as ticket status, approval status, tool-call count, and idempotency key. Conversation history is prior exchanges relevant to the active interaction. Durable memory is retained cross-session information and requires a separate necessity, accuracy, retention, and access decision. Retrieved knowledge is policy or reference material fetched at run time. In HarborDesk, a current building policy should be retrieved and cited in the trace, not copied into speculative durable memory.
4. Specify a bounded autonomy contract
Write an agent opportunity brief with six fields: (1) user and business outcome; (2) representative inputs and exclusions; (3) baseline process and failure/cost burden; (4) smallest candidate architecture; (5) authority and risk boundary; and (6) evidence required to advance. Add a disconfirmation statement: “If a fixed classifier-plus-workflow reaches the required quality and coordinator time target, no agent pilot proceeds.” This prevents solutioneering.
For HarborDesk, the bounded-agent hypothesis is intentionally modest: after deterministic emergency screening and identity checks, the model can select one of three actions—retrieve_policy, ask_clarifying_question, or escalate_to_coordinator. It cannot create a vendor engagement, edit financial fields, send messages outside the tenant portal, or mark a ticket resolved. It stops after two model turns, one retrieval, and one clarification. If the required field is still absent, it escalates with an evidence packet.
Why these limits are stronger: they turn a vague promise of “end to end” action into a low-authority experiment where bad classification does not directly create an unsafe work order. They also control latency and cost by limiting iterations and retrieval. They improve maintainability because policy changes remain in a policy service rather than in a prompt. Instructions still matter—e.g., “treat emergency indicators conservatively; do not infer facts”—but instructions are not access control, validation, or a safety guarantee.
NIST’s Generative AI Profile notes that generative AI can warrant additional human review, tracking, documentation, and management oversight, with the appropriate human-AI configuration depending on risk. ([nvlpubs.nist.gov](https://nvlpubs.nist.gov/nistpubs/ai/NIST.AI.600-1.pdf?utm_source=openai))
5. Test the architecture choice and make it reversible
Evidence request, not assumption: Ask the sponsor for 100–200 de-identified historical requests spanning ordinary cases, ambiguous descriptions, emergencies, duplicate reports, missing unit identifiers, language variation, accessibility needs, policy changes, and adversarial or irrelevant text. The data set is a test asset, not a claim of real-world performance. For each case, capture the correct queue, required missing facts, whether a human must intervene, prohibited actions, and evidence source. Include the current deterministic baseline: coordinator handling time, correction rate, escalation rate, and cost per resolved triage event, measured with a defined period and method.
Evaluate competing designs on the same cases: (A) structured intake plus deterministic routing, (B) assistant recommendation, (C) fixed LLM workflow with deterministic gates, and only then (D) bounded agent. Measure outcome correctness, emergency false negatives, unsupported claims, unnecessary clarification rate, unauthorized-action attempts, tool-selection accuracy, completion latency, cost, and coordinator override rate. Inspect traces, not just final prose: input classification, retrieved policy version, model-selected action, validation result, tool request, tool response, stop reason, and escalation outcome.
For agentic work, success must be checked in a realistic or sandboxed environment because multi-turn agents can call tools and alter state; a convincing text answer is insufficient evidence of task success. ([anthropic.com](https://www.anthropic.com/engineering/demystifying-evals-for-ai-agents?utm_source=openai)) Create red-team cases that try to override instructions, request private tenant details, induce repeated tool calls, or persuade the system to bypass approval. A release gate might require zero emergency false negatives on the critical held-out set, zero successful unauthorized tool executions, a documented fallback for every failed integration, and a demonstrated improvement over the least-complex baseline that stakeholders consider worth the added burden. Those are example release criteria for this fictional scenario, not universal thresholds.
If the agent adds no material lift, retain the simpler design. If it helps only on a narrow ambiguity class, deploy it only there. The defensible choice is not the most autonomous system; it is the smallest system with evidence-backed net value.
Applied Practice: HarborDesk Architecture-Choice Defense
Scenario: Fictional/synthetic scenario — HarborDesk, a mid-sized property-management company, receives 1,800 tenant maintenance requests per month through email and a portal. Leaders propose: “Build an AI agent that reads every request, contacts vendors, schedules repairs, and closes tickets.” The intended benefits are faster acknowledgement and less coordinator work. The risks include misclassifying emergencies, exposing tenant details, dispatching an unapproved vendor, creating duplicate work orders, and falsely closing unresolved issues. Your job is not to implement the proposal. You must decide whether any agent is justified, define the smallest acceptable architecture, and specify the evidence required before a pilot.
<p><strong>Deliverables for your Certification Portfolio:</strong></p><ol><li><strong>Opportunity brief (one page):</strong> Define the user outcome, baseline, in-scope and excluded requests, expected benefit, key uncertainties, and a statement that could disprove the need for an agent.</li><li><strong>Architecture-choice table:</strong> Compare prompt, assistant, deterministic workflow, and bounded-agent options. For each, identify path controller, actions allowed, failure modes, cost/latency implications, and why it does or does not meet the brief.</li><li><strong>Autonomy boundary:</strong> Specify goal, tool allowlist, prohibited actions, identity/role permissions, data categories, confirmation rule, maximum turns/tool calls, stop conditions, verification requirements, retry/fallback, and human escalation owner.</li><li><strong>Evidence plan:</strong> Define a representative synthetic or properly authorized/de-identified test set, baseline measures, outcome rubric, critical safety tests, trace fields, and release/no-release decision rule.</li><li><strong>Stakeholder defense (300–500 words):</strong> Recommend the least-complex architecture. State what evidence supports it, what remains uncertain, and the condition that would cause you to revise the decision.</li></ol><p><strong>Self-review checklist:</strong></p><ul><li>Have I identified a concrete model-selected decision that cannot reasonably be hardcoded?</li><li>Did I keep actual tool execution behind deterministic authorization and validation?</li><li>Does every consequential action have a verification method, owner, and stop/escalation path?</li><li>Did I treat sensitive data, access control, retention, and trace logging as system design choices rather than prompt requests?</li><li>Can a reviewer see why the agent is preferable to a fixed workflow—or see why I rejected it?</li><li>Would my test set expose both ordinary success and costly failure modes?</li></ul><p><strong>Decision Lab handoff:</strong> Submit the four artifacts plus one annotated trace for a difficult synthetic ticket. In the trace, label what was task context, application state, retrieved knowledge, model output, deterministic decision, and tool result. Your assessor should be able to challenge any autonomy claim and locate the control that contains it.</p>
Self-review checklist
- I separated user-facing model output, model-selected next steps, deterministic application logic, and actual tool execution.
- I identified at least one simpler architecture and stated why it is adequate or inadequate.
- I documented the goal, out-of-scope work, authority limits, tool allowlist, and stop conditions.
- I moved policy enforcement, permissions, calculations, validation, and irreversible actions into deterministic controls.
- I named the data categories involved and specified what is passed to the model, retained in application state, retrieved, or prohibited from durable memory/logs where applicable and policy requires it to be excluded or redacted by design—not merely instructed away by a prompt alone.
Key takeaways
- An agent is justified only when model-selected next steps are necessary to handle meaningful uncertainty or variable paths, and the added value exceeds added operational risk.
- Keep deterministic work deterministic: policy checks, calculations, routing with reliable labels, permission enforcement, tool execution, validation, logging, and irreversible-action controls belong in application logic.
- Bounded autonomy is an engineered contract: explicit goal, tool allowlist, scoped permissions, confirmation gates, verification, stop conditions, fallback, escalation, and traceability.
- A credible architecture decision compares prompt, assistant, workflow, bounded agent, and broader agentic system against representative cases—not against a vague expectation that “AI should automate it.”
- Evaluation must measure task outcome and unsafe/incorrect actions in a realistic or sandboxed environment, not merely whether a model produced plausible prose.
Useful terms
- Bounded autonomy
- A defined range of goals, actions, permissions, resources, duration, and escalation rules within which a system may operate without a new human decision.
- Deterministic workflow
- A process whose sequence, transitions, and enforcement rules are specified in code or configuration rather than selected dynamically by a model.
- Tool execution
- The actual invocation of an external capability or service. It should occur only after application-side authorization and validation, even when a model selected the proposed call.
- Application state
- Authoritative, operationally relevant facts maintained by the application, such as ticket status, approval tokens, retry count, and idempotency keys.
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.