Governance for AI Agents
AI Agents have significantly changed the software landscape by introducing new dimensions that need to be controlled, audited and regularly updated. This skill introduces not just a framework but the spectrum of changes that help explain how these new systems are offering numerous new surfaces for both failures and attacks. Whether you are a developer, an architect, a systems/operation engineer, or a technology decision maker, the content here will give you the foundations to understand this new landscape as well as a framework to ensure you can safely bring this type of application into your portfolio.
|
Upon completion of the Governance for AI Agents skill and assessment, you will earn a Credly badge that you are able to share with your network. |
Learning Objectives
Explain governance fundamentals for AI agents as an extension of existing enterprise governance practices: Understand how governance connects safety, security, compliance, observability, ownership, controls, and evidence to keep agent autonomy accountable.
Apply least-privilege, guardrail, and policy-enforcement patterns within a defined governance architecture: Use access boundaries, approvals, runtime controls, data protections, and monitoring practices to manage how agents act and what they can reach.
Identify MongoDB platform features that enable governance controls for AI agents: Recognize how capabilities such as role-based access control, encryption, auditing, logging, retrieval scoping, and environment separation support governed agent architecture.
Who is this Course Good for?
This skill badge is designed for application developers, platform and infrastructure engineers, security and compliance professionals, data and database teams, support operations, and technical decision-makers responsible for building or operating AI agents.
It is especially useful for people who need to define what an agent can access and change, decide when a person must intervene, establish accountable ownership, or ensure that an incident can be reconstructed and addressed.
Application teams will use the skill to identify control points in instructions, context, tools, actions, and handoffs. Platform and data teams will focus on identity, authorization, data access, environment separation, logging, and evidence. Security, compliance, and operations teams will focus on risk, approvals, incident response, and ongoing validation.
The course is also a fit for teams adopting AI agents in production or modernizing existing workflows. It emphasizes practical governance decisions and enforcement points rather than a single vendor implementation, so learners can apply the concepts across agent architectures and deployment environments.
What to Expect in this Course
The skill begins with the practical problem created when an AI agent can act across systems at machine speed without clear boundaries, meaningful oversight, or a defensible record. You’ll learn why governance must connect safety, security, compliance, and observability through policy, ownership, controls, and evidence.
Next, you’ll map the agent control surface and examine the risks that governance must address. You’ll identify what the agent can access, what it can change, what can influence its behavior, where a person intervenes, what evidence remains, what the agent relies on, and how to prevent one mistake from multiplying.
The autonomy, identity, and access portion focuses on defining decision rights before launch and reevaluating them as the agent changes. You’ll compare autonomous, approval-required, and prohibited actions; apply least privilege; distinguish delegated user authority from service account authority; and preserve traceable identity and authorization through every hop.
The architecture portion shows how governance becomes enforceable. You’ll work with action boundaries, action gates, approval controls, context and data constraints, rate and budget guardrails, memory policies, idempotency, rollbacks, and compensating actions. You’ll also examine how application controls work alongside platform controls such as database permissions, encryption, auditing and logging, retrieval scoping, and environment separation.
The auditability and incident response portion addresses what happens when prevention fails. You’ll learn how to capture agent traces, policy evaluations, tool calls, approvals, memory activity, identities, and outcomes; then use that evidence to detect, contain, analyze, and remediate an incident. You’ll connect safe recovery paths, rollback ownership, post-incident review, and regression testing into an accountable response process.
The final portion treats governance as an operating practice rather than a launch checklist. You’ll apply versioning and validation to models, prompts, policies, and dependencies; use red-teaming, exception review, and regression tests to expose weaknesses; monitor behavioral, configuration, memory, and documentation drift; and make risk-based tradeoffs as the system evolves.
Summary of the Course
- Explain how governance coordinates safety, security, compliance, and observability for AI agents.
- Identify the control surface and recognize access, behavioral, oversight, reliability, and operational risks.
- Define autonomy boundaries and apply least-privilege access to data, tools, tenants, and permissions.
- Distinguish delegated user identity from service account identity and preserve traceability through every hop.
- Select runtime controls for action gating, approvals, data handling, budgets, rate limits, memory, and safe recovery.
- Describe how application and platform controls can work together to enforce policy and capture evidence.
- Plan auditability and incident response across detection, containment, analysis, remediation, rollback, and cleanup.
- Apply continuous governance practices, including versioning, validation, red-teaming, exception review, regression testing, and drift monitoring.
- Match governance controls and human oversight to the impact, reversibility, and operational risk of an action.
Aaron Becker | Technologist, Education
Aaron Becker is a Technical Trainer, Instructional Designer, and Training Manager who has worked in the tech sector for over 13 years. Before joining the Curriculum team at MongoDB, Aaron worked in DevOps at CircleCI, creating their first Certification course (CircleCI Associate Developer) and leading a team responsible for creating and managing the educational content for CircleCI Academy for external/customer training, as well as CircleCI University for internal team member training.
Prior to that, Aaron worked in data protection, redundancy, and security at Carbonite, where he headed up the Training team, created and delivered ILT training courses for Carbonite's Mid-Market and Enterprise level products, and assisted over 150 employees in earning Microsoft certifications.
Aaron enjoys writing, performing, recording, mixing and mastering music, playing video games, and writing biographical text in the third person.
Parker Faucher | Senior Curriculum Engineer
Parker Faucher is a Senior Curriculum Engineer on the MongoDB University team, where he designs and develops technical learning content for developers and data professionals. Based in Phoenix, Arizona, Parker specializes in building skills-based learning experiences across topics like vector search, AI applications, and MongoDB performance, helping learners go from concept to hands-on practice.
With a strong focus on quality and efficiency, Parker also leads efforts to integrate AI tooling into the curriculum development workflow, streamlining reviews, accelerating iteration cycles, and freeing up more time for the work that matters most.
Sarah Evans | Senior Curriculum Engineer
Sarah Evans is a Senior Curriculum Engineer at MongoDB, where she designs and develops technical learning experiences for MongoDB University. With a background that bridges curriculum design and hands-on technical expertise, she specializes in translating complex database and data modeling concepts into clear, accessible content for developers and technology professionals. Sarah is passionate about practical, engaging technical education and brings a deep interest in AI-driven development to her work helping learners navigate the intersection of modern databases and intelligent application design.
It’s 2 AM at LeafyBank. A customer has reported a duplicate charge. The support agent, Branch, reads the account history, decides a refund is appropriate, and issues a $10,000 refund. Unfortunately, the customer was mistaken, but the refund was still granted.
Without a defined governance policy to follow, which might prevent the autonomous approval of refunds over a certain dollar amount, or require an accountable person to approve such requests, this is a very possible outcome.
Of course, this is exactly the kind of outcome we want to prevent.
To do so, it’s not enough to just ask: “How do we stop the agent from making a mistake?” We must also ask: “How do we control what the agent is allowed to do, who is accountable, and what happens when prevention fails?”
That is what governance is for.
Governance is the set of policies, responsibilities, controls, evidence, and response practices that keep an autonomous system accountable as it takes on real work.
It includes both the technical policies that constrain the agent, and the policies that define the behavior of the people involved in the workflow.
The root problem is the same whether an action is taken by a person or an AI agent: if there is no governance defining what is allowed, who is accountable, or what evidence must be kept, mistakes and abuse are far more likely to occur.
Think of the agent, Branch, as a new employee who can work at machine speed. It has a corporate card, access to customer records, and the ability to call other systems. You wouldn’t give a brand new employee every key and ask them to “use good judgment.” You would define the job, limit their access, require approval for high-impact actions, and keep a record of what happened.
Branch can answer questions and fulfill requests by retrieving data, choosing tools, and changing state in LeafyBank’s systems. Its capabilities might include looking up an order, issuing a refund, updating a subscription, sending an email, or handing the request to a person.
That is what makes agent governance different from governing a more predictable application. With traditional software, we have the opportunity to review and test behavior before deployment.
An agent’s behavior is shaped at runtime by its prompt, the data it retrieves, the tools available to it, and the model’s interpretation of the situation.
A unit test can verify a fixed path, but it cannot cover every path the agent may take when the prompt, retrieved context, or model changes.
Governance for AI Agents therefore combines pre-deployment testing with runtime controls and evidence.
For agents, governance must cover more than the service account or database. It must cover the instructions that shape the agent, the records it can retrieve, the tools it can call, the actions it may take, the people who approve exceptions, and the evidence captured along the way.
Across this skill, we will follow our LeafyBank example.
We’ll begin by defining governance, distinguishing it from safety, security, compliance, and observability, and identifying key agent-workflow risks.
Then we’ll discuss autonomy boundaries, least-privilege access, traceable identities, and meaningful approval for high-impact actions.
Next, we’ll enforce policy across application and platform layers with action gates, data and budget guardrails, governed memory, safe actions, and platform controls such as RBAC and auditing.
We’ll capture evidence and respond to failures through detection, containment, analysis, remediation, and accountable recovery.
Finally, we’ll keep governance current through versioning, evaluations, red-teaming, exception review, regression tests, drift monitoring, and risk-based tradeoffs.
By the end of this skill, you should be able to look at an agent and ask practical questions: What can it access? What can it change? When must a person intervene? What evidence of an incident will exist tomorrow morning? And how will the team know when yesterday’s controls no longer fit today’s agent?
Agents that access real data, call real tools, and take action without waiting for approval from a person are already a reality. Governance is what makes that autonomy bounded, visible, and accountable.
Once you’ve completed this skill, you’ll be ready to apply these concepts by earning the Governance for AI Agents skill badge through Credly.
It’s more than just a digital badge that you can share on LinkedIn: it’s proof that you understand how to make agent autonomy bounded, visible, and accountable. I’ll see you in the next video.
