Personalized AI infrastructure
Documentation Standards for a Superintelligence-Ready Company
Minimum documentation standards for processes, roles and AI agent scopes, so company knowledge survives tool and model changes. A how-to for leaders.

Documentation for AI agents means writing down, in a stable form, the processes an agent follows, the roles that own each decision, and the exact scope the agent may touch. A company meets a useful minimum when someone who did not build the agent can run the process from the documents alone and predict what it will do. That standard matters most when tools and models change, because the knowledge then has to live in company records rather than in a prompt or a vendor's settings.
Key takeaways
- Documentation for an AI agent covers four things: the process it follows, the role that owns each decision, the scope it may touch, and the evidence that it behaved as designed.
- A document meets the standard only when an outsider can use it to predict the outcome of recent cases.
- Write processes in terms of triggers, inputs, decisions and handoffs, not in terms of a product or model name.
- Every agent scope needs a named human owner, an explicit list of tools and data sources, and approval boundaries written in plain language.
- Keep a change log and a review date on every document, so that a tool or model change updates the record instead of replacing it.
Why documentation decides whether knowledge survives change
Most companies treat their operating knowledge as something that lives in people's heads and in shared folders. When an agent is added, a third place appears: the instructions, tool definitions, memory stores and permission settings that tell the agent what to do. If that third place is the only complete record, the company has handed its knowledge to whichever tool holds it. A model upgrade or a change of vendor then forces a rebuild from memory, and the rebuild is usually incomplete in ways nobody notices until a customer or a colleague does.
The fix is not a large manual. It is a small set of standards that every process, role and agent scope must meet before it counts as ready. The standards are deliberately plain, so an operations leader can check them without reading code, and they apply whether the company runs one agent or several. A useful test is to ask whether the documents would still make sense if every tool in the stack were replaced next quarter.
Standard one: write each process as a procedure someone can check
A process document should describe the work as it is actually done today, including the exceptions the team quietly handles. Describe what the process achieves and which decisions it makes, not which product performs each step, because products change more often than processes do. The minimum content is short:
- Name the trigger that starts the process and the source it reads from.
- List the inputs required, and state what to do when one is missing or unclear.
- Write each decision as a question, with the possible answers and the rule that selects one.
- Write each action in the form "who or what does what to which record."
- State the output, where it goes, and what counts as done.
- Record the exceptions the team handles today, including the informal ones.
Test the document before relying on it. Give it to someone outside the team and ask them to predict the outcome for three recent cases, including one unusual case. If they cannot predict an outcome, the document is missing a decision rule, and that gap will become a silent failure once an agent starts acting on it.
Standard two: name a human owner for every role and decision
Every role, whether held by a person or an agent, needs one accountable human owner. The owner is not necessarily the heaviest user of the agent. The owner approves changes to the role's scope, decides exceptions, and receives incident reports. When a document lists a team or a shared mailbox as owner, accountability usually disappears at the first incident.
Separate three things in every role document: what the role is for, what it may decide alone, and what it must hand to a person. The third item is where most unclear documents fail. A role that may "update customer records" needs a sentence about which updates it may make without approval, which ones need a reviewer, and what it does when the data conflicts with another source. For a practical method to test those boundaries, see How to Run a Permission Review for Your AI Agents, Step by Step.
Standard three: write every agent scope as permissions, data and tools
An agent scope is the complete list of what the agent can read, write, send and decide. Write it as three lists: the data sources it may read, the tools it may call with the actions allowed in each, and the channels where it may speak or receive requests. Each entry needs a reason. Access granted "for convenience" is the most common source of later surprises, because nobody remembers why it exists when it is time to remove it.
Keep credentials out of the document. The scope names the permission, not the secret. Access should be granted through the organization's identity system, following the principle of least privilege, which the OWASP authorization guidance describes in detail. Tool descriptions belong in the scope as well. Anthropic's guidance on writing tools for agents stresses clear descriptions of what each tool does and when it should be used, and the same text serves as the contract that a replacement tool must match.
Also state which external content the agent reads, such as inbound emails, web pages or uploaded files. Write down that instructions found inside such content are treated as data, not as commands, and name the person who reviews any action triggered by it. Prompt injection is one of the main risks in agent systems, and a scope that ignores it is incomplete even when its permissions look narrow.
For a visual index of where each scope sits in the wider stack, Draw Your AI Stack: A One-Page Architecture Map for Leaders offers a useful starting frame.
Standard four: keep evidence and a record of every change
Documentation without records of behavior is only intention. For each agent, define in writing what gets logged: the request received, the data sources consulted, the tools called, any approval requested and the decision made, and the final output. Logs are only useful when their structure is consistent. The OpenTelemetry observability primer explains why traces, metrics and logs need a shared structure before anyone can answer questions from them, and the same discipline applies to agent records. Set a retention period that matches the company's policy, and review a sample on a fixed schedule.
Define the success check in writing as well. A small, fixed set of representative cases, each with an expected outcome, should be rerun whenever the model, the prompt or a tool changes. A fixed set is more reliable than memory of what seemed to work. Record each run with the date, the version tested and the result.
Every change to a process, role or scope gets a short entry: what changed, why, who approved it, what evidence supports it, and which documents were updated. Tool and model changes count as changes. This is where the standard protects the company most, because a replaced model can be assessed against the test set and the change entry rather than against someone's recollection. The procedure for requesting and approving such changes is described in How to Request and Approve Changes to a Managed AI Agent.
Checklist and an illustrative scenario before go-live
Illustrative scenario: a service company prepares refund requests with an agent, and a finance reviewer approves each one above a set amount. The process document lists the trigger, the three eligibility checks and the approval threshold. The scope lists the order system as read-only and the payment tool as not accessible to the agent. When the company later replaces its order system, the new connection was built from the scope list, and the same six written test cases were rerun before go-live. Nothing had to be rediscovered from the old system's settings, and the change entry showed which checks had been retested.
Before any agent goes live, confirm that the following are true:
- Every process has a trigger, inputs, decision rules and a definition of done.
- Every role has one accountable human owner and a list of decisions that require approval.
- Every scope lists its data sources, tools and channels, with a reason for each entry.
- Credentials are referenced by name in the access system and never written into a document.
- Logging covers requests, tool calls, approvals and outputs.
- A fixed set of test cases with expected results is written down and has been run once.
- A change log exists, and each document carries a named owner and a review date.
Keeping the standard alive after launch
Be Human designs, implements and operates this layer for companies. A first engagement defines one useful role, the memory and tools it needs, its approval boundaries and an observable success criterion, and the documents described above are written as part of that definition rather than after it. In managed operations, the same records support monitoring, recurring evaluations, integration maintenance, permission review and controlled changes, so the company keeps its knowledge in its own records when a model or tool is replaced. The aim is that the next change becomes a documented update rather than a rebuild.
If you are not yet sure which process should be documented first, the free Be Human AI diagnostic will help you find the first task worth handing to an agent.
Frequently asked questions
How much documentation is enough for one AI agent? Enough that an outsider can run the process and predict the outcome of test cases without asking the builder. For most single roles this means one short process document, one role document with an owner, and one scope list covering data, tools and channels. Length matters less than whether each decision rule is written down.
Who should write these documents? The operations lead or process owner should supply the decisions and exceptions, because only they know how the work is really done. The person building the agent can draft the scope and the tool list, and a reviewer outside the team should test the result with real cases before anything goes live.
Do these standards apply to a very small company? Yes, in a lighter form. A two-person business still needs a written trigger, a decision rule, an owner and a list of what the agent can access, often on a few pages. The guidance in Superintelligence for a Two-Person Company: The Minimum Viable Layer shows how to keep that layer small without skipping the parts that protect the business.
How often should the documents be reviewed? Review them whenever a tool, model, process or owner changes, and on a fixed schedule set by the company, so that no document goes unchecked for long. Permissions deserve the most frequent attention because access tends to accumulate over time. The review should update the change log, so the record shows what was checked, by whom and with what result.
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.


