Improving
Data

Next-Gen Data: The Foundation Trusted AI Agents Depend On

Jeff Armstrong Jeff Armstrong November 19, 2026 6 minutes
Asset - Thumbnail - Next-Gen Data: The Foundation Trusted AI Agents Depend On

AI Agents: Governance Now Covers Who and What 

AI agents are moving from demos into production. They reason over enterprise data, retrieve it, and take action on it. That is powerful, but only when agents have deep business context and a sound foundation underneath that context. Without it, agent access stops being the win and becomes the risk. 

For years, data governance asked one question: who can see this report? People hesitated when a number looked wrong, and they only saw what they knew to look for. An agent does not work that way. It reads everything it can reach, connects dots nobody planned for, and answers with confidence. Every shortcut in a permission model, every unlabeled dataset, and every final_v4 copy of a report is now a risk. 

The question has changed. Now it is who and what can see your data, when, and for what purpose. This post covers the four things that need to be true before agents touch enterprise data: clear data ownership, secure AI infrastructure with guardrails, a unified and trusted data platform, and the Microsoft IQ layers that sit on top of it. 

Data Domains: Trust Needs a Named Owner 

Ask the same question of your data twice and you may get two answers. Ask how many clients you have, and two reports may disagree. Someone then has to decide which number reaches leadership. A person knows to be suspicious of that gap and can pick up the phone. An agent cannot. It finds both reports, picks one, and answers with total confidence. That is why trust starts with a data domain: a business area with a named owner, shared definitions, and the data that belongs to it. Domains like client, account, transaction, or compliance are business concepts, not systems. A domain may draw from several sources, and one source may feed several domains. What matters is that you choose a boundary and someone owns it. Trust depends on four roles, and three of them sit in the business rather than IT: 

  1. Domain owner: a senior business leader accountable for the domain. They set direction, resolve conflicts, and approve access. 

  2. Data steward: the person who decides what fields mean, keeps definitions consistent, and flags quality issues. Stewardship is usually a role someone wears alongside their day job. 

  3. Subject matter experts: operational specialists who advise on definitions and edge cases, such as the client who looks active but is not. 

  4. Technical custodian: the IT or data engineering team that builds and maintains pipelines, storage, and access controls. 

The business decides what data means. IT implements those decisions. When IT owns the data alone, it is usually owned by nobody. An agent needs six signals to judge whether data is trustworthy, and it must be able to read them without asking a person: 

  • Definition:  What does this mean? The steward writes it, and the owner signs off. 

  • Certification:  Is this the approved version? The steward proposes it, and the owner approves. 

  • Lineage:  Where did it come from? The platform records it, and the custodian keeps pipelines clean. 

  • Quality:  Is it complete, current, and correct? Stewards set the rules, and custodians run them. 

  • Sensitivity:  How carefully must we handle it? The owner classifies it, and the custodian applies the label. 

  • Access:  Who and what may use it, and for what? The owner approves, and the custodian implements. 

The first four tell you whether you can rely on the data. The last two tell you whether you may use it. Missing any one of them leaves an agent guessing. 

Landing Zones: How Far an Agent Can Stretch 

Domains tell an agent what is reliable. They cannot stop it from reaching data it should never touch. That is the job of the landing zone, which answers one question: how far can an agent stretch, and who decided that? 

Agents are different from reports. A report shows a number and waits. An agent reads, decides, calls tools, and acts, often many times a minute with nobody watching each step. The landing zone is the environment an agent is born into, and its guardrails should be set once, not rebuilt for every project. 

The usual pattern looks like this. A team builds an agent in a couple of weeks and connects it with their own credentials because that is the fastest path. The agent now sees everything the builder can see. It points at a broad workspace because narrowing it would take another sprint. Nobody names an owner or records what it reads. Nobody did anything reckless per se. The result is an agent with inherited access, no review, no owner, and no audit trail. Multiply that across every agent your organization plans to build. 

An AI landing zone prevents this by extending the standard Azure landing zone. It is not a separate foundation. It is a workload landing zone that inherits the same management hierarchy, policy, identity, networking, and logging, and adds an agent-specific layer: 

  • Identity: each agent gets its own identity, least-privilege permissions, and a named owner. Shared logins make it impossible to tell which agent did what. 

  • Data boundary: workspace roles and sensitivity labels enforce the domain rules, so an agent cannot reach past what its domain allows. 

  • Tools and actions: an allow list defines what an agent may call, and an approval step gates any write or change. 

  • Content safety: filters inspect what the agent takes in and what it returns. 

  • Audit: a record of what each agent accessed, called, and returned, so you can prove what happened. 

  • Policy and compliance: approved models, permitted regions, and approved endpoints, enforced at scale. 

  • Network: private connectivity between agents and models, with no public shortcut. 

Not every guardrail applies to every agent, but every agent should be checked against all of them. If you can only answer two questions today, start with data boundary and audit. An agent can only stretch as far as the last gate allows. 

Fabric: One Governed Estate, One Answer 

Moving every source onto one platform does not fix governance. A bigger platform with two definitions of a client and no named owner is still a mess. All you have done is move the sprawl into a single tool. What changes the outcome is what the data carries with it: an agreed definition, a certification, a sensitivity label, and a rule about who can see it. When those travel with the data, people and agents get the same answer. 

Most organizations today run several warehouses and a data lake, each with its own access model and its own idea of what a client is. Any agent pointed at them inherits whichever answer it happens to find. A unified estate in Microsoft Fabric keeps the same people, sources, and questions, but gives the business one version of the truth. 

The estate has six parts: 

  1. OneLake: one logical data lake with one copy of the data, using shortcuts instead of duplicates. 

  2. Domains and workspaces: business areas that group items, where ownership and policy are set. 

  3. OneLake catalog: where people and agents discover and govern items, with owner, endorsement, labels, and lineage shown beside each one. 

  4. Endorsement: promoted, certified, and master data labels that tell a person or agent which data is approved. 

  5. OneLake security: access control down to the table, row, and column, plus workspace roles. 

  6. Capacity: the compute that runs workloads, which sets the limits on how much and how often. 

Access in Fabric is layered, and an agent should pass through every layer a person would: tenant and capacity settings, workspace roles, item permissions, OneLake security, and sensitivity labels. Agents should receive the narrowest role that works, never a shared admin account. An agent acting for a user never sees more than that user can. Access is decided once in the data layer, not separately in every report and every agent. 

When an agent answers a question, it should follow the same steps a careful analyst would. It maps the business meaning to an entity with one agreed definition. It resolves that entity to a certified item in the catalog, not any table that happens to match. It applies security to decide which rows and columns it may read. It answers from certified data, with lineage showing where the number came from. And it logs what it accessed so the answer can be audited later. Same question, one answer, one owner, and a trail to prove it. 

IQ Layers: Consuming Trust, Not Creating It 

Microsoft's IQ layers give agents the context they need to act like they understand your business. Each one widens what an agent can know, and each one consumes whatever your domains have defined, certified, and labeled. An IQ layer does not create trust. It consumes it. 

  • Fabric IQ:  gives agents the state of your business as entities like client, account, and transaction. The foundation must supply domain definitions, owners, and certified sources behind each entity. 

  • Foundry IQ:  gives agents your organization's knowledge, such as policies, contracts, and playbooks. The foundation must supply labels and certification, so agents quote current, approved policies. 

  • Work IQ:  brings in how your people work across mail, files, meetings, and chats. The foundation must supply access that reflects real need, so agents surface only what a person may see. 

  • Web IQ:  brings in information from the outside world. The foundation must supply a clear internal boundary and sensitivity labels, so web claims never blend into certified internal numbers. 

Agent 365 sits alongside these layers as the control plane, so you can see which agent is acting, who it acts for, and what it is doing. Fabric IQ can use AI to draft an ontology from existing semantic models and domain definitions, which gets you to a first draft faster. The draft is only as trustworthy as the domains and certified items underneath it. Without solid domains, two definitions of a client give you two different answers to the same question. 

Where to Start: Three Checks

You do not need a platform before you define your data domains. Domain work can begin with the business alone, and it is worth doing even if you already run Fabric. Many organizations start there and build the technical environment around the domains they agree on. To make the foundation concrete, start with three checks: 

  • Name an owner for each core business domain, and write down its boundary. 

  • Confirm that every agent has its own identity, a named owner, and a least-privilege role. 

  • Verify that certified items, sensitivity labels, and lineage are visible in your catalog for the data agents will use. 

If you already have an estate, a quick on-ramp can start from your existing semantic models and move toward a medallion architecture with an ontology. Executive sessions on AI strategy and token spend are also useful for leadership teams setting direction. Every agent you build will inherit whatever trust, ownership, and guardrails sit underneath it. For a conversation about your data foundation, reach out to our team at improving.com/contact. (linked)