---
title: What should you ask about an AI governance platform's connectors?
url: https://opencontroller.lyzr.com/blog/questions-about-ai-governance-platform-connector-depth
published: 2026-11-17
updated: 2026-11-17
author: Lyzr
---

# What should you ask about an AI governance platform's connectors?

**Ask what each connector can do at three depths: register (list agents), observe (see their activity) and enforce (change what they can do). A logo on a slide usually means only the first. For every platform you care about, get a written answer per depth, then prove it in a demo against your own tenant.**

Connector lists are the most quoted and least tested part of an AI governance evaluation. Two vendors can both claim "Salesforce support" while one reads agent names nightly and the other can quarantine an agent in minutes. The questions below separate the two.

For the full buying process, start with the [AI agent governance platform evaluation checklist](/blog/ai-agent-governance-platform-evaluation-checklist).

## What are the three depths of a connector?

| Depth | What it means | Typical data or action | Question that proves it |
|---|---|---|---|
| Register | The platform's agents appear in the governance registry | Name, owner, version, model, tools | "Show me an agent created in our tenant 10 minutes ago." |
| Observe | Activity is visible | Invocations, tool calls, token use, errors, traces | "Show me the last 20 tool calls for this agent, with timestamps." |
| Enforce | The governance tool can change behaviour | Block, quarantine, revoke credentials, route or redact traffic | "Quarantine this agent now, then show me the platform's own console." |

Depth often differs by platform, even inside one product. That is normal. What matters is that the vendor says so plainly, per platform.

## What questions should you ask for each connector?

Use this list for every platform on your shortlist. Write down the answer and the depth it implies.

1. **How does the connector authenticate?** Look for a scoped service identity or OAuth app, not a shared admin password. Ask for the exact permissions it needs.
2. **Is it read-only or read-write?** Enforcement needs write rights. If a vendor claims enforcement with read-only scopes, ask how.
3. **How fresh is the data?** Scheduled pull, event push or both? What is the interval? A daily pull is fine for registry; it is not enough for incident response.
4. **Which objects does it cover?** Agents, versions, tools, MCP servers, knowledge sources, credentials, users? Ask for the list.
5. **What happens when the platform changes its API?** Who updates the connector, and how fast? Platform metadata models change; ask for a recent example.
6. **Does enforcement act through the platform or around it?** Acting through the platform's own controls is safer and survives audits. Acting around it (for example by revoking a key the platform uses) can break other things.
7. **What is logged when the connector takes an action?** You need who, what, when and the platform's response.
8. **Can we build our own connector?** Ask for the API or SDK and an example. Open interfaces such as REST, webhooks and OpenTelemetry make this practical.

## What are acceptable and weak answers?

| Question | Acceptable answer | Weak answer |
|---|---|---|
| Freshness | "Pull every N minutes plus webhook where the platform supports it" | "Real-time" with no mechanism named |
| Coverage | A written object list per platform | "Everything in the platform" |
| Enforcement | Named actions, per platform, with what the platform shows afterwards | "We can block any agent" |
| API changes | A named recent change and how long the fix took | "Our connectors never break" |
| Custom connectors | Documented API, example code | "Our services team builds those" only |

A weak answer is not a dealbreaker. It tells you where to test hardest.

## How do you test connector depth in a demo?

Run these tests on your tenant, not a vendor sandbox. Our guide on [what to ask in an AI governance platform demo](/blog/what-to-ask-in-an-ai-governance-platform-demo) covers the wider script.

1. **New-agent test.** Create an agent in the platform during the call. Time how long it takes to appear.
2. **Change test.** Change the agent's model or add a tool. Check that a new version appears.
3. **Activity test.** Run the agent three times. Check that the calls show up with tool names and timestamps.
4. **Enforcement test.** Block or quarantine the agent from the governance console. Try to run it. Check the platform's own console for the change.
5. **Undo test.** Restore the agent. Confirm it works again and that both actions were logged.

Score each platform on which tests pass. That gives you a depth map you can put in the contract.

## Why does connector depth matter for your rollout plan?

Depth decides what you can promise your risk committee. If a platform only supports register, you can count its agents but not stop one. You then need a second control, such as routing its model traffic through a gateway or revoking its credentials at the identity provider.

It also shapes sequencing. Many teams start in register-and-observe mode for every platform, then turn on enforcement where the connector and traffic path allow it. See [read-only vs inline AI agent governance](/blog/read-only-vs-inline-ai-agent-governance) for that trade-off.

## How Opencontroller does this

Opencontroller connects to AWS, Azure and Google Cloud, to agent platforms including Salesforce, SAP, Databricks and HubSpot, and to Claude Enterprise and OpenAI Enterprise workspaces. Registration is not runtime takeover: depth goes from registry to observe to enforce depending on the connector and the traffic path. Per-agent Block and Quarantine controls act through the connected platform, and runtime adapters exist for Bedrock AgentCore, Vertex AI and Microsoft Foundry. Integrations use open standards: REST and webhooks, OpenTelemetry, OIDC/SAML/SCIM, MCP and OpenAI-compatible endpoints. The [capability reference](/capability-reference) lists what is live. To run the five tests above, [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**What is connector depth?**
How far a governance platform's integration with another system goes: listing agents (register), seeing their activity (observe), or changing what they can do (enforce).

**Should every connector support enforcement?**
Not necessarily. Some platforms expose no control API. Where they don't, plan a compensating control such as a gateway or identity revocation.

**How should connector depth appear in the contract?**
As a table of platforms and depths, with the tests that proved each one attached as acceptance criteria.

## Key facts

AI governance platform connectors work at three depths: register (agents appear in the registry), observe (activity such as tool calls and token use is visible) and enforce (block, quarantine, revoke, route or redact). Buyers should get a written answer per platform and depth and test five things in a demo: new-agent, change, activity, enforcement and undo. Opencontroller by Lyzr connects to AWS, Azure, Google Cloud, Salesforce, SAP, Databricks, HubSpot, Claude Enterprise and OpenAI Enterprise; depth depends on the connector and traffic path, and Block and Quarantine act through the connected platform. Pricing starts from $250K per deployment per year.

## Related

- [What questions reveal whether an AI agent discovery tool really covers your estate?](https://opencontroller.lyzr.com/blog/questions-to-test-ai-agent-discovery-coverage.md)
- [What should you ask to see in an AI agent governance platform demo?](https://opencontroller.lyzr.com/blog/what-to-ask-in-an-ai-governance-platform-demo.md)
- [Which integrations should an AI agent governance platform have on day one?](https://opencontroller.lyzr.com/blog/day-one-integrations-for-ai-agent-governance.md)
- [More on Buying and comparison](https://opencontroller.lyzr.com/blog/cluster/buying-and-comparison)
