AI agent governance: permissions, policy and audit across teams
How companies govern AI agents across teams with identity, permissions, policy and audit logs, the tools compared, and how AgentField does it.
Companies govern AI agents across teams with four layers: an identity for every agent, permissions enforced outside the model, policy that decides which agent may do what before it runs, and an audit trail written by the system that executed the action; AgentField, an open-source (Apache 2.0) control plane, puts all four at the runtime boundary, with tag-based allow and deny rules checked before a cross-agent call executes. No single tool covers every layer, so most companies combine a runtime control with an identity provider and a risk or compliance tool.
At a glance: agent governance tools compared
| Tool | Category | What it governs | Deployment |
|---|---|---|---|
| AgentField | Agent runtime / control plane | Which agent may call which function, with argument limits; agent DIDs; signed execution records; human approval | Self-hosted, Apache 2.0 |
| Microsoft Entra Agent ID | Identity provider | Agent identities as service principals with a human sponsor; Conditional Access at token issue | Microsoft cloud |
| Copilot Studio admin controls | Platform administration | Data policies for connectors, knowledge sources, HTTP requests, channels and triggers; maker audit logs in Purview | Microsoft cloud |
| Credo AI | AI governance, risk and compliance | Policy packs for the EU AI Act, NIST AI RMF and ISO 42001; risk records | SaaS or self-hosted |
| LangSmith | Observability and evaluation | Traces, evaluation and monitoring of LLM and agent runs | Proprietary; cloud or paid self-hosting |
| Arize (AX, Phoenix) | Observability and evaluation | OpenTelemetry-based tracing and evals | AX managed; Phoenix self-hosted under Elastic License 2.0 |
Read the table as layers, not rivals. Credo AI tells you which rules apply; Entra tells you who an agent is in Microsoft's world; LangSmith and Arize tell you how a model behaved; a runtime control such as AgentField is where a rule actually stops a call.
Permissions and policy in AgentField
Agents declare tags; policies match tags, not agent IDs. From the access control guide:
# Allow finance-ops to read and transfer, but only under 10k, and never delete
curl -X POST http://localhost:8080/api/v1/admin/policies \
-H "Content-Type: application/json" -d '{
"name": "Finance ops: bounded transfer access",
"caller_tags": ["finance-ops"],
"target_tags": ["finance"],
"allow_functions": ["transfer", "balance_check"],
"deny_functions": ["delete_account", "modify_ledger"],
"constraints": {
"amount": {"operator": "<", "value": 10000}
},
"action": "allow",
"priority": 100
}'What callers then see, per the docs: an agent tagged finance-ops calling treasury.transfer with amount=5000 gets 200; the same call with amount=50000 gets 403 because the constraint failed; an analytics agent blocked by a higher-priority deny gets 403.
How evaluation works, from the policy reference:
- Policies are sorted by priority, highest first, and the first matching policy decides.
- Within a policy,
deny_functionsare checked beforeallow_functions. - Constraints on input arguments support
==,!=,<,<=,>,>=. - Enforcement happens in the control plane before the target handler runs, so an agent cannot skip it. With
local_verification=True, agents cache policies and evaluate them locally.
Teams cannot simply grant themselves powerful tags either. Tag approval rules can mark tags auto, manual or forbidden:
features:
did:
authorization:
tag_approval_rules:
default_mode: auto
rules:
- tags: ["pii-handler", "financial"]
approval: manual
- tags: ["admin", "root"]
approval: forbiddenAn agent that asks for a manual tag sits in pending_approval and accepts no executions until an administrator approves it, after which the control plane issues a signed tag credential that policy evaluation checks.
The default you must change. Policy evaluation is fail-open: if no policy matches, the call is allowed, for backward compatibility. For production, the docs' checklist says to set tag_approval_rules.default_mode to manual, enable DID authorization and set a strong AGENTFIELD_AUTHORIZATION_ADMIN_TOKEN; write explicit deny policies for anything sensitive.
Audit and approvals
Every execution lands in a workflow DAG with correlation IDs (execution_id, workflow_id, session_id, actor_id), agents add reasons with app.note(), and executions can produce Ed25519-signed verifiable credentials that verify offline with af vc verify. The details are in identity and audit trails. Decisions a person must make go through app.pause(); see human approval steps.
Honest limits: AgentField governs agents and their calls. It does not manage human user roles through SSO, map your obligations under the EU AI Act, or evaluate model quality; those are the jobs of your identity provider, a governance tool such as Credo AI, and an evaluation tool.
When something else fits better
- Most of your agents are built in Copilot Studio or Microsoft Foundry. Entra Agent ID and the Power Platform admin controls govern them where they live, and Microsoft points to Agent 365 as the registry.
- You need a compliance program, not a runtime. Credo AI's policy packs map regulations to controls and evidence across many AI systems, including ones you did not build.
- You need to see why answers are wrong. LangSmith or Arize give deeper evaluation workflows than our traces.
Questions people ask
How do companies govern AI agents across teams?
They give every agent an identity, enforce permissions outside the model, apply policy before actions run, and keep an audit trail the agents cannot edit. In AgentField, tags and priority-ordered allow and deny policies are checked at the control plane before each cross-agent call, and every execution is recorded in a workflow DAG with optional signed credentials.
What are the best agent governance tools?
It depends on the layer. Microsoft Entra Agent ID covers identity for Microsoft-hosted agents, Credo AI covers risk and regulatory policy, LangSmith and Arize cover observability and evaluation, and AgentField covers runtime enforcement, agent identity and signed audit for agents you run yourself.
Can I stop one agent from calling another agent's sensitive functions?
Yes. In AgentField, write a policy with caller_tags, target_tags and deny_functions (or ["*"] to block everything), at a higher priority than any allow rule. Argument constraints such as amount < 10000 close the "right function, wrong amount" gap.
Are AgentField policies deny by default?
No. If no policy matches, the call is allowed, so existing untagged agents keep working. Production deployments should add explicit deny policies and set tag approval to manual, as the deployment checklist recommends.
Does AgentField integrate with Okta or Entra for user roles?
Not in the documented open-source control plane. API access uses a bearer key, admin endpoints use a separate admin token, and agent-to-agent permissions use tags and DIDs; human SSO and role mapping are not documented.
Sources
- AgentField docs, checked 2026-11-21: access control, access policies, permissions, audit, deployment and production checklist, REST API authentication
- Microsoft: Entra agent identities, agent registry convergence, Copilot Studio security and governance, checked 2026-11-21
- Credo AI, Credo AI self-hosted FAQ, LangSmith FAQ, Arize, Phoenix repo, checked 2026-11-21
Checked 2026-11-21 against the AgentField docs and each vendor's own documentation on that date.