Obsidian Runtime Policy Enforcement Adds Action Controls Across Supported Agent Tools
Obsidian Security announced new agent controls on November 10, 2026, targeting dangerous actions that can occur despite valid access permissions. Obsidian runtime policy enforcement evaluates proposed operations before execution, using business context to decide whether they should proceed. Its scope depends on supported enforcement connections.
The distinction matters for enterprises choosing between discovering agents and controlling their behavior. An inventory can identify an assistant with database access. Preventing an inappropriate operation requires a control in the execution path, where the assistant’s request becomes an application action.
Anthropic’s Claude Code illustrates the broader shift toward controls around agent execution. Obsidian is pursuing a different layer: centrally managed business policies across supported tools. The resulting pressure falls on security and platform teams, which must establish where those policies actually apply.
Obsidian Runtime Policy Enforcement Moves Beyond Agent Inventory
Obsidian’s runtime policy announcement introduces its Runtime Policy Decision Engine, a service that evaluates proposed agent actions against organizational rules. The company says decisions incorporate identity, employment, application, and customer-supplied data context. Supported connections can allow or block operations, with human approval available where supported.
The change concerns what an agent does with access it already holds.
Discovery answers whether an agent exists and what it can reach. Governance addresses its permissions and configuration. Runtime enforcement addresses an operation while execution is still preventable. These functions complement each other, but they answer different questions.
That separation changes how buyers should interpret a security platform’s coverage. Finding an agent inside a business application does not establish that every operation passes through a blocking control. A vendor’s integration list therefore needs more explanation than a collection of product names.
Obsidian also announced an MCP Security Proxy and a Policy Decision API. MCP, or Model Context Protocol, is a standard for connecting AI applications with external tools and data. An API is a software interface through which systems exchange requests and responses.
The proxy checks tool calls on supported connections. The API extends policy decisions to customer-operated gateways and agent tools. A gateway is an intermediary that routes requests between systems and can apply controls along that route.
Those additions create different ways to place a decision before an operation. They also create different implementation responsibilities. When a customer controls the gateway, returning a decision and enforcing that decision become distinct parts of the security arrangement.
Runtime coverage also expands to Codex alongside existing coding-agent support, according to Obsidian. That expansion should be read as a specific product claim. It does not establish identical capabilities across every platform mentioned elsewhere in the company’s materials.
The practical significance is architectural. A company can retain legitimate agent access while adding conditions to particular operations. Whether that arrangement works depends on the rules, the available context, and the path each request follows.
Consider the difference between permitting database access and authorizing a destructive database operation. Both concern the same application, but the business consequences differ. An enterprise needs enough detail to distinguish them before it can make a useful policy decision.
Obsidian runtime policy enforcement brings that distinction into the product’s central proposition. The announcement establishes the intended control model. It does not establish that every enterprise workflow already runs through that model.
Security Teams Must Account for Actions, Not Just Access
The immediate pressure falls on the teams approving agents for work with sensitive systems. A permission review can establish that an account needs access. It cannot, by itself, establish that every later operation serves the approved business purpose.
A valid account provides evidence of access authority, not evidence that every requested action is appropriate.
This is the operational problem behind the announcement. Enterprises want agents to complete useful work without granting unrestricted discretion over everything an account can reach. The security requirement sits between broad denial and unqualified permission.
An illustrative customer-service workflow shows the distinction. An assistant might need to retrieve customer records to prepare an internal response. Sending those records to an outside address presents a separate decision, even when the account technically permits both operations.
That example is an analytical scenario, not a reported Obsidian customer deployment. It shows why reviewing the destination, requested operation, and business purpose matters. The application name alone cannot explain the risk.
Platform engineers inherit part of this responsibility. They determine which tools agents can invoke and how those requests reach business systems. A policy service has limited practical value if the relevant request never reaches its enforcement connection.
Application owners also face a clearer burden. They must distinguish activities that are routine from activities that require additional authority. A general statement that an agent can use a system leaves too much ambiguity for action-level decisions.
Data owners have another role. A rule involving sensitive information needs a defensible definition of sensitivity. If that definition varies across teams, a central policy can produce inconsistent outcomes despite consistent execution.
For knowledge workers, the same distinction appears when assistants move from finding information to distributing it. A searchable collection and an external communication workflow create different exposure paths. Convenience does not remove the need to account for those differences.
Teams building a searchable knowledge base should therefore distinguish retrieval permissions from authority to change or share source material. That principle applies regardless of which assistant eventually uses the information.
The expected Obsidian agent security impact is consequently organizational as well as technical. Buying an enforcement layer does not resolve disagreements about ownership, acceptable use, or escalation. It makes those decisions necessary inputs to a working control.
This is also why security teams need evidence beyond the number of blocked requests. A high blocking count can indicate useful protection, excessive restriction, or a poorly configured workflow. The outcome requires interpretation against the legitimate task.
The more meaningful question is whether employees can complete authorized work while inappropriate operations stop at the intended boundary. That question connects security performance to business operations. It also prevents a busy dashboard from becoming a substitute for demonstrated control.
Central Decisions Still Need Enforcement in the Request Path
Obsidian’s policy decision architecture separates evaluation from execution. Its technical description says an enforcement connection pauses a request, obtains a decision, and applies the result. Customer gateways using the API remain responsible for enforcing the returned decision.
A central decision becomes a control only when the execution path honors it.
This separation is familiar in security architecture, but agents make its consequences especially visible. A correct evaluation cannot protect an operation that bypasses the evaluator. Nor can a returned rejection help if downstream software proceeds anyway.
The distinction also explains why a uniform policy interface does not necessarily produce uniform capabilities. Different tools expose different intervention mechanisms. The ability to observe, interrupt, block, or request approval must be established for the relevant connection.
Obsidian’s technical post specifically identifies approval support for Claude Code policies that run before an operation. That detail limits how broadly readers should interpret references to human approval. A general capability description should not become an assumption about every supported environment.
The same post describes recording decisions and testing rules in a flagging mode before blocking traffic. Those features address separate operational needs. Observing a rule’s matches helps teams understand its effects; enforcing that rule changes what the agent can accomplish.
For buyers seeking Obsidian agent security explained, the useful question is where each responsibility sits. The central service evaluates policy. The connected execution component implements the result. The customer must establish that the complete arrangement covers the intended workflow.
A hypothetical document-sharing operation illustrates the dependencies. A policy might permit internal sharing while restricting external destinations. To apply that distinction, the request must expose enough destination information, and the execution component must preserve the evaluated operation.
If the operation changes after evaluation, the original decision might no longer address the action being performed. That is an architectural concern buyers should examine. It is not evidence of a specific defect in Obsidian’s implementation.
Request identity presents a related issue. A shared service account might identify the software executing an operation without clearly identifying the employee who initiated it. Business policies based on individual responsibility need a trustworthy relationship between those identities.
The policy layer also needs a defined response when context is missing. Blocking protects the boundary but can interrupt legitimate work. Allowing preserves availability while accepting uncertainty. Neither choice should emerge accidentally from an integration error.
These considerations explain the tradeoff in centralized enforcement. Shared decisions can reduce inconsistent rules across tools. However, the system still depends on accurate inputs and reliable execution controls at each connection.
Obsidian runtime policy enforcement should therefore be assessed as a connected architecture. A console demonstration shows policy authoring. Evidence from the actual request path shows whether that policy governs the business operation under review.
Native Agent Controls and Shared Policies Address Different Boundaries
Anthropic provides a useful comparison because its published security approach emphasizes boundaries around a coding agent’s execution environment. Its Claude Code sandboxing documentation describes filesystem and network isolation, alongside the problem of repeated approval prompts.
Sandboxing restricts the environment in which software operates. It can constrain accessible files and network destinations. That provides a different form of protection from evaluating an application operation against an employee’s business role.
Execution isolation and business authorization address different questions, so enterprises should evaluate how the controls work together.
A network boundary might permit access to an approved business service. A business policy might still reject a particular operation within that service. Conversely, an appropriate application request does not justify unrestricted access to the surrounding machine.
This comparison does not establish that either vendor replaces the other’s protections. It identifies different enforcement boundaries. Treating them as interchangeable would leave buyers without a clear account of which risks each control addresses.
Anthropic also describes approval fatigue, where repeated prompts weaken the attention users give individual decisions. That matters when organizations propose human review as the answer to every uncertain agent action. Review capacity is an operational constraint.
An employee facing frequent interruptions may struggle to distinguish a consequential request from routine activity. A meaningful approval therefore needs useful information about the requested action. The presence of an approval button alone says little about review quality.
Cloudflare provides another comparison at the connection layer. Its MCP server portals became generally available on September 24, 2026. The company describes a common endpoint for approved servers, activity logging, and additional traffic controls.
That infrastructure gives enterprises a place to manage connections. Obsidian’s proposition emphasizes contextual decisions about the operations flowing through supported paths. The overlap creates integration opportunities, while leaving distinct responsibilities for routing, authentication, policy evaluation, and execution.
For an enterprise buyer, the important competitive question is therefore specific: which component knows enough to make the required decision? A connection service can know where traffic is going. A business policy can require additional facts about the actor and information involved.
Those facts do not always belong to the same system. Integrating them introduces dependencies that need ownership and monitoring. The benefit of centralization must be weighed against the effort required to keep those relationships accurate.
This creates a more useful basis for comparison than broad claims about comprehensive agent security. Buyers can examine the boundary, the decision inputs, and the enforceable outcome. They can then identify where complementary controls remain necessary.
The Obsidian agent security impact will depend partly on that fit. Enterprises with fragmented tools face a coordination problem. A shared policy layer is relevant when it reduces that fragmentation without obscuring the underlying enforcement responsibilities.
Broad Coverage Does Not Establish Uniform Protection
Help Net Security’s November 11 coverage describes both expanded runtime controls and discovery across agents embedded in business applications. Its agent security coverage also includes supportive comments attributed to Cloudflare product manager Kenny Johnson and former Gartner analyst Avivah Litan.
Those perspectives identify demand for shared policies and cross-application context. They appear within announcement coverage, however. They should not be treated as independent performance testing or proof of protection across all listed environments.
The announcement establishes product scope claims, while effectiveness remains a separate question requiring operational evidence.
The reviewed materials do not establish a universal breach-prevention rate or consistent performance across every integration. They also do not justify assuming that every discovered agent supports the same blocking and approval behavior.
That leaves a substantial evaluation task for enterprise buyers. A coverage claim should identify the application, agent interface, supported operation, and available response. Without those details, the word “supported” can conceal materially different security arrangements.
Independent security guidance provides a useful reference point. OWASP’s agent security guidance recommends narrowly scoped tools, explicit authorization for sensitive operations, and approval checks outside the agent’s own context. These recommendations are general guidance, not an assessment of Obsidian.
OWASP also emphasizes binding approval to the exact actor and operation. Changing a destination or parameters should require fresh authorization. This addresses a basic integrity problem: approval must apply to what executes, rather than a similar earlier proposal.
The skeptical issue is therefore broader than whether a model receives malicious instructions. Prompt injection, where untrusted content attempts to redirect an assistant, is one possible cause of inappropriate behavior. Ordinary mistakes and misunderstood tasks also warrant controls.
A policy layer does not need to diagnose every cause to reject a clearly prohibited operation. However, a harmful action can still fit an incomplete policy. Enforcement quality and policy completeness are separate dimensions of protection.
Context freshness adds another uncertainty. A rule based on employment or team membership needs current information. An outdated relationship can make a consistently applied decision inappropriate for the present circumstances.
Operational reliability matters too. Buyers need to understand what happens during a policy-service interruption or delayed response. The reviewed announcement does not settle every failure behavior for every connection, so those details require explicit verification.
Logging introduces its own handling questions. Records containing operation arguments can help explain decisions, but they can also contain sensitive information. Retention, access, and redaction deserve attention alongside the visibility those records provide.
None of these considerations establishes a flaw in the announced product. They define the evidence needed to evaluate it fairly. Claims about contextual control become credible through documented behavior under realistic operating conditions, including incomplete information and failed connections.
Three Signals Will Show How the Expansion Performs
The next stage should be judged through specific evidence rather than broader language about agent autonomy. Over the coming months, coverage detail, deployment results, and failure testing will provide different views of the announcement’s practical significance.
The strongest evidence will connect a stated policy to an observed execution outcome in a defined environment.
The first signal is more detailed documentation of enforcement support. Buyers should watch for descriptions of supported operations, connection requirements, and differences between blocking, flagging, and approval. Documentation should also explain where a capability remains unavailable.
That detail would strengthen the case for a shared policy layer by making deployment scope reviewable. A longer list of discovered platforms would provide less evidence. Discovery breadth and enforceable action coverage answer different questions.
The second signal is production evidence about legitimate work and inappropriate operations. Useful reporting would explain which workflows ran, what policies governed them, and how teams distinguished helpful intervention from unnecessary interruption.
This does not require publishing confidential customer data. A documented evaluation can describe the task, expected outcome, actual outcome, and relevant integration. That structure lets readers assess a claim without relying on a broad statement that security improved.
Evidence of successful workflow completion would strengthen the operational case. Reports of frequent unexplained interruptions or routine exceptions would weaken it. The point is to assess whether enforcement remains useful after the initial demonstration.
The third signal is transparent testing of failures and alternate paths. Evaluations should examine missing context, unavailable services, changed operations, and requests that avoid the intended connection. These conditions reveal how a control behaves when its assumptions stop holding.
Clear results would strengthen confidence in the architecture’s boundaries. Unresolved ambiguity would narrow the conclusions buyers can draw. A system can still provide value within a defined scope, but that scope needs to remain visible.
Together, these signals keep the discussion tied to the announcement’s actual promise. Central policies are useful when they govern the operations an enterprise cares about. Consistency matters only alongside sufficient context and dependable enforcement.
For teams considering the expansion, start with a consequential workflow and ask which decisions require business context. Establish the permitted task, the prohibited operation, and the evidence that distinguishes them. Then examine whether the relevant execution path supports that distinction. Compare the result with existing application permissions and native agent boundaries. Ask how missing information, changed requests, and service interruptions affect the outcome. Obsidian runtime policy enforcement offers a specific approach to this problem, but its value depends on the connected deployment. Use the next product documentation and operational evidence to assess that fit. Which sensitive agent action can your organization currently observe, yet still cannot reliably stop before execution?



