Noma Security Is Now a Native Guardrail Across the TrueFoundry Stack

Every team shipping AI features hits the same wall. Developers want to connect to whatever model or agent framework gets the job done. Security teams need to know that every prompt, every response, and every action an agent takes is being checked for data leaks, prompt injection, and unsafe behavior.

The usual answer is to engineer each application with its own security SDK, then maintain that by hand as models and agents multiply. But that approach breaks down fast. Every time there’s a new app, there’s a new integration. For each new model, there’s a new configuration. The result is security coverage that ends up patchy and hard to audit.

That’s the gap this partnership with TrueFoundry and Noma closes. Noma Security is now available as a native guardrail across two points in the TrueFoundry stack: the AI Gateway, which governs every request in and out of a model, and the newly open sourced Agent Harness, which governs what an agent does once it starts taking action. Turn Noma on at either layer, and it inspects traffic and agent behavior in real time.

One Guardrail, Two Points of Enforcement

TrueFoundry AI Gateway governs every request in and out of a model, with routing, rate limiting, and observability built in. It’s a natural place to enforce a policy once, uniformly.

But an agent’s real risk shows up in what it can reach once it starts acting: credentials, databases, MCP servers, actions taken on a user’s behalf. TrueFoundry’s Agent Harness extends the same native guardrail model to that level. It exposes native hooks that call Noma before an agent action executes, so a risky tool call gets evaluated before it runs, not after.

Both integrations leverage the same context. Noma’s platform feedback loop connects AI-SPM (what an agent connects to), Access Control (what it is permitted to do), and AI Red Teaming (how it can be manipulated) directly into the AI-DR engine. So a verdict at the Gateway or the Harness is judged against the agent’s real blast radius, not a request or command in isolation, which is how the same action can be waved through for one agent and blocked for another with broader access.

That’s the idea behind our Open Enforcement principle: customers define their AI Constitution once and enforce it everywhere, at the request layer and the action layer. It’s why we invest in partnering with the best AI infrastructure providers in the market.

What Noma Sees and Does

Noma’s AI-DR engine provides runtime detection and response for AI agents. It inspects live traffic, not just configuration: user prompts, model responses, and the inputs and outputs of tool calls, catching prompt injection, sensitive data exposure, and unsafe agent behavior as they happen.

For every piece of traffic or action, Noma returns a clear verdict: allow, block, mask sensitive fields, or alert. Each evaluation carries application and user context, so the same policy engine can reason about who made a request and which app it came from, not just what the request contained.

Layered Protection, One Configuration

With Noma running as a native guardrail, security stops being something each application team implements on its own. Any model or agent reachable through TrueFoundry, whether through the Gateway or the Agent Harness, inherits the same inspection.

Enforcement behavior is configurable per guardrail:

• Enforce: blocks on any violation.
• Enforce But Ignore On Error: still blocks real violations, but lets traffic through if Noma itself is unreachable.
• Audit: logs everything without blocking anything.

Every verdict, whether it comes from the Gateway or a Harness hook, lands in the platform’s request traces, giving security and platform teams one audit trail across all their AI traffic.

How it Works

At the Gateway:

1. The application sends a request to TrueFoundry AI Gateway using the OpenAI-compatible API it already calls.
2. The gateway forwards the content to Noma AI-DR over HTTPS: the prompt, and optionally the model response and any tool-call inputs and outputs.
3. Noma inspects the traffic in real time and returns a verdict: allow, block, mask, or alert.
4. The gateway enforces that verdict before anything reaches the model or the user.
5. Optionally, the model’s response is sent back to Noma for a second check before it returns to the application.
6. Every verdict is logged in the gateway’s request traces.

In the Agent Harness:

1. Before runtime, Noma’s AI-SPM and Access Control establish what the agent connects to and what it is permitted to do, and AI Red Teaming surfaces how it can be attacked.
2. The agent proposes an action, and the harness’s native hook intercepts it before it executes.
3. Noma’s AI-DR engine evaluates the action against that context, not just the raw command.
4. An unsafe action is blocked before it runs. A safe one proceeds within the agent’s permissions.
5. The verdict feeds back into the Noma Platform, informing the next decision.

Get Started

Setup is simple. Add Noma Security as a guardrail in your TrueFoundry account, provide your Noma API key, and choose an enforcement strategy. You can set an Application ID and map request metadata to a user ID so Noma sees full context, and point it at your production or sandbox endpoint. From there, scope the guardrail to the users, teams, and models you want covered, whether that traffic runs through the Gateway or the Agent Harness.

Security shouldn’t be the thing that slows AI adoption down. TrueFoundry routes and governs every request and every agent action. Noma decides what is safe, informed by the full context of what that agent is and what it can reach. The platform enforces that decision on the spot. Turn it on once, and every model and agent behind TrueFoundry inherits the same runtime protection, no per-application wiring required.