Personalized AI infrastructure
Enterprise Superintelligence Stack: IT Leader's Pre-Production Checklist
Enterprise superintelligence stack checklist: components to verify before an AI agent layer touches production, including permissions and monitoring.

An enterprise superintelligence stack is the set of layers that lets company AI agents keep their identity, memory, tools, permissions and operating context, while people can see and limit what those agents do. Before such a layer touches production systems such as customer records, billing or internal approvals, an IT leader should be able to verify each component, name its owner and describe how it will be stopped. The checklist below follows the order in which those checks are most useful.
Key takeaways
- Verify identity, permissions and a stop control before memory or tools are connected.
- Treat agent memory as governed data with an owner, a retention rule and a deletion path.
- Give every tool its own scope, approval threshold and audit record.
- Require traces and evaluations that show what an agent did, not only what it answered.
- Document rollback and ownership so that pausing the layer never depends on one person or one vendor.
What must the stack contain before it reaches production?
Think of the stack as a set of separate responsibilities rather than one product. A model supplies reasoning. Retrieval supplies the records the agent may read at the moment it answers. Memory stores what the agent should carry from one session to the next. Tools let it act in other systems. Permissions decide which actions are allowed and under what conditions. Observability records what happened, evaluation tests whether behavior still meets the standard you set, and governance names who decides when that standard changes.
A production-ready layer should be able to answer these questions for each component:
- Who owns it, and who is allowed to change it?
- Which data or systems does it touch?
- What can it do without a human approving first?
- How is its activity recorded, and for how long is that record kept?
- How is it paused, and how quickly does the pause take effect?
If any answer is missing, the component is not ready for production, however capable the underlying model is. Greater capability raises the stakes of these questions. It does not answer them.
How do you give an agent an identity it can be held to?
An agent should act under its own identity, not under a shared employee login or an administrator's credentials. A separate identity makes its actions attributable, lets you scope its access without changing anyone else's, and gives you one place to revoke it. Use the authorization patterns your identity provider already supports, and keep the agent's permissions narrower than those of the person who configures it. Access decisions should be enforced by the systems the agent calls, not left to the agent's own reasoning. The OWASP authorization guidance is a useful reference for checking that point.
Verify these items before connecting anything:
- The agent has a dedicated account in each system it uses.
- Each account has the minimum read and write scope its role requires.
- No credential is stored in prompts, memory entries, shared documents or logs.
- Credential rotation and revocation have a named owner.
- Access reviews are scheduled in advance, not assumed to happen. A practical sequence is described in quarterly permission reviews.
What should the agent be allowed to remember?
Memory is where many stacks quietly accumulate risk. A useful agent carries context: a customer's preferred contact channel, an open approval, a supplier's agreed terms. Each of those is a record someone has to own. Before enabling memory, decide which categories of information it may hold, which sources may write to it, how long entries live, and how a person removes an entry that is wrong or should not exist.
Retrieval and memory are different tools with different failure modes. Retrieval-augmented generation fetches current material from sources you control when a question is asked, which keeps the knowledge in the system of record. Storing long-lived summaries or adjusting the model on company material bakes information into behavior or notes that are harder to inspect and harder to delete. For many teams, retrieval is the easier starting point because each answer can point back to a source.
Illustrative scenario: a scheduling agent at a small services company learns that one customer prefers calls before noon. The preference is written to memory with the staff member who recorded it, and it expires when the customer account is closed. When the customer asks for the record to be deleted, the operations lead removes it from the memory store and then checks that the agent no longer offers morning call slots for that customer.
Which tools can the agent use, and under what limits?
Each tool an agent can call is a small interface with a possible side effect. Treat it the way you would treat system access for a new team member. Define what the tool does in one sentence, which inputs it accepts, what it returns, whether it writes anything, and which conditions require a human to approve. Describe the tool to the agent with the same care you would give a written procedure, because vague tool descriptions lead to misuse even when the permissions are correct.
Content the agent reads, including emails, web pages, tickets and uploaded documents, can contain text written to manipulate it. This is prompt injection. The OWASP prompt injection prevention guidance describes defenses that should be in place before any tool with side effects is connected. The core principle is that content the agent reads is data, not authority. Authority comes from the permission layer, not from instructions found inside a document.
Before connection, work through these steps in order:
1. List every tool and mark each one as read-only or write. 2. Set approval thresholds in business terms, such as the size of a commitment or the type of record that changes, and have the finance or operations lead sign the figures. 3. Require human approval for any action that cannot be reversed easily. 4. Test with adversarial inputs, such as a document instructing the agent to ignore its rules or to export data. 5. Record every call with its inputs, outputs and any approver.
Thresholds deserve slow adjustment once the agent has a track record. The reasoning behind that is set out in approval thresholds for superintelligent agents.
How do you prove what the agent did?
Observability is the difference between an agent you can operate and one you can only hope about. Traces should capture each step: the request, the context retrieved, the tool calls, the approval decisions and the final output. The OpenTelemetry observability primer explains how traces, metrics and logs fit together, and its generative AI conventions describe consistent ways to label model calls. You do not need to adopt every convention on the first day, but you do need a single identifier that links one agent action to all of its evidence.
Evaluation answers a different question: does the agent still behave as expected after a change to the model, a prompt, a tool or the underlying data? Build a small set of test cases from real work. Include ordinary requests, awkward edge cases, and cases where the correct behavior is to refuse or escalate. Run the set before each change and on a recurring schedule. An evaluation is only as good as its cases, so review the cases whenever the business process they describe changes.
A short checklist for this stage:
- Every action produces a trace with a unique identifier.
- Logs exclude secrets and unnecessary personal data.
- Evaluation cases exist for normal work, edge cases and refusals.
- Results are compared before and after each change, not just after.
- Someone reviews a sample of traces on a fixed schedule during the early period of operation.
What stop rules, rollback and ownership must exist?
Every layer needs a stop rule written in plain language. The rule states which symptoms trigger a pause, who is allowed to pause, and what happens to work in progress. A pause should disable write actions first and leave read-only access available so that the team can investigate. Keep a rollback path for prompts, configurations and tool versions, and test that path once before production so you know it works under pressure.
Name an owner for each component and an alternate who can act when the owner is unavailable. Record where credentials, memory stores and logs are kept, and make sure more than one person can reach them. This matters because a staff change or a vendor change should not leave the company unable to stop or repair its own agent. The NIST AI Risk Management Framework offers a shared vocabulary for mapping, measuring and managing these risks, which helps when the conversation moves to leadership and the board.
Failure in an agent layer rarely looks dramatic at first. The early signs are often small, such as a tool being called more often than usual or a memory entry that no one can trace. The patterns are described in failure modes of a company agent layer, which is worth reading before the stop rules are finalized.
How do you run the checklist before go-live?
Work through the checklist in this order: purpose and ownership, identity, memory, tools, observability and evaluation, then stop rules. Do not connect production systems until each section has a written answer and a named owner. Start with one role rather than a platform, and record the decision in a one-page runbook that a new operator could follow without help from the person who wrote it.
Be Human approaches this as a managed service. A first engagement defines one useful role, the memory and tools it needs, its approval boundaries and one observable success criterion. Managed operations then cover monitoring, recurring evaluations, integration maintenance, permission review and incident response, so the checks in this list are repeated as the agent and the business change rather than performed once at launch. If you are not sure which process should become the first task for an agent, take the free Be Human AI diagnostic to find it.
Frequently asked questions
What is an enterprise superintelligence stack? It is the group of layers that lets company AI agents hold identity, memory, tools, permissions and operating context under human control. The useful way to think about it is as separate responsibilities, each with an owner, rather than one product. A layer is ready for production when every component can be described, limited and stopped.
Does every component need to be fully built before the first agent goes live? Each component needs a written answer and an owner, but none needs to be elaborate on day one. A narrow first role usually needs a small set of tools, limited memory and a simple trace of each action. Expansion should follow evidence from that first role rather than precede it.
Who should own this checklist inside the company? The IT leader usually owns the technical controls, such as identity, access, logging and stop mechanisms. Operations or the business owner should sign off on the approval thresholds and the success criterion, because those decisions depend on how the work is actually done. Assigning both makes the checklist a shared responsibility rather than a technical afterthought.
How often should these checks be repeated? Run the evaluation cases before each change to the model, prompt, tool or data, and review permissions on a fixed schedule. Review a sample of traces regularly during early operation, and revisit stop rules after any incident. The checks are meant to be repeated as the agent and the business change, not completed once and filed.
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.


