RiseLab

AI Agent Governance: Closing the Gap Between Policy and Practice

Most governance frameworks say who should be watching an AI agent. They rarely say what the platform does while nobody is looking. Here is a practical way to build enforcement into the execution path.

RiseLab ·

A control gate sitting between a row of AI agent nodes and a set of business systems, with a human reviewer approving one action

Most enterprises now have an AI governance framework on paper. Fewer have one that actually stops an agent from doing something it shouldn't. That gap is the real problem in AI agent governance: policy is written at the speed of meetings, and agents act at the speed of API calls.

A RACI matrix tells you who is responsible. It does not give that person anything to look at in time to act. The practical answer is to move as much governance as possible out of documents and into the platform that runs the agents.

This article lays out a working approach: what to enforce in the execution path, what to leave to people, and where RiseLab fits.

Why governance documents don't stop agents

A governance document can assign an owner, define an escalation path and list prohibited actions. It cannot intercept a tool call.

When an agent can send an email, write to a CRM or post content, the control that matters is the one sitting between the agent's decision and the outside world. If that control is a review meeting next Thursday, it isn't a control.

Three questions separate real governance from aspirational governance:

  • Can the platform refuse an action? Or does it only record that the action happened?
  • Can a person see a run while it is happening? Or only after it ends?
  • Can you prove who approved what? Or do you reconstruct it from chat history?

If the answer to each is "only afterward," you have documentation, not governance.

AI agent governance has to run in the execution path

The design principle is simple: controls belong where the work happens. In practice that means five layers, each enforced by the platform rather than by convention.

1. Put people at the decisions that matter

Not every step needs a human, and a platform that asks for approval on everything trains reviewers to click "yes." The skill is choosing which decisions are critical and routing only those.

RiseLab routes critical AI decisions through configurable human approval workflows. Every approval leaves an audit trail. That gives the reviewer a bounded set of decisions to look at and gives the auditor a record to inspect.

Structured validation helps here too. In October 2026, RiseLab began validating trading decisions that end with a structured ticket block against a defined schema before use. If the block fails validation, it is refused with a stated reason rather than being re-drafted by the Order Desk model, which could have placed a trade the decision did not state. The principle generalizes: when an output doesn't match what was authorized, refuse it visibly instead of quietly repairing it.

2. Make side effects happen once

Some of the worst agent incidents are mundane: a retry sends the same message twice, or a fallback to a second model provider repeats a write.

As of October 2026, when an agent team takes an action that changes something outside the system, such as sending an email or Slack message, writing to a CRM or Jira, or posting content, that action executes only once per run. If a retry or provider fallback tries to repeat it, the agent receives the original successful result instead of acting twice. A duplicate attempt while the first is still in progress is refused, and a failed attempt is cleared so it can be retried.

There is a caveat worth knowing. If the underlying coordination store is unavailable, runs proceed without this protection and the event is logged. Good governance design states its failure modes plainly.

3. Filter and test at the boundary

Content controls are the layer most teams already understand. RiseLab applies guardrails for content filtering and PII detection.

Guardrails are only as good as your evidence that they hold. RiseLab tests models against adversarial attacks, including jailbreak and prompt injection testing and bias and toxicity probes. It also publishes a public trust scorecard that runs a fixed 94-probe adversarial corpus across 8 categories against its deployed input filter, and the same corpus gates every release. A fixed corpus matters because it lets you compare results from one release to the next instead of grading against a moving target.

4. Control who can do what

Agents inherit the permissions of whoever configures them, so identity is a governance control, not an IT footnote. RiseLab supports SSO, role-based access control, audit logs, and encryption at rest and in transit.

The operational payoff is attribution. When something goes wrong, you can answer who changed the agent, who ran it and who approved the step.

5. Watch the run, not just the result

Monitoring that only reports finished runs is too slow for agents. Several October 2026 releases address this directly:

  • Team runs are recorded on the ledger from the moment they start, so a run in progress is visible.
  • A run interrupted by a crash or restart is closed out cleanly and kept in history.
  • Every scheduled background job now raises an alert when it crashes, returns an error, or misses its expected run time.
  • Alerts go to the responsible team, or to configured operations contacts, and duplicate alerts are suppressed so one failure doesn't flood recipients.

When failures are found, they need a human disposition. Owners and admins can mark failed team runs as reviewed, and a dialog requires a note explaining the review. After a review, the failure count only reflects failures that happened afterward, while the runs keep their state and error details. That produces a record of who looked at each failure and what they concluded.

Cost is a governance signal too

Runaway spend is often the first visible symptom of an agent behaving badly: a loop that never terminates, or a context that keeps growing.

RiseLab tracks AI infrastructure cost in real time with budget alerts and usage analytics by user and project. In October 2026, agent runs also began keeping tool results within a size limit and trimming older tool-loop history when conversations grow large. Anthropic prompt cache reads and writes are tracked and priced into run cost. A cost line that matches what a run actually did is a useful anomaly detector.

Let evidence write the rules

Static rules go stale. A better pattern is to let teams propose rules from evidence and have people approve them.

Paper trading findings that meet the evidence bar are filed once into the team's proposal queue as proposed house rules, with supporting evidence attached. Nothing changes until a proposal is approved. New proposals are also compared against existing house rules and proposals, not just exact wording, so reworded duplicates don't clutter the review queue. This keeps rule-making slow enough for humans to judge while still being driven by what agents actually did.

What still belongs to your people

A platform can enforce policy, but it cannot write it. Someone has to decide which decisions are critical, who reviews them, what counts as an acceptable failure rate and how often to revisit the thresholds. Treat that as an ongoing responsibility, not a launch task.

A sensible rollout sequence:

  1. Inventory the actions your agents can take outside the system.
  2. Mark which of those are critical and route them to approval.
  3. Set role-based access and turn on audit logging before you widen access.
  4. Add guardrails and run adversarial tests against them.
  5. Set budget alerts and assign an owner for failure review.

Next step

If your governance plan is still mostly a document, start by picking one agent workflow and putting enforcement in its execution path. See how approvals, guardrails, audit logs and cost tracking fit together in the RiseLab Platform, then map your first critical decision to an approval workflow.