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

Personalized AI infrastructure

Superintelligence Layer Diagram: How the Components Connect

A plain walkthrough of a company superintelligence layer: its models, harness, memory, tools, permissions, channels and observability, and how they connect.

Be Human typographic cover with the title: Superintelligence Layer Diagram: How the Components Connect
Conceptual illustration created with AI · Be Human

A superintelligence layer diagram shows the parts a company needs to run AI agents under its own control: models, a harness, memory, tools, permissions, channels and observability. The components connect in one loop. A channel delivers a request, the harness assembles context from memory, a model proposes an action, permissions decide whether a tool may run, and observability records what happened so the company can review it and improve it.

Key takeaways

  • The layer is a set of separate parts, and each part needs a named owner before any build starts.
  • Models are the most replaceable component, so the company should own the harness, memory, permissions and records around them.
  • Every tool call passes a permission check outside the model, and high-impact actions wait for a named human approval.
  • Observability is how you prove the layer works, so it belongs in the first design rather than after launch.
  • Draw the diagram for one role and one success criterion, then add components only when that role needs them.

Why draw the layer before choosing a model

Most companies begin the AI conversation with a model vendor and a demo. A diagram reverses that order. It asks which parts the company must control, which parts can be swapped, and who answers for each one when something goes wrong. Those answers matter more than any single model, because models change often while operating context, approved knowledge and the record of decisions should survive a change of supplier.

A useful diagram fits on one page. It has a box for each component, arrows for the path of a request, and a line at the top that names the role it serves. Any box without an owner is the first gap to close. Leaders who want the same exercise from a planning angle can compare it with Draw Your AI Stack: A One-Page Architecture Map for Leaders, and the reasoning behind keeping parts swappable is covered in How to Avoid AI Vendor Lock-In With Business Agents.

The seven components and what each one does

Each component has one job. Keeping the jobs separate is what lets you change one part without rebuilding the others.

  • Models: the reasoning engines that read a request and propose the next step. They can be replaced as better options appear, which is why the layer should never depend on a single one.
  • Harness: the code and configuration that runs the agent loop. It sets instructions, limits how many steps a run may take, and decides when to stop or hand the case to a person.
  • Memory: the approved knowledge the agent may read, such as policies, product facts, account history and past decisions. It lives outside the model so the company can inspect, correct and delete it.
  • Tools: the actions the agent can take in other systems, such as looking up a shipment, drafting a quote or updating a ticket. Each tool has a defined input, a defined output and an owner.
  • Permissions: the rules that state which agent identity may use which tool, on which data, for which operations, and which actions require a human to approve first.
  • Channels: the places where people and systems reach the agent, such as email, a chat workspace or a web form. Each channel carries its own identity and its own limits on what the agent may show.
  • Observability: the record of every run, including the request, the memory used, each tool call, each approval, the outcome and the cost, so that someone who did not build the agent can review its behavior.

A chatbot is usually a model with a text box. The layer adds the rules and records around the model, and most of the operational work lives in those rules and records rather than in the model itself.

How one request moves through the layer

The arrows in a diagram matter more than the boxes. Follow one request from start to finish to see how the components depend on each other.

Illustrative scenario: a customer service coordinator at a small distributor forwards a message asking for a refund on a late delivery. The channel attaches the coordinator's identity to the request, so the agent knows who asked and what that person is allowed to see. The harness loads the role instructions and retrieves the returns policy and the order history from approved memory, not from the model's general knowledge. The model reads the case and proposes two tool calls: one to look up the shipment record and one to draft a refund.

The permission layer allows the shipment lookup because it is read-only and within scope. The refund is a write action above the threshold the company set, so the harness pauses the run and sends the proposed refund to a named approver through the same channel. When the approver confirms, the refund tool executes once, carrying an idempotency key so that a retry after a network failure cannot issue the refund twice. Payment providers document this pattern in their guidance on idempotent requests, which is a useful reference whenever your own tools write data. Observability then stores the whole trace: the request, the memory items used, both tool calls, the approval, and the final status.

The same sequence fits most business processes. Replace the refund with a contract draft, a purchase order or a schedule change, and the steps stay the same: identify, retrieve, propose, check, pause if needed, execute once, record.

Where permissions sit, and why they are not in the prompt

Permissions must be enforced outside the model. A prompt can state that the agent should not issue refunds above a limit, but instructions are only guidance. The model also reads text from emails, documents and web pages, and that text may contain instructions of its own. The OWASP guidance on prompt injection prevention rests on this point: untrusted input cannot be trusted to police the system that reads it. The enforcement belongs at the tool, which checks the calling identity, the data scope and the operation type before it acts.

Authorization must also be checked at each point of access, not assumed from an earlier step. OWASP's authorization guidance describes the same principle for application code in general. Apply it to agents by giving each agent its own identity and its own grants, separate from staff accounts.

A permission rule worth writing down should state:

  • which agent identity is calling the tool
  • which operation is allowed, such as read, draft, send or change
  • which data fields are in scope
  • which condition forces a named human approval
  • when the grant expires and who is responsible for renewing it

Review these rules on a schedule rather than only at setup. The AI Agent Permission Review walkthrough shows how to run that review step by step.

Observability: the component that proves the layer works

Observability answers the question every operations leader eventually asks: what did the agent do, and why? The OpenTelemetry observability primer describes the basic structure. A trace follows one request through a system, and each step inside it is recorded as a span with timing, status and attributes. For an agent, a span can represent a model call, a memory retrieval, a tool call or a wait for approval, so the whole run reads as one timeline.

Record enough to judge the behavior without the engineer who built it. That means the reason for each tool call, the memory items that were used, the approver's identity, the final outcome and the cost of the run. Cost per run is what lets a finance lead judge whether the role earns its place. The same records also show when a model change made the agent slower, less accurate or more expensive.

Be Human designs, implements and operates this layer for companies, and its managed operations include monitoring of these traces, recurring evaluations against the success criterion set at the start, and permission review on a fixed schedule. When an incident happens, the response begins from the recorded trace rather than from memory, so the review starts from evidence. The company keeps ownership of the diagram, the rules and the records throughout.

A checklist for your first diagram

Before you draw the layer for a real role, confirm these points on paper:

  • Name the one role the layer will serve, and write its success criterion in one sentence.
  • List every model, tool, memory source and channel the role touches, with an owner for each.
  • Mark which memory items are approved, which are drafts, and which must never be stored in the layer.
  • Write each approval boundary as a rule with a named approver, not as a general hope that the agent will be careful.
  • Give the agent its own identity and grants, separate from any staff login.
  • State what each channel may show and who can read the output.
  • Confirm that every run leaves a trace a reviewer can read without help from the builder.
  • Name who can pause the agent, how they do it, and who gets told.

Three mistakes show up in many first drafts. The first draws the model in the center and treats everything else as plumbing, which hides the parts the company must own. The second treats memory as a saved chat history, which mixes approved facts with guesses. The third gives the agent a shared login, which makes its actions impossible to attribute.

Where to start with your own layer

Choose one role with a clear output, a small set of tools and a success criterion that someone can check within a month. Build only the components that role needs, and add the rest when the evidence asks for them. A layer grows in the same order as trust: one role first, then a second role that reuses the same memory and permissions, then wider coverage.

If you are not yet sure which task should go first, take the free Be Human AI diagnostic to find the first task worth handing to an agent.

Frequently asked questions

Is the harness the same thing as the model? The model produces the reasoning and the proposed next step, while the harness is the surrounding code and configuration that runs the loop, supplies instructions and context, limits the number of steps and decides when a run must pause. Replacing a model should not require rewriting the harness, which is one reason to keep the two separate.

Do small companies need all seven components on day one? Usually not. A narrow first role may use one model, a few tools, a memory of approved documents, one channel, basic permissions and a simple trace. The other components can be added as the role proves its value and as the risk of its actions grows.

How is memory different from what the model already knows? Model training is general knowledge that the model provider controls and that you cannot easily inspect. Memory is your company's approved material, stored outside the model and retrieved when a request needs it, so you can review it, correct it and remove items when they become wrong.

Who should own the diagram? A named executive sponsor should own the business purpose, an operations lead should own the day-to-day boundaries, and a technical owner should maintain the components. Review the diagram whenever a tool, a channel or a permission changes, because an outdated diagram is worse than none for the people who must act on it.

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 →