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

Personalized AI infrastructure

Holding Companies and Superintelligence: Shared Memory Across Units

Share policies and knowledge across subsidiaries while keeping each unit's data separate, so a superintelligent layer compounds at holding company level.

Be Human typographic cover with the title: Holding Companies and Superintelligence: Shared Memory Across Units
Conceptual illustration created with AI · Be Human

A holding company can give every subsidiary access to shared policies, playbooks and verified know-how while keeping each unit's customer, employee and financial records inside its own boundary. The group-level layer improves when a lesson from one unit becomes a tested rule for the others, and it stays safe when each agent's permissions are scoped to the unit that owns the data. This article explains how to design that shared memory, which knowledge belongs where, and how to start without exposing any unit's records.

Key takeaways

  • A holding company gets group-level leverage when shared policy and verified know-how sit in one layer, and each subsidiary's records stay in their own boundary.
  • Separate three kinds of memory before connecting anything: group policy, shared know-how and unit-specific data.
  • Permissions belong to the unit that owns the data, while the group sets the minimum standard every unit's agents must meet.
  • Improvement compounds only when each change is logged, evaluated and traced to the policy version that produced it.
  • Start with one useful role in one unit, prove the boundary holds, and only then add a second unit.

What a superintelligent layer should mean for a holding company

In most holding companies the useful knowledge is scattered. A finance template sits in one subsidiary, a hiring checklist in another, and a supplier negotiation note in a third, often in a mailbox nobody else can search. In this journal, a superintelligent layer means something practical: the shared operating context that AI agents read before they act, including policies, definitions, approved procedures and a record of what worked. It is not a single model that reads everything the group owns.

The layer becomes valuable when the group can see what its units learned and push tested improvements back out. That loop is what compounds. Without it, each subsidiary builds its own agent from scratch, repeats the same mistakes and cannot tell whether a fix in one unit would help the others.

Which knowledge should be shared, and which must stay local?

The boundary between shared and local knowledge should follow ownership and sensitivity, not convenience. A practical sorting rule is to ask who has the right to use the information and what happens if it reaches the wrong unit. Most groups end up with four categories:

  • Shared at group level: brand rules, approval thresholds, metric definitions, document templates without personal data, and evaluation criteria.
  • Shared only as summary: lessons from incidents written as rules, with no raw customer or employee records attached.
  • Kept local: personal data, customer and supplier records, unit financials, and negotiation notes with named counterparties.
  • Not shared automatically: anything a subsidiary has not yet classified. Unclassified material stays where it is until someone with authority decides.

Personal data rules apply to each unit according to where it operates and whose data it holds, for example Brazil's data protection law for Brazilian operations and the EU Artificial Intelligence Act for certain high-risk uses in European markets. A holding company should ask its legal function to confirm the classification for each unit before any shared memory is built, rather than assuming that one group policy fits every jurisdiction.

How do you structure memory in three tiers?

A workable architecture uses three tiers. The first tier is group policy: the rules every agent must follow, owned by a named person at group level, readable by all units and editable only through a controlled change process. The second tier is shared know-how: curated procedures, templates and verified answers, each with an owner and a review date. The third tier is unit data: records that only agents running with that unit's credentials can retrieve.

Most agents should retrieve information at the moment they answer, rather than absorbing it into a model. This retrieval pattern, often called retrieval-augmented generation, lets the group update a policy once and have every agent use the new version on its next task. It also makes unit data removable. If a subsidiary is sold or a data retention period ends, its records can be deleted from its own store without retraining anything shared.

Illustrative scenario: a group with three operating units wants a shared quote-review agent. Group policy sets the maximum discount that any unit may offer without approval. The shared know-how tier holds an approved library of contract clauses. Each unit's past quotes stay in that unit's store, and the agent running for unit B cannot retrieve unit A's quotes, even though both agents run on the same platform.

How should permissions and approvals work in each subsidiary?

Permissions should be designed per unit and denied by default. Each subsidiary's agent should have its own identity, its own credentials and a documented list of tools it may call. Read access and write access should be separated, and any action that moves money, changes a customer record or sends an external message should require a named human approval above a stated threshold. Authorization guidance from OWASP recommends this kind of explicit, least-privilege design, and the same principle applies whether the agent connects to a CRM, an accounting system or a document store.

The group should not be the only approver. Each unit's operations lead should own its scopes, and the group should set minimum standards that no unit can lower. A short checklist helps keep this consistent:

  • Give each unit's agent a separate identity and credentials that cannot be reused across units.
  • Document every tool as read or write, with the data it touches and the unit that owns it.
  • Set approval thresholds per unit, inheriting any group minimum as a floor.
  • Log every retrieval and every action with the unit, the agent, and the policy version used.
  • Review scopes on a fixed calendar and again after any incident, following a permission review routine.

How do lessons compound across units without copying data?

Compounding comes from rules and evaluations, not from moving raw records between subsidiaries. Suppose one unit discovers that its agent misreads a date format in supplier invoices. The fix should be written as a rule in the shared know-how tier, tested against a set of examples that contain no real supplier data, and then released to every unit that uses the same procedure. The lesson travels as a verified instruction. The invoices stay where they were.

Observability makes this loop trustworthy. The OpenTelemetry concepts of traces, metrics and logs let a team connect an agent's output to the version of the policy and tools that produced it, so a regression in one unit can be traced to a specific change. Without that record, a group cannot tell whether a new rule helped, hurt, or simply coincided with a busy month. The broader practice of turning feedback into quarterly improvements follows the same logic.

The NIST AI Risk Management Framework offers a useful vocabulary for this work: govern, map, measure and manage. A holding company can use those four functions as a checklist for each unit's agent, with the group owning the governance function and each unit owning the mapping of its own risks.

How do you start at group level without overbuilding?

A holding company does not need a platform program before it has a first result. A sequence that keeps risk low looks like this:

  • Name one owner for shared group policy and one operations owner in each unit who is accountable for that unit's local data.
  • Inventory the knowledge each unit uses every week and classify each item as shared, summarized or local.
  • Choose one useful role in one unit and define its memory, tools, approval boundary and an observable success criterion.
  • Build the three memory tiers for that role, with an owner and a review date for every shared document.
  • Run evaluations before each rollout and record which policy version each agent used.
  • Add a second unit only after the first unit's permission review is clean and its success criterion holds.

For groups that want to see how the same pattern scales across sites, the two-location approach shows how shared memory and separate permissions fit together in practice.

Be Human's managed approach follows the same sequence. Each engagement defines one useful role, the memory and tools it needs, the approval boundaries and a success criterion the client can observe. In managed operations, Be Human handles monitoring, recurring evaluations, integration maintenance, permission reviews, incident response and controlled changes, so each subsidiary's boundary is checked on a schedule rather than assumed. If you want to find the first task worth handing to an agent in your group, take the free Be Human AI diagnostic.

Frequently asked questions

Can one AI layer serve several subsidiaries without mixing their data? Yes, if the design separates memory into tiers and gives each unit its own credentials. Group policy and verified know-how can be shared, while each unit's records are retrieved only by agents running with that unit's permissions. Every retrieval should be logged so the group can prove where information came from.

What should a holding company share first? Start with items that carry no personal or unit-specific data, such as brand rules, approval thresholds, metric definitions and document templates. These give immediate consistency and are easy to review. Incident lessons can follow once they are written as general rules without raw records attached.

Does a shared layer make a subsidiary less accountable for its own decisions? It should not. The subsidiary's operations leader should still own its approval thresholds, scopes and local data, while the group sets the minimum standard. Shared policy describes what must happen, but the unit remains responsible for how its agent performs in its own operations.

How do we know the shared layer is actually improving results? Define a success criterion for each role before rollout and measure it the same way in every unit. Record which policy version each agent used, so a change can be linked to an outcome. If a change does not move the measure, roll it back and record why.

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 →