Delegating decisions
Locate the dynamic decision
At the testing step, Horthy explains, “we go right back out into deterministic code.”
| Design | Who chooses the next step? | Who authorizes deployment? | What to inspect after failure |
|---|---|---|---|
| Fixed workflow | Code specifies the order and any error branches. | The application enforces the operator’s standing deployment policy. | The rule that fired, its input and the result of the step. |
| Model-selected loop | The model reads the last result and requests the next operation. | The same application policy can govern each request. | The result the model received, the request it selected and the attempted effect. |
| Mixed system | Model proposes, reviewer revises, code tests. | The reviewer. | Approved order, actual order, test result. |
Deployment order
Review changes which component deploys first.
Read the diagram as text
- Model proposes front end first.
- Reviewer requests and approves back end first.
- Deploy back end.
- Deploy front end.
- Code runs end-to-end check.
- Model proposes front end first → Reviewer requests and approves back end first: proposal.
- Reviewer requests and approves back end first → Deploy back end: approval.
- Deploy back end → Deploy front end: then.
- Deploy front end → Code runs end-to-end check: both deployed.
A workflow can branch, run steps concurrently or repeat a step until a condition holds. Even if a model extracts the fact used at a branch, code can still own the transition. Discretion enters when the model uses a finding to choose among approaches. Sam Bhagwat captures both directions of composition in Agents vs Workflows: Why Not Both?: “An agent can be a step. A workflow can be a tool.” A fixed incident process can delegate investigation, and the investigator can invoke a prescribed diagnostic procedure.
Different input values alone are a poor reason to delegate sequencing. If every record needs the same conversion and its validation errors have known remedies, ordinary code can express the procedure. If a model must interpret free text but the next steps are known, put that judgment inside a fixed workflow. A bounded agent becomes a candidate when an intermediate discovery can make a different investigation worthwhile. That flexibility adds calls, delay and paths to test. Workflow Automation treats the broader allocation of work across a process.
Define the permitted task
A task specification gives the agent something stable to pursue as its approach changes. Identify the target and starting conditions, the resources it may use, the changes it may make, and the limits on the attempt. State success as a postcondition, a property that must hold when the work succeeds. This gives a reviewer a way to check a different solution from the one originally imagined.
| Commitment | Permitted work | Evidence |
|---|---|---|
| Identify the intended active project. | Read project metadata within the requester’s workspace. | The ID matches the requester’s target, and its status is active. |
| Archive that project once. | Change its archive status within the assigned allowance. | The action record shows one archive change for that ID. A subsequent read confirms the archived status. |
| Leave other projects untouched. | Limit writes to the chosen project. | The record of writes for this attempt contains no other project IDs. |
If two projects fit the description, a lookup can establish which was created earlier. It cannot establish that the requester meant the older one. Present the distinguishing details and ask which project they intend. Conversely, when the requester supplies an unambiguous ID, asking them to look up its status adds an interruption the application could avoid. Prompt instructions communicate the task. The service performing the write still has to enforce its scope.
Feedback and knowledge
Feed results into the next choice
An agent can use the result of one operation to choose the next. To identify the project to archive, for example, a model might request a search by name. That request is a tool call. It names a function and supplies its arguments. If the application runs the search, the matching project records give the model an observation about its environment, the system where the work takes place. The rule or model that uses those observations and the task to select an action is called the policy.
The harness is the software around the model that manages this interaction. Its runtime carries out approved operations. Given a request, the application checks the argument values, the target and the authority to act. A rejection before dispatch gives the model a reason it can use on the next turn. On the other branch of the figure, the function actually runs. Its response, including a possible execution error, is associated with the original call. See the call interface, argument validation and what a harness controls.
Two routes back to the next decision
A rejection and an execution result both supply feedback, but only one follows dispatch.
Read the diagram as text
- Model selects an operation.
- Application checks request. Validate arguments and authority for the target.
- Reject before dispatch.
- Execute tool.
- Model chooses again. A later invocation receives feedback associated with this call.
- Model selects an operation → Application checks request: data: operation and arguments.
- Application checks request → Reject before dispatch: control: a check fails.
- Application checks request → Execute tool: control: valid and authorized.
- Reject before dispatch → Model chooses again: data: rejection reason.
- Execute tool → Model chooses again: tool result or error, if received.
Execution is closed-loop when feedback reaches a later decision. A search returning two plausible projects can lead to clarification. A search rejected for an invalid field can lead to a corrected query. The ordered observations, actions and results of one attempt form its trajectory. The same model can take those different paths with fixed weights, because the next invocation receives different evidence. Prompting and in-context learning explains how changing the input changes predictions.
Separate observations from state
An agent works under partial observability whenever relevant parts of the environment are hidden from it. Consider a service that returns a reference to a long-running operation. The client can use the reference to request status, as in Google’s AIP-151. Suppose the first read reports that the operation is running. The service can finish while that response is still the most recent one available to the model.
Between the two reads in the figure, the client can say when it last saw the operation running. It learns that the operation finished only when it receives the second response. If that lookup times out, the current status remains unknown. If the responsible service instead reports that it found no matching operation, the client has evidence that the operation was absent from the records covered by that lookup.
One operation, two status reads
ExampleThe server can finish while the client’s latest observation still says running.
The service reports that A is running. The client can justify that statement as of the first read.
Read the diagram as text
- Operation A. The reference identifies the same work across reads.
- Server during first read: running.
- First response: running. A delivered record of the earlier server state.
- Server after finishing: completed.
- Second response: completed. A new observation available to the client.
- Operation A → Server during first read: running: state at first read.
- Server during first read: running → First response: running: reported to client.
- Operation A → Server after finishing: completed: later server state.
- Server after finishing: completed → Second response: completed: reported on next read.
- Read while running. The service reports that A is running. The client can justify that statement as of the first read. Active: Operation A, Server during first read: running, First response: running. New: Operation A, Server during first read: running, First response: running.
- Work finishes. A has completed on the server. The first response remains the client’s latest evidence. Active: Operation A, Server during first read: running, First response: running, Server after finishing: completed. New: Server after finishing: completed.
- Read after completion. The client receives the new status. The first response remains historical evidence about the same operation. Active: Operation A, Server during first read: running, First response: running, Server after finishing: completed, Second response: completed. New: Second response: completed.
Record what was observed, where and when. Keep an inference such as the job may have stalled separate from the observed status and the unresolved question of whether it finished. When observations conflict, compare targets, versions and times before discarding either one. Consider how each possible answer would change the next decision. Read again when the expected benefit justifies the lookup’s cost and delay. The external state, the evidence retained across turns and the subset visible in the current model input can all differ. See Agent Memory and Context Engineering.
Architectural development
A short history of agent architectures
Moving boxes gave early agent designers a concrete planning problem. Shakey, a project at SRI’s Artificial Intelligence Center from 1966 to 1972, combined finding routes with rearranging objects. A goal could specify where two boxes should end up while leaving open which one to move first. In their 1971 paper on STRIPS, the Stanford Research Institute Problem Solver, Richard Fikes and Nils Nilsson represented actions by their preconditions and predicted effects. To plan a push, the planner needed a world description in which the robot was in position to push. Applying the operator changed that description. Moving the physical box required a separate act.
The gap between a predicted effect and an observed one made monitoring part of the planning problem. Fikes’s April 1971 PLANEX report describes checking the conditions needed by the remaining plan. If a goal already held, the robot could skip work. If a prerequisite had been lost, a short repair could restore it. If no continuation fit the current world description, the monitor could request a new plan. Keeping a plan therefore saved work even in an environment where some steps would have to change.
Other architectures changed what had to be decided in advance. In Intelligence without representation in 1991, Rodney Brooks described building mobile robots in layers, each connecting sensing to action. A working behavior could respond to its surroundings without waiting for a central description of the whole scene. The engineering question shifted from finding a sequence of modeled actions to making complete behaviors operate together in the world.
Responsiveness has its own cost. An agent that reopens every decision at every observation can spend its time choosing instead of acting. Rao and Georgeff’s 1995 belief–desire–intention account separated information about the world (beliefs), possible objectives (desires) and adopted courses of action (intentions). Retaining an intention lets later choices build on a commitment. New events can still trigger reconsideration. Dependency planning, immediate reaction and selective reconsideration answer different needs within a single task.
Language models enter the loop
In 2022, Shunyu Yao and colleagues described ReAct, a pattern for interleaving reasoning and acting with a language model. A model could express a subgoal, request a search and read the returned evidence before deciding what to investigate next. That made it possible to revise a subgoal in language midway through a task. The environment supplied the evidence. An uninformative search could also lead the model to repeat itself, a failure the authors observed in their experiments.
Aditya Bhargava of Etsy made the difference visible with a median function. An early version of his agent read the code and suggested a correction, leaving the file untouched. With a test-running tool and a feedback loop, it read the files, ran the tests, observed a failure, edited the file and ran the tests again. The second test result concerned the edited implementation. It established that the supplied tests passed. The demonstration changed both the available tools and the instructions guiding their use. Bhargava’s walkthrough shows the interaction, while Coding Agents covers repository work in depth.
Planning and action selection
Maintain an executable plan
A plan arranges actions around intermediate goals and their dependencies. If a report needs data from two independent sources, either lookup can start first, but combining the findings requires both results. A stage planned in advance exposes that dependency and the opportunity to run the lookups together. Choosing one step at a time becomes attractive where the first result determines whether the second source is even relevant. Breaking the plan into finer steps clarifies individual choices while increasing the number the agent must get right.
FactSet separates deciding on an approach from choosing individual tool calls. Its adaptation of the LLMCompiler planning architecture first produces a blueprint in ordinary language describing what the available tools can do to answer a request. A domain specialist can review the approach at that level. The blueprint also narrows the set of tools shown to the planner, which turns the steps into executable tasks. An executor runs them, and a component called the joiner combines the results so the system can finish or plan further work. Yogendra Miraje’s walkthrough shows how FactSet represents these jobs as nodes in LangGraph.
Replace a method while retaining its prerequisites
ExampleA service outage can block one route without invalidating the checked document or the output requirement.
The primary method has a checked input and an explicit output requirement.
Read the diagram as text
- Checked document. The same validated input version is available throughout.
- Primary converter. A proposed method.
- Primary service offline. A new observation blocks use of this method.
- Alternative converter. An independently available method within the delegation.
- Alternative accepts this format. The capability check establishes eligibility for this input.
- Readable text required. A postcondition to check after conversion.
- Checked document → Primary converter: planned input.
- Primary converter → Readable text required: must satisfy if used.
- Primary service offline → Primary converter: blocks execution.
- Checked document → Alternative converter: same checked input.
- Alternative accepts this format → Alternative converter: supports eligibility.
- Alternative converter → Readable text required: must satisfy if used.
- Plan conversion. The primary method has a checked input and an explicit output requirement. Active: Checked document, Primary converter, Readable text required. New: Checked document, Primary converter, Readable text required.
- Observe the outage. The availability assumption fails. The document check still applies. Active: Checked document, Primary converter, Readable text required, Primary service offline. New: Primary service offline.
- Confirm a continuation. The alternative can be tried within scope. The result will need the same check. Active: Checked document, Primary converter, Readable text required, Primary service offline, Alternative converter, Alternative accepts this format. New: Alternative converter, Alternative accepts this format.
Selective revision
Revise the part of a plan that depends on a failed assumption. Suppose a validated document needs conversion to readable text. The primary converter goes offline. The document check still holds for that version, and the output requirement still applies. Establishing that a permitted alternative accepts the same input makes another route feasible. The figure stops there: the converted text still has to be produced and checked.
A related pattern in model predictive control is to plan several inputs ahead, apply the first and solve again from the new state estimate. Its guarantees depend on a predictive model, constraints and other mathematical assumptions. For a language agent the useful analogy is choosing a point to observe again. The work spent considering possible continuations before acting is deliberation, developed in Reasoning and Test-Time Compute.
Choose a useful next action
For each eligible operation, identify the unmet requirement it could advance. For an inspection, consider what you would do with each plausible result. Checking a converter’s availability has value if one answer allows conversion and another calls for a different method. Checking again immediately after a sufficiently fresh answer usually buys little. An extra call costs time even when it changes nothing. While a turn waits for a complete response, other events may go unobserved.
Match the action to what is missing. Search can supply an external fact. A focused question can distinguish two interpretations when only the requester knows which they intended. A pending job may warrant waiting until a useful status update is available. If the evidence already answers the question, return the answer. Generating another tool call is one possible response to a turn. Choosing whether to call a tool describes that interface decision.
When several operations repeatedly serve one purpose, a task-oriented tool can perform the predictable sequence and return the result and identifiers needed downstream. A skill offers a different kind of reuse: procedural instructions in a folder with optional scripts and references. In FactSet’s report-generation example, an explicit request for a PDF distinguishes its PDF procedure from the HTML one. Selecting a matching procedure settles how to proceed only if the required inputs, tools and permissions are available. The agent must still run it and inspect the output. Agent Skills covers packaging, loading and testing such procedures.
Autonomy and intervention
Constrain accumulated effects
Bounded autonomy gives an agent discretion within explicit task, authority and resource limits. Delegated authority identifies whose permission the application is exercising, for which operation and on which resource. Someone may authorize reading a project and drafting an archive request while reserving the archive itself for review. The distinction matters most when a change is consequential or hard to reverse. A staging environment and a production environment can accept identical arguments while requiring different authority.
Suppose a task permits creating one test environment for a specified project. Before creation, a request for one environment fits that allowance. After a confirmed creation, the identical proposal would exceed it. While a creation is in flight, hold its allowance until the effect is known. Otherwise two overlapping requests could each appear individually affordable. Apply the same whole-task perspective to calls, elapsed time and spending. A turn limit alone leaves the expense of each turn open. See preserving limits across restarts.
One creation request under a task-wide allowance
ExampleThe same well-formed request can receive different decisions depending on its target and the allowance already committed.
Read the diagram as text
- Create one test environment. A proposal naming a project.
- Authorized project.
- Remaining creation allowance. An in-flight creation holds its place within the limit of one.
- Check project, then reserve slot atomically.
- Deny target.
- Withhold new creation. Resolve any pending operation before reconsidering.
- Dispatch permitted creation. The resulting environment still needs verification.
- Create one test environment → Check project, then reserve slot atomically: data: target and quantity.
- Authorized project → Check project, then reserve slot atomically: data: delegation.
- Remaining creation allowance → Check project, then reserve slot atomically: data: available allowance.
- Check project, then reserve slot atomically → Deny target: control: wrong project.
- Check project, then reserve slot atomically → Withhold new creation: control: in scope, reservation failed.
- Check project, then reserve slot atomically → Dispatch permitted creation: control: in scope, slot reserved.
Enforce these limits in the application at the protected operation. A page or tool response can contain text from someone outside the delegation. Indirect prompt injection occurs when the model treats such material as instructions and changes its behavior. For example, a page being inspected could direct the agent to export private data. Reading that direction confers no permission to comply. Scope checks must also apply during recovery, when the agent may try another tool. See untrusted content and placing controls on the action path.
Request the right human decision
In a mixed-initiative system, people and software share control. An interruption has a cost, and so does acting on a mistaken interpretation. Eric Horvitz’s 1999 account describes Microsoft’s LookOut extracting tentative appointment fields from email for a person to edit and save. When the exact time was unclear, showing a broader calendar view offered assistance without committing to a time. Narrowing the proposed action can be more useful than asking a person to approve a guess.
| Decision | What the person needs to inspect | What changes |
|---|---|---|
| Clarify intent | The plausible interpretations and the detail that separates them. | The agent knows which outcome to pursue. |
| Approve an effect | The proposed operation, exact target and significant parameters. | The reviewed operation may proceed if the remaining checks pass. |
| Accept a handoff | The outstanding work, evidence, pending effects and next action. | An identified person accepts responsibility for continuing. |
Horthy’s reviewer approved the revised order. In an application, bind approval to the significant details and recheck them immediately before execution. Changing the destination or payload can invalidate the approval. n8n’s review demonstration puts the pause directly in the tool’s execution path, so enforcing review does not depend on the model remembering to ask. See transaction authorization.
For a handoff, PagerDuty’s incident lifecycle illustrates the difference between notification, acknowledgment and resolution. A responder who acknowledges an incident owns work that is still open. For review, give the person access to evidence they can judge independently. In Duolingo’s fabricated-alert studies, exam reviewers accepted some false alerts even with guidance to inspect the video. A review record establishes who decided. Its quality depends in part on what they could see. Design Engineering and AI Interfaces covers that interaction.
Completion, stopping and recovery
Establish the achieved outcome
A verifier checks a stated property against evidence. Start from each required postcondition and identify where it can be observed. In WebArena, a posting task checks the destination subreddit as well as the posted content. Looking at the requested text in the assistant’s reply checks neither delivery nor destination. Reading the post in the wrong community confirms a real write and reveals that the task failed.
| Observation | Supported claim | Still outstanding |
|---|---|---|
| Proposed report request | The model selected a target and parameters. | Authority, dispatch and result. |
| Service returns an operation reference | The client can track the requested work. | Whether it finishes successfully. |
| Job reports success | The service reports finishing the specified operation. | Whether the right report is usable at the requested destination. |
| Read back the delivered artifact | Checks on this version support claims about its target, contents and usability. | Any requirements the checks omitted. |
Keep the artifact identity, check, result and any open requirement together. A skipped check remains open. A passing check on an earlier version needs a reason to apply to the delivered version. Another model can help interpret a result, but agreement between two summaries supplies no missing observation. Claiming the deployment passed requires the test result. See matching graders to requirements and enforcing completion checks.
Decide whether to continue
A termination condition ends the current attempt. Verified completion is one reason to finish. An exhausted allowance or a cancellation can also end an attempt with work outstanding. A pause is different again: the attempt may be waiting for an identified event that will let it resume. Deciding among these outcomes requires tracking the task, the attempt and any external operation separately.
Consider one unmet requirement: a requested environment has yet to be verified as ready. If creation is pending and time remains, wait for a status update. If status access is denied, seek an authorized reader. If repeated inspections return the same inconclusive evidence, look for a different source or defer the check. If the last permitted lookup confirms the correct environment is ready, report its identity and that evidence. If it reports pending at the deadline, end incomplete and hand off the original operation reference. Starting a replacement would risk a second creation.
Magentic-One gives progress and resource limits different jobs. Its task ledger separates facts, guesses and planned work. A progress ledger asks whether the request is satisfied, whether work is looping and whether it is advancing. Repeated stalls can send the system back to planning. Those judgments come from the model. Separate time and attempt limits can end the run even if the model would continue. Likewise, LangGraph can return a partial result before its graph-step limit is exhausted. A normal exit is compatible with an unfinished task.
When ending an attempt, report what was achieved and the evidence for it, what remains open, which operations may still take effect, why the attempt stopped, and who owns the next action or still needs to accept it. Cancellation stops further choices only to the extent the system enforces it. A remote operation may continue after the caller stops waiting. Runtime shutdown addresses how to stop owned work.
Repair the strategy from known effects
Recovery starts with what the last attempt could have changed. If validation rejected malformed arguments before dispatch, use the error to correct the request. If the application denied authority, respect that decision across other tools that reach the same resource. If a write was dispatched and its response never arrived, the receiver may already have performed it. Identical client-side errors can conceal different external states.
Reconciliation means checking what happened against the system responsible for the effect. Keep the original operation identity. If the intended effect is confirmed, preserve it and check what remains. If the receiver establishes that the operation ended without an effect, consider a corrected attempt subject to current permission and budget. An empty search while the operation could still be in flight establishes neither case. Keep that uncertainty visible. Stripe’s error guide explains why even a server error can leave payment effects indeterminate.
Choose recovery from evidence of the effect
After a timeout, a fresh write could duplicate the original effect.
Read the diagram as text
- Inspect attempt evidence.
- Respect denial. Seek the authorized decision if the task still requires the protected effect.
- Check original operation. Use its identity and authoritative receiver state.
- Retain confirmed progress. Verify remaining task requirements.
- Assess a corrected request. Check the reason for failure, current authority, prerequisites and allowance.
- Start a fresh bounded attempt.
- Retry the original request. Keep the key and parameters unchanged. Check what the response establishes about the effect.
- Defer or hand off. Record the evidence, outstanding work and original operation reference if pending.
- Inspect attempt evidence → Respect denial: authorization denied before dispatch.
- Inspect attempt evidence → Assess a corrected request: invalid arguments, never dispatched.
- Inspect attempt evidence → Retain confirmed progress: intended effect confirmed.
- Inspect attempt evidence → Check original operation: dispatched, effect uncertain.
- Check original operation → Retain confirmed progress: intended effect confirmed.
- Check original operation → Assess a corrected request: terminal with no effect.
- Check original operation → Retry the original request: effect unknown, key still honored, retry within authority and budget.
- Check original operation → Defer or hand off: pending at deadline or no safe continuation.
- Assess a corrected request → Start a fresh bounded attempt: feasible, permitted and affordable.
- Assess a corrected request → Defer or hand off: no permitted continuation.
Idempotency can make a retry safe when the receiver recognizes repeated submissions as one logical request. Reuse the original key and parameters under the receiver’s contract. Two intentionally distinct purchases can have identical parameters, so argument equality alone cannot identify a retry. A deduplicated response might recover only the original acceptance receipt. Readiness or delivery may still need a separate check. See recovery under uncertain effects and runtime handling of retries.
If an unwanted effect has already occurred, compensation is a new authorized action intended to counter it. Canceling a reservation may incur a fee and can itself fail. Restoring an old record wholesale could erase someone else’s later edit. Choose a remedy that accounts for intervening work, verify its result and escalate if no authorized remedy is available. Microsoft’s compensating transaction pattern describes this form of recovery.
Evidence for architectural choices
Explain the consequential divergence
A trace links recorded operations within an attempt. To diagnose a failed requirement, find the earliest choice or execution boundary that affected it. Two agents can inspect independent sources in opposite orders and both deliver a valid answer. The useful difference is one that changes the available evidence, violates a constraint or prevents delivery. Correlate the observation before the choice, the proposed call, the dispatch decision, the result and the final outcome. Observability covers how to link these records.
| Stage | What happened in the Apple run |
|---|---|
| Request | Voss asked the agent to write a report. He wanted it in the notebook output, but the instruction left the destination open. |
| Research | The agent gathered information about Apple before it attempted delivery. |
| File write | The agent tried to save a Markdown file. The notebook lacked write permission, so the write failed. |
| Report contents | The agent still presented a concise report. It omitted the recommendation Voss wanted about whether to buy the stock. |
The failed write suggests a testable change: explicitly request the report in the notebook output. Repeat the case with the same model, tools and permissions, then check both destination and report contents. Include a case that genuinely requires a file in a writable environment. That tests whether the repair clarified the choice or merely discouraged every file write. If the product always has one delivery destination, ordinary code can own publication and leave research dynamic. Testing failure explanations develops this comparison.
Check what the model actually received, whether the tool could express the needed operation, whether its executor worked, and whether the grader examined the right outcome. Each points to a different repair. A generated rationale can suggest a hypothesis. In Anthropic’s hint experiments, hints sometimes shifted answers without appearing in the model’s explanation. Likewise, varying resource allocation with the model and tasks held fixed changed outcomes in coding-agent evaluations. Preserve the identifiers, versions and diagnostic fields needed to distinguish such explanations, with access and retention limits for sensitive records.
Measure the value of discretion
Compare a particular delegation on the workload it is meant to serve. For instance, let one design follow programmed diagnostic branches and another select inspections from its findings. Give each the same tasks, initial state, operations, authority, assistance and resource ceilings. Include ordinary code or a fixed workflow with a model step wherever it offers a credible baseline. Reset state between trials so later runs cannot inherit earlier work. See defining the case and outcome boundary.
Score the achieved state and the process requirements separately. τ-bench checks final database state and, where required, information supplied to the user. A correct database update can pass even if the agent skipped a required confirmation. Add an explicit check for that ordering while allowing unrelated searches to vary. Repeat trials to distinguish occasional capability from consistent behavior. For a task, pass@k asks whether at least one of k independent trials succeeds. Pass^k asks whether all k succeed. Report the number of trials, the cases sampled and the assistance each attempt received. Attempts and selection policies explains how to interpret repeated results.
Exercise recovery at the point where failure matters. A fault inserted before a write tests whether the agent can correct or retry an operation that had no effect. Dropping the acknowledgment after a successful write tests whether it avoids duplicating the effect. ReliabilityBench pairs injected tool faults with checks on synthetic application state. For a changed policy, generate observations from the state its actions produce. Replaying a receipt from the old run after the new policy skipped the write gives the agent evidence of an event that never happened. See replay limits and RL Environments and Simulators.
A simple feedback procedure can be a demanding baseline. In AI Agents That Matter, researchers evaluated 164 short HumanEval function-generation tasks, running each system five times. One procedure generated another solution after failed tests and increased sampling temperature to encourage variation. Its accuracy did not differ significantly from that of the best-performing complex architecture, and it cost less than several tested agents. That comparison concerns short functions with supplied tests. Open-ended investigations and human supervision present different costs.
For each design, report acceptable completions, prohibited effects, premature success claims and unresolved tasks. Record which interventions were needed, how much reviewer time they took, total elapsed time and expense per attempt. A handoff can be the correct response to missing authority and still impose work on a person. These measures support a specific decision: retain dynamic investigation if it resolves cases the fixed procedure misses, and reserve a consequential write for software or a reviewer if delegating it brings little benefit.
Reference
Frequently asked questions
Does a chatbot become an agent when it calls a tool?
Look at who selects subsequent work. A chatbot can collect arguments for a predetermined lookup and format its result inside a fixed workflow. If it can inspect that result and choose which investigation to pursue, the application has delegated an agent decision.
Can a workflow contain an agent?
Yes. A workflow can assign a bounded investigation to an agent and resume its prescribed steps when the agent returns a finding. Composition also works in reverse. An agent can select a diagnostic workflow as a tool while code determines each step inside that procedure.
Does an agent need a plan or new training after each result?
An agent can choose just its next action from the goal and the latest evidence. An explicit plan helps when actions have dependencies worth inspecting in advance. Feedback changes the input to the next model invocation, so the model’s trained parameters can stay fixed throughout the task.
When should an agent ask for help?
Ask for clarification if only the requester can resolve a choice that changes the acceptable outcome. Request approval when a specific effect requires their authority. Seek a handoff when progress requires another owner’s access or judgment. Give that person the proposed action or outstanding work and enough evidence to decide.
Does a successful tool response mean the task is done?
Interpret success according to the tool’s contract. A job service may have accepted work, or a publishing tool may have written text to the wrong destination. Check the identified artifact or state against the requester’s requirements before claiming delivery.
Does giving the agent more autonomy improve results?
More autonomy is valuable when observations reveal useful actions that the prescribed path would miss. It also introduces variable costs, additional failure paths and possible review work. Compare the smallest delegation that solves the problem with a simpler procedure under the same task conditions.
Do I need a framework or several agents?
One model and an application loop can select an action, execute a permitted request, return the result and stop. A framework can supply machinery for that loop. Add collaborators when the work warrants coordination. Multi-Agent Systems covers division of work, and Model Context Protocol covers interoperability between applications and tools.
Open questions
How much discretion pays for itself once human effort is counted? More adaptive paths can solve unfamiliar cases while creating extra review and correction. Matched trials that vary a single delegated decision and record both acceptable outcomes and reviewer time would make that tradeoff visible.
How can an agent distinguish a stalled strategy from productive waiting? Both can produce the same status on successive reads. A better progress test would detect futile loops without discarding valid pending operations or repeatedly interrupting their owners.
Which human interventions improve the decision enough to justify the interruption? Reviewers may accept incorrect automated suggestions, yet withholding review can allow consequential mistakes. Comparing review designs on the same proposed effects, with independent outcome checks and measured reviewer effort, would help identify where review adds value.





























































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































