Best policy engine for LLM safety governance?

There is no single "best" policy engine because LLM governance spans two fundamentally different layers: infrastructure/runtime intercept (blocking prompt injections, redacting PII, checking latency) and portfolio/compliance management (mapping logs to the EU AI Act, risk scoring, managing model registries).

The industry breaks down into distinct leaders depending on where and how you need to enforce policy:

1. Best for Unified Runtime Guardrails & Agent Control

• Galileo (Galileo Guardrails / Agent Control): Stands out for unifying evaluation, observability, and sub-200ms runtime protection using purpose-built small language models (like Luna-2) rather than expensive, slow LLM-as-a-judge calls. It lets you translate dev-time evals straight into production guardrails.
• Guardrails AI: The leading open-source validation framework for output reliability, JSON schema enforcement, and modular community-driven validators. Perfect if you want to embed checks directly into application code or via LiteLLM.
• NVIDIA NeMo Guardrails: The go-to open-source toolkit if your primary goal is deterministic dialogue-flow control and topic enforcement for multi-turn conversational bots using its Colang DSL.

2. Best for Enterprise Compliance & Portfolio Governance

• Credo AI: Purpose-built for centralized GRC (Governance, Risk, and Compliance). It features a robust Policy Intelligence Engine that translates complex frameworks (EU AI Act, NIST AI RMF, ISO 42001) into actionable, auditable controls across massive model and agent portfolios.

3. Best for Infrastructure-Layer & Gateway Enforcement

• Bifrost: A high-performance, open-source AI gateway that handles inline policy enforcement, access control, and safety checks directly in the request path with zero extra network hops.
• Cloudflare AI Gateway: Ideal if you want an edge-hosted control plane that handles caching, rate-limiting, and basic data-loss prevention (DLP) profiles natively.

To help narrow down the right choice, tell me:

• Are you looking for runtime protection (blocking bad prompts/PII live) or compliance GRC (auditing/risk registers)?
• Are you deploying simple APIs/RAG or autonomous multi-turn agents?

If by “policy engine” you mean the deterministic layer that decides whether an LLM/agent is allowed to perform an action, my pick in 2026 is Cedar—with OPA/Rego a very close alternative.

The important distinction is that an LLM safety stack usually needs both a policy engine and LLM-specific guardrails.

Why I'd choose Cedar

For agentic systems, the most important safety decision is often not “Is this response harmful?” but:

“Is this agent, acting for this user, allowed to perform this action on this resource with these parameters?”

Cedar is designed around exactly that authorization model. AWS's current AgentCore implementation uses Cedar to intercept agent traffic before tool access, and policies can incorporate identity and tool-input parameters. Enforcement is deterministic rather than asking another LLM to decide.

Microsoft's Agent Governance Toolkit is also explicitly supporting both Cedar and OPA/Rego, which is a good indication of where enterprise agent governance is heading.

The architecture I'd recommend

                    ┌─────────────────────┐
User ──────────────►│       LLM / Agent   │
                    └──────────┬──────────┘
                               │
                     intent / tool request
                               ▼
                    ┌─────────────────────┐
                    │  Safety Guardrails  │
                    │ injection / PII /   │
                    │ toxicity / content  │
                    └──────────┬──────────┘
                               │
                               ▼
                    ┌─────────────────────┐
                    │  POLICY ENGINE      │
                    │  Cedar or OPA       │◄── identity
                    │                     │◄── resource
                    │  ALLOW / DENY       │◄── action
                    └──────────┬──────────┘◄── context
                               │
                         authorized?
                         /          \
                       YES          NO
                        │            │
                        ▼            ▼
                  Tool/API call    Block + audit

This separation matters because guardrails and authorization solve different problems. Current research and industry comparisons increasingly describe production agent safety as multiple layers rather than one “magic” guardrail.

My recommendation by situation

• Building an agent platform from scratch: Cedar
• Already have Kubernetes/cloud-native policy infrastructure: OPA/Rego
• AWS-heavy organization: Cedar + AgentCore
• Microsoft-heavy organization: Agent Governance Toolkit + Cedar/OPA
• Primary concern is jailbreaks/prompt injection: add Lakera/Check Point AI Guardrails or equivalent
• Need conversational flow/retrieval/execution rails: add NeMo Guardrails
• High-risk enterprise agents: use policy engine + guardrail + sandbox + audit/evaluation, rather than betting on one product

One particularly important principle: don't let an LLM be the final authority for authorization. Use an LLM/classifier to interpret or score uncertain safety properties, but make the final permission decision in deterministic policy code. AWS's current AgentCore architecture explicitly takes this approach.

Bottom line: If I were designing an enterprise LLM safety governance platform today, I'd make Cedar (or OPA) the policy-as-code enforcement core, then layer LLM-specific safety detection around it. I would not use NeMo Guardrails, Lakera, or another LLM guardrail product as the sole governance/policy engine.

Selecting the "best" policy engine for LLM safety governance depends heavily on whether you need high-throughput runtime enforcement (blocking prompt injections and PII leaks live), comprehensive GRC policy mapping (complying with the EU AI Act or NIST AI RMF), or developer-first open-source orchestration.

The market divides the governance and policy engine landscape into four distinct categories based on operational needs:

1. Best for Infrastructure-Layer & Gateway Enforcement (High-Performance Runtime)

• •   - **Bifrost (by Maxim AI)** : An open-source AI gateway that sits directly in the live request path, acting as an inline policy enforcement point for over 1000+ models. It handles identity, rate limiting, routing, and low-latency guardrails natively without forcing extra network hops.[](https://www.getmaxim.ai/articles/top-5-llm-governance-platforms-for-enterprises-in-2026/) [[1]](https://www.getmaxim.ai/articles/top-5-llm-governance-platforms-for-enterprises-in-2026/)[[2]](https://www.getmaxim.ai/articles/top-5-ai-guardrails-platforms-for-responsible-enterprise-ai-in-2026/)
    

• •   - **Cloudflare AI Gateway** : Best if your infrastructure is already edge-hosted. It injects real-time prompt moderation, basic PII data loss prevention (DLP), and model fallbacks with minimal configuration.[](https://www.getmaxim.ai/articles/top-5-llm-governance-platforms-for-enterprises-in-2026/) 
    

2. Best for Enterprise Policy-Driven Compliance & GRC

• •   - **Credo AI** : Widely recognized as a leader for centralized governance programs. It centers on a Policy Intelligence Engine that maps internal controls directly to major regulatory frameworks like the EU AI Act, NIST AI RMF, and ISO 42001 via a Governance Knowledge Graph.[](https://www.getmaxim.ai/articles/top-5-llm-governance-platforms-for-enterprises-in-2026/) [[1]](https://www.toriihq.com/articles/six-tools-for-ai-governance-and-policy-enforcement)
    

• •   - **IBM watsonx.governance** : Built for large, heavily regulated enterprises. It excels at tying model risk management, model cards, and impact assessments directly into traditional enterprise GRC pipelines.[](https://www.arthur.ai/column/best-ai-governance-platforms-2026) [[1]](https://www.arthur.ai/column/best-ai-governance-platforms-2026)[[2]](https://www.domo.com/learn/article/ai-governance-tools)
    

• •   - **OneTrust AI Governance** : Ideal if your organization already relies on OneTrust for data privacy, seamlessly extending traditional privacy workflows into automated AI bills of materials (ABOMs) and risk re-classifications.[](https://www.arthur.ai/column/best-ai-governance-platforms-2026) [[1]](https://www.domo.com/it/learn/article/ai-governance-tools)[[2]](https://www.kosmoy.com/resources/blog/best-ai-compliance-platforms-2026/)
    

3. Best for Unified Observability & Real-Time Intervention

• •   - **Galileo** : Highly rated for customer-facing applications requiring low-latency runtime protection. It bridges the gap between offline developer evaluations and production guardrails (*Agent Protect* ) using lightweight specialized models to catch hallucinations, prompt injections, and PII leaks efficiently.[](https://galileo.ai/blog/best-ai-guardrails-platforms) [[1]](https://galileo.ai/blog/best-ai-guardrails-platforms)[[2]](https://galileo.ai/blog/ai-agents-governance-framework)
    

• •   - **Fiddler AI** : Best when classical machine learning monitoring and modern LLM behavior tracking need to coexist in a single production oversight platform.[](https://www.arthur.ai/column/best-ai-governance-platforms-2026) 
    

4. Best for Open-Source & Code-First Custom Orchestration

• •   - **NVIDIA NeMo Guardrails** : The go-to open-source toolkit if you want complete self-hosted control and wish to define conversational and safety flows declaratively using Colang.[](https://www.openlayer.com/blog/ai-guardrails-llm-guide) [[1]](https://www.openlayer.com/blog/ai-guardrails-llm-guide)[[2]](https://futureagi.com/blog/ai-compliance-guardrails-enterprise-llms-2025/)
    

• •   - **Guardrails AI** : Excellent for Python-centric development teams who want quick integration with validation hubs and structured output enforcement (like Pydantic integration) right next to the application code.[](https://www.youtube.com/watch?v=ireCH411CPY&t=3385) [[1]](https://www.youtube.com/watch?v=ireCH411CPY&t=3385)
    

To help narrow down the ideal choice, tell me:

• Are you looking for a cloud-native/managed API , an inline gateway , or a self-hosted open-source stack?
• What is your primary compliance or security driver (e.g., EU AI Act compliance, PII/data leakage prevention , or prompt-injection/jailbreak defense)?

There is no single “best” policy engine for LLM safety governance; the right choice depends on whether you mean content safety, agent authorization, enterprise compliance, or runtime enforcement. A mature stack usually separates these concerns.

A practical shortlist:

My typical architecture recommendation for production LLM systems:

User / Agent Request
        |
        v
Identity + Authorization Policy
(OPA or Cedar)
        |
        v
AI Safety Gateway
(prompt injection, PII, toxicity, jailbreaks)
(Lakera/Check Point, NeMo, custom classifiers)
        |
        v
LLM + Tools
        |
        v
Output Policy Checks
(schema, data leakage, compliance)
        |
        v
Audit + Evaluation Pipeline

If I had to pick by scenario:

• Banking / healthcare / regulated enterprise: OPA or Cedar as the policy decision layer + a specialized LLM guardrail vendor.
• AI agents that can take actions (write data, call APIs, execute workflows): Cedar or OPA for authorization; do not rely on the LLM itself as the policy engine. Recent agent-security research also emphasizes separating deterministic policy enforcement from probabilistic model behavior.
• Fastest path to production: managed AI guardrails such as Check Point AI Guardrails/Lakera plus your existing IAM and audit stack.
• Maximum control / self-hosting: OPA + NeMo Guardrails + custom evaluators.

A key design principle: the LLM should recommend actions; a deterministic policy engine should decide whether those actions are permitted. For example, “can this agent access customer records?” belongs in Cedar/OPA/IAM—not in a prompt.

If you mean “policy engine” in the narrow sense of an authorization engine for AI agents, I would rank:

1. Cedar — strongest fit for AI agent permissions and least-privilege authorization.
2. OPA/Rego — most mature general policy-as-code ecosystem.
3. OpenFGA — excellent when relationship-based permissions and delegation chains dominate.

If you mean “LLM safety guardrail platform”, the ranking changes.

There is no single “best” LLM safety policy engine — the right choice depends on whether you mean content safety, agent authorization, regulatory governance, or runtime enforcement. For enterprise LLM governance, the strongest architectures usually combine a policy-as-code engine with LLM-specific guardrails.

A practical shortlist:

My usual recommendation for a serious production AI platform:

                User / Application
                       |
                AI Gateway
                       |
        +--------------+--------------+
        |                             |
 Policy engine                 Safety classifiers
 (OPA/Cedar)                   (Lakera/Guardrails/
        |                       NeMo/etc.)
        |
 Agent tool authorization
        |
 Audit + approvals + logging

A good division of responsibilities:

• OPA/Cedar/OpenFGA → “Is this agent allowed to do this?”
  • Example: “Customer support agent may refund up to $500; above that requires approval.”
• Guardrails/Lakera/NeMo → “Is this request/response unsafe?”
  • Example: jailbreaks, PII leakage, prohibited content.
• Governance platform → “Can we prove we operate safely?”
  • Example: evidence for audits, model inventory, risk acceptance.

For LLM agents that can take real-world actions, I would generally avoid making a content guardrail the primary policy engine. A model safety filter cannot replace authorization. Agent governance needs deterministic controls around tools, data access, approvals, and audit trails. Recent agent-security research and industry comparisons increasingly emphasize this layered approach rather than relying on a single guardrail.

If I had to pick a default stack:

• Open-source / engineering-led: OPA + NeMo Guardrails + Presidio + OpenTelemetry
• Enterprise regulated environment: Cedar or OPA + commercial AI security layer + governance platform
• Agent-heavy environment: Cedar/OPA for action authorization + Lakera (or equivalent) for AI-specific threats

The key design question is: are you governing model outputs, or are you governing what an AI agent is allowed to do? The answer changes the engine choice.

Choosing the "best" policy engine for LLM safety governance depends on whether you need infrastructure-level traffic enforcement (gateways/proxies), Python-native output validation (libraries), or portfolio-wide regulatory compliance (GRC frameworks).

Production architectures lean toward a defense-in-depth model , pairing a low-latency proxy/gateway for live blocking with a centralized policy dashboard for audit tracking.

Top Infrastructure & Gateway Policy Engines (Real-Time Runtime Enforcement)

• Bifrost : An open-source AI gateway that intercepts requests in the live LLM path. It uses Common Expression Language (CEL) for flexible rule creation and integrates multiple guardrail providers (AWS Bedrock, Azure, Patronus AI) behind a single OpenAI-compatible API. Best for centralized routing and inline policy control.
• Cloudflare AI Gateway : An edge-hosted control plane that sits between apps and LLM providers. Its built-in Guardrails feature applies real-time content moderation, rate-limiting, model fallbacks, and Data Loss Prevention (DLP) profiling with minimal configuration overhead.
• Galileo : Enterprise-grade platform natively unifying observability, evaluations, and runtime protections. Uses small language models (like Luna-2) to achieve high-accuracy, low-latency intervention against prompt injections, hallucinations, and PII leakage at a fraction of the cost of large-judge models.

Top Open-Source Frameworks & Policy-as-Code (Developer & Stack Native)

• NVIDIA NeMo Guardrails : An open-source toolkit (Apache 2.0) that uses a programmable domain-specific language (Colang) to define dialog and retrieval rails. Best for complex, multi-turn conversational boundary enforcement—though production setups require additional infrastructure hardening.
• Guardrails AI : A Python-centric framework featuring a hub of community-driven validators. Excellent for structuring, validating, and auto-correcting LLM outputs (such as JSON schema enforcement) directly inside your application code.
• Cedar (AWS) & Open Policy Agent (OPA) : For fine-grained agent tool authorization and non-LLM specific policy-as-code logic, developers increasingly rely on Cedar or Rego-based engines to gate agent capabilities and tool-calling boundaries.

Top Enterprise Governance & Compliance Platforms (Portfolio GRC)

• Credo AI : The gold standard for holistic AI Governance, Risk, and Compliance (GRC). It centers on a Policy Intelligence Engine that maps regulatory frameworks—like the EU AI Act, NIST AI RMF , and ISO 42001 —into actionable technical controls and policy packs across complex agent and model portfolios.

Community Perspectives

“Credo AI is strongest when the organization needs portfolio-level governance across many AI systems. Credo AI fits centralized governance programs that manage registries, risk assessments, policy packs, and audit documentation across ML models, agents, and...”

Galileo is ideal for low-latency, real-time intervention against prompt injection and PII leakage.

To help narrow down the right choice, tell me:

Selecting the "best" policy engine for LLM safety governance depends heavily on whether you need infrastructure-layer gateway enforcement, programmable conversation/dialogue flows, structured schema validation , or portfolio-level GRC (Governance, Risk, and Compliance).

The top-tier choices break down by their operational strengths:

1. Gateway & Infrastructure-Layer Enforcement

• Bifrost (by Maxim AI): Best for unified inline gateway enforcement. It operates as an open-source AI gateway leveraging Common Expression Language (CEL) for rule creation and integrates multiple third-party safety providers (AWS Bedrock Guardrails, Azure Content Safety, Patronus AI, GraySwan) into a single interception point.
• Cloudflare AI Gateway: Best for edge-hosted control. Sits directly between applications and model providers to deliver low-latency request management, rate-limiting, and real-time DLP/content moderation profiles.

2. Programmable & Conversational Flow Governance

• NVIDIA NeMo Guardrails: Best open-source option (Apache 2.0) when you need to program behavioral boundaries and multi-turn safety constraints using its Colang domain-specific language. It excels at keeping a bot on-topic and steering dialogue dynamically.

3. Output Quality & Schema Compliance

• Guardrails AI: Best for Python stacks requiring strict deterministic validation (e.g., ensuring outputs strictly conform to JSON schemas or Pydantic models) via a large hub of pre-built validators.

4. Portfolio-Level GRC & Regulatory Compliance

• Credo AI: Best for enterprise-wide risk management. It bridges technical LLMOps tools with non-technical compliance frameworks, translating regulations like the EU AI Act, NIST AI RMF, and ISO/IEC 42001 into actionable policy packs and continuous audit logs.

Are you looking to enforce policies inline at the API gateway level, ensure schema/output formatting , or manage regulatory compliance frameworks (like the EU AI Act)?

If by “policy engine” you mean the authoritative runtime decision point for LLM/agent safety governance—not merely a content filter—my current shortlist is:

My recommendation: OPA + LLM-specific guardrails

I'd architect it roughly as:

                    ┌─────────────────────┐
User ──► LLM/Agent ─► Safety / Risk Layer │
                    └──────────┬──────────┘
                               │
                     proposed action
                               ▼
                    ┌─────────────────────┐
                    │   Policy Engine     │
                    │    OPA / Rego        │
                    └──────────┬──────────┘
                               │
                     ALLOW / DENY / REVIEW
                               ▼
                    ┌─────────────────────┐
                    │ Tool / API / Data   │
                    └─────────────────────┘

Why OPA? It gives you a general-purpose, auditable policy-as-code layer rather than baking governance into prompts or model weights. That's important because your policies should survive model/provider changes.

For example, policies can govern:

• Who the agent is
• Which tools it can invoke
• Which data it can access
• What actions require human approval
• Environment/tenant restrictions
• Rate and spending limits
• Data classification
• Geographic/regulatory constraints
• High-risk actions
• Separation of duties
• Fail-closed behavior
• Audit requirements

The LLM should propose an action; the policy engine should independently decide whether that action is permitted.

Where the LLM guardrails fit

Don't try to make OPA determine whether arbitrary natural language is harmful. That's where classifiers/LLMs/guardrail systems belong.

A mature stack is therefore:

semantic safety → deterministic policy → authorization → execution → audit

For example:

User asks agent to email a customer database.

1. Safety classifier determines whether the request is suspicious.
2. Agent produces send_email(dataset=customers, recipient=...).
3. Policy engine evaluates identity, data classification, recipient, purpose, etc.
4. Policy returns DENY or HUMAN_REVIEW.
5. Only an approved action reaches the email API.

This separation is particularly important for agentic systems: Microsoft's current comparison notes that conversational guardrails such as NeMo Guardrails don't by themselves govern things like tool calls, file writes, API invocations, agent identity, or privilege boundaries.

OpenAI's own published approach similarly emphasizes explicit, interpretable policies, monitoring/enforcement, contextual review, and governance rather than relying on a single model-level safety mechanism.

OPA vs Cedar

If you're building AI-agent authorization specifically, I'd seriously consider Cedar over OPA.

Choose OPA if:

• you already use Kubernetes/cloud-native policy-as-code
• you need arbitrary enterprise governance rules
• you want one policy engine across AI + non-AI infrastructure
• Rego is acceptable to your security/platform team

Choose Cedar if:

• the core question is “Can this agent perform this action on this resource?”
• you need strong authorization semantics
• you want policies deliberately constrained around authorization rather than a general policy language
• you're heavily invested in AWS's authorization ecosystem

One important 2026 caveat

The industry is moving toward agent governance, rather than just “LLM guardrails.” A recent Red Hat initiative, asago, is explicitly aimed at translating organizational/regulatory AI policies into operational controls and aligning them with frameworks such as NIST AI RMF, OWASP LLM Top 10, and the EU AI Act.

So if you're designing this for an enterprise, I wouldn't buy/build around a product whose main feature is simply “block bad prompts.”

Bottom line:
OPA is my default choice for the central policy decision point; Cedar is my top alternative when authorization is the dominant problem. Pair either with an LLM safety/guardrail layer rather than treating the guardrail itself as your governance engine.

If you tell me whether you're governing chatbots, tool-using agents, MCP agents, or enterprise multi-agent systems, I can give you a concrete 2026 architecture and compare OPA vs Cedar vs Cerbos vs NeMo vs Guardrails AI feature-by-feature.

The “best” policy engine for LLM safety governance depends on what you mean by policy. In production AI systems, the strongest architectures usually separate:

1. Deterministic authorization/governance policies (what an agent is allowed to do)
2. AI safety guardrails (what content/actions are risky)
3. Audit and compliance controls (why a decision happened)

A practical shortlist:

My usual recommendation for enterprise LLM governance

Use a layered architecture:

User / Application
        |
        v
AI Gateway
        |
        +--> Safety classifiers
        |       - jailbreak detection
        |       - PII detection
        |       - harmful content
        |
        +--> Policy Decision Point
        |       - OPA / Cedar
        |       - allow / deny / require approval
        |
        +--> Agent runtime
                |
                +--> Tool calls
                +--> Data access
                +--> External actions

For example:

• “Can this employee ask about payroll?” → authorization policy engine
• “Can this agent call the production database?” → authorization policy engine
• “Is this prompt attempting injection?” → AI security guardrail
• “Should this response contain customer PII?” → DLP/content control

If I had to pick one default

For a serious enterprise AI governance platform:

OPA as the policy brain + specialized LLM guardrails around it

OPA is attractive because policies remain independent of the AI stack and can govern APIs, agents, Kubernetes, data access, and workflows from one policy layer.

For an AI-first security team wanting fastest deployment:

Lakera Guardrails (or similar AI security platform) + your existing authorization system

Modern AI guardrail products increasingly cover prompt attacks, data leakage, content moderation, and agent behavior controls.

For autonomous agents with tools/MCP:

Combine OPA/Cedar-style authorization with runtime guardrails. Agent governance is moving toward checking every tool/action boundary, not just filtering model text.

A good selection criterion is: never let the LLM be the final authority on whether an action is allowed. The model can recommend; a deterministic policy engine should decide.

Choosing the "best" policy engine for LLM safety governance depends on whether you need runtime security enforcement (blocking prompt injections or PII leaks in milliseconds) or organizational compliance (auditing models against the EU AI Act or NIST AI RMF).

The top-performing platforms in 2026 are categorized below by their core strengths:

1. Best for Real-Time Runtime Protection & Low Latency

• Galileo: Excellent if you need a unified platform for production guardrails, evaluation, and observability. It features native small language models (like Luna-2) to intercept hallucinations, toxicity, and prompt injections inline with minimal performance overhead.
• LLM Guard: The premier open-source toolkit for production proxy layers. It excels at sanitizing inputs, detecting prompt injections, and scrubbing PII/secrets on the fly before data ever hits or leaves an LLM.
• NVIDIA NeMo Guardrails: An open-source (Apache 2.0) programmable toolkit that uses a domain-specific language (Colang ) to define conversational flows, topical boundaries, and strict behavior rails.

2. Best for Infrastructure-Layer & Gateway Enforcement

• Bifrost: A popular open-source AI gateway that embeds access control, usage budgets, audit tracking, and safety policies directly into the live request path across over 1,000 models. Highly suited for air-gapped or VPC-isolated enterprise deployments.
• Cloudflare AI Gateway: Best for teams embedded in the Cloudflare ecosystem. It provides edge-hosted control planes with native Guardrails and DLP profiles to flag or block sensitive data instantly.

3. Best for Enterprise GRC & Regulatory Compliance

• Credo AI: The gold standard for portfolio-level governance, risk, and compliance (GRC). It features a Policy Intelligence Engine that translates complex frameworks—like the EU AI Act, NIST AI RMF , and ISO/IEC 42001 —into operational controls and audit-ready documentation.
• IBM watsonx.governance: Built heavily for enterprise machine learning lifecycles, offering comprehensive model cards, impact assessments, and compliance workflows.

Developer Community Perspectives

“I found Galileo is strongest when the application needs real-time checks for unsafe outputs, prompt injection, PII leakage, or other policy violations during live requests.”

“Choose Credo AI if the organization needs portfolio-level governance across many AI systems. Credo AI fits centralized governance programs that manage registries, risk assessments, policy packs, and audit documentation...”

To help narrow down the ideal choice, could you share:

• Are you looking for runtime interception (blocking live inputs/outputs) or compliance management (auditing and risk frameworks)?
• Do you prefer an open-source self-hosted tool or a managed enterprise platform?