Personalized AI infrastructure
Superintelligence Stack Diagram: Seven Layers Explained Plainly
Seven layers make up a company superintelligence stack, from models and memory to permissions and observability. Learn what each does and which ones to own.

A superintelligence stack is the set of seven layers a company needs to run capable AI agents on its own knowledge without losing control of them: models, memory, tools, identity and permissions, channels, operating context, and observability. Each layer answers a different question about the business, such as where reasoning happens, what the agent knows, what it may touch, and how anyone can tell whether it behaved well. Leaders do not need to build all seven themselves, but they do need to know which layers they own and which they simply rent.
Key takeaways
- The stack has seven layers, and each one answers a different question about control.
- Models are usually rented. Memory, permissions, operating context and evaluation sets should belong to the company.
- Permissions and observability are the layers most often skipped, and they are what make an agent safe to expand.
- Name an owner for each layer in writing before the first agent is built.
- A useful first agent should touch only three or four layers, at a narrow scope, with clear approval boundaries.
What the seven layers are, in plain terms
The stack is easier to reason about when each layer is named by the question it answers. This is the working vocabulary we use with leaders, and it is deliberately short.
- Models: the language and reasoning engines that generate answers and proposed decisions. They are almost always rented from a provider.
- Memory: the company records the agent may retrieve, such as customer history, product specifications and written procedures, along with the rules for keeping them current.
- Tools: the actions the agent can take, such as reading an order status, drafting a quote in a billing system, or opening a support ticket.
- Identity and permissions: the agent's own account, its scoped access, and the rules that decide when a person must confirm an action.
- Channels: the places where the agent meets people or systems, such as email, a website chat, a messaging app or an internal workspace.
- Operating context: the role definition, tone rules, escalation paths and success criteria that tell the agent how its job is done.
- Observability: the logs, traces, test sets and reviews that show what the agent did, why it did it, and whether it met the criterion.
Read from the bottom up, the layers depend on each other. A model without memory guesses, memory without permissions can leak, and tools without observability cannot be audited. That dependency is the reason to design the layers together, even if they are built in stages.
Which layers should you own, and which can you rent?
Renting is the normal arrangement for models, and it is a reasonable one. Providers change their systems faster than most companies could, and a well designed stack lets you change the model without rebuilding everything else. Ownership matters most in four places: the memory your company curates, the permissions the agent holds, the operating context that records your decisions, and the evaluation set that defines good work. These are the assets that make an agent yours. If you change providers later, they should move with you.
For each layer, ask the same four questions before work starts:
- Who holds the account, the credentials and the administrative rights for this layer?
- Could we export our data, instructions or test cases in a usable format on short notice?
- Who approves a change here, and is that person named?
- Is there a fallback, a second provider or a manual procedure if this layer fails?
A one-page drawing that places each layer and its owner is the fastest way to answer these questions. The architecture map method for leaders shows how to build that drawing in an afternoon.
How do memory and tools work together?
Most business agents do not need their underlying model retrained on company information. The more common pattern is retrieval, where the agent looks up approved records at the moment it needs them. The AWS guidance comparing retrieval with fine-tuning sets out the tradeoffs, and for most operations teams the practical advantage is simple: when a procedure or a product detail changes, you update a record instead of re-teaching a system. Retrieval also lets you show where an answer came from, which matters when a customer or auditor asks.
Tools need the same discipline. Each tool should do one clearly described job, return results in a predictable shape, and fail in a way that the agent and the people around it can understand. Anthropic's engineering guidance on writing tools for agents is a useful reference for the design side. Start with a short list. An agent with a dozen loosely defined tools is much harder to test than one with three well defined tools.
Memory is only as good as the records behind it. Duplicate customer files, outdated procedures and unlabeled documents will reach the agent unchanged. The data foundations guide covers the cleanup that should happen before memory is connected.
Permissions and observability: the layers that decide what is safe
Identity and permissions carry most of the risk, and they are the layers leaders are most tempted to skip during early enthusiasm. The agent should have its own identity, not borrow an employee's login. Its access should be the smallest set that lets it do the job, and actions with financial, legal or customer impact should route to a named person above a defined threshold. OWASP's authorization guidance is a useful reference for the principle: access decisions should be explicit and enforced by the system, not left to the model's judgment.
Agents also read outside text, such as emails and web pages, and that text can contain instructions meant to steer them. The OWASP prompt injection guidance describes the input side of this problem. Permissions are the backstop. An agent that cannot send payments cannot be talked into sending one. Permissions also need a review schedule, not only a setup. The quarterly permission review describes the steps and the evidence worth keeping.
Observability answers whether the other layers are working. OpenTelemetry's observability primer explains the basic vocabulary of logs, metrics and traces, and the same ideas apply to agents. Record which request came in, which records were retrieved, which tool was called, what came back, and who approved what. Pair this with a small written set of test cases drawn from real work, and rerun it after every change. Without that, a change that looks harmless can quietly reduce quality for weeks before anyone notices.
Illustrative scenario: a maintenance company's first agent
The following scenario is illustrative and does not describe a real client. A regional maintenance company wants an agent that answers customer questions about scheduled visits and prepares draft quotes for staff to review.
The model is rented from a provider. The memory holds visit policies, the current service price sheet and each customer's visit history, and the office manager owns and updates those records. The tools let the agent read the calendar, look up service history and create a draft quote, but not send it. The agent has its own account with read access to the calendar and write access only to drafts. It answers through the website chat and the shared inbox. Its operating context is a written role with tone rules and an escalation rule that sends complaints to a named person within the hour. Observability consists of a set of test questions taken from past emails, rerun before every change, and a weekly review of logs during the first month.
The useful outcome is not the diagram itself. The office manager can point to the owner of each layer and to the one action the agent is not allowed to take on its own.
How does Be Human handle this in a managed engagement?
Be Human designs, implements and operates this kind of stack as a managed service, with the company keeping its identity, memory, channels, tools, permissions and operating context under its own control. A first engagement defines one useful role, the memory and tools that role needs, the approval boundaries, and an observable success criterion, and it records which layers the company owns. Managed operations can then include monitoring, recurring evaluations, integration maintenance, permission review, incident response and controlled improvements. The service is delivered remotely, in English or Portuguese.
Where to start
Start by drawing the seven layers for one process you already understand. Mark the owner of each layer, and circle the single action the agent may not take without a person. Then choose the smallest task that uses only three or four layers well, and write down how you will know it worked. Teams that do this first usually find that the hardest part is the ownership conversation, not the technology.
Take the free Be Human AI diagnostic to find the first task worth handing to an agent.
Frequently asked questions
Is the superintelligence stack a product I can buy? The seven layers describe what a company intelligence setup contains, so they are a way of thinking rather than a single product. Some vendors sell individual pieces, and a managed partner can assemble and operate them for you. The practical test is whether you can name the owner of each layer and move your assets if the arrangement changes.
Which layer should a small company build first? Most small companies should begin with operating context and observability, because they are inexpensive to write and make every later decision easier to check. Memory comes next, limited to the records the first task actually needs. Models can be chosen last, since they are the layer most likely to change.
Do I need all seven layers before an agent goes live? No. A first agent can run on a small set of layers when its scope is narrow and its approval boundaries are strict. What you cannot skip is a named owner for each layer in use and a way to see what the agent did.
How is this different from ordinary automation? Automation scripts follow fixed steps. An agent built on these layers chooses among steps, reads from memory and may act through tools, which is why identity, permissions and observability carry more weight. The difference determines how much oversight the work needs before it runs without supervision.
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.


