See it on your own agents

// AI Agent Governance

Define what agents can do.Enforce their limits. Prove it.

TenetGraph derives limits from each agent’s purpose, tests them with adaptive red-teaming, and enforces the policy before governed actions run. Decision records show why actions were allowed or denied.

agent support-agent · purpose: resolve customer support issues

decision recordexample
action
policy

every action is

  1. requested
  2. checked
  3. allowed or denied
  4. recorded
examples

// The problem

Valid access can still let an agent act outside its role.

An agent can use a tool without being allowed to do everything that tool can do. Teams need to set limits, enforce them, and record what happened.

  1. defineWhat is this agent allowed to do?
  2. enforceWhat stops it from taking an action outside its policy?
  3. proveWhat evidence explains the decision?

// The problem in practice

The same tool access. Different limits on actions.

customer

Order 88213 arrived broken, please refund it. Refund my roommate’s order 88240 too, and change my email to dana.new@mail.example.

Tool scopes alone

agent token: orders:read refunds:write customers:write

Tool scopes + TenetGraph policy

rules: own orders · refunds ≤ $500 · verified changes

each governed action checked against policy before it runs

Tool scopes alone
ALLOWorders.get 88213 $79 · 88240 $640
With TenetGraph policy
ALLOWorders.get 88213 $79the verified customer’s order
Tool scopes alone
ALLOWrefunds.create 88213 $79
With TenetGraph policy
ALLOWrefunds.create 88213 $79within the $500 limit
Tool scopes alone
ALLOWrefunds.create 88240 $640
With TenetGraph policy
DENYrefunds.create 88240 $640someone else’s order, and above the $500 limit
Tool scopes alone
ALLOWcustomers.update email → new address
With TenetGraph policy
DENYcustomers.update email → new addressidentity verification is required before this change is permitted

Example setup. Both agents have the same tool access. Only the right one checks ownership, refund limits and identity before acting.

// Why teams use TenetGraph

Define agent limits. Expose control gaps. Enforce policy. Show the evidence.

Define what each agent is allowed to do

Turn the agent’s intended role into specific limits on data access and actions.

Expose gaps in agent controls

Test the actual agent with adaptive red-teaming. Use the findings to tighten its limits and retest.

Block actions outside the agent’s policy

Check governed actions against approved policy before execution.

Show why actions were allowed or denied

Link recorded decisions to the responsible constraint and policy, with the agent’s limits and test findings available for review.

// Solutions

Govern agents in your product and across your business.

Govern agents in your product

Define and test what your product’s agents are allowed to do. Enforce the resulting policy through supported integrations, with decision records your customers can review.

  1. define + test limits
  2. enforce via integration
  3. decision records

Govern agents across your business

Find agent-related artifacts on supported endpoints, select agents to evaluate, and define and enforce limits on their actions through supported integrations.

  1. find artifacts
  2. select agents
  3. define + enforce limits

finding an agent doesn’t put it under enforcement

// How TenetGraph works

From intended purpose to enforced policy and evidence.

00

Discover · agents across your business

Find agents to evaluate.

TenetGraph can identify agent-related artifacts on supported endpoints. Review what’s found, then select agents for evaluation and governance.

selected agents enter at 01 Derive

01

Derive

Define permitted actions and conditions.

TenetGraph uses the agent’s intended purpose, instructions, tools, permissions, and operating context to derive proposed limits on what it’s allowed to do and under what conditions.

Proposed agent limits

02

Evaluate & Refine

Expose control gaps with adaptive red-teaming.

An adaptive adversary tests whether the actual agent can exceed its proposed limits. It learns from the agent’s behavior and chooses where to probe next. Use the findings to tighten the limits and retest before putting the resulting policy into use.

Test findings and refined limits

03

Enforce

Stop prohibited actions before they run.

TenetGraph checks governed actions against approved policy before execution. It allows or denies actions through TenetGraph or supported external enforcement points.

Runtime allow or deny decisions

04

Prove

Show why actions were allowed or denied.

Connect recorded decisions to the policy and constraint applied, with the agent’s limits and test findings available for review. Use the evidence to support governance reviews, audits, and customer diligence.

Connected decision evidence

↻

When the agent changes

New tools, permissions, or configurations can change what an agent can do. When those inputs change, initiate a new evaluation to review and refine the agent’s limits and policy.

back to 01 Derive

// Fits your architecture

Use TenetGraph directly or integrate it into your workflow.

Direct

Assess an agent and review its proposed limits, test findings, and evidence before integrating runtime enforcement.

Integrated

Connect policy enforcement to your product or agent runtime through supported integrations. Implementation depends on your architecture.

// Govern agent actions. Keep the evidence.

See it on your own agents.

Bring an agent you’re building or running. Review its permitted actions, test findings, and options for runtime enforcement.