NewA private AI, small enough to run on a Raspberry Pi.ArticleThe South African GPU map. What is actually available for AI here.ArticleThe week the cloud blinked. Why private AI just got urgent.VoiceSeven voices, 100+ languages, on hardware you own.StackBuilt by senior engineers running real systems in production.BuildPrivate AI infrastructure, engineering, and guardrails on one stack.NewA private AI, small enough to run on a Raspberry Pi.
NPU LabsNPU LABS
Contact us

Privacy at runtime

AI Guardrails

Your data and your rules, enforced in the request path.

Entry points

Developer
AI Agent
IDE / Coding Assistant
Agent Runtime

Interception

Guardrail hooks

Policy engine

Data classification
Secret detection
Prompt & context inspection
Tool permission control
Approved model routing

Decision

Redact / tokenise
Block / warn / require approval
Route to approved AI provider

Repository & delivery

  1. 01Git repository
  2. 02Pre-commit checks
  3. 03Pull request checks
  4. 04CI/CD policy gates

Agent system access

  1. 01MCP servers
  2. 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.

01

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.

02

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.

03

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.

04

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.

05

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.

01

IDE and coding assistants

Detect sensitive data before it is sent to an AI tool

02

Agent SDK hooks

Inspect prompts, tool calls, file reads, file writes, and approvals

03

Git repositories

Block secrets, unsafe generated code, and policy violations before merge

04

Pull requests

Run AI usage, code quality, security, and data-risk checks

05

GitHub Actions and CI/CD

Enforce policy gates before deployment

06

MCP servers

Control what agents can access and when

07

Enterprise model gateways

Route requests only to approved models and providers

08

Audit systems

Capture evidence of AI usage, approvals, and policy decisions

Developer AI tools and agent SDK integrations

Implemented across the tools developers and agents already use.

NPU AI Guardrails can be implemented across typical integration points, including:

Claude Code and Claude SDK eventsGitHub Copilot workflowsGitHub ActionsOpenAI Agents SDKLangGraph and LangChain callbacksCursor-style IDE agentsMicrosoft developer and Azure AI toolingAWS Bedrock-based AI workflowsMCP serversCustom internal agent frameworks

The implementation is designed around policy-as-code, event-driven enforcement, and auditable controls.

Example 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.

Guardrail

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.

Guardrail

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.

Guardrail

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.

Guardrail

The guardrail checks the agent role, task purpose, data classification, and approval status before allowing access.

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

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.

Recommended implementation approach

From AI usage today to enforceable controls in production.

  1. 1

    AI usage and risk assessment

    Review how teams currently use AI tools, coding assistants, chat interfaces, agent frameworks, repositories, and automation platforms.

  2. 2

    Policy-to-control mapping

    Translate AI usage policy, POPIA requirements, security standards, and engineering rules into enforceable technical controls.

  3. 3

    Guardrail integration

    Implement guardrails across IDEs, AI assistants, agent SDK hooks, MCP servers, Git repositories, pull requests, and CI/CD pipelines.

  4. 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. 5

    Continuous improvement

    Tune the guardrails as teams adopt new AI tools, new agent workflows, and new delivery patterns.

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

Where 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.

    Talk to us

  • 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.

    AI Engineering

  • 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.

    Agentic WoW