Personalized AI infrastructure
Holding Company Superintelligence: Shared Agents, Separate Memory
A holding company can share agent infrastructure across subsidiaries while each entity keeps its own memory, permissions and data boundaries. Here is how to set it up.

A holding company can run one shared layer of AI agent infrastructure for all of its subsidiaries, as long as the layer separates what is common from what belongs to each entity. The group shares the runtime, tool standards, monitoring and review process, while each subsidiary keeps its own memory store, permission grants and data boundary. That separation is what lets an agent serving one company avoid reading another company's records by accident.
Key takeaways
- Share the platform, not the memory. Runtime, tool definitions, logging and review processes can be common, but memory stores belong to each entity.
- Grant permissions per entity, even when the same agent role appears in several subsidiaries.
- Write the boundary down and have the group and each subsidiary sign it before any agent connects to live data.
- Test isolation on purpose by asking questions that should be refused, and keep the results as evidence.
- Start with one shared service that saves real effort in at least two subsidiaries, not with a group-wide platform built in advance.
Why holding companies are tempted to share everything
A holding company usually sees the same problem repeated across its portfolio. Each subsidiary wants an assistant for its sales team, its finance team or its customer support, and each one starts by building its own connectors, prompts and document collections. The result is duplicated work, inconsistent controls and no single view of what the group is actually running.
The pull toward sharing everything is understandable, but the risk sits in one place. Agents become useful when they have context, and context is exactly what should not drift between companies. A shared document index, a shared conversation history or a shared credential can all carry one subsidiary's supplier terms or customer details into another subsidiary's answers. The design task is to share what reduces effort and keep separate what carries ownership.
Separate what is shared from what each entity owns
The most useful exercise before any build is a written split between shared services and entity-owned assets. A workable starting list looks like this:
- Shared by the group: the agent runtime, approved tool definitions, logging standards, evaluation templates and the incident process.
- Owned by each subsidiary: memory and knowledge stores, customer and supplier records, permission grants, approval thresholds and operating hours.
- Decided jointly: which role templates may be copied into another entity, who may request a new tool, and how cross-entity reporting is produced and approved.
Memory deserves the closest attention. In a retrieval setup, the agent fetches passages from a store at the moment it answers, so the store's boundaries become the agent's boundaries. If two subsidiaries write into one index without tags that the retrieval layer enforces, a query from one company can surface a document from the other. The safer pattern is one store per entity, with the entity identifier checked by the system before any passage is returned. The [Google Cloud retrieval-augmented generation architecture](https://docs.cloud.google.com/architecture/rag-capable-gen-ai-app-using-vertex-ai) describes the general flow that makes this boundary visible in the design.
For a deeper look at how a company's layers fit together, draw your AI stack on one page before deciding which layer each subsidiary touches.
Design permissions per entity, not per agent
A common mistake is to define permissions on the agent as a whole. An agent that can read the group's shared reporting tool and also the property subsidiary's lease system then has access to both, regardless of which company it is currently helping. Permissions should attach to the pair of role and entity, with separate credentials for each subsidiary's systems.
The check itself belongs in the tool layer, not in the instructions given to the model. The [OWASP authorization guidance](https://cheatsheetseries.owasp.org/cheatsheets/Authorization_Cheat_Sheet.html) makes the general point that access decisions should be enforced by the system that holds the resource. For delegated access to third-party systems, the [OAuth 2.0 authorization framework](https://developers.google.com/identity/protocols/oauth2) gives each subsidiary a way to grant a specific scope and revoke it without touching the others.
Prompt injection is the second reason to keep the check outside the model. A document from one subsidiary can contain text written to steer the agent toward another company's data. The [OWASP prompt injection prevention guidance](https://cheatsheetseries.owasp.org/cheatsheets/LLM_Prompt_Injection_Prevention_Cheat_Sheet.html) recommends limiting what the model can reach, so a manipulated answer still cannot pull records outside the entity it serves.
Step-by-step plan for shared services with separate memory
The following sequence fits a holding company that wants to start with two or three subsidiaries and expand only after the first boundary holds:
- Map each subsidiary's data classes and name the person accountable for each class.
- Write the group's shared services in one charter, including who maintains them and how changes are requested.
- Create one memory store per entity, each with its own access identity and retention rule.
- Bind every agent session to exactly one entity at runtime, so the entity is set by the system and not by a convention in the prompt.
- Scope tool credentials per entity and record the entity identifier on every tool call.
- Run boundary tests with requests that must be refused, such as asking one subsidiary's agent for another subsidiary's supplier list.
- Set a review date for permissions and assign one owner per entity who signs the result.
The [OpenTelemetry observability primer](https://opentelemetry.io/docs/concepts/observability-primer/) is a useful reference for the logging side. Traces and logs that carry the entity identifier let the group answer who accessed what, without reading the content of the answers.
What an illustrative scenario looks like
Illustrative scenario, not a client case: a holding group owns a retail subsidiary, a logistics subsidiary and a property subsidiary. The group wants one reporting agent that drafts weekly operating summaries for each company. The retail team's supplier prices must not reach logistics carriers, and the property team's lease terms must stay inside property. The group agrees on a shared reporting template and shared logging. Each subsidiary receives its own memory store, its own credentials to its own systems and a separate approval threshold for anything that leaves the company. The first boundary test asks the retail context for logistics rates, and the system refuses it and records the refusal. The group then has evidence that the boundary works, not only a policy that says it should.
How Be Human's managed approach handles this
Be Human designs this kind of layer as a managed service, starting with a first engagement that defines one useful role, the memory and tools it needs, the approval boundaries and a success criterion that can be observed. For a holding company, the boundary map for each subsidiary is part of that design, and the agent's identity, memory and permissions stay under the group's control. After launch, Be Human operates monitoring, recurring evaluations, integration maintenance, permission review and incident response, so that a change for one subsidiary is reviewed against the others before it reaches production.
Operating the shared layer over time
The boundary is not finished when the first agent goes live. Subsidiaries change systems, staff move between companies and new tools get added. A quarterly review of permissions and a written process for requesting changes keep the separation accurate. Running a permission review step by step gives a method that works for each entity separately and for the group as a whole.
Review also protects against quiet dependence on one vendor. If the group's shared services are documented in plain terms and the memory stores can be exported per entity, changing the underlying platform later is a managed task rather than a rebuild. The [NIST AI Risk Management Framework](https://www.nist.gov/itl/ai-risk-management-framework) offers a structure for deciding which risks to monitor and who owns each one.
If you want to find the first task across your group that is worth handing to an agent, take the free Be Human AI diagnostic.
Frequently asked questions
Can a holding company use one AI agent for several subsidiaries? Yes, if the agent's runtime and tool definitions are shared but each session is bound to one entity at a time. Memory, credentials and approval thresholds should belong to each subsidiary, and the system should enforce which entity a session is serving. Without that binding, the agent can carry context across companies in ways that are hard to detect afterward.
What should stay separate between subsidiaries? Memory stores, customer and supplier records, access credentials, approval limits and operating hours should stay separate by default. Shared services can include the runtime, the logging standard, evaluation templates and the incident process. Anything that crosses entities should be a deliberate, documented decision with a named owner.
How do we test that the boundary actually holds? Write requests that the agent must refuse, such as asking one subsidiary's assistant for another subsidiary's records, and run them on a schedule. Keep the refusals and the logs as evidence, and repeat the tests after any change to tools, data sources or permissions. A boundary that has never been tested is a policy, not a control.
When should a holding company start this kind of shared layer? Start when at least two subsidiaries have a concrete task that would benefit from the same agent, and when the group can name an owner for each entity's data. Starting with one shared service and one boundary test is more useful than designing a group-wide platform before any agent has proven its value.
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.


