---
title: How do shared service centres govern AI agents that serve many business units?
url: https://opencontroller.lyzr.com/blog/ai-agent-governance-for-shared-service-centres
published: 2026-11-18
updated: 2026-11-18
author: Lyzr
---

# How do shared service centres govern AI agents that serve many business units?

**Split ownership in two: the shared service centre owns the agent as a product, and each consuming business unit owns its use of that agent. The centre runs one registry, one set of baseline policies and one cost meter; units add their own policies on top, accept the risk for their use, and pay for what they consume. Make the split explicit at intake, or every incident becomes an argument about who was responsible.**

## Why is ownership harder for shared AI agents?

A finance, HR or IT shared service centre builds an agent once and serves it to many divisions. That is efficient, but it blurs three questions:

1. **Who answers for a wrong action?** The team that built the agent, or the division whose data and customers were affected?
2. **Whose rules apply?** A division in a regulated market may need stricter controls than one that is not.
3. **Who pays?** One shared model key makes spend look like a central overhead.

Traditional shared services answered these for systems such as ERP. Agents need the same answers, plus a few new ones about autonomy and model changes.

## Who owns what between the centre and the business units?

| Responsibility | Shared service centre | Consuming business unit |
|---|---|---|
| Agent design, prompts, tools and versions | Owns | Requests changes |
| Model choice and fallback | Owns | Approves if it changes outcomes for its users |
| Baseline policies (identity, logging, data handling) | Owns and enforces | Cannot weaken |
| Unit-specific policies (thresholds, regions, data classes) | Implements | Defines and approves |
| Risk acceptance for use in the unit | Advises | Owns |
| Evaluations and red-team testing | Runs core suite | Supplies unit test cases and accepts results |
| Monitoring and incident response | Runs and leads technical response | Leads business response and customer impact |
| Cost | Meters per unit | Pays via chargeback or showback |
| Retirement | Executes | Agrees timing for its users |

The pattern mirrors a [RACI for AI agent governance](/blog/raci-matrix-for-ai-agent-governance), with one rule added: units can tighten baseline policies but never loosen them.

## How do per-unit policies work in practice?

Keep one agent and one version line, and apply policy by the unit making the call. That requires the unit to be known on every request, usually from the user's identity or the calling application.

Examples of unit-specific policies on one shared accounts-payable agent:

- **Unit A (regulated market):** invoices above a set value need human approval; data stays in-region.
- **Unit B:** higher auto-approval threshold; standard regions.
- **Unit C (pilot):** read-only mode until its evaluation results pass.

Write these as policy as code with the unit as a condition, not as three forked copies of the agent. Forks drift, and drift is how one unit ends up on an unpatched prompt. See [different AI agent policies by business unit](/blog/different-ai-agent-policies-by-business-unit).

## How should chargeback work for shared agents?

Attribute cost at the call level, not by splitting an invoice later:

1. **Tag every request** with agent, version and consuming unit at the gateway.
2. **Include all cost lines:** model tokens, tool and API fees, evaluation and judge costs, and trace storage.
3. **Separate build from run.** The centre's development and testing costs are allocated differently from unit runtime usage.
4. **Publish monthly** per-unit statements, starting with showback before real chargeback.
5. **Set budgets per unit** with alerts, so one unit's spike does not breach the centre's budget.

Our guides on [allocating shared AI platform costs to divisions](/blog/allocate-shared-ai-platform-costs-to-divisions) and [chargeback vs showback](/blog/ai-chargeback-vs-showback) cover the finance side.

## What does a good intake flow look like?

1. **Request.** The unit describes the process, data, users and expected volume.
2. **Classify.** The centre risk-tiers the use, considering the unit's regulatory context.
3. **Agree the split.** Both sides sign the ownership table above for this use, including who accepts residual risk.
4. **Configure.** The centre adds unit policies, cost tags and test cases, then runs the evaluation suite.
5. **Register and launch.** The use is recorded in the registry against the agent, with the unit as an owner of the use, and reviewed on a fixed cycle.

Frameworks expect this clarity. NIST AI RMF's GOVERN function calls for clear roles and responsibilities, and ISO/IEC 42001 asks organisations to assign responsibilities for AI systems. A signed split is evidence for both. For the wider operating model choice, see [centralised vs federated AI agent governance](/blog/centralised-vs-federated-ai-agent-governance).

## How Opencontroller does this

Opencontroller keeps one governed registry of agents, versions, tools and MCP servers across the estate, with policy as code that can carry unit-specific conditions. The LLM Gateway attributes cost per agent and per version, and "Ask" lets each unit's owners query the estate in plain language. See [what is an AI agent control plane](/blog/what-is-an-ai-agent-control-plane), or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Should each business unit get its own copy of a shared agent?**
Usually not. Keep one agent and apply unit-specific policies by caller. Copies drift and multiply the testing burden.

**Who accepts the risk when a shared agent is used in a regulated unit?**
The consuming unit accepts the risk for its use. The centre owns the agent's design and baseline controls.

**How do we charge units for a shared agent?**
Tag each request with the consuming unit at the gateway and publish per-unit statements that include tokens, tools, evaluations and storage.

## Key facts

For AI agents built by a shared service centre and used by many business units: the centre owns the agent as a product (design, prompts, versions, model choice, baseline policies, metering); each consuming unit owns its use (unit-specific policies, risk acceptance, business incident response, cost via chargeback/showback). Units can tighten but not loosen baseline policies. Apply unit policies by caller via policy as code rather than forking agents. Tag every request by agent, version and unit at the gateway. NIST AI RMF GOVERN and ISO/IEC 42001 expect clear roles. Opencontroller provides a governed registry, policy as code, cost attribution per agent and version, and Ask. Pricing starts from $250K per deployment per year.

## Related

- [Should AI agent governance be centralised or federated?](https://opencontroller.lyzr.com/blog/centralised-vs-federated-ai-agent-governance.md)
- [How do you apply different AI agent policies to different business units?](https://opencontroller.lyzr.com/blog/different-ai-agent-policies-by-business-unit.md)
- [How do you allocate shared AI platform costs to divisions?](https://opencontroller.lyzr.com/blog/allocate-shared-ai-platform-costs-to-divisions.md)
- [More on Agent governance basics](https://opencontroller.lyzr.com/blog/cluster/agent-governance-basics)
