Skip to content
be-human.ai
← Back to the journal

Personalized AI infrastructure

Superintelligence Layer Parts List: Seven Components to Inventory

The company superintelligence layer has seven parts: models, harness, memory, tools, permissions, channels and observability. Inventory which ones you own.

Be Human typographic cover with the title: Superintelligence Layer Parts List: Seven Components to Inventory
Conceptual illustration created with AI · Be Human

A company superintelligence layer has seven components: the models that reason, the harness that runs them, the memory they draw on, the tools they can call, the permissions that bound them, the channels where they meet people, and the observability that shows what they did. To inventory it, list each component, name the person who answers for it, and mark whether your company controls it or rents it from a vendor.

Key takeaways

  • The layer has seven parts: models, harness, memory, tools, permissions, channels and observability. Missing one of them usually shows up later as a surprise.
  • Each part needs a named owner inside the company and a clear answer to whether it is owned or rented.
  • Renting a part is not the risk. Renting a part that nobody can describe, change or switch off is.
  • Permissions and observability decide whether anyone can review what an agent did, so they belong on the first inventory, not the last.
  • Start with one role and one recurring task, then extend the inventory as that role earns trust.

Why start with a parts list instead of a platform

Buyers often ask for a platform before they know what that platform must contain. A parts list reverses the order. It names the pieces any working agent needs, so you can compare vendors, internal staff and your own records against the same set. It also exposes a common failure: a demonstration works because one tool connects to one spreadsheet, and nobody can say what happens when that spreadsheet changes or the person who set up the connection leaves.

The list is not a purchase order. Its purpose is to show what you own, such as your records, your instructions, your approval rules and your usage history, and what you rent, such as model access, hosted runtime and vendor connectors. Ownership questions become answerable once every part has its own line. If you have not yet drawn your stack on one page, Draw Your AI Stack: A One-Page Architecture Map for Leaders is a useful companion to this inventory.

Models, harness and memory: the parts that reason, run and recall

The model is the reasoning engine. Most companies rent it through an API, which is a normal arrangement. What you own is the choice of model for each task, the evaluations that show it performs on your work, and the rule for who may change the version. Write down the model name and version the agent uses today, who can switch it, and what test must pass before a switch goes live.

The harness is the code and configuration around the model. It sends instructions, loops the model through steps, handles retries and stopping conditions, and decides when a person must take over. Anthropic's engineering notes on long-running agents describe this scaffolding as what carries work across sessions. For the inventory, ask where the harness is hosted, who wrote it, whether your team can read it, and how changes to it are recorded.

Memory is what the agent can recall when it answers. It usually has three forms: standing instructions, documents retrieved at question time, and the history of the current task. Retrieval-augmented generation fetches relevant records when a question arrives, instead of training the model on them, and Google Cloud's reference architecture for retrieval-augmented applications shows how those pieces connect. For each memory source, record where it lives, who can edit it, how long it is kept, and whether it contains personal data. Memory is only as reliable as the records behind it, so a stale price list or an outdated policy will produce confident and wrong answers.

Tools, permissions and channels: where the agent touches real work

Tools are the actions the agent can take: read a calendar, draft a quote, update a ticket, send a message. Each tool has a blast radius, meaning the amount of damage a wrong call can cause. The Model Context Protocol offers one standard way to expose tools and context to models, and its introduction explains the client and server roles involved. In the inventory, list every tool, what it reads, what it writes, and which account it uses to act.

Permissions answer who authorizes what. Give the agent its own identity rather than letting it borrow a person's login, and grant the smallest set of rights that the task needs. OWASP's authorization guidance points toward enforcing access decisions on the server for each action, not assuming them from one earlier sign-in. Add approval thresholds for anything that sends money, sends messages outside the company, deletes records or publishes content. Those thresholds are business decisions, so the business owner should set them, not the developer who built the connection.

Channels are where the agent is reachable and where it posts: email, a chat workspace, a website form, a messaging app, or a phone line. Each channel brings its own identity, retention and privacy rules. Content arriving through a channel can also contain instructions meant to redirect the agent. OWASP's prompt injection guidance recommends treating incoming and retrieved text as untrusted data, which is a design decision you should be able to point to in the inventory.

Observability: the part most teams skip

Observability is the record of what the agent did, why it did it, and how well it worked. OpenTelemetry's primer describes the basic signals, which are traces that follow a request through steps, metrics that count and time things, and logs that record events. Its semantic conventions for generative AI extend those ideas to model calls and tool use. You do not need to adopt every convention to benefit from the principle: a task should leave a trail that a non-engineer can read.

For the inventory, record what is logged, where the logs are stored, who can read them, how long they are kept, and who reviews failures. Add recurring evaluations as well. OpenAI's evals guide and Anthropic's notes on evaluating agents both describe building a fixed set of realistic tasks and rerunning it after every change. Cost belongs here too. The FinOps Foundation's unit economics material treats cost per completed unit of work as the useful measure, so write down what one finished task costs in model usage and staff review time, not only the monthly invoice.

A step-by-step inventory you can run this week

The following sequence takes one role at a time. It is designed for an operations leader and an accountable business owner, with technical staff checking the columns they can verify.

  • Pick one role and one recurring task it would perform. Write the task in a single sentence that a new employee could follow.
  • For each of the seven parts, write one line: current owner, owned or rented, where it lives, and when it last changed.
  • Mark each part as known, partly known or unknown. Work on the unknown lines first, because they carry the most risk.
  • For every tool and channel, name the account it uses and confirm that someone without engineering skills can revoke that access.
  • Write the approval rule for each action that sends, spends, deletes or publishes something outside the company.
  • Confirm where the logs are kept and who opens them when a result looks wrong.
  • Note which parts you would need to move if the vendor changed terms, and what that move would require.
  • Record the completed inventory in your own change log and schedule the next review before you close the document.

The result should fit on a few pages. If it does not, the role is too broad, and the scope should be narrowed before any build begins.

Illustrative scenario: a ten-person services firm

The following scenario is illustrative and does not describe a real client. A ten-person firm wants an agent to draft replies to inbound quote requests. The inventory shows a rented model accessed through an API, instructions kept in a shared document that two people edit, a memory made of a spreadsheet with an older price list, and a tool that creates draft quotes using the owner's personal login. The channels are email and a website form, and the only logs are the email threads themselves.

The inventory changes three decisions. The agent gets its own account with draft-only rights, so it cannot send anything without a person's approval. The price list gets a named owner and a review step before each use. Every draft is logged with the inputs it used. None of these changes requires a larger platform. They require the firm to see the parts clearly before deciding which ones to trust.

Keeping the inventory current, and where to begin

Be Human designs, implements and operates this layer as one system. In a first engagement, the team defines one useful role, the memory and tools it needs, the approval boundaries and an observable success criterion, so the inventory begins with a working scope rather than a wish list. Managed operations then cover monitoring, recurring evaluations, integration maintenance, permission review, incident response and controlled improvements, and each change is recorded through a request that the business owner can read. The parts list stays accurate because it is maintained, not because it was written once. For the permission side of that work, Quarterly AI Agent Permission Review: Steps and Evidence describes what a recurring check should contain, and Avoid AI Vendor Lock-In With Business Agents covers how to keep rented parts replaceable. Take the free Be Human AI diagnostic to find the first task worth handing to an agent.

Frequently asked questions

Do I need all seven parts in place before I start? You do not need all seven built before starting, but you do need to know that each part exists and who answers for it. A single well-scoped role can run with a small set of tools, a clear memory source and a simple log. The inventory shows which parts are thin, so you can decide what to strengthen first.

Which part should I inventory first? Start with permissions and tools, because they determine what the agent can change in your business. Once you know which accounts it uses and which actions require approval, the rest of the inventory has a clear boundary to sit inside. Memory and channels come next, since both can carry outdated or sensitive content into the agent's answers.

Is a rented model a risk for my company? A rented model is a dependency, and dependencies are manageable when they are known. Record the model version, the evaluations that cover your tasks, and the steps needed to switch providers. If those records exist, a vendor change becomes a planned project instead of an emergency.

Can my team own the inventory without engineers? An operations leader or business owner can own the inventory, since the questions are about accountability, approval and risk. Technical staff should verify the columns about hosting, versions, access and logs. Splitting the work this way keeps the decisions with the people who carry the consequences.

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.

Less busywork. More room for you.

Bring us the work you wish you had time for.

Book a call to try a personalized AI agent free for 7 days ↗Or take the free AI diagnostic →