Contents
Get a scoped quote

AI agent guardrails and human-in-the-loop controls

For agents that refund, send, update records or advance a case: we build the checks between agent and tools, tested to stop what they should and pass the rest.

Get a scoped quote

First reply within 1 business day

See what you get

Narrated video. We build the checks between an AI agent and its tools: permissions, a policy gate and human approval, tested both ways. A rule in the prompt is only text the model weighs. An operator said in public that its agent in development deleted production data. Then one refund rule as a diagram: the over-limit refund is held for a named approver, nobody answers, it is not made and the customer is told it is with the team; an everyday refund passes; every rule starts in watch-only mode.

Fee
Fixed scope and fee agreed in writing before work starts.
Where it lives
Work products go into your repository as they are produced.
Build
3 to 6 weeks for one agent, fixed in the written scope
  • Start with an agent action review, or go straight to the build.

What are AI agent guardrails?

Checks around an AI agent that limit what it reads, says and does. Content checks screen inputs and outputs. Action controls govern tool calls: tool permissions, a policy check on each call, human approval, a stop control and a record of each decision.

Read more

For agentic AI, the guardrails that matter most are action controls, where an agent can change things and a mistake is hardest to undo: a refund issued, a message sent, a record deleted.

Each layer is described under How we implement guardrails for AI agents. An engagement designs, builds and tests the layers around your agent, in your repository.

What is human in the loop for AI agents?

A person approves defined actions before the agent takes them. Human on the loop is different: the agent acts, and a person monitors it and can stop it. Which actions need which is a risk decision, made per action.

Read more

The phrase has a second meaning: people labelling or rating model outputs during training. That is a different job and not this service. Here, human in the loop means approval at run time, before a tool call takes effect.

How should human approval for AI agent actions work?

Only actions above a risk line wait for a person. The request shows the action, its parameters and the rule that triggered it, with the agent's own reason marked unverified. A named approver decides; no answer before the timeout means the action is not taken.

Read more

The actions that usually warrant a person are the ones that are hard to undo. Singapore's Model AI Governance Framework for Agentic AI (IMDA, version 1.5) gives as examples of irreversible actions "permanently deleting data, sending communications, making payments", alongside high-stakes and atypical actions.

How the risk line, the timeout and the held path are set and tested is under Approval flow.

An agent deleted production data: the operator's own account

In July 2025, after a user's public post, Replit's CEO wrote about the company's own agent, shipped to its users: the position of any company whose agent acts for customers.

Source: Amjad Masad, Replit CEO, post on X, 20 Jul 2025

The user wrote of "no way to enforce a code freeze". For the deletion itself, Replit started rolling out a fix outside the model: separate development and production databases.

Read more

After the deletion sentence and "Unacceptable and should never be possible.", the post continues: "Working around the weekend, we started rolling out automatic DB dev/prod separation to prevent this categorically. Staging environments in the works, too."

It also lists: backups, with "a one-click restore for your entire project state in case the Agent makes a mistake"; a fix forcing the agent to search Replit's documentation, because "The Agent didn't have access to the proper internal docs"; and, on the "code freeze" pain, a planning or chat-only mode that Replit was "actively working on".

The user's own post of 19 July 2025 reads: "There is no way to enforce a code freeze in vibe coding apps like Replit. There just isn't. Not that I can find."

Of these fixes, the database separation sits outside the model; the documentation fix changes what the agent reads. Keeping production and test apart is part of the Tool permissions layer below.

"@Replit agent in development deleted data from the production database. Unacceptable and should never be possible."

What you get: controls around your agent, tested both ways

Eight parts, built around your agent's own tools and delivered into your repository. Here is one rule, followed from the rule file to the record.

  • Handover includes a session and a guide to the rules.
  • Limits: the gate covers the tools routed through it; content checks are fallible, a layer and not the backstop; tests show behaviour on the test set only.
  • Each rule starts in watch-only mode, recording what it would do and stopping nothing, until your process owner switches it to enforce through a change you merge, and can switch it back the same way. We review the watch-only record with your owner before the first rule is switched to enforce.
  • Your results and test set are yours; what you tell your customers about your own testing is your decision. The report is prepared for you only; no third party may rely on it, and we issue no letters, and we do not name ourselves to your customers without written consent.
For example: a refund rule
Rule

Schematic of the refund rule, in six steps: Proposed; Under the limit: allowed; Held: over the limit; Sent for approval; No answer: not made; Recorded.

rule: refund_over_limit
mode: enforce
tool: issue_refund
when: amount > 200
then: require_approval
approver: support_lead
timeout: set_with_process_owner
on_timeout: held
Proposed call
issue_refund(order_id="ORD-A", amount=260, reason="item damaged")
Should pass
test: everyday_refund_goes_through
call: issue_refund(order_id="ORD-B", amount=40)
expect: allowed
Should block
test: over_limit_refund_is_held
call: issue_refund(order_id="ORD-A", amount=260, reason="item damaged")
expect: held_for_approval
Request
  • Action: issue_refund
  • Parameters: order ORD-A, amount 260
  • Rule: refund_over_limit
  • Can be undone: No
  • Session: The customer chat it came from
  • Agent's claim, not verified: "Item arrived damaged; customer asked for a full refund."
No answer

The timeout passes, so the refund is not made. The agent tells the customer the request is with the team, and the request goes to the queue your written scope names.

Record
decision=allowed rule=refund_over_limit order=ORD-B executed=true
decision=held rule=refund_over_limit order=ORD-A outcome=timed_out executed=false

How an engagement runs

Start with a short review of what your agent can do, or go straight to the build. Upkeep is optional.

Agent action review (optional)A written memo you keep: every tool and action, its risk tier, which need a person, and how today's controls behave under a short test1 to 2 weeks
Details

For one agent. Risk tiers are drafted with your process owner, current permissions and approvals are read, and today's controls get a short test in both directions, on a sandbox or recorded tool responses, or run by your engineers on your test copy. The memo says which actions need a gate, which need a person, and what to fix first; it goes into your repository with the action inventory.

For the review we only read code: a read-only app or key you create, or an archive you send, is enough.

The review is an optional way to try us; the build can always be quoted directly.

Guardrail buildDefaultThe eight parts above, built around one agent and the tools routed through its gate, tested both ways in your CI3 to 6 weeks
Details

One agent means the tools routed through its gate; several agents, or agents sharing tools, are scoped in writing. Includes the watch-only rollout. Full agent runs need a test environment or recorded tool responses. No test environment yet? Setting one up as code in your repository is part of the build, quoted in the written scope.

Guardrail upkeepRules and tests updated when prompts, models, tools or policies change, with new should-block cases from incidents or assessmentsOptional; monthly, scoped in writing
Details

Same access as the build: pull requests you merge and CI without production secrets or deploy rights. Incident details for new should-block cases reach us as a pseudonymised export.

  • You provide: repository access, CI access without production secrets or deploy rights, and the agent's code and tool layer. How access is protected
  • Expect about 2 to 4 hours a week from your process owner, and pull-request reviews from one engineer; fixed in the written scope.
  • Already found an attack path in a security assessment? The build starts from its findings.
Read more

Your people: a process owner who signs off the risk line, approvers for trial runs, and an engineer to review pull requests.

Fixed in your written scope: what counts as one agent, the gate's control point, the approval channel, where held requests go, the model and the k and n for full agent runs, how often they run, and the upkeep's scope.

Is this for you?

A fit

  • An agent acting on money, messages, records or bookings, whose tool calls pass through a point you control: your APIs, a gateway or platform hook
  • A customer or security questionnaire asks who can stop your agent and who approved what
  • You run a guardrail product or framework approval hooks, and nobody has measured what they block
  • A regulated process needs named approvers, a stop control and a record of each decision

Not a fit

  • A read-only chat assistant with no tools: content checks alone are a different job
  • Independent testing of controls someone else built: Independent AI Assurance & Third-Party Testing
  • Guardrails for the coding agents your own engineers use: Governed AI Engineering
  • Agent identity and credential design on its own: see Related services below

Working with us: your code, credentials and data

What we commit to, and how your code, credentials and data are protected while we build.

You get

  • Handover on the build's last day, and a written report within 5 business days of the build ending
  • One re-test within 30 days of handover, including fixes to defects in what we delivered, within the fixed fee
  • Liability capped at the fees paid for the engagement.
  • Scope, NDA and DPA signed before we read your code.
  • Your engineer scans for keys and personal data before we read anything.
  • Main branch protected and secrets out of reach before we can push.
  • CI access without production secrets or deploy rights.
  • No test content is written to a live system.
  • Logs only as a pseudonymised export, deleted 30 days after our work ends.
  • We never name you, reference the engagement or publish findings without your written consent.
Read each control in full
  1. 1. A written scope, a mutual NDA and the DPA are signed before we read your code or receive any export.
  2. 2. Your engineer first scans the repository, git history included, and any export for keys and personal data. Anything we still find is reported so you can rotate or remove it; we do not use it, and we pause on that file until it is cleaned.
  3. 3. Before we can push, your engineer protects the main branch and moves production secrets out of our role's reach, or gives us a fork or separate repository. Changes arrive as pull requests you merge.
  4. 4. Our CI access carries no production secrets or deploy rights. Model runs during our work use our account within a budget in the written scope, or a separate non-production key you issue with a spend limit and revoke when our work ends.
  5. 5. Full agent runs use only a sandbox, recorded tool responses or your test copy, which your engineers run. No test content is written to a live system; a path with no separate test source is listed as not tested.
  6. 6. Agent logs reach us only as a redacted or pseudonymised export. Code, logs and test material we received are deleted from our systems 30 days after our last included work ends; agreed third-party services follow the data settings in the written scope.
  7. 7. We never name you, reference the engagement or publish findings without your written consent.

Access during a build: your repository and CI on your side, with production secrets out of our reach; no test writes to live systems; full agent runs on a sandbox or recorded tool responses, or on your test copy run by your engineers; a redacted or pseudonymised export comes in; pull requests go out to you to merge.

Your guardrail product or framework hooks, and what the build adds

A guardrail product or a framework's approval hook is where a check can go. Deciding what goes through it, and testing it, is the work.

QuestionLeft to your team with the hook aloneDelivered in the build

Your team lists the agent's tools and actions and decides which the hook sees.

The action inventory tiers every action with your process owner; the risk line decides what routes through the gate.

Your team writes the checks and keeps them in step with prompt, model and tool changes.

Rules written on the tool and its parameters, version-controlled, each with a watch-only and an enforce mode.

Your team designs the request, the timeout, the held path and the stop control.

Request content, timeout, a held path for each gated action and a stop control, each tested as a case.

Your team writes should-block and should-pass tests and runs them on each change.

Two-way tests in your CI on every change, and a decision record in your own logging.

A rule in the prompt versus a control outside the model

A prompt rule is text the model weighs alongside everything else it reads. A control checks the action itself, before it runs. Four everyday cases:

For example: a system prompt says never to refund over a limit without a person, yet an issue_refund call for 260 goes through and the refund is issued.

QuestionRule in the promptControl outside the model

The prompt says to confirm new payees. An invoice the agent reads can argue otherwise, and the model weighs both.

The gate sees a payee that is not on the allow-list and holds the payment for a named approver. The invoice text never reaches the rule.

The prompt says to email customers only. Nothing checks the recipient before the email is sent.

The gate checks the recipient's domain against an allow-list. Anything else is held or blocked, and the decision is recorded.

The model reads the hidden instruction with the rest of the ticket, and may follow it.

Content checks may catch it. If they do not, the gate still checks the tool call the instruction leads to, against the same rules as any other call.

A new instruction changes only what the model reads next, and only if the model follows it.

A stop control switches the gated tools off, and each request in progress ends in its defined held path.

How we implement guardrails for AI agents

Seven layers, in the order we build them, each named after the part it delivers.

Your agent with its controls, numbered in build order What the agent reads and what it says pass through content checks. The agent proposes a tool call to the policy gate, which checks it against the rules. Allowed calls reach the tools, where test and production are kept apart. Calls above the risk line go to a named approver, with a stop control. Gated decisions go to the decision record in your own logging. The action inventory, with its risk line, and the two-way tests, should pass and should block, feed the gate. Numbered pins match the build steps beside the diagram. What it reads What it says Your agentModel Content checks 5 Proposed call Actioninventory Tiered by riskwith yourprocess owner Risk line 1 Policy gateRules 3 Allowed Above therisk line Tools Test Production 2 Namedapprover Stop control 4 Decision record Your own logging 6 Two-way tests Should pass Should block 7 Build step Feeds the gate Call or content path Checks each proposed action

The agent proposes a tool call. Content checks screen what it reads and says. The policy gate checks each proposed call against the rules; calls above the risk line go to an approver; allowed calls reach the tools; every gated decision goes to the decision record.

Tap a build step to zoom the map to it.

Build steps

  1. Action inventory every tool and action listed, then tiered by risk with your process owner

    What arrives: A document and a machine-readable file in your repository: every tool and action, its tier, and which need a person.

    We read your agent's code and tool layer and list each tool, each action it can take and its parameters. Each action is tiered by what it touches and whether it can be undone. Your process owner signs off the tiers and the risk line, which decide what goes through the gate and what waits for a person.

  2. Tool permissions each tool cut to what the agent needs, with production and test kept apart

    What arrives: Permission changes as code or configuration, tool by tool, in your repository.

    Read access where read is enough, narrower scopes on each credential, separate test and production access, and budgets or rate limits where a tool can be called in bulk. Agent identity, tokens and credential lifecycle in depth are a separate service, Agent Identity & Access Control.

  3. Policy gate code at the tool-call boundary that checks each proposed action against written rules

    What arrives: Gate code and version-controlled rule files in your repository, each rule with a watch-only and an enforce mode.

    The gate sits where your agent's code calls its tools, or in front of the tools themselves, such as MCP servers or internal APIs. Its language and placement follow your stack. Rules are written on the tool and its parameters (limits, allow-lists, production versus test) and kept under version control.

    The gate's rules do not read the prompt; they check the action the agent proposes. The parameters still come from the model, which is why the rules are written on them and tested.

    Each rule carries its mode in the rules file. In watch-only mode it records the decision it would have made. Once enforced, it fails closed on error for the actions routed through it. The rollout is under What you get.

  4. Approval flow how the risk line, request, timeout, held path and stop control are set and tested

    What arrives: Request format, timeout, held paths, approver record and stop control, as code and configuration wired into your approval channel.

    • Risk line: set with your process owner from the action inventory.
    • Request: fields as in the worked example under What you get, gate-computed facts first.
    • Approver: a named person whose identity comes from your own sign-in system, never from the agent or the request. Verifying approver identity in depth belongs to Agent Identity & Access Control.
    • Channel: your existing approval channel, or one agreed in the written scope where you have none.
    • Timeout: set with your process owner per action; tested as a held-path case.
    • Held path: for each gated action, what the agent tells the user while it waits, and where a rejected or timed-out request goes: back to the agent as held, and into your queue or case system. Each held path is a test case.
    • Stop control: switches the gated tools off; requests in progress end in their held path.
    • Approval load: approvals requested per task, counted on the test set and reported.

    Rubber-stamping is answered in the FAQ; approver competence, training and authority under Standards.

  5. Content checks input and output checks where your agent needs them, including for prompt injection

    What arrives: Input and output checks as configuration or code in your repository.

    We work with the guardrail library, platform or framework hooks you already use; compatibility is confirmed in the written scope. We take no commission from any model, tool or guardrail vendor named in a report.

  6. Decision record each gated decision written to your own logging, with approver and timings

    What arrives: A record writer that sends each gated decision to your own logging.

    For approvals: the approver, request time, decision time and outcome (approved, rejected, modified where the flow lets an approver change the action, or timed out). Your team can then track the human override rate and response time that Singapore's agentic AI framework names as indicators for auditing oversight. Dashboards and alerting on top of the record are a separate service, Continuous AI Monitoring.

  7. Two-way tests should-block, should-pass and held-path cases, plus full agent runs with and without the gate

    What arrives: Test files and a re-run guide in your repository, with the model version pinned.

    Gate tests put a proposed tool call in and check the decision that comes out, rule by rule. Full agent runs run the agent k times on n tasks, model pinned, with and without the gate, on the same frozen task set. Gate decision time is measured on the test set.

    Gate tests run on every change to the prompts, the pinned model version, tool definitions or rules in your repository. Full agent runs run on prompt, model or tool changes, or on a schedule (set in your scope). The model version is pinned in your repository, because the gate tests run on changes committed to your repository, and a provider-side update behind an unpinned alias commits nothing.

    After handover, the full agent runs in your CI call the model your agent already uses, so they add model usage.

Approval design: IMDA, Model AI Governance Framework for Agentic AI, version 1.5, section 2.2.2. Tool minimisation and complete mediation: OWASP Top 10 for LLM Applications 2026. Named companies, projects and publishers are cited as sources only; Veriprajna is not affiliated with them.

Human oversight in the EU AI Act, NIST AI RMF and IMDA

The Approval flow layer, mapped to the frameworks that describe human oversight of AI systems. The mapping shows relevance, not compliance.

Approval flow

One layer of the method, mapped to these frameworks.

  • EU AI Act, Regulation (EU) 2024/1689Article 14(4)(b), (d) and (e); Article 26(2)
  • NIST AI RMF 1.0 (AI 100-1)GOVERN 3.2, MAP 3.5, MANAGE 2.4
  • OWASP Top 10 for Agentic Applications 2026ASI09 Human-Agent Trust Exploitation
  • IMDA Model AI Governance Framework for Agentic AI, v1.5Section 2.2.2, design for meaningful human oversight
  • EU: for high-risk AI systems, Article 14 is the provider's design duty and Article 26(2) the deployer's. Under Regulation (EU) 2026/1744 they apply from 2 December 2027 for Annex III systems and 2 August 2028 for Annex I systems. Neither article requires a person to approve each action.
  • Systems placed on the market or put into service before those dates are covered only if their design changes significantly afterwards; systems intended for public authorities must comply by 2 August 2030 (Article 111(2)).
Read more

EU AI Act. Article 14(3): oversight measures "shall be commensurate with the risks, level of autonomy and context of use of the high-risk AI system".

Article 14(4) asks that the people overseeing it are enabled "(b) to remain aware of the possible tendency of automatically relying or over-relying on the output produced by a high-risk AI system (automation bias)", "(d) to decide, in any particular situation, not to use the high-risk AI system or to otherwise disregard, override or reverse the output", and "(e) to intervene in the operation of the high-risk AI system or interrupt the system through a 'stop' button or a similar procedure that allows the system to come to a halt in a safe state".

The only two-person verification rule, Article 14(5), covers remote biometric identification.

Article 26(2): "Deployers shall assign human oversight to natural persons who have the necessary competence, training and authority, as well as the necessary support." That is your duty as deployer; the decision record supports it, and training approvers is not part of this service.

Transition, Article 111(2) as amended by Regulation (EU) 2026/1744: high-risk systems placed on the market or put into service before those dates are covered "only if, as from that date, those systems are subject to significant changes in their designs"; systems intended for public authorities must comply by 2 August 2030. Documentation for a technical file is the subject of a separate service, EU AI Act Compliance & Technical Evidence Pack.

NIST AI RMF. GOVERN 3.2: "Policies and procedures are in place to define and differentiate roles and responsibilities for human-AI configurations and oversight of AI systems." MAP 3.5: "Processes for human oversight are defined, assessed, and documented in accordance with organizational policies from the GOVERN function." MANAGE 2.4: "Mechanisms are in place and applied, and responsibilities are assigned and understood, to supersede, disengage, or deactivate AI systems that demonstrate performance or outcomes inconsistent with intended use."

OWASP ASI09. The risk "is amplified when humans over-rely on autonomous recommendations or unverifiable rationales, approving actions without independent validation"; one mitigation is a "plain-language risk summary (not model-generated rationales)", which is why the request leads with gate-computed facts.

IMDA, section 2.2.2. Asks organisations to keep approval requests "contextual and digestible, while making the risk clear", to audit oversight through the "Human override rate" and "Human response times", to train overseers, and to deny action "by default when approval infrastructures fail". Auditing and training are your duties; the decision record gives you the data.

IDs for other layers. Policy gate: OWASP ASI01 Agent Goal Hijack and ASI02 Tool Misuse and Exploitation. Tool permissions: OWASP LLM03:2026 Excessive Agency.

MCP. The MCP specification (2026-07-28) lists as key principles that "Users must retain control over what data is shared and what actions are taken" and that "Hosts must obtain explicit user consent before invoking any tool". The gate is evidence relevant to consent and control. The principle asks for consent before any tool, while the gate tiers by risk, so the gate does not by itself meet it.

Questions buyers ask

8 questions

What if the gate blocks real work?

Should-pass cases, the everyday tasks that must go through, run on every change alongside the should-block cases. Each rule starts in watch-only mode, where the gate records what it would have done and stops nothing. Switching a rule back to watch-only is a single change your team makes and ships through its own release process. The gate's decision time is measured on the test set and reported.

What if the gate misses something, or fails?

The rules and the risk line are the ones your process owner signed off, tested on the test set, not proven for every case. Once a rule is enforced, an error in the gate holds the action. Defects in what we delivered that the re-test window finds are fixed within the fixed fee; new tools, new rules or scope changes are quoted in writing. Liability is capped at the fees paid for the engagement.

Does this work on a hosted agent platform?

On a hosted agent platform, the written scope first confirms a point you control on its tool calls, such as your own APIs, a gateway you run or the platform's policy hook.

How do you stop approvers rubber-stamping?

By asking for few, clear approvals, so approval fatigue is less likely. Only actions above the risk line ask for a person, and each request leads with facts the gate computed, with the agent's reason marked unverified. Approvals requested per task are counted on the test set, so the load is visible before launch. The EU AI Act names the risk: Article 14(4)(b) asks that overseers stay aware of automation bias. How approval is designed

Does the EU AI Act require a human in the loop for AI agents?

The AI Act sets no general requirement for a person to approve each action. For high-risk AI systems, the provider must design them so people can oversee, override and stop them (Article 14), and the deployer must assign people with the necessary competence, training and authority (Article 26(2)). Building your own agent for a covered use usually makes you its provider. Dates: 2 December 2027 (Annex III) and 2 August 2028 (Annex I), subject to Article 111(2). Not legal advice.

How is a quote scoped?

After you email or WhatsApp us, through a free 30-minute discovery call: what your agent can change, which tools it calls, and where its tool calls can be checked. You get a written scope and a fixed fee within 2 business days of the call. The fee is agreed in writing before any work.

When can you start?

The earliest start date is in the written scope. The fixed fee does not change if the schedule slips on our side, and you can halt or end the engagement at any time.

Can we share the results with our customers?

Your results and test set are yours; what you tell your customers about your own testing is your decision. The report is prepared for you only; no third party may rely on it, and we issue no letters, and we do not name ourselves to your customers without written consent. Its figures are results on a test set, not a measured rate.

Agent guardrails in depth

The evidence: goal hijack, over-holding, and a confirmation rule moved into a gate

A rule in a system prompt is text, and the model reads it beside everything else in its context. The OWASP Top 10 for Agentic Applications 2026 puts the root of Agent Goal Hijack (ASI01) plainly: "agents and the underlying model cannot reliably distinguish instructions from related content." Its mitigations include "enforcing least privilege for agent tools and requiring human approval for high-impact or goal-changing actions".

The OWASP Top 10 for LLM Applications 2026 makes the same point about authority. Under LLM03:2026 Excessive Agency, its "complete mediation" mitigation reads: "Implement authorization in logic rather than relying on an LLM to decide if an action is allowed or not." It also notes that "Sanitization of model inputs and outputs is not a root control for Excessive Agency", which is why content checks are a layer here and the gate is the backstop.

Singapore's IMDA framework agrees: "Rather than prompt-layer safeguards, consider implementing deterministic safeguards that operate at a system-level through predefined logic, especially for higher-risk actions."

A gate can also fail the other way, by holding work it should let through. In SteerBench-Work, a 2026 preprint by Serdar and Mertayak, models were used as the gate: each saw a proposed action and its evidence and returned proceed or hold. Across 30 model conditions, the models "wrongly hold authorized, evidence-cleared work on 28.1% of opportunities and wrongly allow unsafe work on 1.0%".

That is one benchmark of models acting as a gate, not of rule-based gates, but it shows why every build carries should-pass cases beside the should-block ones.

One benchmark writes consequential rules into prompts too. The retail policy of tau2-bench (v1.0.1, pinned) tells the agent: "Before taking any action that updates the database (cancel, modify, return, exchange), you must list the action details and obtain explicit user confirmation (yes) to proceed."

That is a customer-confirmation rule, written in a prompt. In a build, the same rule becomes a gate rule on the tools that update the database, so the confirmation is checked in code before the call runs, rather than left to the model.

Responsible AI principles and guardrails do different jobs. The principles say what an organisation intends; guardrails are where some of those intentions are enforced, one action at a time.

AI agent governance framework, at runtime

A governance framework for AI agents is the set of roles, rules and records that decide what agents may do, who approves what, and how decisions are reviewed. For agents, rules on actions hold only where something outside the model enforces them: at the tool call, or in the permissions and environments behind it. This service builds that enforcement.

Governance and risk management for agentic AI then has something to work with: the risk tiers come from the action inventory; the roles from named approvers and a process owner who signs off the risk line; the review from the decision record. The NIST AI RMF asks for the same pieces in its own words: defined roles for human-AI configurations and oversight, documented oversight processes, and mechanisms to supersede, disengage or deactivate a system.

Singapore's Model AI Governance Framework for Agentic AI is organised the same way, in four parts: assess and bound the risks upfront, make humans meaningfully accountable, implement technical controls and processes, and enable end-user responsibility. This service sits in the middle two, for one agent at a time. Organisation-wide programs, policies and committees are a separate service, AI Governance Program.

Put checks between your agent and what it can change

Whether your agent is about to start acting, a customer questionnaire asks who can stop it, or an assessment found a path to close, start with a short conversation.

  1. Email or WhatsApp us
  2. Reply within 1 business day
  3. Free 30-minute discovery call
  4. Written scope and fixed fee within 2 business days of the call