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

Personalized AI infrastructure

The Superintelligence Stack: Five Layers a Company Should Own

The superintelligence stack has five layers: models, harness, memory, tools and observability. Here is which your company must control and which to rent.

Be Human typographic cover with the title: The Superintelligence Stack: Five Layers a Company Should Own
Conceptual illustration created with AI · Be Human

The superintelligence stack for companies is the set of five layers that make an AI agent useful inside a business: the model that reasons, the harness that runs it, the memory it draws on, the tools it can act through, and the observability that shows what it did. A company does not have to build every layer, but it should control the ones that hold its knowledge, its permissions and its evidence, because those decide whether the agent stays safe and useful when the underlying model changes.

Key takeaways

  • The company intelligence layer has five parts: models, harness, memory, tools and observability.
  • Models are the layer most worth renting, since they change on the provider's schedule rather than yours.
  • Control memory, permissions and evidence, the three layers that carry your company's knowledge and authority.
  • Observability is what lets you review, audit and improve an agent instead of trusting it.
  • Map one role across all five layers before you buy or build anything.

Why the stack is more than a model

When leaders ask about superintelligence for their company, they often mean a model: which one, how capable, how fast. A model alone can answer questions, but an agent that works inside your operation also needs to run a loop, look up records in your systems, take actions and leave a trail. Those are separate pieces, and each can fail on its own. A wrong answer may come from an outdated document, a permission that is too broad, a weak instruction wrapper, or a model that was swapped without anyone testing the change.

Thinking in layers gives you a map of where control actually sits. If you want to sketch your own version on a single page before any vendor conversation, Draw Your AI Stack: A One-Page Architecture Map for Leaders walks through the same idea at the level of decisions.

Layers one and two: the model and the harness

The model is the reasoning engine. Companies usually rent it through an API or a product. The useful question is not which model is best in general but which one performs well on your tasks, measured on your own examples. Keep a set of real cases with known good answers and rerun them whenever the provider changes a version. A company that builds its workflows around one vendor's specific features inherits that vendor's release schedule. Renting a model is reasonable. Depending on it without a test set is not.

The harness is the code and configuration around the model. It assembles the instructions, decides which tools the model may call, handles retries and timeouts, stops runaway loops, requests human approval at the boundaries you set, and decides what is written to memory. Anthropic's engineering guidance on harnesses for long-running agents explains why this scaffolding matters once work spans many sessions. For a business, the harness is where your rules become executable. If the refund approval rule exists only in a policy document, the agent will not follow it. If the rule lives in the harness, the agent cannot skip it.

Layer three: memory and what the agent is allowed to know

Memory is everything the agent can draw on when it answers: product documentation, customer history, process notes, and decisions from earlier cases. Most business agents do not learn by changing the model's weights. They retrieve relevant material when needed and place it into the context window. This pattern is usually easier to update and audit than retraining, because removing a document stops the agent from using it. Fine-tuning has its place for tone or narrow output formats, but for company facts, retrieval keeps the source visible. Anthropic's guidance on context engineering treats what enters the window as a deliberate design choice, not a default.

Control matters here because memory is where your know-how lives. Decide which sources the agent may read, who owns each source, how often it is refreshed, and what must never be stored. Old, contradictory or private records make an agent confidently wrong. The question of what should stay out of shared models is covered in Superintelligence and Intellectual Property: Protect What You Know.

Layer four: tools and permissions, where an agent acts

Tools are the actions: read a calendar, draft an email, update a ticket, query a database, issue a credit. Every tool is a permission. The common failure is granting an agent the broad rights of the person who set it up, so it can do far more than its job requires. Access should be scoped to each action, tied to a named identity you can revoke, and reviewed on a schedule. OWASP's authorization guidance makes the same point in general software terms: check access on every request rather than assuming it from earlier steps.

Treat the model's input as untrusted. Text in an incoming email or a web page can contain instructions that try to redirect the agent, which is the prompt injection risk the OWASP cheat sheet describes. Limit what each tool can do even when the model asks for more, and require human approval for anything that cannot be undone. The routine for checking all of this is set out in How to Run a Permission Review for Your AI Agents, Step by Step.

Layer five: observability and evidence

Observability answers three questions: what happened, why it happened, and what it cost. For an agent, that means a record of each run: the request, the memory retrieved, the tools called, the approvals requested, the output, and any error. OpenTelemetry describes traces, metrics and logs as the basic signals of a system you operate, and the same concepts apply to agent runs. You do not need the vocabulary to act on it. You need to be able to answer a manager's question about what the agent did last Tuesday.

Observability is also what makes improvement safe. Recurring evaluations run the same test cases after each change to the model, prompt, memory or tools. Without them, every update is a guess. Companies that keep their own trace and evaluation records hold the evidence needed to decide whether to keep a provider, change one, or roll back a change.

Which layers your company must control

The five layers do not need the same ownership. The useful test is whether a layer holds your knowledge, your authority or your evidence. If it does, your company should control it, meaning you hold the configuration, the records and the right to move them. If it is a replaceable commodity, renting is reasonable. Use this guide as a starting point:

  • Models: rent, but keep your test cases and prompts under your own control so a switch is a measured change.
  • Harness: control it, because the approval rules, stop conditions and write rules encode your policy.
  • Memory: control it, including sources, owners, refresh dates and exclusions.
  • Tools and permissions: control them, with each grant tied to an identity you can revoke the same day.
  • Observability: control the records, keeping logs and evaluation results in a store you can export.

Illustrative scenario: a small equipment distributor wants an agent to answer order status questions from dealers and draft replies for staff. The model is rented and could be replaced. The harness allows drafts but holds every outgoing message for approval. Memory is limited to the daily order export and the shipping policy. The agent can read orders but cannot change them. Each run is logged, and before any model or prompt change, the team reruns its set of real dealer questions. A dealer email that says to ship to a new address is treated as content to report, not as an instruction to follow.

How to start: a plan for the first month

Before you choose tools, write down your stack for one role. The steps below keep the work small enough to finish and specific enough to review. The full arc of the first months after launch is described in What the First Months With a Managed AI Agent Look Like.

  • Pick one role with a clear task and a single business owner, such as order status replies or first-line support triage.
  • Write the five layer answers on one page: which model, which rules in the harness, which sources in memory, which actions in tools, and which records in observability.
  • Mark each layer as rent or control, and name the person who could revoke access on the same day.
  • Collect a set of real cases with known good answers before building anything.
  • Set an approval boundary for every action that cannot be undone.
  • Agree on a success measure the business owner can check without reading code.
  • Schedule a permission review and an evaluation rerun before the first live run.

Be Human designs and operates this kind of layered setup as a managed service for companies. The first engagement defines one useful role, the memory and tools it needs, its approval boundaries and an observable success criterion. Managed operations can then cover monitoring, recurring evaluations, integration maintenance, permission review, incident response and controlled improvements, so the company keeps control of its identity, memory, channels and permissions while the operating work follows a written plan. If you want to find the first task worth handing to an agent, take the free Be Human AI diagnostic.

Frequently asked questions

Do I need to build all five layers myself? No. Most companies rent the model and a good part of the tooling, then configure the harness, memory and records around it. The test is control, not construction: you should be able to change, inspect or remove whatever holds your knowledge and authority. A managed provider can run the layers day to day, but the rules and records should remain yours.

Which layer should a company control first? Start with permissions and memory, because they decide what the agent can do and what it can know. Harness approval rules come next, since they encode your policy. Observability should be in place before the first live run, otherwise you cannot tell what went wrong or why.

Does a more capable model remove the need for the other layers? No. A stronger model reasons better, but it cannot see records you did not give it, cannot act through systems you did not connect, and cannot show what it did without logs. Capability improves the model layer only. The other four still need owners, rules and evidence.

How do I know if my stack is ready for a live agent? Check that each layer has a named owner, a written rule, and a test or log you can show a manager. Confirm that access can be revoked the same day, that irreversible actions require approval, and that the latest set of test cases passed. If any of these is missing, keep the agent in a pilot until it is closed.

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 →