Personalized AI infrastructure
Superintelligence for CIOs: Architecture Decisions to Make This Quarter
The architecture decisions a CIO should make now on agent identity, memory, tool scopes and logs, so a more capable AI agent plugs into the company.

A CIO preparing for more capable AI agents should settle four architecture decisions this quarter: how each agent is identified, where its memory lives, how narrowly its tools are scoped, and what its logs must prove. These choices cost little to make early and a great deal to retrofit, because a stronger model only adds value when it can act inside boundaries the company already controls. The sections below cover each decision, the order to make them in, and what a managed approach looks like once they are in place.
Key takeaways
- Give every agent its own identity, separate from any person or shared account, so its access can be granted, limited and revoked.
- Keep agent memory in stores you own and can inspect, with written rules for what may be stored, who can read it and when it is deleted.
- Scope each tool to the smallest action the job requires, and put approval gates on anything that spends money, changes records, sends external messages or deletes data.
- Record every run as a trace that names the agent, the model and prompt versions, each tool call, each approval and each source read.
- Treat the company layer as the asset and the model as a replaceable component, and test any model change against your own evaluations.
Why the architecture comes before the model
Models change often, while identity systems, data stores and approval rules change slowly. That difference is the reason to decide the stable parts first. A more capable agent does not need new permissions to become risky. It uses the permissions it already has, more effectively and across more steps. If those permissions were granted to a shared account, or to an employee who has since changed roles, the stronger agent inherits that problem at a higher speed.
The practical test is simple. Could you replace the model underneath your agent next month without changing who the agent is, what it can read, what it can do, and how you would prove what it did? If the answer is no, the layer is still owned by a vendor, and the company has not yet built its own.
Give each agent an identity of its own
Treat each agent as a non-human principal with a name, a named business owner and a documented purpose. It should not log in as a staff member, and it should not share a service account with other automations. Separate identities let you grant, limit, review and revoke access without touching anyone else's work. The authorization guidance from OWASP is a useful reference: access decisions should follow explicit rules, be enforced on the server side, and be checked on each request rather than assumed from an earlier session.
For each identity, record the systems it can reach, the credential type, the expiry or rotation rule, and the person who approves changes to its access. When an agent is retired, disable its identity in the same change. Leaving it active is how old access survives longer than the work that needed it.
Decide where memory lives and who can read it
Memory is the part of the architecture most often left to a vendor default, and it is the hardest to move later. Separate three kinds of context. Working context is what the agent needs for the current task and should expire when the task ends. Reference knowledge, such as policies, product specifications and procedures, belongs in documents you own and should be retrieved at the moment of use. Decision records, meaning what the agent did, why, and who approved it, belong in a log you control.
Retrieval and fine-tuning are often confused. Retrieval fetches current documents when a question is asked, so if you update or delete a source, the agent stops using it. Fine-tuning changes model behavior in ways that are hard to inspect and very hard to reverse for a single record. For most company knowledge, the architecture should favor retrieval from a store with access controls and retention rules.
Write down what must never enter memory: credentials, personal data beyond what the purpose requires, and client information covered by contractual restrictions. Then decide who can read each store and whether memory is shared across sites or separated by location. The question is worked through in shared memory and separate permissions across locations.
Scope every tool to the smallest useful action
A tool is the agent's hand, so define each one as a named action with explicit parameters, not as general access to an API. Read and write actions should be separate tools, so a permission review can grant one without the other. Writes need particular care. An agent that retries a failed request can create duplicate orders or messages unless the write carries an idempotency key that the receiving system honors. Payment platforms document this pattern publicly, and it is a fair question to ask any integration partner: what happens when the same request arrives twice?
Attach approval gates to actions that spend money, change customer records, send external messages or delete data. Write the threshold as a rule, for example that any refund above a limit set by the finance owner goes to a named person, rather than leaving the judgment to the agent. The guide to setting approval thresholds for stronger agents describes how to calibrate these gates as capability grows.
Write logs that answer an auditor's questions
A log that records only final answers will not help when something goes wrong. Record each run as a trace: the trigger, the model and prompt versions, each tool call with its parameters and result summary, each approval, and the final output. The OpenTelemetry observability primer explains the difference between traces, metrics and logs, and the same vocabulary applies to agent runs. Store references to sensitive records rather than full copies wherever the purpose allows.
Before go-live, confirm that your logs contain at least these elements:
- The agent identity and its named owner on every event
- The model and prompt versions used for each run
- The tool name, parameters (redacted where needed) and outcome of each call
- The approver's name and timestamp for each gated action
- Identifiers of the documents retrieved, so you can see which sources informed an answer
- The retention period and deletion procedure for each log store
- A test showing that a trace is still written when a run fails
Logging also matters for security. Untrusted text inside documents, emails or web pages can contain instructions that try to make an agent misuse its tools. OWASP's guidance on prompt injection is clear that this risk must be managed in the design, and a complete trace is how you find out which input led to an unexpected action.
A 90-day sequence and an illustrative scenario
Illustrative scenario: a regional services company wants an agent to draft follow-ups for overdue invoices. The CIO's first pass gives the agent one identity, read access to the invoice ledger, a draft-only email tool, and a rule that any message to a customer goes to the account manager for approval. Retrieval uses the company's written collection policy rather than a copy embedded in the model. Logs record which invoices were read and which drafts were approved. This scenario shows the shape of the decisions and reports no results.
For a company starting from a blank page, a workable sequence looks like this:
- Weeks one and two: name the agent's owner and purpose, list the systems it may touch, and write the list on one page.
- Weeks three and four: create the identity, the memory stores and the first tool definitions, with read and write actions separated.
- Weeks five and six: set the approval gates, connect logging, and test a failed run to confirm that its trace is complete.
- Weeks seven and eight: run recorded evaluations on real tasks and review what the agent read and wrote.
- Weeks nine to twelve: decide whether to widen scope, with each change filed as a request that names its approver.
Keep the company layer separate from the model
The architecture should expose stable interfaces: the tool definitions, the memory stores, the identity and the logs. The model sits behind those interfaces and can be changed when an evaluation shows that a new one performs your tasks better and within your rules. This separation is what turns a future model upgrade into a controlled change instead of a rebuild. Vendor-specific features, such as proprietary memory formats or exports that omit logs, are the usual sources of trouble. The checklist in the guide on avoiding AI vendor lock-in is a practical way to test them before renewal.
Running the layer after go-live
Architecture decisions decay unless someone maintains them. Permissions drift as projects change, integrations break when a vendor updates an interface, and evaluations stop reflecting the work once the business changes. A quarterly review of identities, scopes and logs, with the evidence kept alongside the architecture record, is a reasonable minimum.
Be Human designs and operates this layer for companies. In a first engagement we define the one role an agent will perform, 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 the identity, memory, tool and log decisions stay under the company's control as models change.
If you want to find the first task worth handing to an agent, take the free Be Human AI diagnostic.
Frequently asked questions
Do I need to choose a model before setting up this architecture? No. Identity, memory, tool scopes and logs should be defined in terms of your company's data and permissions, so they hold whichever model sits underneath. Choosing a model is a later decision, tested against your own evaluations. Keeping the two apart is what makes a future, stronger model a replacement rather than a rebuild.
Who should own these decisions inside the company? The CIO should own the architecture record, but each agent needs a named business owner who approves its purpose and its approval thresholds. Security and finance may need to sign off on specific gates. A short written charter keeps those roles clear before the first agent goes live.
Is it safe to keep agent memory in a vendor's platform? It can be, if you can export the records, see who accessed them, set retention periods and delete data on request. Ask for those capabilities in writing before storing anything sensitive. If memory cannot be moved or inspected, treat it as a dependency and plan for how you would exit it.
How often should these decisions be revisited? At least once a quarter, and again whenever an agent gains a new tool, a new data source or a new location. Each review should compare current permissions with the original record and remove anything no longer needed. Every change should be filed as a recorded request with an approver, not made as an informal adjustment.
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.


