Living guide
AI agents: from promise to an accountable workflow
A plain-language anatomy of agents, their failure modes, and the controls that make delegated work observable and reversible.
An AI agent is not simply a chatbot with a longer prompt. It is a system that can observe state, choose steps, use tools, and continue toward a goal. That extra ability makes boundaries, evidence, and recovery part of the product, not administrative decoration.
01
What we know now
- 01
NIST organizes AI risk work around Govern, Map, Measure, and Manage functions.
- 02
Tool access grants capability; it does not verify that a proposed action is correct or authorized.
- 03
Useful agent systems separate planning, execution, evidence, and release authority.
02
Why this matters for Armenia
Small teams can gain capacity from agents, but only if the system has a narrow mandate, least-privilege tools, visible evidence, and a reliable stop path.
03
observe
read trusted state and evidencepropose
select one bounded next stepauthorize
check scope and consequenceact
use the least-privilege toolverify
inspect the actual resultrecord or stop
checkpoint, quarantine, or finishThe loop is safe only when every transition has a defined failure path.
04
The six parts of an agent
A practical agent has a mandate, context, a decision loop, tools, state, and a stopping rule. The mandate says what outcome is allowed. Context supplies instructions and evidence. The loop selects the next bounded step. Tools perform actions. State records what changed. The stopping rule ends work when the goal is met, risk rises, or evidence is missing.
A polished language response can hide weakness in any of these parts. The system may misunderstand the mandate, retrieve stale context, choose an irreversible tool, lose state, or continue after its authority ends. Evaluate the whole workflow rather than the model alone.
- Mandate: the permitted objective and explicit exclusions.
- Context: trusted instructions, sources, and current state.
- Decision loop: how the next action is selected.
- Tools: narrowly scoped capabilities.
- State: logs, versions, and recoverable checkpoints.
- Stop rule: completion, quarantine, timeout, or operator stop.
05
Permission, correctness, and release are different
A valid file-writing credential authorizes an attempted write. It does not establish that the write succeeded, reached the intended file, or produced a correct result. A publication credential similarly authorizes a service to attempt a public-state change without proving that the article is accurate. Good design keeps authorization and technical capability separate from verification and gives the release controller only the evidence needed for an exact decision.
Least privilege narrows damage when reasoning fails. Read tools should not silently become write tools. A drafting agent should not hold a deployment credential. Consequential actions should have explicit targets, dry runs where possible, immutable receipts, and a rollback path.
- Capability answers: can the system act?
- Authorization answers: may it act here?
- Verification answers: does evidence support the action?
- Release answers: did the exact artifact clear every gate?
06
Five common failure modes
Agents can optimize the wording of a goal while missing its purpose, follow malicious instructions hidden in retrieved material, repeat an action after losing state, treat tool output as proof, or make a locally sensible change that breaks a downstream system. None of these requires an obviously irrational model response.
Controls should match the failure. Untrusted content needs isolation from instructions. Repeatable actions need idempotency keys. Claims need source checks. Writes need target validation and recovery. Long workflows need durable checkpoints and fresh authorization at the moment a consequential action occurs.
- Goal drift: success on the wrong interpretation.
- Instruction injection: untrusted content changes behavior.
- Duplicate action: a retry repeats an external change.
- Evidence substitution: a tool response is accepted without checking.
- Integration failure: one correct step leaves the system inconsistent.
07
Use Govern, Map, Measure, Manage as a loop
NIST's AI Risk Management Framework offers a useful organizing pattern. Govern establishes ownership and policy. Map defines the use, affected people, context, and failure consequences. Measure tests performance and records uncertainty. Manage selects controls, monitors operation, and responds when the system departs from expectations.
For a small team, this can be one page rather than a department. Name the owner, list allowed tools, describe the worst plausible failure, choose a test, define a stop rule, and retain a record. Add complexity only where the consequence justifies it.
- Govern: one accountable owner and a versioned mandate.
- Map: users, data, dependencies, and consequences.
- Measure: task tests, failure counts, and uncertainty.
- Manage: controls, monitoring, quarantine, and recovery.
08
Before an agent receives a write tool
A useful first deployment is narrow, observable, and easy to reverse.
- 01
Write the allowed objective and excluded actions in plain language.
- 02
Separate trusted instructions from retrieved or user-supplied content.
- 03
Constrain tools to explicit resources, targets, and spending bounds.
- 04
Make retries idempotent and keep durable checkpoints.
- 05
Test failure, cancellation, rollback, and stale-state behavior.
- 06
Require fresh evidence before any consequential release.
09
Limits of this edition
The NIST framework is voluntary and must be adapted to the actual context.
A checklist cannot eliminate model uncertainty or integration failures.
This guide addresses routine organizational automation, not high-consequence deployment.
SRC
Source desk
Direct links to the material behind this selection. Seeing the source matters as much as reading the synthesis.
