Personalized AI infrastructure
Superintelligence Layer on Existing Software: Three Integration Patterns
Compare three ways to add a company intelligence layer to current software, with trade-offs for memory, permissions and observability, plus a decision checklist.

A superintelligence layer on existing software is the set of memory, tools, permissions and observability that lets AI agents work across your current systems under human control. Companies usually build it in one of three ways: connect agents directly to each system, place a shared context index beside those systems, or route every agent action through a governed gateway. Each pattern handles memory, permissions and observability differently, so the right choice depends on how many systems the first role touches and how much the agent is allowed to change.
Key takeaways
- The layer is defined by four controls: memory, tools, permissions and observability. If one is missing, the agent becomes hard to trust and harder to correct.
- Direct connectors are the quickest pattern to start, but permissions scatter across every system and audit trails stay uneven.
- A shared context index gives the company one governed view of what it knows, but it creates a second copy of sensitive data that needs its own access rules.
- A governed gateway gives the cleanest permission model and audit trail, at the cost of more upfront design and one more component to operate.
- Choose the pattern from the systems the first role touches, the sensitivity of the data and the actions the agent may take, then pilot one role before expanding.
What the layer has to do on top of existing software
Your current systems were built to record work: the CRM logs customer contact, the helpdesk tracks tickets, the accounting package holds invoices and the shared drive keeps contracts. None of them was designed to let an agent reason across all of that. The layer adds four things. Memory defines what the agent knows, where that knowledge came from and how long it stays valid. Tools define the actions the agent may take, described precisely enough that a wrong call is easy to spot. Permissions define which identity the agent acts under, which actions it may perform alone and which ones need a named person to approve them. Observability records what the agent read, what it decided and what it changed, so that a person can reconstruct any task afterward.
Observability deserves the most attention early. The OpenTelemetry documentation frames the problem as the ability to ask questions about a system's behavior from the telemetry it emits, such as traces, metrics and logs. For an agent, the trace should connect a request, the context retrieved, each tool call and the final outcome in one timeline. If the agent's activity is split across four vendor dashboards with different clocks, you do not have observability, you have four partial logs.
The systems of record stay the source of truth in every pattern. The layer should not quietly become one. A common mistake is letting the agent's memory turn into an unofficial database that nobody maintains. Treat memory as a derived view that can be rebuilt from the source systems. If you want a one-page picture of where each system sits before you choose a pattern, the AI stack architecture map guide walks through that drawing.
Pattern one: direct connectors to each system
In the first pattern, the agent receives one tool per system. Each tool uses the vendor's API, webhooks or built-in automation rules. The agent keeps its own memory store, written from its past interactions and from notes it is allowed to save. There is no shared index and no central gateway. Each connector is configured where it lives.
The strength is speed and a small number of moving parts. When one role touches two or three systems and mostly reads or drafts, direct connectors are usually the least work to get running and to explain to the people using the agent.
The trade-offs appear as the role grows. Permissions scatter: each connector has its own token, its own scopes, its own expiry date and its own admin screen, so a permission review means opening every one of them. The OAuth 2.0 guidance from Google is a useful reference for requesting narrow scopes rather than broad access in each connector. Observability depends on what each vendor logs, which is often less than you need. Memory drifts, because the agent may keep an old address or an outdated price that was copied from a note and never corrected. Finally, any connector that reads external content, such as customer emails or ticket text, can carry instructions that try to override the agent's behavior. The OWASP prompt injection guidance describes this risk, and it becomes serious when the same agent holds write tools.
Direct connectors are a reasonable starting point for a single, narrow role with read-heavy work. They become expensive to govern once several roles share the same systems.
Pattern two: a shared context index beside your systems
In the second pattern, the company builds a retrieval layer over approved documents, records and summaries. When an agent needs context, it queries the index and receives the relevant passages to reason over. This is the usual technical base for retrieval-augmented generation, as described in Google Cloud's reference architecture: the model draws on current company material at question time instead of being retrained on it. Changes that the agent proposes still go back to the system that owns the record, through an action request, rather than through the index.
The strength is one governed place for company knowledge. Several agents can share the same vetted context, which keeps answers consistent across roles. Fewer agents need direct write paths into core systems, which narrows the surface you have to protect.
The trade-offs are specific. The index is a copy, so it can go stale. Every entry needs a source, an owner and a verification rule. The index also gathers sensitive material in one store, so its access rules must mirror the permissions of the source systems. A search that ignores those permissions will expose content to people and agents who should never see it. Observability has to cover retrieval, not only final answers, because a wrong answer often traces back to the wrong passage being retrieved. You need to be able to see which items were returned for each request.
Each indexed item should carry the same minimum fields:
- The source system and the record identifier it came from.
- A named owner who can confirm or correct the content.
- The date it was last verified against the source.
- The access groups copied from the source system, enforced at query time.
- A flag for content that must never be retrieved into an agent's answer.
The shared index depends on clean records. If the source data is inconsistent, the index will faithfully reproduce the inconsistency. The data foundations guide explains what to fix before indexing.
An index that ignores source permissions is a data leak with a search box.
Pattern three: a governed gateway between agents and systems
In the third pattern, the agent never calls a business system directly. Every tool call, memory read and memory write passes through a gateway. The gateway checks the identity behind the request, evaluates policy and approval rules, applies rate limits, and writes a trace of the request and result. The Model Context Protocol offers a common way to describe tools to agents, which helps keep tool definitions consistent across agents and models. The gateway is where you enforce what those definitions allow. Anthropic's guidance on writing tools for agents recommends narrow, clearly described tools, and the gateway is where that narrowness becomes a real limit.
The strength is a single permission model, a single audit trail and a single place to stop an agent. Approval thresholds become configuration rather than logic scattered across workflows. If you later change the model or the vendor, most of the change happens at the gateway, not in every workflow. That matters for avoiding lock-in, a point covered in how to avoid AI vendor lock-in.
The trade-offs are real. The gateway needs more design before the first role works. It is an extra service to run, monitor and secure. It adds latency to every call, and if it feels slow, people will route around it, which defeats the purpose. The gateway is also a high-value target, so authorization must be checked on every request, not only when a session begins. The OWASP authorization guidance is clear that access decisions should be enforced consistently at each point where a resource is used. Finally, a gateway that is poorly designed can become a bottleneck for every team, so its scope should match the actions that truly need control.
How the three patterns compare on memory, permissions and observability
The patterns differ most on the three controls that decide whether an agent can be trusted in daily work. The comparison below is qualitative and describes where each pattern tends to need more effort.
- Memory: Direct connectors keep memory inside each agent, so drift is likely and cleanup is manual. A shared index centralizes memory with source and freshness rules, which needs disciplined ownership. A gateway routes memory writes through policy checks, which makes them easiest to audit, but each memory type needs a named owner from the start.
- Permissions: Direct connectors spread permissions across many vendor consoles, which makes reviews slow. A shared index must mirror source access rules at query time. A gateway concentrates permissions in one model, which is the easiest to review and the easiest to get wrong if the policy is careless.
- Observability: Direct connectors depend on what each vendor logs. A shared index must record which items were retrieved for each request. A gateway can produce one trace per task that spans retrieval, tool calls and approvals.
- Time to a first working role: Direct connectors are usually the quickest. A shared index adds a data preparation step. A gateway adds platform design work before the first role goes live.
- Cost of change: Direct connectors multiply the work when a system changes. A shared index limits the change to its ingestion rules. A gateway localizes change to the gateway, provided its interfaces are stable.
No pattern is universally better. Many mature setups combine them: direct connectors for one low-risk read-only role, a shared index for company knowledge, and a gateway for any action that writes to a system of record.
How to choose and pilot the first pattern
Choose the pattern after you have chosen the first role, not before. The role determines the systems, the data sensitivity and the actions, and those three facts usually settle the pattern. Use the following sequence:
- Step one: List every system the first role must read and mark each one as the source of truth or as a derived view.
- Step two: Classify each action as read only, reversible write, or external or financial action. Automate only the first two at the start.
- Step three: If the role touches one or two systems and only reads or drafts, start with direct connectors. If it draws on many sources that other roles also need, add a shared index. If it writes to several systems or needs approvals, use a gateway.
- Step four: Write the success criterion before building. It should name the task type, the evidence a reviewer will check and the sample size that will be reviewed each week.
- Step five: Define stop rules: the conditions that pause the agent, the person notified and the fallback process for the team.
- Step six: Pilot with a small group of users, review the traces weekly and widen access only after the criterion is met.
Illustrative scenario: a regional services company wants an agent to draft quotes from its CRM and its price book. The role touches two systems and only drafts, so the team starts with direct connectors and a human sends every quote. Months later the same agent is asked to answer questions about contract terms and warranty conditions. The team adds a shared index for those documents, keeps the quote path unchanged, and moves any write to the CRM behind an approval step. Each change was driven by a new requirement, not by a platform preference.
How Be Human runs this in managed operations
Be Human designs and operates this kind of layer as a managed service. A first engagement defines one useful role, the memory and tools it needs, its approval boundaries and an observable success criterion, so the pattern follows from a real task. Managed operations then cover monitoring, recurring evaluations, integration maintenance, permission review, incident response and controlled improvements, which keeps connectors, indexes and gateway policies under review as your systems change. The design aims to keep decisions about memory and access with your own leaders, not hidden in configuration nobody reads.
If you are unsure which pattern fits your first role, the free Be Human AI diagnostic can help you find the first task worth handing to an agent.
Frequently asked questions
What is a superintelligence layer on existing software? It is the governed set of memory, tools, permissions and observability that lets AI agents work across systems you already run, such as a CRM, helpdesk or accounting package. The layer does not replace those systems. It defines what agents may know, what they may do, who they act for and how their activity is recorded.
Do I need to replace my current systems to add one? No. All three patterns work alongside existing software, and the systems of record stay the source of truth. The real work is in defining permissions, memory rules and traces for the systems you already have, which is usually more demanding than the technical connection itself.
Which pattern is safest for permissions? A governed gateway is usually the easiest to review because permission decisions live in one model and one audit trail. It is only safe, however, if authorization is checked on every request and the policy is written carefully. Direct connectors can be safe for narrow read-only roles, but they become hard to audit as the number of connectors grows.
How do I know the layer is working? Judge it against the success criterion you wrote before the pilot, and check it with traces rather than impressions. Review a sample of tasks each week, confirm that the agent stops when its stop rules trigger, and verify that retrieved context was current and permitted. If you cannot reconstruct a task from its trace, the layer is not yet observable enough to expand.
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.


