Personalized AI infrastructure
Superintelligence Layer Architecture: A Reference for Small Companies
Models, harness, memory, tools, permissions, channels and observability for a small company's superintelligence layer, with one named owner for each part.

A superintelligence layer reference architecture for a small company is a set of seven working parts: models that do the reasoning, a harness that runs them, memory they can read, tools they can call, permissions that limit what they may do, channels where people reach them, and observability that records what happened. Each part needs one named owner inside the company, because an agent that nobody answers for drifts out of date without anyone noticing. The sections below explain what each part must do and which owner role should hold it.
Key takeaways
- Treat the layer as seven parts, and give each part one owner who answers for its behavior and its changes.
- Keep memory and permissions outside the model, so either can change without rebuilding the other.
- Let the harness, not the prompt, enforce retries, stop rules and approval steps.
- Make observability a requirement from the first build, not a report added after launch.
- Start with one role, a short list of tools and one success criterion, then add parts only after the first one is measured.
Give each part one owner before you choose tools
Most architecture diagrams show boxes and arrows and leave out the question that matters most in a small company: who decides when a box changes. A reference architecture is useful when every part has a named decision owner. In a small company those owners are usually roles rather than departments, and one person may hold more than one role. What matters is that every change has someone accountable for approving it and someone who will notice when it goes wrong.
The operations leader usually owns the business rules and the success criterion, because the layer exists to serve a specific job. The remaining parts can be split between an internal technical owner and an outside implementation partner, as long as the split is written down. A practical checklist looks like this:
- Name one owner for models and the harness, who approves any model or version change.
- Name one owner for memory, who decides what enters, what leaves and how errors are corrected.
- Name one owner for tools and permissions, who approves each new action the agent can take.
- Name one owner for channels, who controls where the agent speaks and under which identity.
- Name one owner for observability, who reads the logs and decides when an issue becomes an incident.
- Write the owners into the agent's runbook with the date of the last review.
The governance side, including who meets to approve changes, is covered in a committee charter for small companies.
Models: choose by task and keep the choice replaceable
The model does the reasoning, and it is the part most likely to change. A drafting task, a classification task and a multi-step task that touches several systems have different needs for quality, speed and cost, so the right model can differ from one task to the next. Place every model behind one interface in the harness. That way, switching models does not force a rewrite of memory, tools or permissions.
Record cost and outcome per completed task, not only the monthly bill. A model that looks cheap per call can cost more per finished request if it needs retries or frequent human corrections. The technical owner should be able to answer, for any task, which model handled it, how long it took and what it cost.
Harness: the program that decides what happens next
The harness is the program around the model. It assembles the context, sends it to the model, reads the response, calls tools, handles errors, counts steps and decides when to stop or ask a person. Anthropic's engineering guidance on long-running agents describes this kind of structure as what lets an agent keep working across sessions, with explicit progress records and clear checkpoints.
Put approval thresholds and stop rules in the harness, not in the prompt. A prompt is an instruction the model may follow or misread. The harness is code that enforces a limit regardless of what the model produces. Set a maximum number of steps per task, a timeout, a retry limit, and a rule that sends uncertain cases to a named person. The operations leader approves the thresholds, and the technical owner implements and tests them.
Memory: what the agent may remember and where it lives
Memory covers three kinds of information: the context for the current task, company records the agent looks up when it needs them, and a small set of durable notes such as the status of an open case or a standing customer preference. For most small companies, retrieving records at request time is a safer pattern than training a model on company data. The source stays in systems the company controls, and a wrong record can be corrected or removed without retraining anything.
Give every memory item a source, a date of last update and an owner. The records owner decides what enters the memory, who may correct it and when an item expires. Without those rules, an agent will confidently repeat an old answer as if it were current fact.
Illustrative scenario: a repair shop with three technicians uses an agent to answer customers who ask about job status. The agent reads job records from the shop's own system rather than from its notes. When a technician changes a promised completion day, the records owner updates the job, and the next answer reflects the change without anyone editing the agent.
Tools and permissions: the agent acts only as far as it is granted
Tools are the actions the agent can take: read a calendar, draft a reply, create a record, send a message, update a status. Each tool needs a written description of what it does, a scope that limits it to the records it needs, and a permission level that separates reading from writing. Writing and sending deserve the closest attention, because those steps are the hardest to undo quietly.
Treat anything the agent reads as untrusted input. Emails, web pages and uploaded documents can contain text written to steer the model. OWASP's prompt injection guidance recommends that the application, not the model, enforce what an action is allowed to do. Authorization belongs outside the model: the tool checks identity and scope on every call, following the same discipline OWASP describes in its authorization guidance.
Grant tools to the agent's own identity with least privilege, and require human approval for money movement, deletions and messages sent outside the company. The permissions owner, usually the business owner, approves each new action before it reaches production.
How Be Human handles this: in managed operations, Be Human writes the scope and approval boundary for each tool, keeps a register of credentials and permissions that the client can read, and runs scheduled permission reviews. Changes to tools move through a written request and an approval step, so the permissions owner sees each new capability before it goes live. The routine is described in quarterly permission reviews for AI agents.
Channels and observability: where people meet the agent and how you see its work
A channel is where a person or system reaches the agent: email, a chat window, a web form, a messaging app or an internal screen. Start with one or two. Each channel needs a clear identity, so people know they are talking to an agent and which function it represents, along with its own rules about what can be asked and what cannot.
Observability is how the owner sees what happened. OpenTelemetry's observability primer describes telemetry in terms of traces, metrics and logs, and the same logic applies to agents. A trace of one request should show the input, each model call, each tool call, each approval request and the final outcome. Record enough to reconstruct any decision, and apply the same retention and privacy rules you apply to the source records, since logs often contain personal data.
Add evaluations on top of logs. Keep a fixed set of past requests with known good answers, run it after every change to the model, prompt, tools or memory, and review the differences before release. The observability owner reads a regular summary of failed and escalated requests, because those show where the rules are weak.
A first-build plan for one role
The fastest route to a usable layer is to build around one role and let the other parts grow from it. The plan below fits a small company with one operations leader and one technical owner, internal or outside.
- Step one: write the role's job in two sentences, including what the agent must never do.
- Step two: list the seven parts and write one owner's name beside each.
- Step three: define one observable success criterion, scored on a fixed test set that the owner reviews every week.
- Step four: list every tool the agent needs and mark each one as read or write.
- Step five: set approval boundaries and write the stop rules into the runbook.
- Step six: connect one channel and turn on logging before the first real request.
- Step seven: run a pilot with a small group, review the logs each week, and change one thing at a time.
Keep the first version narrow on purpose. Adding a second channel, a second role or a broader memory store before the first one is measured makes failures harder to trace. For a wider view of how the pieces connect, a one-page architecture map is a useful companion. If you are not sure which of these parts your company already has, the free Be Human AI diagnostic will help you find the first task worth handing to an agent.
Frequently asked questions
Does a small company need all seven parts from the first day? You need a working version of each part, but not a full build of every part. A single role can run on a simple model choice, a short memory of verified records, two or three tools, one channel and basic logs. The parts can grow once the first role has proven its value.
Can we change the model later without rebuilding the rest? Yes, if the model sits behind one interface in the harness and memory, tools and permissions live outside it. Each model change should still run through the evaluation set, because a new model can respond differently to the same request. The technical owner records the change and its result.
Who should own the layer if we have no technical staff? Assign all seven owners anyway, and let an outside implementation partner hold the technical ones under a written scope. The operations leader keeps the business rules, the success criterion and the permission approvals. Ownership, not tooling, is what keeps the layer under your control.
How will we know the agent is working? Measure against the success criterion you wrote before launch, using the same test set every week. Read the logs for failed or escalated requests, not only the successful ones, because those show where the rules are weakest. If the test results and the logs disagree, investigate before changing anything.
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.


