Write a shared specification of the task, its limits and the evidence needed to accept the result.
What you'll learn
- Define the trigger, inputs, output, exceptions and human handover.
- State whether the agent drafts, schedules, sends or changes a record.
- Use real cases and keep unresolved decisions with named owners.
- Test actual results, permissions and recovery before live actions.
Say you show an implementer a successful follow-up email. The example shows the wording, but not why it was sent, who approved it or when it should have stopped. A brief records those decisions so the builder and reviewer can test the same intended workflow.
What is an AI agent brief, and what is it not?
An agent brief is an agreed specification of the task, its limits and the result the reviewer should accept. A prompt may be part of the implementation, but a fluent example alone does not define who may send, change a record or decide an exception.
Test cases that differ from the examples too. Missing context, conflicting instructions and unexpected requests can expose tasks an agent handles badly, even when its routine draft sounds convincing.
A brief is not a prompt. It is a specification of a business process — a document you can rehearse with an unfamiliar reader to find missing context. Writing it is a process-documentation exercise, not a prompt-writing exercise.
A vague brief leaves decisions undefined even when the prompt produces fluent text. Discovering those gaps before launch avoids asking the team to resolve them repeatedly in live work. Put each unresolved decision with a named owner before treating it as an agreed rule.
Which five questions must every brief answer?
Use these five questions to organise the specification. Record the normal path, decisions that change it and what happens when no rule fits. The example waiting period and word limit are chosen policy settings, not universal recommendations.
The brief defines the task, allowed actions and human handover. Use it to find missing decisions, then test the running agent, its connections and permissions against those requirements.
A complete brief answers five questions. If any one of them is missing, the brief is incomplete.
What does each AI agent brief question require?
Each question needs a specific, testable answer rather than a description of intent.
1. What triggers the agent? A specific, observable event that starts the workflow. Not "when a lead needs following up" — "when five business days have passed since the approved proposal message, no later reply is recorded and the proposal remains open." The trigger must be testable: either it fires or it doesn't.
2. What does the agent receive? The exact inputs available at the moment the agent runs. Field names, data types, which fields may be empty, which are always populated. An agent cannot use information it was not given. Define how a missing or contradictory value changes the next step.
3. What does the agent produce? The specific output, in a specific format. Not "a follow-up email" — a follow-up email with these fields, this tone, this maximum length, this subject line structure. Include recipient and allowed action, and state what evidence the reviewer uses to accept the result.
4. What are the acceptable exceptions? Every workflow has cases that fall outside the main path. The brief names them explicitly: which inputs trigger a different output, which cases get routed differently, which situations require a human decision. "It depends" is not an exception rule.
5. What happens when the agent can't decide? The escalation path. A specific action for inputs that don't match any defined case. Not "the agent will handle it appropriately" — a named step. Flag for review. Send to a queue. Reply with a holding message. Test that the workflow actually stops and the receiving person can act on the handover.
What do the five brief answers look like for a lead follow-up?
The lead follow-up workflow below fills all five answers with one concrete value each.
The table sets out what each of those five answers specifies for the same case.
| Brief component | What it specifies | Example — lead follow-up workflow |
|---|---|---|
| Trigger | The observable event that starts the workflow | Open proposal, five business days since approved send, no later reply or contact restriction |
| Inputs | Exact data fields available when the agent runs | Record and recipient identity, approved-send date, latest reply, proposal status/value, contact restrictions, approval owner |
| Output | The specific deliverable, format, and length | Follow-up email: subject line format, chosen 150-word limit, account-manager voice, recipient and approval recorded |
| Exception rules | Named cases that follow a different path | "Do not contact" tag → skip; proposal value above the agreed review threshold → route to founder for manual send |
| Escalation path | The defined action when no rule matches | Flag for manual review; add to "Needs attention" CRM queue with an agreed review deadline |
What happens when a brief is incomplete?
A fluent output does not settle a decision the brief left undefined.
A brief can describe the common case while leaving unusual inputs unresolved. Early successful examples do not prove that the agent has rules for a missing value, conflicting instruction, or unexpected request.
Without a stop and review path, an uncovered case can produce an output that looks plausible but is wrong. Repeated corrections can consume the time the workflow was meant to recover. Investigate whether the cause is a missing business rule, a faulty connection, a permission problem, or unreliable model behavior before changing the brief.
Define unresolved cases as explicit holds for review. The person responsible can then decide whether to add a rule, repair the connection, or keep that task outside the agent’s scope.
How do you write a brief before you know what to put in it?
Build the brief from actual work rather than memory alone. Observe routine cases and meaningful variations, then record the decisions and sources the written version needs.
How do you observe the work a brief has to describe?
Shadow the person doing the task. Include normal work, incomplete inputs and cases that need a different outcome or a human decision. Compare the ideal description with what the actual tools and records allow.
For each instance, record the trigger, available information, decision, output, and exceptions. Choose cases for meaningful branches rather than treating a fixed count as coverage. Ask the operator about rare consequential cases and add the agreed handling or a stop for review.
A shadowing session produces a draft brief. Test it against fresh cases held out from the walkthrough. A gap may need a clearer rule, an additional source or another action; assign the fix before live work relies on it.
What are the seven steps of a shadowing session for an AI agent brief?
A shadowing session runs in seven steps, from choosing the person to shadow to testing the draft on fresh cases.
Choose the right person to shadow
The person who currently does the task, not the person who explains it best. The explainer knows the ideal case. The doer knows what actually happens.
Observe representative real cases
Watch the workflow run on actual inputs with actual outputs. Described examples reflect what the person thinks they do. Observed instances reflect what they actually do — including the variations they do not consciously notice.
Record the same five fields for each instance
What triggered it, what information was available, what decision was made, what was produced, and whether any exception was handled. Compare entries to identify meaningful differences and the source of each decision.
Identify the common path
Identify the normal path from observed cases and confirm it with the task owner. Keep variations separate; a repeated pattern does not establish complete coverage.
Extract exception rules from real cases
Exceptions found in the observed cases are named explicitly in the brief. Each one specifies the condition and the different path it triggers. "When X, do Y instead" — not "handle appropriately."
Write the escalation path for everything else
Cases that did not appear but could — ones the doer can describe from experience — go into the escalation path with a specific action. The escalation path is the brief's definition of "I don't know" — and it cannot be left undefined.
Test the draft against fresh real inputs
Use new cases, including routine work and meaningful exceptions. Record the expected result first. Fix ambiguous rules or missing sources and repeat affected checks before live actions.
What are the most common briefing mistakes?
Use the table to review gaps that can otherwise become correction work. These are failure scenarios to test, not measured frequencies. A configured stop can contain an unclear case before a live mistake.
| Mistake | What it looks like in the brief | Failure to test for |
|---|---|---|
| Description instead of trigger | "When a lead needs following up" | Agent triggers inconsistently; different runs produce different results |
| General inputs instead of field names | "The CRM information about the contact" | Agent fails on records with missing fields; errors are unpredictable |
| Output category instead of format | "A follow-up email" | Output format varies every run; team edits every output before sending |
| No exception rules | Brief covers the main path only | Agent applies the main-path logic to minority cases; wrong outputs compound each month |
| No escalation path | "The agent will handle it" | Undefined inputs produce confident-looking outputs that are quietly wrong |
| Brief written from ideal-case data | All examples use complete, well-structured records | Missing, inconsistent or unusual inputs have no safe handling path |
For each applicable row, write the expected behaviour and the test that exposes the gap. Check the cause too: connections, permissions and model behaviour can fail even when the business rule is clear.
How do you validate a brief before the build starts?
Test the brief with real inputs and write the expected result before running anything live. Cover a normal case, a missing required field, a duplicate record, an unavailable tool, and an action that needs permission. Agree the action and exception owner for each case before asking the builder to implement it.
Anthropic's January 2026 evaluation guide describes a task with defined inputs and success criteria and separates the agent's claim from the final system result.[1] Apply that distinction to acceptance: reported sending and a verified saved result are different evidence.
The new hire test. Give the brief to someone who does not know the workflow. Ask them to describe what they would do with a real input. Questions reveal missing information; a different answer reveals ambiguity. This is a useful review, not proof that every case is covered.
The exception walk. Use recent unusual cases and ask whether the brief specifies an action or a stop. Add cases that did not appear in the sample but could matter, including missing consent or two records matching the same person. Keep unresolved cases with a named reviewer.
The action test. State whether the output is a draft, a scheduled action, or an immediately sent message. Name who may approve it and what evidence confirms success. If a connection fails halfway through, define whether to retry, verify the result first, or ask a person. Review the finished workflow against these criteria before giving it live sending or write access.
Passing these tests reduces ambiguity. It does not guarantee complete coverage or replace testing the actual permissions and connections.
Download the AI agent briefing checklist (PDF)
How does the brief become the implementation?
A complete brief is the specification for the implementation. It does not replace connecting the tools, enforcing permissions, testing the workflow, or assigning operational responsibility.
The five questions in the brief correspond directly to the five components of an agent system: trigger logic, input schema, output template, conditional routing, and fallback handling. The builder still has to verify how the real tools support the requirements and identify remaining questions.
The time needed to write and validate the brief depends on the workflow, its exceptions, and the quality of existing records. Estimate against those dependencies and acceptance tests rather than the document length.
The brief establishes agreed business rules. Implementation quality also depends on the connections, permissions, tests, and ongoing operation. Resolve ambiguities before launch while continuing to check the running workflow afterward.
Frequently asked questions
What is an AI agent brief?
An agent brief is a specification of the workflow: trigger, inputs, output format, acceptable exceptions, and escalation. It gives the builder and reviewer a shared definition of the expected result. It is not a prompt or a replacement for implementation testing.
What five questions must an agent brief answer?
Define what triggers the agent, what inputs it receives, what it produces, which exceptions have agreed handling, and what it does when it cannot decide. Include whether it may only draft or may also send and change records.
What happens when an agent brief is incomplete?
An input outside the described cases may lead to a wrong output or an undefined action. A configured stop and review path can contain the problem. Corrections after launch can reveal a missing rule, but they can also reveal a connection, permission, or model problem.
How do you write a brief if the process is not documented?
Observe the person who does the work using representative real cases. Record the trigger, available information, decision, output, and exceptions. Select cases for meaningful branches and seek rare consequential cases separately.
How do you validate an agent brief before building?
Record expected results for normal and exceptional cases, ask an unfamiliar colleague to follow the brief, and define approval, stopping, and recovery rules. Then test the connected implementation against those criteria before granting live sending or write access.
Notes
- Demystifying evals for AI agents. January9,2026 Accessed October 15, 2026.
