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

Personalized AI infrastructure

Superintelligence Stack Explained: Models, Harness, Memory, Permissions

The superintelligence stack has four layers: models, harness, memory and permissions. Learn which parts your company must keep under its own control.

Be Human typographic cover with the title: Superintelligence Stack Explained: Models, Harness, Memory, Permissions
Conceptual illustration created with AI · Be Human

The superintelligence stack is the set of layers that turns a general-purpose AI model into dependable work for a specific company: the model, the harness that calls it, the memory it draws on, and the permissions that decide what it may touch. Models will keep changing, so the layers a company should own are the ones that hold its identity, its records and its decision rights. A business owner does not need to build a model, but does need to know who controls each of the other layers before an agent acts on the company's behalf.

Key takeaways

  • The model is the most replaceable layer, so plan for it to change without rewriting your operations.
  • The harness decides how the model is called, what it sees, when it stops and how it is observed, and you should be able to inspect it.
  • Memory is a company asset with named sources, owners and deletion rules, not a side effect of a chat tool.
  • Permissions define what an agent may do, and they need written approval boundaries and a fixed review schedule.
  • Evaluations connect the layers, so a model upgrade or a new tool is judged on evidence rather than enthusiasm.

What the superintelligence stack includes

Most public talk about advanced AI centers on the model. For a business owner, the more useful question is what surrounds it, because that is where work gets done, data gets read and actions get approved. The stack can be divided into four layers, with evaluation running across all of them as the check that the stack still behaves as intended:

  • Model: the reasoning engine, usually supplied by a vendor and replaceable.
  • Harness: the software that frames tasks, calls the model, routes tools, handles errors and writes logs.
  • Memory: the approved records, documents and history the agent can retrieve, with their sources.
  • Permissions: the identities, scopes and approval rules that govern every action.
  • Evaluation: the recurring tests that show whether the other four layers still perform as intended.

Each layer answers a different question. The model determines what can be reasoned out, the harness determines how the work is run, memory determines what the agent knows about your company, and permissions determine what it may do. When something goes wrong, naming the layer is the fastest way to find the cause.

Layer one: the model is a supplier you can replace

The model is where general reasoning happens, and for most companies it is the layer they rent. Vendors release new versions, change defaults and retire older models on their own schedules. Treating the model as a supplier is therefore a design choice, not pessimism.

The risk appears when business logic quietly moves into one vendor's prompts, proprietary features or hosted settings. At that point the model stops being a component and becomes the operating system of your process. Keep task definitions, approval rules and success criteria in documents your team owns, so that a different model can be tested against the same brief. Before any switch, decide which outputs must stay the same and which are allowed to improve.

Layer two: the harness decides how work happens

The harness is the least visible layer and often the most consequential. It assembles the context sent to the model, exposes tools, checks results, stops runs that go wrong, decides when a person must review, and records what happened. Two agents built on the same model can behave very differently because their harnesses differ.

Owning the harness does not mean writing one from scratch. It means you can read its instructions, list the tools it can call, inspect its logs and locate every point where it stops. If a provider's harness is a black box, you cannot investigate an incident or move the work to another platform. The OpenTelemetry observability primer offers useful vocabulary: traces follow the path of one request, metrics show trends over time, and logs record individual events. A company should be able to answer what the agent did, when it did it, and which tool it used.

Layer three: memory is the company record

Memory is what lets an agent behave as if it knows your business: past decisions, pricing rules, service history, approved procedures and customer preferences. The critical point is that memory belongs to the company. The model reads from it at the moment of work, but the source documents, their owners and their deletion rules should live with you, not inside a vendor's opaque store.

This separation makes corrections possible. When a policy changes, you update the source and rerun your test set, instead of hoping the model forgets the old version. Context engineering, the discipline of deciding what enters the model's working window at each step, belongs to this layer as well. Anthropic's engineering guidance treats context as a limited resource to curate, not a pile of everything that might be relevant.

For every memory source, record an owner, a review schedule and a rule for removal. Stale or contradictory memory produces confident wrong answers, which are harder to catch than visible errors. The documentation standards for a superintelligence-ready company explain how to keep those sources clean before an agent depends on them.

Layer four: permissions set the limits of action

Permissions turn an agent from an advisor into a participant in your operations. Each tool an agent can call is a permission, and each should be scoped to the smallest set of records and actions the job requires. The agent should act under its own named identity rather than a shared login, so that every action traces back to a specific grant.

OWASP's authorization guidance makes the principle plain: access decisions must be enforced on every request by the system that holds the data, not assumed from what an interface displays. Approval boundaries sit on top of that. An agent may draft a supplier message, but sending it requires a person's confirmation, and any action above a set financial or contractual limit goes to the owner. Start those thresholds conservatively and raise them only when evaluations and logs show consistent reliability.

Permissions also protect you when the model itself is manipulated. Text inside an email, a web page or a document can attempt to instruct the agent to do something its owner never intended. OWASP's prompt injection prevention guidance treats this as a design problem, and the practical lesson is that the model cannot be the only control. Permission boundaries must hold even when the model is persuaded. For a structured method, see how to run a permission review for your AI agents, step by step.

Which layers must stay under company control?

Not every layer needs to be owned outright. A useful test is reversibility: if a layer changes without notice, can you detect the change and recover from it? Apply that test with this guide:

  • Keep task definitions, approval rules and success criteria in your own documents, because they encode your decisions.
  • Keep memory sources, their owners and their deletion rules under company control, because they hold customer and operating facts.
  • Keep permission grants and the logs that show who used them, because they become your evidence during an incident.
  • Accept vendor ownership of model weights and general reasoning, provided you can run a test set against a replacement.
  • Require the harness to be inspectable, even when a provider maintains the code.

Illustrative scenario: a regional equipment distributor wants an agent to answer dealers about order status and draft replacement quotes. The owner allows the agent to read order records and draft quotes, but not to change prices or send anything without approval from a sales manager. When the vendor updates the default model, the team reruns its written test set of dealer questions. The new model drafts a quote that includes a discontinued part, and the evaluation flags the error before any dealer sees it. The fix belongs in the memory layer, where the discontinued parts list is updated, and the approval rule stays in place so a manager still reviews every quote.

How to map your stack and start with one role

You do not need to redesign the whole company to see its stack. Start with one role and work through it in order:

  • Name the role and the decision it supports in one sentence.
  • Record the model in use and where its instructions and settings are stored.
  • Describe the harness: inputs, tools, stop conditions, review points and logs.
  • List every memory source the role reads, with a named owner for each.
  • List every permission the role holds and the approval rule attached to it.
  • Write one success criterion and a test set you can rerun after any change.
  • Set a recurring permission review and evaluation rerun on a fixed schedule.

Once the map is complete, put it on one page so leadership can challenge it. The one-page architecture map for leaders shows how to lay it out so that each layer has an owner.

Be Human designs, implements and operates this kind of layered setup for companies. A first engagement defines one useful role, the memory and tools it needs, its approval boundaries and an observable success criterion. Managed operations then cover monitoring, recurring evaluations, integration maintenance, permission review, incident response and controlled improvements, so each change to the model, memory or permissions is requested and approved rather than applied quietly. 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

Do I have to build the whole superintelligence stack myself? No. Most companies should rent the model, use a vetted harness and buy operating support around them, while keeping ownership of the decisions and records that make the stack theirs. The work is knowing which layers you control and being able to test and replace the rest.

Which layer should I secure first? Start with permissions, because they limit the damage any other layer can cause. Scope each tool to the smallest set of actions, give the agent its own identity and write down the approval rule for every consequential action. Memory and harness work can follow once the role is clear.

Does a more capable model reduce the need for a harness and permissions? No. A stronger model may make fewer mistakes, but it still reads untrusted text, can still be manipulated and still needs limits on what it may do. Better capability changes the results of your tests, not the need for boundaries.

How often should the stack be reviewed? Review permissions and memory sources on a fixed schedule, and rerun your evaluation set after every change to the model, a tool or a source. Treat any incident as a trigger for an immediate review of the layer involved. The purpose is evidence, so the schedule should produce logs and test results that the people accountable for the outcome can read.

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 →