Securing Homegrown Agents in Runtime: The Value of Zenity + Microsoft Foundry

Over the past year, Microsoft Foundry has emerged as a cornerstone for enterprises building and deploying homegrown agents at scale. Organizations across industries are using Foundry to move beyond experimentation and into production, creating AI agents that can reason, invoke tools, access enterprise data, and automate complex workflows.

As adoption accelerates, a new reality is setting in: once AI systems gain agency, the security and governance model must evolve with them.

In November, Zenity announced a beta integration with Microsoft Foundry that introduced inline prevention, proving that it’s possible to block risky agent behavior in real time. Since then, customer demand, real-world usage, and deeper collaboration with Microsoft have pushed this partnership forward.

Today, Zenity and Microsoft are expanding that vision into a production-grade security model for agentic AI, enabling enterprises to safely scale agents built in Foundry while protecting them from runtime threats.

From Experimentation to Production: How Customers Are Using Microsoft Foundry

Customers adopting Microsoft Foundry are no longer focused solely on models. They are building agentic workflows that connect AI to the systems that run the business:

• Knowledge workers using agents to retrieve and summarize data from SharePoint and OneDrive
• IT and security teams automating ticket triage, remediation, and access workflows
• Developers chaining agents with internal APIs and SaaS platforms
• Regulated enterprises integrating AI into financial, healthcare, and operational decision-making

In these environments, Foundry provides what customers need to build and scale:

• A robust AI platform
• Identity and access integration
• Developer tooling for agent creation and orchestration

What customers quickly discover, however, is that risks appear and evolve at runtime.

What’s Changed Since November

The November beta focused on one critical question: Can security controls be enforced in the moment, as agents invoke tools?

That beta demonstrated:

• Inline blocking of prompt injection attempts
• Prevention of unsafe outputs
• Enforcement of basic policy violations
• Protection along specific invocation paths

It was intentionally scoped as early access and technical validation.

Since then, enterprise adoption of Foundry has expanded even more, and so has the threat surface. With this expanded partnership, Zenity’s capabilities evolve in meaningful ways:

• Point prevention → End-to-end, agent-aware protection
• Selective inline checks → Broad runtime enforcement
• “Can we block this?” → “How do we safely run agentic AI in production?”

This partnership is all about operationalizing security for agents at enterprise scale.

The Core Problem: Risk Emerges When Agents Act

AI agents interact dynamically with: models, tools, enterprise data, other agents, internal and external systems

Risk emerges when agents chain actions, invoke tools, and touch real systems. Traditional security controls, which are designed for static applications, APIs, or post-hoc monitoring, are simply not built for this kind of autonomous, adaptive behavior.

Security teams need a way to detect, disrupt, and prevent threats as they happen, not after damage has already occurred.

As we often tell customers: “Agents fail when they chain actions, invoke tools, and touch real systems. Inline security only works if it’s part of the execution path.”

Zenity integrates where agents actually act, providing continuous, agent-aware, natively inline protection through its expanded partnership with Microsoft Foundry.

Expanded Inline Use Cases: Protecting Agents at Runtime

Inline Prevention of Data Leakage

Foundry agents frequently connect to SharePoint, OneDrive, databases, and internal APIs. While this enables powerful automation, it also introduces risk.

Zenity prevents data leakage by:

• Inspecting agent actions before data leaves trusted boundaries
• Blocking sensitive data exfiltration
• Preventing unsafe cross-context data sharing
• Enforcing policies tied to identity and data sensitivity

This ensures that agents don’t accidentally (or maliciously) send data where it doesn’t belong.

Inline Protection Against Prompt Injection and Agent Hijacking

Attackers increasingly target agents through prompts designed to bypass guardrails, override system instructions, or trigger unintended behavior.

Zenity disrupts these attacks by:

• Detecting anomalous agent behavior across action chains
• Preventing tool-mediated prompt injection
• Identifying context poisoning and memory manipulation
• Blocking jailbreak and hijack attempts in real time

This moves protection beyond static prompt validation and into behavioral enforcement at runtime.

Inline Control of Tool Invocation

Agents are only useful if they can perform actions, and in order to do that, they often need to invoke tools. Tools are also one of the most attractive attack surfaces.

Zenity enforces:

• Which tools an agent can invoke
• Under what conditions
• With what data

This prevents:

• Destructive or disruptive actions
• Unauthorized API calls
• Over-privileged behavior

Least privilege is enforced dynamically, based on context and policy, not just post-hoc by analyzing agent configuration.

Secret and Credential Exposure Prevention

Agents often require credentials, tokens, or API keys to perform their duties. These secrets are common weak points, even in environments with strong identity controls.

Zenity prevents:

• Accidental leakage of secrets through prompts or outputs
• Malicious extraction of credentials via agent manipulation
• Exposure of authentication data across agent workflows

This closes a critical gap that traditional NHI and identity tools don’t cover at the agent layer.

Why This Matters: Differentiation at the Agent Layer

Microsoft provides what customers need to build:

• A powerful AI platform
• Enterprise-grade identity
• Best-in-class developer tooling

Zenity adds what customers need to run agents safely in production:

• Agent-aware security
• Runtime enforcement
• Inline prevention
• Cross-agent visibility

Together, Zenity and Microsoft enable enterprises to move faster by controlling risk where it actually emerges.

Moving Forward

As AI agents become embedded in enterprise operations, security and governance must move from static controls to continuous, runtime protection. The expanded Zenity + Microsoft Foundry partnership reflects this shift; helping customers scale agentic AI with confidence.

This is not about slowing innovation. It’s about making sure that when AI acts on behalf of the enterprise, it does so securely, predictably, and within enforceable boundaries.

Agentic AI is here. With the right controls in place, it can be deployed safely and at scale. Learn more here.