Personalized AI infrastructure
Superintelligence Layer Components: A Checklist Buyers Can Use
Seven parts every AI agent needs: models, harness, memory, tools, permissions, channels and observability. A checklist to find the gaps before you commit.

AI agent infrastructure is the set of components that lets an agent do useful work safely: a model, a harness that runs it, memory it can read, tools it can call, permissions that limit those actions, channels where people reach it, and observability that shows what it did. A buyer can check each component for an owner, a written boundary and readable evidence, and any component that fails those tests is a gap to close before the agent touches real work. Be Human uses the term superintelligence layer for this operating set around the model.
Key takeaways
- A working agent needs seven parts: models, a harness, memory, tools, permissions, channels and observability. A missing part usually shows up later as a gap in control, not in the demo.
- Every component needs a named owner inside your company, a written boundary and evidence you can read without the vendor in the room.
- The harness and the permission design decide what an agent can actually do, so review them before you compare model names.
- Memory holds your company knowledge, so decide what it may store, who may change it and how a record is removed.
- Observability is the component buyers skip most often, and it is what makes incident response and permission reviews possible.
Why check components instead of features
Software pages describe what an agent can do. A component check asks what each part is responsible for, who controls it and what evidence shows that it works. That shift matters because agent projects rarely fail in the first demo. They fail later, when a tool sends the wrong message, a memory record goes stale, or nobody can explain why the agent acted.
Use the list in this article during a vendor demo, an internal design review or a proposal meeting. If a component cannot be named with an owner, a boundary and a way to inspect it, treat it as missing. A missing component is not always a reason to stop, but it is always a reason to write the gap down before anyone signs.
The seven components in plain terms
Each component has a narrow job. Keep these definitions in front of you when you read a proposal.
- Models: the language or reasoning engines the agent calls to read, classify, draft or decide. Check that you can change models without rewriting the agent's rules and memory.
- Harness: the program around the model that assembles context for each request, runs the loop of reasoning and action, retries failed calls, enforces time limits and hands work to a person when a rule requires it.
- Memory: the stored material the agent may retrieve, such as policies, product facts, customer history and past decisions.
- Tools: the actions the agent can take, such as reading a calendar, creating a draft, opening a ticket or updating a record.
- Permissions: the rules that state which identity the agent acts under, which actions and records that identity may touch, and when a person must approve first.
- Channels: the places where people and systems reach the agent, such as email, chat, a web form or an internal application.
- Observability: the logs, traces and evaluations that show what the agent saw, decided and did.
Each part can be simple. The risk comes from a part that is missing entirely, or one that is controlled by someone outside your company with no way for you to see it.
Models and harness: the engine and the traffic rules
The model generates text, classifications or decisions. By itself it does not remember your customers, hold your permissions or know when to stop. The harness supplies those behaviors, and a weak harness is the most common reason a capable model produces unreliable work in production.
Two questions separate a serious harness from a thin wrapper. First, can the model be replaced without rewriting the rules, memory and tool definitions? Second, what happens when a tool fails twice or the model returns an answer that does not match the required format? If the answer is that someone will look at it later, the harness is incomplete. Retries need particular care. A retried action such as creating an order must not create two orders, so well-designed tools recognize a repeated request by a unique key and return the original result.
Memory: what the agent knows and who may change it
Memory is where most of the agent's usefulness comes from, and where most of its risk sits. In practice it is usually a set of approved documents and records indexed for retrieval, plus a log of past interactions. Retrieval means the system fetches relevant records at the moment they are needed. That is different from training the model on your data, and the difference matters when a policy changes or a record must be deleted.
A memory component is ready for a pilot when you can answer these questions:
- Which source system each memory item comes from, and who owns that source.
- Who may add, correct or delete an item, and whether each change is recorded.
- Whether memory is separated by customer, location, brand or legal entity.
- When an item expires or is reviewed, so outdated prices or policies do not stay in use.
- Whether personal data is stored in memory at all, and under which written rule.
If a vendor says memory is handled automatically, ask for the export and deletion procedure in writing. Memory that you cannot export or purge is memory you do not control.
Tools and permissions: the line between suggesting and acting
A tool is an action the agent can take. The Model Context Protocol offers one common way for models to connect to tools, which helps with portability, but a standard connection is not a permission decision. Permissions answer a different question: which identity the agent uses, what that identity may do, on which records, and whether a named person must approve the action first. For a broader view of how these checks are repeated over time, see Quarterly AI Agent Permission Review: Steps and Evidence.
OWASP's authorization guidance makes the same point from the software side: access decisions should be checked on each request, against the actual user or service and the resource involved, not assumed from a login earlier in the session. Agents also read untrusted text such as customer emails and web pages, which can contain instructions meant to redirect them. Defenses against prompt injection belong in the permission design, not only in the prompt.
Write a boundary for every tool, using four levels:
- Read only: the agent may look up records and summarize them without approval.
- Draft: the agent may prepare a message, quote or change, which a named person must review and send.
- Act within limits: the agent may act alone below a stated threshold of value, volume or scope, and must stop above it.
- Never: actions the agent may not take under any condition, such as deleting customer history.
For a step-by-step method to test these boundaries, see How to Run a Permission Review for Your AI Agents, Step by Step.
Channels and observability: how people reach the agent and how you see it
Each channel carries a different identity risk. An email address can be spoofed, a chat tool may have its own user accounts, and a web form is anonymous unless you verify the person. Map every channel to an identity method and to the short list of tasks it may trigger. A channel that can reach the agent but cannot be tied to an identity should be limited to reading public information.
Observability means that the agent's actions can be reconstructed afterward. The OpenTelemetry primer describes the basic signals: logs record discrete events, traces follow one request across its steps, and metrics summarize behavior over time. For an agent, a useful trace shows the request, the memory items retrieved, each tool call with its result, every approval and the final outcome. Tracking cost per completed task is also useful, since FinOps practice treats unit economics as a way to connect spending to the work delivered.
Evaluations complete the picture. A small, fixed set of realistic tasks, run after each change to the model, memory or tools, shows whether quality moved. Without that set, an update can quietly change behavior, and nobody notices until a customer does.
A gap check to run before any pilot
Run this check in one working session with the person who will own the agent, and record the results on a single page.
- Write the single role the agent will perform and one success criterion it must meet, in one sentence.
- For each of the seven components, record the product or internal owner and the person accountable inside your company.
- Mark each component as present, partial or missing, and note the evidence you saw, such as an export file or a sample trace.
- For each tool, classify the action as read, draft or act, and name the person who approves it.
- Confirm where memory is stored, who may edit it, how a record is removed and whether personal data is included.
- Ask for one sample record of a completed task that shows the inputs, tool calls, approvals and outcome.
- Decide which gaps must close before the pilot starts and which can wait for the first review.
Illustrative scenario: a regional services firm plans an agent to answer customer emails and draft quotes. The vendor demo shows a capable model, a memory of past jobs and an email channel. The gap check finds no approval step before a quote is sent, no record of which price list the agent used and no way to remove a customer's notes. The firm agrees that the pilot waits until those three items close, and in the meantime the agent is limited to reading and drafting.
Be Human designs, implements and operates this layer for companies, and keeps each component under human control. A first engagement defines one useful role, the memory and tools it needs, the approval boundaries and an observable success criterion. Managed operations then cover monitoring, recurring evaluations, integration maintenance, permission review and incident response, so gaps found at the start are tracked rather than forgotten. The service is remote, in English and Portuguese.
If you are not yet sure which task is worth handing to an agent first, the free Be Human AI diagnostic can help you find it.
Frequently asked questions
Is a model enough to run an AI agent? No. A model produces answers or decisions, but it does not hold permissions, memory, a stopping rule or a record of what it did. A company needs the harness and the surrounding components before an agent can handle real work with accountability.
Which component do buyers most often skip? Observability and permission boundaries are the two most often left vague. Vendors tend to show the agent working, and they less often show a readable trace of each action or a written list of what the agent may never do. Ask for both before comparing features.
Do we need all seven components for a small pilot? A pilot needs every component in a minimal form. The model and harness can be simple, memory can be a short set of approved documents, and tools can be limited to reading and drafting. What cannot be skipped is an owner, a boundary and a record for each component.
How often should the gap check be repeated? Run it before a pilot, again before any expansion of tools or memory, and on a regular schedule after launch. A quarterly rhythm is a practical default, because models, integrations and staff roles change more often than most written policies are updated.
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.


