Privacy at runtime
AI Guardrails
Your data and your rules, enforced in the request path.
Entry points
Interception
Policy engine
Decision
Repository & delivery
- 01Git repository
- 02Pre-commit checks
- 03Pull request checks
- 04CI/CD policy gates
Agent system access
- 01MCP servers
- 02Business-system access controls
Every path feeds the audit and evidence store, ready for security, compliance, and architecture review.
Control layers
Five layers of enforcement, from prompt to pull request.
Prompt and context controls
NPU AI Guardrails inspect the information being sent to AI tools. This can include detection of:
- Client names
- ID numbers
- Policy numbers
- Account numbers
- Financial information
- Medical or claims information
- Biometric references
- Confidential documents
- Internal source code
- Credentials and secrets
- Production data
Where needed, the guardrails can block the request, warn the user, redact the data, tokenise the data, or require approval.
Model and provider controls
Not all AI models and providers should be treated the same. NPU AI Guardrails can enforce approved routing rules, such as:
- Block public or personal AI tools for client information
- Allow only enterprise-approved AI services
- Route sensitive workloads to private or self-hosted models
- Route low-risk tasks to approved external models
- Enforce model selection by data classification
- Log the model, provider, purpose, and policy decision
This allows organizations to use AI without losing control over where data goes.
Agent tool controls
AI agents can call tools, read files, modify code, query systems, and trigger workflows. NPU AI Guardrails help control:
- Which tools an agent may use
- Which files an agent may read or write
- Which MCP servers an agent may access
- Which APIs an agent may call
- Which environments an agent may touch
- When human approval is required
- When execution must be blocked
This is critical for agentic software delivery, where AI is not only generating text but taking actions.
Repository and pull request controls
AI-generated code must still meet engineering standards. NPU AI Guardrails can add checks for:
- Secrets committed to source control
- Unsafe generated code
- Missing tests
- Weak error handling
- Unapproved dependencies
- Licence and package risk
- Insecure configuration
- Policy violations
- AI-generated changes that require human review
These checks can run during pre-commit, pull request review, and CI/CD.
Audit and evidence
Organisations need evidence that AI is being used responsibly. NPU AI Guardrails can capture:
- Which AI tool was used
- Which model or provider was used
- What policy applied
- Whether data was redacted
- Whether a request was blocked or approved
- Which tools an agent called
- Which files or systems were accessed
- Who approved a sensitive action
- Which pull request or deployment was affected
This creates a practical audit trail for security, compliance, architecture, and governance teams.
Guardrails where the work happens
Practical enforcement points, not theoretical governance.
The guardrails can be applied across the tools, systems, and pipelines your teams already use.
IDE and coding assistants
Detect sensitive data before it is sent to an AI tool.
Agent SDK hooks
Inspect prompts, tool calls, file reads, file writes, and approvals.
Git repositories
Block secrets, unsafe generated code, and policy violations before merge.
Pull requests
Run AI usage, code quality, security, and data-risk checks.
GitHub Actions and CI/CD
Enforce policy gates before deployment.
MCP servers
Control what agents can access and when.
Enterprise model gateways
Route requests only to approved models and providers.
Audit systems
Capture evidence of AI usage, approvals, and policy decisions.
Claude Code and Claude SDK events
GitHub Copilot workflowsGitHub Actions
OpenAI Agents SDK
LangGraph and LangChain callbacksCursor-style IDE agents
Microsoft developer and Azure AI tooling
AWS Bedrock-based AI workflowsMCP serversCustom internal agent frameworksExample use cases
What the guardrails do in practice.
Preventing client data exposure
A developer attempts to paste a client record into a coding assistant to generate a support script.
The guardrail detects personal and financial information, blocks the request, and suggests a redacted version using placeholders.
Controlling AI-generated code in pull requests
A pull request contains AI-generated code that adds a new dependency and modifies authentication logic.
The guardrail flags the change for additional review, checks the dependency risk, and requires security approval before merge.
Enforcing approved model usage
An internal agent attempts to send sensitive business context to an unapproved external model.
The guardrail blocks the request and routes the task to an approved enterprise model or private model endpoint.
Securing MCP access
An agent tries to query a business system through an MCP server.
The guardrail checks the agent role, task purpose, data classification, and approval status before allowing access.
POPIA-aligned AI usage
Designed for POPIA-aligned AI usage.
For South African organizations, client information must be handled carefully when AI tools are used. NPU AI Guardrails are designed to support POPIA-aligned operating controls, including:
- Data minimisation
- Purpose-based processing
- Client-data classification
- Prevention of unnecessary personal information exposure
- Redaction and tokenisation before AI processing
- Approved provider and model usage
- Cross-border data handling controls
- Audit evidence for internal governance
- Role-based access to sensitive workflows
- Controls for financial, identity, biometric, policy, claims, and regulated data
The goal is simple: developers and agents should not be able to casually send sensitive client or company information to unapproved AI services.
Compliance and standards
Built to align with ISO/IEC 42001.
ISO/IEC 42001 is the first international standard for AI management systems. It governs how AI is built, deployed, and monitored across an organisation, not just what a single model does. We design the whole NPU Labs stack to align with it, so the controls a client needs for POPIA, GDPR, and their own board are already in the architecture.
ISO/IEC 42001
AI management system
POPIA
South Africa
GDPR
EU and UK
NIST AI RMF · EU AI Act
Risk frameworks
Recommended implementation approach
From AI usage today to enforceable controls in production.
- 1
AI usage and risk assessment
Review how teams currently use AI tools, coding assistants, chat interfaces, agent frameworks, repositories, and automation platforms.
- 2
Policy-to-control mapping
Translate AI usage policy, POPIA requirements, security standards, and engineering rules into enforceable technical controls.
- 3
Guardrail integration
Implement guardrails across IDEs, AI assistants, agent SDK hooks, MCP servers, Git repositories, pull requests, and CI/CD pipelines.
- 4
Monitoring and audit evidence
Capture logs, policy decisions, approvals, model usage, tool calls, and evidence required by security, legal, compliance, and architecture teams.
- 5
Continuous improvement
Tune the guardrails as teams adopt new AI tools, new agent workflows, and new delivery patterns.
The human layer
The system decides what is allowed. People decide what is right.
Every control on this page exists to protect a judgement call, not to remove one. Guardrails catch the things a machine should never be trusted to weigh on its own, and hand them to somebody who can be held to the answer.
That is the difference between a system your board can sign off and one nobody wants to put their name to. Every escalation has a named owner. Every override belongs to a person, and it always wins. Nothing important happens because a model felt confident.
We are not automating your people out of the loop. We are making the loop worth their time.
Outcomes
What organizations get from NPU AI Guardrails.
- Use AI developer tools safely
- Reduce accidental client-data exposure
- Enforce AI policy at the point of use
- Support POPIA-aligned AI operations
- Improve visibility of AI-assisted work
- Control agent access to tools and systems
- Protect source code, secrets, and internal information
- Create audit evidence for governance teams
- Adopt agentic delivery without losing control
Common questions
Questions we get asked about AI guardrails.
What are AI guardrails?
Policy enforced in the request path, not a document on a shelf. As developers and agents use AI, the guardrails inspect the prompt, the model and provider, the tools an agent may call, and the code it produces, then block, warn, redact, tokenise, route, or require approval based on your rules.
How is this different from a written AI usage policy?
A usage policy tells people what they should do. Guardrails make it happen at runtime. The same policy becomes enforceable controls across IDEs, agent runtimes, repositories, CI/CD, and model gateways, with an audit trail for every decision.
Where do the guardrails plug in?
Across the tools your teams already use: IDEs and coding assistants, agent SDK hooks, Git repositories, pull requests, GitHub Actions and CI/CD, MCP servers, enterprise model gateways, and audit systems. The design is policy-as-code, event-driven, and auditable.
Will guardrails get in my developers' way?
They protect a judgement call rather than remove one. Low-risk work flows through untouched, sensitive data is redacted or tokenised, and only genuinely risky actions pause for approval. Every escalation has a named owner, and a person always makes the final call.
Do they work with our existing AI tools?
Yes. The guardrails sit across Claude Code and the Claude SDK, GitHub Copilot, OpenAI Agents SDK, LangGraph and LangChain, Cursor-style IDE agents, Microsoft and Azure AI tooling, AWS Bedrock workflows, MCP servers, and custom internal agent frameworks.
How does this help with POPIA and ISO/IEC 42001?
The controls a client needs for POPIA, GDPR, and their own board are built into the architecture: data minimisation, redaction before AI processing, approved provider and model usage, role-based access, and audit evidence. The whole stack is built to align with ISO/IEC 42001, though NPU Labs is not an accredited certification body.
Not the question you came with?
Ask us about your setupWhere this shows up in your work
Three real situations. Three places guardrails earn their keep.
Scenario 01
You're shaping the AI policy
Legal wants a written usage policy. Security wants enforceable controls. The team wants a way to ship work. Guardrails turn the policy from a PDF into something that actually runs.
Scenario 02
You're plugging into the engineering stack
AI tools, IDEs, agent SDKs, MCP servers, Git repos, CI/CD. Guardrails wrap all of it: enforce model routing, flag risky pull requests, redact PII, log every tool call.
Scenario 03
You're rolling out agentic delivery
Your team uses AI agents to plan, build, and review. Guardrails travel with the agents: same policy, same audit trail, applied at every step in the loop.