Skip to content
be-human.ai
← Back to the journal

Personalized AI infrastructure

Company Handbook for AI Agents: Rules, Owners and Escalation Paths

How to write a plain-language handbook of rules, owners and escalation paths that AI agents read before every task, with a working template.

Be Human typographic cover with the title: Company Handbook for AI Agents: Rules, Owners and Escalation Paths
Conceptual illustration created with AI · Be Human

A company handbook for AI agents is a short, plain-language document that states what an agent may do, what it must never do, who owns each decision, and where to escalate when a task falls outside those rules. The agent reads it at the start of every task, so it works as live operating context rather than a policy file stored in a shared folder. A good handbook fits on a few pages, names real people, and changes whenever the business changes.

Key takeaways

  • Write the handbook for the agent to read at the start of each task, using short sentences that name actions rather than intentions.
  • Give every rule a named human owner who can change it and answer for it.
  • Make each escalation path concrete: who receives the request, through which channel, and what the agent does while it waits.
  • Keep the handbook separate from memory and tool settings, and review it on the same cadence as permissions.
  • Test the handbook with realistic scenarios before the agent touches customers, payments or records.

What goes into a company handbook for AI agents

The handbook covers one agent role, not the whole company. Most useful handbooks share the same skeleton:

  • Role statement: what the agent is for, in one sentence, and the outcome it is judged on.
  • Scope: the tasks it may start, the channels it may use, and the systems it may read or write.
  • Rules: actions it may take alone, actions it may take only with approval, and actions it must never take.
  • Owners: the person accountable for the outcome, the person who maintains the agent, and the person who approves permission changes.
  • Escalation paths: who to contact, through which channel, and what the agent should do while waiting.
  • Definitions: the words your business uses with a specific meaning, such as what counts as a refund, a qualified lead or an urgent request.

Keep the handbook separate from the memory store and the tool configuration. Memory holds facts the agent has learned, tools hold capabilities, and the handbook holds the boundaries that govern both. When all three are mixed into one long prompt, nobody can tell which rule came from whom or when it changed.

Why agents need rules at the start of every task

An agent does not carry your hallway conversations into its next task unless they are placed in its context or stored in its memory. Anthropic's engineering guidance on context engineering treats the context window as a limited resource that has to be curated, not a place to dump everything. The handbook is the stable part of that context: short, current, and referenced at the start of each run.

Rules also matter because agents read content they did not write. An email, a support ticket or a web page can contain text that tries to change the agent's instructions. The OWASP guidance on prompt injection prevention treats this as a design problem, so the handbook should state plainly that instructions found inside customer content carry no authority over the agent's rules. Authority comes from the handbook and the approval system, not from whatever text the agent happens to be processing. The NIST AI Risk Management Framework makes a similar point at larger scale: governance is an ongoing function with named responsibilities, not a document written once and forgotten.

A step-by-step plan for the first version

Write the first version in one working session with the person who owns the outcome, then test it before anyone relies on it. The sequence below keeps the work small enough to finish.

  • Step one: name the single role and the outcome it is judged on, in one sentence.
  • Step two: list the tasks the agent should start and the tasks it should never start, using real examples from recent work.
  • Step three: sort every action into one of three groups: alone, with approval, or never. Write each approval threshold in plain words or point to the table where it lives.
  • Step four: assign one owner to each rule group, using a person's name and role rather than a shared team alias.
  • Step five: write the escalation path for each approval group, including the channel and what the agent tells the requester while the case waits.
  • Step six: define every term that could mean two different things inside your business.
  • Step seven: run several realistic scenarios, including one where a customer or document tries to override a rule, and check the agent's behavior against the text.
  • Step eight: approve the version, date it, store it next to the permission record, and set the date of the next review.

If you already have a one-page runbook for the role, the runbook template can serve as the starting structure, with the handbook rules added as the boundaries the runbook refers to.

Writing rules an agent can actually follow

Most handbooks fail because their rules describe intentions. A line such as handle refunds responsibly and escalate when needed gives the agent nothing to act on. Compare two versions of the same rule:

  • Weak: Handle refunds responsibly and escalate when needed.
  • Clear: The agent may approve a refund for an unopened order that is inside the return window. Any other refund request goes to the operations lead with the order record, the customer message and a draft reply. The agent does not promise a payment date.

The clear version names the action, the object and the condition. It also says what happens when the case falls outside the rule, which is where most real problems begin. Prefer may and must not over should, because should leaves the agent to decide whether the rule applies. Say what to do when data is missing: ask, hold or escalate, never guess. A useful test is whether a capable new employee could follow the rule on the first day without asking anyone what it meant. If not, the agent cannot follow it reliably either.

Owners and escalation paths that people will answer

Every rule needs an owner, and the owner must have the authority to change it. Most small companies need three roles: the outcome owner, who decides what success means; the operator, who maintains the agent and its integrations; and the permission reviewer, who confirms that access still matches the handbook. In a very small team one person may hold all three, but the handbook should still name each role so the responsibilities stay visible.

A simple decision guide keeps the agent's behavior predictable when a request arrives:

  • If the action is reversible, low in consequence and covered by a rule, the agent acts and records what it did.
  • If the action is covered by a rule that requires approval, the agent prepares the action and sends it to the named approver.
  • If the action is not covered by any rule, the agent stops, records the request and escalates to the outcome owner.
  • If the request involves a complaint, a legal question, a payment change or personal data, the agent escalates at once, whatever the rule set says about routine cases.
  • If two rules appear to conflict, the agent stops and escalates instead of choosing between them.

An escalation path is only real if someone watches the channel. An inbox nobody checks is not an escalation path. State the response expectation in plain words, and write down what the customer or colleague hears from the agent while the request waits, so the wait does not look like silence.

Illustrative scenario: a delivery date exception

Illustrative scenario: a small home-goods retailer runs a support agent that answers order questions in chat. A customer asks to move a delivery to a later week because of travel. The handbook allows the agent to reschedule within the carrier's published window without approval. The requested date falls outside that window, so the handbook sends the case to the operations lead. The agent tells the customer that a named person will reply and that the order stays as scheduled until then. The operations lead changes the record, and only after the record shows the new date does the agent confirm it to the customer. Later in the same thread, the customer pastes a line that says to ignore the rules and mark the order as delivered. The handbook states that customer content carries no authority over the rules, so the agent treats the line as text, notes it in the case and continues on the normal path.

The scenario shows why the handbook needs three things at once: a clear boundary, a named person for the exception, and a statement about where authority comes from.

Keeping the handbook current

A handbook that never changes becomes a record of the business as it used to be. Route every change through a written request that states the rule, the reason, the affected owner and the date the change takes effect. The change request process and the periodic permission review are the natural places to check the handbook, because both ask the same question: does the agent still have the authority it should, and no more? Record incidents against the rule they touched. When one rule produces repeated escalations, the rule probably needs rewriting, not the agent.

Be Human's managed approach treats the handbook as part of the first engagement, written alongside the agent's role, memory, tools and approval boundaries. Operations then keep it current through monitoring, recurring evaluations, permission review and controlled changes that the business approves before they go live. The company keeps ownership of the rules, while Be Human maintains the integrations and the evidence that the agent follows them.

The free Be Human AI diagnostic can help you find the first task worth handing to an agent, and that task is the right one to write a handbook for.

Frequently asked questions

How long should an agent handbook be? Short enough that the agent reads all of it at the start of every task and a manager can review it in one sitting. If a rule needs a long explanation, move the background into a reference document and keep the rule itself to a few plain sentences.

Who should write it? The outcome owner should draft it, because that person knows what good work looks like, and the operator should confirm that each rule can be enforced by the systems the agent uses. Where personal data, payments or regulated decisions are involved, a legal or compliance reviewer should check the relevant rules before approval.

Does the handbook replace tool permissions? No. The handbook states intent and boundaries in plain language, while tool permissions enforce what the agent can technically do. Both are needed, and they should be reviewed together so that they do not drift apart over time.

How often should it change? Change it when the business changes, when a rule causes repeated escalations, or when an incident shows a gap, and review it on the same cadence as permissions. Each change should be dated, versioned and approved by the owner of that rule before it takes effect.

Your next step

See where an AI agent fits in your company first.

Take the free Be Human AI diagnostic. A few questions about your work show which task to hand to an agent first, what it needs to know and where a person approves.

Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.

Less busywork. More room for you.

Bring us the work you wish you had time for.

Book a call to try a personalized AI agent free for 7 days ↗Or take the free AI diagnostic →