
PlainID is a Runtime Authorization Platform built for the AI era. Built on Policy-Based Access Control (PBAC), PlainID takes authorization logic out of individual applications and hardcoded scripts, defining it once as central policy and enforcing it dynamically at runtime wherever access happens—across applications, APIs, microservices, data platforms, and agentic AI workflows. Founded in 2014 by Oren Ohayon Harel (CEO) and Gal Helemski (Co-Founder & CPO), PlainID enables organizations to Go Beyond Who Gets In™ by shifting security from front-door authentication to continuous, intent-aware runtime authorization.
At A Glance
| Vendor | PlainID, founded 2014, Tel Aviv and New York |
|---|---|
| Category | Enterprise Runtime Authorization Platform/ Policy-Based Access Control (PBAC) |
| Identities covered | Human users (workforce, customer, B2B), non-human identities (services, workloads, APIs), and autonomous AI agents |
| Deployment | SaaS control plane; decision points in PlainID Cloud or customer-hosted on Kubernetes, as a standalone service, or on Amazon ECS |
| Policy as code | Structured Rego import and export via Management APIs, GitOps workflows, and CI/CD automation |
| Agentic AI | MCP Gateway, RAG and output guardrails, agent discovery for AWS Bedrock AgentCore and Microsoft Foundry |
| Analyst recognition | Overall Leader, KuppingerCole Leadership Compass: Policy Based Access Management (2025), Gartner 2026 Hype Cycles (Digital Identity, APIs) and Representative Vendor in Market Guide for Guardian Agents |
What The Platform Does
Most enterprises manage authentication centrally through an identity provider, but leave authorization embedded inside each application as hard-coded roles and entitlements. PlainID centralises that authorization layer into a single control plane while distributing enforcement across the tech stack. The platform operates around an end-to-end Discover → Manage → Enforce lifecycle:
Discover
The Discover stage builds the context needed to write policy. It identifies and enriches identities, AI agents, resources, MCP servers, tools, APIs and data sources, and maps the access relationships between them. It can also discover authorization policies that already exist inside connected platforms, and adds ownership, purpose, sensitivity and risk context to what it finds. The platform surfaces both direct and indirect access paths.
Manage
The Manage stage is where policy is written and governed. Business and security teams can author policies in a visual interface, while developers can work with policy as code. Governance features include:
- Versioning, approvals and controlled promotion between environments such as staging and production
- A policy simulator for testing and impact analysis before changes go live
- Certification campaigns, audit reporting and business-readable explanations of decisions
- Delegated administration with separation of duties
- Policy360, a connected view of every policy, its dependencies and its change history
Enforce
The Enforce stage evaluates each request against policy using identity, resource, action, business, environmental and risk context. Decisions go beyond a simple permit or deny. Depending on the integration, PlainID can return allowed operations or entitlements, row and document filters, column and response masking, token claims and scopes, permitted tools for an AI agent, constraints on tool parameters, and obligations such as approval or step-up authentication.
How The Architecture Works
PlainID separates where policy is managed from where decisions are made, so that authorization can run close to the systems it protects.
Control plane. PlainID Cloud is a SaaS console organised into Tenants, Environments, Scopes and Workspaces. Separate workspaces handle identities, authorization policies and integrations.
Decision plane. Every tenant includes a cloud-hosted Policy Decision Point (PDP). Organisations that need lower latency or want sensitive attribute data to stay inside their network can deploy Policy Authorization Agents (PAAs) in their own environment. A PAA bundles four components:
- A Hybrid Agent that communicates with PlainID Cloud
- A Policy Information Point (PIP) that retrieves attributes from local data sources such as JDBC databases, LDAP, Microsoft Entra ID, REST services, Azure Cosmos DB, MongoDB and Google BigQuery
- A Policy Decision Point (PDP) that returns runtime decisions to applications and services
- A Redis cache for local caching; PlainID recommends a managed Redis service in production and does not currently support Redis Cluster Mode
In a typical request, an application asks its local PDP for a decision, the PDP fetches any missing attributes from the local PIP, and the decision is returned without data leaving the customer’s network. PlainID recommends one PAA per environment. PAAs deploy through a standard Helm chart, as a standalone binary, or on Amazon ECS, and PlainID’s container images are signed and verifiable with Cosign. Credentials for PlainID’s own connections can be pulled from HashiCorp, AWS Secrets Manager, Azure Key Vault or CyberArk CCP.
Enforcement plane. Pre-built Authorizers and integration patterns extend centrally governed policy across the technical stack. Applications can externalize decisions to local PDPs (Model 1) or leverage Policy Orchestration (Model 2) to translate and synchronize policies natively into systems with embedded access controls (e.g., Snowflake, Databricks, BigQuery) with zero code rewrites.
Agentic edge. PlainID Edge is a customer-deployed component that connects to MCP servers and vector databases, discovering AI tools and data sources and enforcing policy on agent activity.
Where Policies Are Enforced
PlainID’s integrations follow five enforcement patterns.
| Pattern | How it works | Documented integrations |
|---|---|---|
| Token enrichment | The identity provider calls PlainID at sign-in and embeds policy-based claims in the token or SAML assertion. Claims apply for the lifetime of the token. | Okta, Ping, Microsoft Entra ID, Auth0, Thales, Cisco Duo (Alpha) |
| API access | A gateway or service mesh asks the PDP for a decision on every request. | Envoy, Istio, Kong, Apigee, Amazon API Gateway, Azure API Management |
| Data access | Row filters, column filters and masking are applied to queries and responses. | Denodo, Trino, SQL Database Authorizer, JSON Filtering Authorizer |
| Native policy orchestration | PlainID translates its policies into a platform’s own access controls and can discover existing native policies. | Snowflake, Databricks, Google BigQuery, Microsoft Power BI, Zscaler Private Access |
| Agentic AI authorization | Framework integrations and the MCP Gateway enforce policy on prompts, data retrieval, tool calls and outputs. | LangChain, LangGraph, MCP Gateway, AWS Bedrock AgentCore, Microsoft Foundry |
The Policy Model
PlainID policies answer three questions:
- Who is defined by Dynamic Groups, which are rules over identity attributes, such as all external customers with Gold membership, or all agents owned by the finance team.
- What is defined by Rulesets over asset types and their attributes, combined with permitted actions, such as bank accounts where the owner matches the requesting user, with View and Manage actions.
- When is defined by Conditions based on IP range, identity attributes, request attributes such as authentication method, or platform-specific signals such as a Zscaler device posture profile.
Each policy is either Allow or Deny. For policy-as-code workflows, PlainID supports Structured Rego, a structured form of the Rego language used by Open Policy Agent. Policies can be exported to Structured Rego and imported back through the Management APIs, and exports use a consistent ordering so that changes produce small, reviewable diffs in Git. Structured Rego follows PlainID’s schema: each policy carries a PlainID metadata block, expressions compare attributes with values or with other attributes, and time-based conditions are managed in the console rather than in code.
Agentic AI Capabilities
PlainID treats AI agents as identities in the same policy framework as people and services. Agents are registered in the Identities Workspace with their own attributes, grouped with Dynamic Groups, and governed by the same central policies. The platform applies controls at five points in an agent’s flow:
| Input guardrail | Blocks unauthorised queries based on the identity and agent context |
|---|---|
| Data retrieval guardrail | Applies policy filters before data is retrieved, so unauthorised content never reaches the model in RAG pipelines |
| MCP tools guardrail | Controls which MCP servers, tools and tool parameters an agent can use |
| Output guardrail | Masks and filters responses to prevent sensitive data exposure |
| Action & API execution guardrail | Authorizes every downstream microservice, API call, or external action initiated by the agent using runtime-enriched identity and asset context. |
To prevent “agent superpowers”, PlainID enforces Cross-Identity Authorization (Composed Identity), evaluating the human user, the autonomous agent, the service, and the target asset together in a single authorization decision chain. By binding human user claims to agent identities, PlainID provides on-behalf-of accountability and purpose-bound access.
MCP Gateway
The MCP Gateway, part of PlainID Edge, sits between AI agents and an organisation’s MCP servers. Agents connect to a single MCP endpoint instead of to many servers. The gateway automatically discovers connected MCP servers and their tools, uses AI-based classifiers to label each tool by purpose, sensitivity, category and risk, and publishes them to PlainID Cloud as building blocks for policy. It monitors continuously for new, changed or removed servers and tools. On every tool call, the gateway extracts the identity, context, tool and parameters, requests a decision, and either forwards or blocks the call, without changes to existing agents or MCP servers.
Agent Discovery And Framework Support
PlainID connects to AWS Bedrock AgentCore and Microsoft Foundry to discover and register agents, their gateways and their connected targets, using read-only permissions. Agents can also be registered manually. For teams building their own agents, PlainID provides authorizers for LangChain and LangGraph.
AI-Assisted Administration
PlainID offers Daia, an assistant that guides policy creation for agentic AI, and the PlainID MCP Server, which lets administrators query their tenant and author policies in natural language from an MCP-capable client. The MCP Server authenticates each user through OAuth and limits every action to that user’s existing permissions. It is available in US and EU regions, with UK tenants served from the EU region.
Availability
PlainID’s agentic AI capabilities are offered through an Early Access programme that includes a pre-configured demo environment and a working environment for testing. MCP Control is labelled Beta on PlainID’s website. In July 2026, PlainID and Cisco Duo announced Inline Hooks that let Duo call PlainID during sign-in to add policy-based claims to tokens and SAML assertions; this integration is in Alpha with design partners.
Use Cases And Industries
PlainID publishes specialized solution blueprints across workforce, customer, and B2B access control; data access control and data privacy compliance; Zero Trust architecture; and securing AI agents, RAG pipelines, and MCP tools.
| Financial Services | Governs Material Non-Public Information (MNPI), retail banking delegated access, and third-party supplier access. |
|---|---|
| Pharmaceuticals & Healthcare | Protects research data, clinical trial records, and PHI (HIPAA compliance). |
| Enterprise Success & Proven Customers | Trusted by Fortune 500 enterprises and Global 2000 leaders, including Cisco, Citibank, Samsung, Bank Leumi, The World Bank, Dominion Energy, Bayer, Wells Fargo, Boeing, Accenture, and EY. |