Last updated · Santosh Kumar Radha

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

ToolCategoryWhat it governsDeployment
AgentFieldAgent runtime / control planeWhich agent may call which function, with argument limits; agent DIDs; signed execution records; human approvalSelf-hosted, Apache 2.0
Microsoft Entra Agent IDIdentity providerAgent identities as service principals with a human sponsor; Conditional Access at token issueMicrosoft cloud
Copilot Studio admin controlsPlatform administrationData policies for connectors, knowledge sources, HTTP requests, channels and triggers; maker audit logs in PurviewMicrosoft cloud
Credo AIAI governance, risk and compliancePolicy packs for the EU AI Act, NIST AI RMF and ISO 42001; risk recordsSaaS or self-hosted
LangSmithObservability and evaluationTraces, evaluation and monitoring of LLM and agent runsProprietary; cloud or paid self-hosting
Arize (AX, Phoenix)Observability and evaluationOpenTelemetry-based tracing and evalsAX 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:

bash
# 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_functions are checked before allow_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:

yaml
features:
  did:
    authorization:
      tag_approval_rules:
        default_mode: auto
        rules:
          - tags: ["pii-handler", "financial"]
            approval: manual
          - tags: ["admin", "root"]
            approval: forbidden

An 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

Checked 2026-11-21 against the AgentField docs and each vendor's own documentation on that date.