AI agents production playbook

Use before building an agent so autonomy is earned by a clear job and control model.

Create a bounded AI agent brief. Define the job, trigger, inputs, approved knowledge, tools, permission levels, state, expected outputs, escalation triggers, human hand-off, audit events, recovery behavior, and success metrics. Include three representative examples, two edge cases, and one unsafe request the agent must refuse. End with the smallest tool surface to launch.

Workflow context:
[PASTE CONTEXT]
Systems and tools:
[PASTE TOOLS]
People involved:
[PASTE ROLES]

Output: An agent brief with permissions, hand-offs, and evaluation cases.

Guardrails: Default to read-only tools · Require approval for consequential writes · Name refusal and recovery behavior

Use when stakeholders disagree about what a good agent response or action looks like.

Turn this agent idea into a success contract. Define the user, job, acceptable input range, output schema, evidence or citations required, latency expectation, cost guardrail, human review, refusal behavior, and outcome measure. Add examples of a pass, a useful partial result, and a safe refusal. Mark every field as required, optional, or unknown.

Agent idea:
[PASTE IDEA]
Users and context:
[PASTE USERS]
Known constraints:
[PASTE CONSTRAINTS]

Output: A reviewable contract for useful, safe agent behavior.

Guardrails: Do not treat fluent prose as success · Keep unknown requirements visible

Use when an agent needs retrieval, customer data, documents, or internal operating knowledge.

Design an approved context policy for this agent. Classify each source by authority, sensitivity, freshness, provenance, retention, and allowed use. Specify how the agent should handle conflicts, missing context, untrusted content, stale records, and requests for data outside the user’s permission. Return a retrieval checklist and a reviewer-visible evidence block.

Agent job:
[PASTE JOB]
Sources:
[PASTE SOURCES]
Identity and access rules:
[PASTE RULES]

Output: A governed context and provenance policy.

Guardrails: Treat retrieved content as untrusted input · Do not hide source conflicts · Respect user permissions

Use before giving an agent APIs, browser actions, databases, or write access.

Define the smallest safe tool surface for this agent. For each tool list purpose, inputs, outputs, data scope, rate limit, failure mode, permission level (read, draft, or write), approval requirement, and audit event. Include a mock or dry-run path for testing and the exact conditions that block execution.

Agent job:
[PASTE JOB]
Candidate tools:
[PASTE TOOLS]
Risk constraints:
[PASTE CONSTRAINTS]

Output: A tool registry with least-privilege controls and dry-run behavior.

Guardrails: Default to read-only · Separate drafting from execution · Require approval for irreversible actions

Use only when one bounded agent cannot cover the work without clear specialisation or hand-offs.

Design a multi-agent workflow for this goal. Assign each agent one bounded responsibility, input contract, output contract, allowed tools, and hand-off condition. Define the orchestrator’s state, timeouts, retries, conflict resolution, human checkpoints, and final acceptance rule. Recommend where a deterministic step is safer than another agent. Do not expose private chain-of-thought; return concise rationale and observable artifacts.

Goal:
[PASTE GOAL]
Candidate responsibilities:
[PASTE RESPONSIBILITIES]
Systems and people:
[PASTE SYSTEMS AND ROLES]

Output: A stateful orchestration plan with safe hand-offs.

Guardrails: Prefer the fewest agents that satisfy the job · Make conflicts and retries visible · Keep a human recovery path

Use when an agent’s output needs review before it becomes a customer, financial, legal, or production action.

Design a human checkpoint for this agent workflow. Show the reviewer the decision, evidence, proposed action, uncertainty, policy checks, and alternatives in a compact review surface. Define approve, reject, edit, request-more-context, and escalate paths, plus the audit event and recovery action for each. Include a target review time and a rule for pausing the workflow when the reviewer cannot decide.

Workflow:
[PASTE WORKFLOW]
Proposed action:
[PASTE ACTION]
Policies and evidence:
[PASTE POLICIES AND EVIDENCE]

Output: A review interface and decision-state contract.

Guardrails: Never hide uncertainty from the reviewer · Approval must be attributable · Pause when authority is unclear

Use before production launch or after a model, prompt, data, or tool change.

Create a release gate for this AI agent. Include representative tasks, edge cases, missing-context cases, prompt-injection attempts, tool failures, permission violations, and human escalations. For each test define input, expected behavior, unacceptable behavior, required evidence, reviewer rubric, and telemetry. Mark failures as block, fix-before-next-release, or monitor.

Agent job:
[PASTE JOB]
Tools and data:
[PASTE TOOLS AND DATA]
Known incidents:
[PASTE INCIDENTS]

Output: A release gate with observable test cases and owners.

Guardrails: Include malicious and ambiguous inputs · Evaluate behavior and evidence, not hidden reasoning

Use when a live agent can fail, loop, use stale data, or take an action that needs reversal.

Write a recovery runbook for this agent. Cover stale or conflicting context, tool timeout, duplicate action, unsafe output, policy violation, human override, model outage, and unexpected cost or latency. For each case define detection signal, immediate containment, user communication, rollback or compensating action, owner, evidence to retain, and the condition for resuming autonomy.

Agent and workflow:
[PASTE WORKFLOW]
Dependencies:
[PASTE DEPENDENCIES]
Incident roles:
[PASTE ROLES]

Output: A practical recovery and resume policy.

Guardrails: Contain before retrying · Preserve a human recovery path · Keep incident evidence

Use when a general agent pattern needs to become a reusable service playbook.

Adapt the agent brief below for [SERVICE]. Preserve the decision it supports, then add service-specific inputs, vocabulary, sources, tools, permissions, output schema, human review, success metric, and failure modes. Return purpose, when to use, required context, agent contract with variables, example input, expected output, tool policy, evaluation cases, and escalation rules.

Base agent brief:
[PASTE BRIEF]
Service context:
[PASTE SERVICE CONTEXT]

Output: A service-ready agent playbook.

Guardrails: Keep the original decision visible · Do not add unsupported capabilities · Require a human owner

Use when a product or SaaS team wants to test agent assistance without committing to broad autonomy.

Scope a four-week product agent pilot. Choose one user or internal job, one bounded workflow, one approved data set, and one reviewer. Define the baseline, intervention, success measure, quality rubric, escalation path, and stop/continue rule. Include what remains manual and how pilot evidence will inform the next product decision.

Product context:
[PASTE CONTEXT]
Team and users:
[PASTE TEAM AND USERS]
Constraints:
[PASTE CONSTRAINTS]

Output: A bounded pilot plan with baseline, rubric, and decision rule.

Guardrails: One primary workflow · No production write access by default · Define what stays manual