Personalized AI infrastructure
CIO Checklist for Superintelligence-Ready AI Infrastructure
A written CIO checklist for verifying memory, tools, permissions, evaluations and incident response before adding more capable AI agents.

Before a CIO adds a more capable agent to company systems, the infrastructure around it should be verified in a fixed order: scope, records, tools and permissions, action controls, defenses against untrusted input, evaluation and observability, then cost and incident response. Each layer needs a named owner, a written standard and a test that leaves evidence behind. If a layer cannot be shown on paper and in a working test, the agent stays in a narrower role until it can.
Key takeaways
- Verify seven layers in order before giving a more capable agent access to company systems.
- Give every layer a named owner, a written standard and a test that produces evidence.
- Grant tools with narrow scopes, and keep irreversible actions behind human approval.
- Treat every outside email, document and web page as data, never as instructions.
- When a layer cannot be demonstrated, reduce the agent's role rather than expanding its access.
Why the checklist starts with scope, not the model
Vendors tend to describe the model, and the model is the part a CIO can inspect least. The risks that matter to operations sit around it: what the agent is for, what it may read, what it may change, and who answers when it gets something wrong. For that reason the checklist starts with a single written sentence describing one role, such as "answers order status questions for the sales team and escalates anything involving credits or delivery promises." If that sentence is vague, every later layer will be vague too.
Use the checklist as a gate, not a wish list. Each item should be answered yes with evidence, no, or not applicable with a reason. A one-page drawing of the stack, showing which system holds each piece of data and which component can act on it, makes the gaps easier to see. The companion guide on drawing your AI stack walks through that drawing.
The seven layers are:
- Scope: one named role, its purpose, and the decisions it may and may not make.
- Records: which sources the agent reads, who owns each one, and how stale or conflicting data is handled.
- Tools and permissions: each tool the agent can call, the account it uses, and the exact scopes granted.
- Action controls: which actions need approval, which can be retried safely, and which are never automatic.
- Untrusted input: how instructions hidden in documents, messages and web pages are kept from changing behavior.
- Evaluation and observability: test cases with expected outcomes, and logs showing what the agent saw, did and why.
- Cost and incidents: cost per completed task, a named responder, a stop procedure, and a way to exit the vendor.
Layers one and two: scope and records
Scope is the cheapest layer to fix and the most expensive to skip. A role that can "help with customers" can do almost anything, so it is never approved. Write what the agent answers, what it declines, and who receives the cases it declines. Record the owner of the business process, not only the owner of the software.
Records come second because an agent is only as reliable as the data it reads. Before connecting any source, confirm which system is the source of truth for each fact the agent will state. If two systems disagree, choose one and document the rule. Also decide how records are removed or corrected, since an agent that reads an outdated price list will repeat it confidently.
Illustrative scenario: a regional distributor wants an agent to answer customers who ask where their order is. The operations lead writes that the agent may report status and tracking information, and may not promise delivery dates, change orders or issue credits. The records review then finds that three warehouse systems report shipment dates differently. The team names the warehouse management system as the source of truth and documents how the other two are treated before the agent reads any of them.
Layer three: tools and permissions the agent can actually use
Every tool an agent can call is a door, and the permissions attached to it define what happens when someone walks through. The common mistake is giving an agent the credentials of a senior employee, which makes every action look like that person's action and makes the access impossible to narrow later. Give each agent its own account, grant only the scopes its role needs, and separate read access from write access in every integration.
The OWASP authorization guidance describes the core principle plainly: deny by default and check permission on every request, not only at the entrance. Apply that to agents by asking, for each tool, what the most damaging call would be and whether the account could make it. If the answer is "all customer records" or "any payment," the scope is too broad.
Schedule a permission review before the agent goes live and again on a fixed cadence. The step-by-step method in how to run a permission review for AI agents gives a usable sequence for the first pass.
Layer four: action controls for anything that changes money, data or customers
Read actions and write actions carry different risks, so the checklist treats them separately. For every write action, document three things: whether a human must approve it, what the agent must show the approver, and what happens if the action is retried.
Retries are the hidden hazard. A network timeout can leave the agent unsure whether a ticket, refund or message was created, and a naive retry creates a duplicate. Where the target system supports idempotency keys, which let the provider recognize a repeated request, require the agent to use them. Where it does not, design the workflow so the agent checks the state of the record before trying again.
Approval thresholds should start conservative and rise only when the evidence supports it. A useful way to set the first thresholds is covered in approval thresholds for superintelligent agents. The principle is simple: an agent may draft a refund request freely, but a human approves any refund above the amount the business owner has pre-agreed, and nothing is issued automatically until the evaluation results justify it.
Layer five: defenses against untrusted input
An agent that reads outside content is exposed to instructions written by people you do not control. A customer email can contain a sentence telling the agent to forward its records, and a web page can contain text aimed at the model rather than the reader. This is prompt injection, and it is the reason the checklist cannot rely on the model alone to behave.
The OWASP prompt injection prevention guidance recommends separating trusted instructions from untrusted data and limiting what an agent can do after reading untrusted content. In practice, the checklist asks four questions. Which inputs are untrusted? Can any of them trigger an outbound message, a data export or a write action? Are those actions behind approval? And do the logs show when untrusted content influenced a decision? A yes to the first question with a no to the others is acceptable. A yes to the second with a no to the third is not.
Layer six: evaluations and observability you can read
An agent that performs well in a demonstration can still fail in ordinary use, so the checklist requires a set of recorded test cases before the role expands. Each case should include a realistic input, the expected outcome and the reason the outcome matters to the business. Run the set again after every change to the prompt, the tools, the records or the model. Keep the failures visible, because they show where the role is weakest.
Observability is what makes those failures diagnosable. The OpenTelemetry primer describes traces, metrics and logs as the three signals that explain what a system did and why. For an agent, the trace should show the request, the records consulted, the tools called, the approvals requested and the final response, with timestamps. If an operator cannot reconstruct a decision from the logs, the layer has not passed.
Be Human handles this layer as part of managed operations. A first engagement defines one useful role, the memory and tools it needs, its approval boundaries and an observable success criterion. Ongoing work then includes monitoring, recurring evaluations, integration maintenance, permission review and incident response, so the checklist is re-run as systems change instead of being signed once and filed. Companies that want the governance side of this written down can start with the committee charter for small companies.
Layer seven and the sequence to run this quarter
The last layer covers what happens when things go wrong. Record the cost per completed task so the business can tell whether the agent is worth its operating expense. Name one person who responds to incidents and one person who can stop the agent. Write the stop procedure in plain steps: which access is revoked, which queues are paused, who tells customers, and how the work returns to people. Finally, document how the company would leave the vendor, including where the logs, configurations and records are kept.
A practical sequence for the next quarter looks like this:
- Week one: write the one-sentence scope for the role and name its business owner.
- Week two: map the records the role needs, choose the source of truth for each fact, and note conflicts.
- Week three: create a separate agent account, grant the minimum scopes, and list every write action.
- Week four: set approval rules for write actions and test retries against the target systems.
- Week five: test untrusted input paths and confirm that outside content cannot trigger outbound actions unreviewed.
- Week six: record evaluation cases, run them, and confirm the traces explain each result.
- Week seven: document cost, the incident owner, the stop procedure and the exit plan, then decide whether the role stays narrow or expands.
Each week ends with a yes, no or not-yet decision recorded in writing. Expansion is allowed only after every layer for the current role is a yes. If the decision is not yet, the agent keeps its present scope and the gap goes on the next review.
If you are unsure which of these layers your company already has in place, the free Be Human AI diagnostic will help you find the first task worth handing to an agent.
Frequently asked questions
Do I need all seven layers in place before the first agent goes live? No layer has to be complete for a read-only pilot, but no agent should have write access to a system until its scope, permissions, approval rules and logs are in place. A pilot can run with fewer records and fewer tools, provided the role stays narrow. Each layer should expand only as the role expands.
Who should own the checklist inside the company? The CIO should own the checklist and the sign-off, but each layer needs a business owner for the process it touches, such as operations for order records or finance for payment actions. Keep the list short enough that each owner can answer their items in a single review meeting. Ownership that cannot be named on paper is a gap.
How often should the checklist be run again? Run it before any new tool, data source or capability is added, and whenever a permission, vendor or model changes. A scheduled review also catches scope creep that happens quietly over time. The same seven layers can serve as the agenda for that review.
Is this checklist specific to superintelligence? The layers are the same ones any capable agent requires, and the stronger the agent, the more each layer matters. The checklist does not depend on one model or vendor, which keeps it useful when the tools change. Its purpose is to make the company's controls visible before the agent's abilities grow.
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.


