Skip to main content
TrustEdge AI

Singapore Model AI Governance Framework for Agentic AI

Published 20 May 2026, the IMDA Model AI Governance Framework for Agentic AI (MGF Agentic) is the first dedicated, government-issued governance framework for AI systems that plan, act, and adapt on behalf of humans. It is voluntary guidance — not statute — but it is rapidly emerging as the global reference text for how to deploy AI agents responsibly. The framework organizes practice around four iterative dimensions: assess and bound the risks upfront, make humans meaningfully accountable, implement technical controls and processes, and enable end-user responsibility.

Infocomm Media Development Authority (IMDA) · Singapore (with global influence) · Version 1.5 (May 2026) · Effective May 20, 2026 Voluntary Guidance

Overview

The MGF for Agentic AI builds on IMDA's 2020 Model AI Governance Framework but introduces practices specific to systems where the AI takes multi-step actions, uses tools, and operates with varying degrees of autonomy. Agentic systems inherit traditional software and LLM risks — SQL injection, hallucination, prompt injection — but those risks manifest differently through new components: planning and reasoning, tool calls, agent-to-agent protocols, and multi-agent emergent behaviour.

What sets this framework apart is its case-study density. Version 1.5 incorporates feedback from 60+ companies and includes worked examples from Dayos (risk-tiered IT ticketing automation), OCBC (bounded autonomy in source-of-wealth analysis), PwC (allocating accountability across teams), Tencent (CodeBuddy permission tiers for coding agents), X0PA (human checkpoints in recruitment), Terminal 3 (hardware-enforced agent authority), Cyber Sierra (self-reflection architectures for GRC questionnaires), Stability Solutions (internal vs external-facing controls), Google × GovTech (computer-use agent testing), CDL × Knovel (data access boundary validation), Ant International (HopSpec for user-authored agent specifications), and Workday (transparency to end users in HR agents).

The framework is voluntary, but its applicability is global. Singapore is a regional tech hub with deep regulatory influence across ASEAN and beyond, and the MGF Agentic is already being cited as a reference by enterprise customers, vendor risk teams, and other national AI strategies. Treating it as the default governance baseline for any agentic system — wherever it is deployed — is the safest interpretive stance.

Does This Apply to Your Organization?

A five-minute self-assessment. If you answer "yes" to any of the questions below, this framework is directly relevant to your AI governance program.

  • Do you build, deploy, or operate any AI agent that takes multi-step actions on behalf of a human?

    Includes coding assistants in agent mode, customer-service bots that escalate or transact, internal "copilot" tools with tool use enabled, RAG systems with agentic retrieval, and any workflow that strings tool calls together autonomously.

  • Do any of your agents have write access to a system of record (customer DB, payments, communications, code, infrastructure)?

    Write access elevates the impact tier per the framework's risk model. Read-only agents face fewer controls but still require monitoring and identity scoping.

  • Do you use third-party agentic AI products (Microsoft Copilot Agents, Salesforce Agentforce, ServiceNow AI Agents, OpenAI Operator, Anthropic Computer Use, GitHub Copilot Agent Mode)?

    Deployers carry MGF Agentic obligations even when the agent comes from a vendor — including contractual clarity, evaluation of vendor controls, and end-user transparency.

  • Do you deploy multi-agent systems (orchestrator + specialist sub-agents, or peer agents communicating via A2A/MCP)?

    Multi-agent setups introduce qualitatively new risks (agent sprawl, miscoordination, conflict, collusion) and require additional structural controls.

  • Are your agents externally facing, interacting with customers, citizens, or untrusted third parties?

    External agents face elevated risk: prompt injection, social engineering, and trust-asymmetry harms. The framework prescribes additional guardrails for external deployments.

  • Are you a vendor risk team or compliance officer evaluating a counterparty that deploys agentic AI?

    The MGF Agentic gives you a defensible due-diligence rubric. The applicability checklist plus the control mapping below can be adapted directly into a vendor questionnaire.

Framework Components

1

Assess and bound the risks upfront

Determine suitable use cases for agent deployment, and bound risks by design through explicit limits on tools, autonomy, identity, and authorisation before code is written.

2

Make humans meaningfully accountable

Allocate responsibilities across the agentic value chain (model developers, platform providers, system providers, deployers, end users) and design meaningful human oversight that survives automation bias.

3

Implement technical controls and processes

Apply structural, rule-based controls at the tool, protocol, and multi-agent layers; test agents before deployment for execution accuracy, policy adherence, and tool use; monitor continuously after deployment.

4

Enable end-user responsibility

Equip the humans on the receiving end of agents — both those who interact with them and those who integrate them into work — with transparency, training, and escalation paths so trust is earned, not assumed.

How to Apply This Framework

A staged path from "we should look at this" to "this is part of how we ship."

1

Inventory your agentic use cases

1 week

List every system in production or pilot that fits the agentic definition: planning + tool use + multi-step action. Note the action-space, autonomy level, data access, and whether the system is internal- or external-facing.

2

Run the impact + likelihood assessment

1-2 weeks

For each use case, score the impact factors (domain criticality, sensitive data, scope, reversibility) and likelihood factors (autonomy, task complexity, third-party exposure, system complexity). Triage into tiers and decide which use cases need to be re-bounded, deferred, or replaced with deterministic workflows.

3

Assign accountability and design oversight

2 weeks

Build a RACI for the agent lifecycle covering key decision makers, product, security, and end users. Define the human-approval checkpoints for each tier, including format (approve/edit-then-approve/written-justification) and the audit metrics you will track (override rate, response time).

4

Instrument structural controls and rollout gradually

4-8 weeks

Move guardrails from prompt-layer to tool-layer where possible (access controls, sandboxing, typed function calls). Set up evaluation harnesses across execution + policy + tool use + robustness. Stage rollout (whitelisted users → broader org → external) with continuous monitoring against alert thresholds.

Components In Depth

1. Assess and bound the risks upfront

The first dimension asks two questions, in order: is this a suitable use case for an agent at all, and if so, how do we bound the blast radius before we build?

Use-case suitability is a function of likelihood and impact. The framework gives a structured list of impact factors (domain criticality, sensitivity of data the agent can access, scope of actions, reversibility of those actions) and likelihood factors (level of autonomy, task complexity, exposure to external systems, vendor opacity, overall system complexity). Not every workflow that "could" be automated by an agent "should" be. A deterministic workflow may be safer than a non-deterministic one even if the agent looks more impressive in a demo.

Bounding the risk means designing the agent's limits before writing code. Three categories: limits on tool and system access (least-privilege), limits on autonomy (SOPs and approval requirements), and limits on area of impact (network isolation, kill switches). Critical here is the move toward agent-specific identity — every agent should have its own unique, cryptographically verifiable identity, scoped permissions that are non-transferable, and a centrally managed catalogue to prevent "agent sprawl." Where current OAuth and IAM systems fall short for agent use cases, organisations are bridging the gap with intra-org identity systems or evolving standards like OAuth 2.1 over MCP.

Key Outcome

A documented risk assessment per use case, a bounded design (least-privilege tools, scoped autonomy, defined area of impact), and a unique, centrally managed identity per agent.

2. Make humans meaningfully accountable

Agentic systems make traditional accountability harder. The agentic value chain — model developers, tooling providers, platform providers, system providers/app developers, deployers, end users — diffuses responsibility across organisations. Within a single organisation, multiple teams (decision makers, product teams, cybersecurity teams, users) own different pieces of the lifecycle. The framework requires both: clear internal allocation, and explicit contractual allocation with external vendors.

The harder problem is keeping human oversight meaningful over time. Approval requirements degrade into "rubber stamping" when humans are presented with too much, too often, or with insufficient context. The framework prescribes three counter-measures: define significant checkpoints (high-stakes, irreversible, or outlier actions); keep approval requests contextual and digestible with appropriate confidence/risk metadata; and audit the effectiveness of oversight itself — track human override rates (a low rate may signal automation bias), human response times (a short time may signal review fatigue), and watch for "outlier" humans whose decisions deviate from the norm.

Where continuous oversight is impractical at scale, complement with automated monitoring: alerts for logged events, anomaly detection on trajectories, agents monitoring other agents, and deny-by-default when approval infrastructure is unreachable.

Key Outcome

A RACI for the agent lifecycle, contractual clarity with external parties, an oversight design with meaningful checkpoints, and an audit programme that measures whether oversight is actually working.

3. Implement technical controls and processes

Technical controls live across four moments: during design and development, before deployment (testing), after deployment (monitoring), and across the lifecycle (change management).

During development, the framework strongly prefers structural, rule-based controls over prompt-layer instructions. If you do not want an agent to use a tool, do not give it access to the tool — do not just instruct it not to use one. MCP, increasingly, can function as a governance layer that sits between the agent and enterprise systems: filtering sensitive fields, logging every call, whitelisting only trusted servers. Sandbox code execution. Use typed function calls between agents instead of free-text.

Before deployment, testing must cover four agent-specific dimensions: overall task execution, policy compliance, tool calling (right tool, right input, right order), and robustness under edge cases. Test entire workflows, not just final outputs. Test agents individually and together. Test in realistic environments. Repeat tests across varied datasets and stable seeds.

After deployment, the framework prescribes gradual rollout (to trained users, on whitelisted tools, in low-risk systems first), continuous monitoring across user-agent, agent-tool, and model-reasoning layers, alert thresholds with defined intervention levels, OpenTelemetry-grade observability, immutable log retention, and feedback loops into training and evaluation. Throughout the lifecycle, change-management triggers (technical, environmental, performance, regulatory) determine when a change requires a full governance review versus a lightweight prompt adjustment.

Key Outcome

Structural controls at the tool/protocol/multi-agent layers, a test plan that covers execution + policy + tool use + robustness, continuous monitoring with defined alert thresholds and human-in-the-loop interventions, and change-management triggers that fire on the right events.

4. Enable end-user responsibility

The fourth dimension acknowledges that trustworthy deployment does not rest solely on the developer. End users are part of the control system, and the framework segments them into two archetypes with different needs.

Users who interact with agents (customers, HR-self-service users, external chat audiences) need transparency: a clear declaration that they are interacting with an agent, plain-language disclosure of the agent's range of actions and data access, explicit human-escalation points, and clarity on what user data the agent stores and uses.

Users who integrate agents into their work processes (engineers using coding assistants, analysts using research agents, ops staff using automation agents) need training, layered on top of the transparency above. They should know the agent's common failure modes (hallucinations, error loops, outdated policy adherence), have refreshers as features change, have feedback loops to report bugs and override decisions, and — critically — be protected from "tradecraft erosion." If junior engineers never learn to write SQL because the agent always does, the organisation loses both training pipelines and business-continuity resilience. The framework explicitly calls this out: identify the core capabilities of each role and ensure users keep exercising them.

Key Outcome

Transparency artefacts for external-facing agents, structured training programmes for internal users, feedback channels to report issues, and a "tradecraft retention" plan that prevents over-reliance on the agent.

Frequently Asked Questions

Is the MGF for Agentic AI legally binding?

No. It is voluntary guidance issued by Singapore's Infocomm Media Development Authority. There is no penalty for non-adoption.

That said, "voluntary" in 2026 is doing a lot of work. The framework is increasingly cited by enterprise procurement teams as the baseline they expect vendors to demonstrate, by other national AI strategies as a reference text, and by binding regimes (notably the EU AI Act) as a model for what "state of the art" looks like in agentic governance. Treating it as table stakes is the safer interpretive stance.

How is this different from the original Model AI Governance Framework (2020)?

The 2020 MGF (and the 2024 GenAI addendum) addresses general AI systems — primarily predictive models and generative content. The MGF for Agentic AI is purpose-built for systems where the AI plans, calls tools, and acts on the world over multiple steps with varying autonomy.

The four dimensions are conceptually consistent with the parent framework, but the techniques inside each dimension are agent-specific: agent identity management, tool-layer access controls, multi-agent emergent-behaviour testing, agent sprawl prevention, automation-bias countermeasures, and tradecraft retention.

How does this relate to the EU AI Act?

They operate at different layers. The EU AI Act is binding law focused on classifying AI systems by risk and imposing obligations (prohibited, high-risk, limited-risk transparency, GPAI). It does not — yet — have agent-specific obligations.

The MGF for Agentic AI is voluntary guidance focused on how to build, test, and operate agentic systems safely. Most of what MGF Agentic prescribes (risk assessment, human oversight, technical robustness, monitoring) is exactly what EU AI Act Articles 9-15 require for high-risk AI. Adopting MGF Agentic produces much of the evidence an Annex IV technical file demands.

How does this map to NIST AI RMF?

Cleanly. NIST AI RMF's four functions (Govern, Map, Measure, Manage) align dimension-by-dimension with the MGF Agentic. See the Control Mapping table below for the cross-reference.

If you already have a NIST AI RMF programme, you do not need to start over — you need to layer agent-specific controls (identity, tool-layer access, multi-agent testing, automation-bias monitoring) onto your existing Govern/Map/Measure/Manage cycle.

What is an "agent" for purposes of this framework?

IMDA defines agents as AI systems that possess "some degree of independent planning, decision-making, and action-taking over multiple steps to achieve a user-defined goal." The framework focuses on agents built on generative AI models (SLM, LLM, or MLLM), though it acknowledges deterministic and other neural-network agents exist.

Key components of a simple agent: model, instructions, memory, planning/reasoning, tools, protocols, controls, and logging. Multi-agent setups extend this with patterns like sequential, supervisor, and swarm.

Which case studies in v1.5 are most relevant for enterprise IT?

Dayos (risk-tiered automation of IT helpdesk tickets) is the strongest enterprise IT example. Tencent CodeBuddy (permission tiers for coding agents — read free, edit/bash/web-fetch/MCP gated) is the gold standard for governing developer-facing agents. GovTech's phased rollout of Windsurf, GitHub Copilot Agent Mode, and Claude Code shows how to roll out coding assistants with progressively widening capability envelopes. Stability Solutions' contrast between internal-facing and external-facing agents is the cleanest worked example of how risk tier drives control selection.

How does the framework handle multi-agent systems?

Multi-agent systems get explicit treatment in §1.2.3. The framework names the new risks (agent sprawl, miscoordination, conflict, collusion, emergent behaviours that cannot be predicted from individual-agent testing) and requires multi-agent-specific controls: structured schemas instead of free-text between agents, limits on shared memory, system-level testing in addition to per-agent testing, and centralised identity management to prevent uncontrolled proliferation.

What does "meaningful human oversight" actually require?

Three things in combination: significant checkpoints with explicit approval (for high-stakes, irreversible, or outlier actions), digestible approval requests with risk/confidence metadata, and an audit programme that measures whether oversight is working — tracking human override rate, human response time, and outlier reviewers.

The framework is explicit that one-checkbox-per-action approval flows degrade into rubber-stamping. The remedy is to design fewer, better checkpoints rather than more, weaker ones, and to complement human oversight with automated monitoring that fails closed.

How should we handle agent identity?

Every agent should have its own unique, cryptographically verifiable identity that is tied to a supervising agent, human user, or organisational department for accountability. The identity should differentiate the capacity in which the agent acts (independent vs delegated), and all agent identities should be issued and tracked through a central system to prevent agent sprawl.

Authorisations should be scoped, time- or session-bound, non-transferable, follow least privilege by default, and be bounded by the authorising human's own permissions. Where current OAuth and IAM systems do not natively cover agents, options today include intra-organisation extensions (Microsoft Entra Agent ID, Alibaba Agent ID Guard), OAuth 2.1 over MCP, and decentralised identity proposals from CSA and OpenID.

How does this apply to coding assistants like GitHub Copilot Agent Mode or Claude Code?

Coding agents are the case study with the most lived experience to date. The Tencent CodeBuddy worked example in v1.5 is a near-complete blueprint: tiered permissions (Read free, Edit/Bash/WebFetch/MCP gated), per-project default permission levels calibrated to repository risk, plain-language explanations of proposed actions ("here is what this `mysqldump | gzip` command will do, in English"), continuous monitoring for command-injection patterns that revoke whitelisting on suspicious variants, and re-approval on session boundaries.

GovTech's phased rollout pattern — internal employees only, no MCP, low-risk systems first; then central logging, MCP Governance Framework with whitelist gateway, expanded user base — is the operational template most enterprises can copy directly.

What about agentic commerce protocols (Universal Commerce Protocol, Agentic Commerce Protocol, Agentic Mobile Protocol)?

The framework treats agentic-commerce protocols as a fast-evolving extension of the Tools and Protocols components. The core guidance is unchanged: use standardised protocols where applicable, sandbox code execution, whitelist trusted servers, treat MCP as a potential governance layer (filter sensitive fields, log every call). For payments specifically, the framework points to deterministic limits — pre-declared transaction ceilings, cryptographically binding authorisation credentials (see Terminal 3's Verifiable Credential of Intent pattern), and post-action immutable audit trails.

Is there an upcoming version we should plan around?

Version 1.5 was published 20 May 2026 and incorporates feedback from 60+ companies. IMDA explicitly calls this a "living document" and invites further feedback and case studies via go.gov.sg/mgfagentic-feedback. Expect ~annual revisions. The next likely additions are deeper treatment of agent-to-agent protocols, more concrete computer-use agent guidance, and additional case studies in regulated industries.

Where does this leave us if we already follow ISO/IEC 42001?

ISO/IEC 42001 (AI Management System) is the systems-management overlay; MGF Agentic is the technique-level overlay for agentic systems specifically. They are complementary. Most ISO 42001 control objectives (A.5 organisational policies, A.6 internal organisation, A.8 lifecycle planning, A.9 data quality) map directly to MGF Agentic's first two dimensions. The technical-controls dimension adds material that ISO 42001 deliberately leaves to the implementer.

Control Mapping to Other Frameworks

How each requirement in this framework maps to controls in NIST AI RMF, ISO/IEC 42001, SOC 2, and HIPAA Security Rule. Use this to avoid duplicating governance work across frameworks.

This Framework Mapped Controls
Dimension 1: Assess and bound the risks upfront
NIST AI RMF:
MAP 1.1, MAP 2.1, MAP 3.1, MAP 5.1 (context, classification, intended impacts)
ISO/IEC 42001:
A.5.2 (AI risk assessment), A.6.2.2 (AI risk treatment), A.8.2 (AI lifecycle planning)
SOC 2:
CC3.1, CC3.2 (risk assessment), CC9.1 (vendor/business partner risk)
HIPAA Security Rule:
§164.308(a)(1) (Risk Analysis), §164.308(a)(8) (Evaluation)
Dimension 2: Make humans meaningfully accountable
NIST AI RMF:
GOVERN 2.1, 2.2, 3.2, 5.1 (roles, accountability, oversight design)
ISO/IEC 42001:
A.3 (leadership), A.6.1 (organisational roles), A.7 (resources/competence), A.9.4 (human oversight)
SOC 2:
CC1.1-CC1.5 (control environment), CC2.2 (communication)
HIPAA Security Rule:
§164.308(a)(2) (Assigned Security Responsibility), §164.308(a)(3) (Workforce Security)
Dimension 3: Implement technical controls and processes
NIST AI RMF:
MEASURE 1.1, 2.x (evaluation), MANAGE 1.x, 2.x, 4.1 (monitoring, change management)
ISO/IEC 42001:
A.8.3 (design and development), A.8.4 (verification and validation), A.10 (third-party relationships)
SOC 2:
CC6.x (logical access), CC7.x (system operations + monitoring), CC8.1 (change management)
HIPAA Security Rule:
§164.308(a)(5) (Security Awareness), §164.312(a)-(e) (Technical Safeguards), §164.312(b) (Audit Controls)
Dimension 4: Enable end-user responsibility
NIST AI RMF:
GOVERN 4.1, 4.3 (workforce training, user communication); MAP 3.5 (transparency to users)
ISO/IEC 42001:
A.7.4 (awareness), A.9.3 (communication to interested parties)
SOC 2:
CC2.3 (external communication), CC1.4 (commitment to competence)
HIPAA Security Rule:
§164.308(a)(5) (Security Awareness and Training), §164.530(b) (Privacy training)

The Bottom Line

The Singapore MGF for Agentic AI is, today, the most operationally useful agentic-governance document any government has produced. It is voluntary, but it is the document your vendor risk reviewers, your enterprise customers, your auditors, and increasingly your regulators will measure you against. Adopting its four dimensions as the structure of your agentic AI programme means you can answer "how are you governing this?" with a reference that everyone in the room recognises — and it positions you well in front of binding regimes (EU AI Act for high-risk AI, US state laws referencing NIST RMF) without doing duplicate work.

Compliance Relevance

The framework is non-binding, but it interoperates cleanly with NIST AI RMF (Govern/Map/Measure/Manage), ISO/IEC 42001 (AI Management System), SOC 2 (Common Criteria 1-9), and HIPAA Security Rule (administrative, physical, and technical safeguards). Organisations that have built governance around any of these can adopt the MGF Agentic with mostly additive work rather than restructuring. Enterprises subject to the EU AI Act's high-risk obligations will find the MGF Agentic's technical-controls dimension produces much of the evidence that an Annex IV technical file demands.

As of May 22, 2026. We are not lawyers and this is not legal advice. It is the responsibility of consumers of this data that they verify the applicability and current ratified statutes and legal precedence with a qualified attorney licensed in the state or country they are researching.

Need Help with AI Compliance?

Our team helps organizations build compliance-first AI systems that meet current and emerging regulatory requirements.