Skip to content

Platform

One governance layer for every agent you run.

QuadRails defines guardrails once, enforces them on every agent at runtime, observes every decision through OXP and retires controls when the evidence says they no longer work.

guardrail.yamlValidating…
guardrail:
  id: GR-TC-001
  name: "Restricted tool enforcement"
  category: tool-calling
  trigger:
    event: tool_call_requested
    condition: "tool_name IN restricted_tools"
  enforcement:
    mode: BLOCK   # BLOCK | MODIFY | ESCALATE | LOG
    escalation_target: security-team
  thresholds:
    max_calls_per_minute: 30
    circuit_breaker: 3
  scope:
    applies_to_rings: [2, 3]
  meta:
    owner: platform-governance
    approved_by: security-lead

Four pillars

Each rail has an owner, a test and a reason to change.

Guardrails fail quietly when nobody owns them. Every QuadRails control belongs to a pillar, is tested on a schedule and has a written condition for when it changes or retires.

Security & Policies

Owned by platform governance and security engineering.

  • Deterministic rules agents can't override
  • QASA authorizes every tool call; trust scores and execution rings
  • Tested with red-team prompts, spoofed agents and rogue policies
  • Changed when false positives pass 15%

Evals

Owned by the AI evaluation team.

  • Golden sets, release gates and drift detection
  • Groundedness, consistency and hallucination scoring
  • Judge models tested against human labels
  • Re-run when a model, prompt or tool changes

Cost

Owned by FinOps.

  • Budgets by enterprise, team, app and agent
  • Reserve before the call, reconcile after
  • Tested with loops and retry storms
  • Changed when guardrail cost exceeds the risk it blocks

Performance

Owned by platform and SRE.

  • Latency budgets per risk tier
  • Deterministic path first, async judging for low risk
  • Tested with load runs and p95 latency
  • Optimized when a check passes 200 ms

OXP holds it all up.

The Observability and Explainability Platform records every action and verdict, so each pillar's test runs on evidence instead of opinion.

Trigger rateBlock rateFalse-positive rateLatency overheadCost per taskSession health

Guardrail categories

Seven places a guardrail can fire.

Rule-based guardrails are fast and predictable. Semantic guardrails use a model to catch meaning that rules miss. A model judge can tighten a decision but never loosen a rule.

Input

Semantic

Prompt injection, jailbreaks, toxicity and out-of-scope requests.

Before the prompt reaches any agent

BLOCK · REWRITE · WARN · LOG

Output

Semantic

PII masking, hallucination checks, schema and confidentiality.

After the response, before delivery

BLOCK · REDACT · REPHRASE · LOG

Retrieval

Semantic

Source validation, document permissions, groundedness and poisoning.

On every knowledge-base query and result

BLOCK · FILTER · REDACT · LOG

Tool-calling

Rule-based

Tool allow-lists, argument limits, restricted tools and rate limits.

Between the tool decision and execution

BLOCK · MODIFY · ESCALATE · LOG

Execution

Rule-based

Resource quotas, sandboxing, timeouts, write controls and an off switch.

Continuously while the agent runs

HALT · THROTTLE · SANDBOX · ALERT

Planning

Rule-based

Goal alignment, step-level checks, budget pre-flight and scope creep.

After a plan is made, before it runs

REJECT · PRUNE · ESCALATE · LOG

Inter-agent

Rule-based

Agent identity, trust gating, signed messages and delegation rights.

At every agent-to-agent hand-off

BLOCK · QUARANTINE · VERIFY · LOG

Guardrail lifecycle

No guardrail is set and forgotten.

Every guardrail is one YAML policy in a single schema, rolled out in stages and measured before it is allowed to block.

  1. Define

    Write the guardrail as policy: category, trigger, mode, thresholds, scope, owner. The author can't approve their own policy.

  2. Deploy

    Sandbox first, then shadow it against production traffic in log-only mode before it touches a request.

  3. Monitor

    Trigger, block and false-positive rates, plus latency overhead, tracked per guardrail in OXP.

  4. Retire

    Retire when false positives stay above 15% or nothing triggers for 30 days. Retirement is an approved, audited change.

LOG→WARN→BLOCK

QASA, Agent Security Authorization

A tool runs only if the task justifies it.

QASA puts a policy sidecar beside every client, agent and tool server. Each tool call is checked at token exchange, and only approved tools appear in the token the agent receives.

  1. Is this the tool the model actually picked?

    tool_not_selected_by_llm
  2. Did the model pick any tool at all?

    no_llm_calls_made_by_app
  3. Does the stored task fit the tool's purpose? The judge fails closed.

    tool_intent_mismatch

Meta-governance

Policy over policy.

Teams write their own guardrails. QuadRails validates every one at load time and rejects anything that weakens the enterprise baseline, like an admission controller for AI policy.

META-001Trust score stays within enterprise boundsreject
META-002Circuit breaker must be enabledreject
META-003Ring 0 only for orchestrator rolesreject
META-004Ring 2+ agents need argument limitsreject
META-005At least one input rail is activereject
META-006Restricted tools only for Ring 0 and 1reject
META-007Rate limits within enterprise boundswarn
META-008Policy author is not the approverreject

OWASP coverage

All ten agentic risks, covered in depth.

Every OWASP agentic risk has primary coverage from at least one guardrail category, and most from two or more.

ASI01Goal hijackInput, output and planning
ASI02Tool misuseTool-calling and planning
ASI03Identity abuseInter-agent
ASI04Supply chainRetrieval
ASI05Code executionTool-calling and execution
ASI06Memory poisoningInput and retrieval
ASI07Agent-to-agent trafficInter-agent
ASI08Cascading failuresTool-calling, execution, planning
ASI09Trust exploitationOutput and retrieval
ASI10Rogue agentsExecution and inter-agent

See the rails on your own agents.

We'll run one of your agents through QuadRails and walk you through every decision it made.