No entries match these filters. Clear filters
QuilrAI adds attachment scanning for inline images and documents in TrueFoundry SDK request checks, with OCR OCR Optical character recognition, converting text in an image or scanned document into machine-readable characters. It lets software search or process text that was stored as pixels. and visual classification support︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
Input checks now inspect supported inline images and documents — including data URLs embedded in text and HTML — using the same attachment scanning settings as other SDK request checks.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet OCR reads image text in scanned attachments; visual classification is a separate protection that also requires Classify images to be enabled. Not checked yet When an attachment is removed, the rewritten request is complete and the removed attachment field is empty; remote URLs and provider file IDs are not fetched. Not checked yet Output checks do not scan generated images or documents; audio and video content are not scanned; supply complete hook request/response bodies rather than streaming deltas. Not checked yet The endpoint supports LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. Chat Completions hooks and does not implement TrueFoundry MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. pre/post-tool hooks. Not checked yet
5 details in Everything
QuilrAI adds authentication support for live MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. scans, full-report email delivery, and scheduling for WebSocket WebSocket A protocol that upgrades an HTTP connection into a persistent, full-duplex channel, letting a server push data to a client without repeated polling. Cyber tools use it for real-time event streaming and live command output. , voice, and AI workflow agents︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Scan a live MCP server that requires a read-only API key and check that it correctly refuses unauthenticated and invalid-credential requests.
📍 In the QuilrAI console, start a new MCP assessment against a live server. Under Sign-in , choose API key (header), supply the key, and set Access level to Read-only analyst . Run the scan and review the Sign-in section of the report for authentication-bypass findings.
Deliver a run's full findings report — including all evidence and recommended fixes — to recipients who do not have console access.
📍 On the run's page, open the forward summary settings, tick Email the full report instead of the summary , enter the recipient addresses, and save. The next completed run sends the full PDF-equivalent report to each address without requiring a sign-in.
Put a WebSocket agent assessment on a recurring schedule so red-team runs happen automatically.
📍 On the Schedules tab, click New schedule , select a saved WebSocket agent assessment, configure the frequency and time, and save. The run appears in Next 7 days and respects the timezone in Settings → Display .
MCP scans now support sign-in during a live scan using bearer token bearer token A credential that grants access to whoever presents it, without a separate proof of possession. Protecting the token matters because a stolen copy can be used by someone else. , API key (header or query parameter), username and password, OAuth client credentials, a login that returns a token, or a sign-in form session cookie — configured under Sign-in when scanning a live server.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Add an optional Access level field (e.g. Read-only analyst ) to an MCP scan to flag tools that exceed what the credentials should permit, such as write or delete tools reachable by a read-only account. Not checked yet MCP scan reports now include a Sign-in section showing whether the server rejects unauthenticated requests and requests with invalid credentials, and raise a finding when either is accepted. Not checked yet Send a run's full report by email instead of the summary by ticking Email the full report instead of the summary in the forward summary settings on a run's page. Not checked yet Schedule WebSocket agents, voice agents, and AI workflows from the Schedules tab — previously only HTTP agents could run on a schedule. Not checked yet
+4 more
show less
Single-model assessments now include a Schedule step on the Schedules tab. Not checked yet The Gateway-connected card is removed from the New assessment row on the Assessments page, which now shows four cards: Agent , Model , and MCP. Not checked yet The first assessment card on the Assessments page is renamed from Agent to AI App / Agent. Not checked yet Schedules now follow the timezone set in Settings → Display , and clicking a run on Next 7 days , the +N more runs line, or the first run under Runs in the next 24h opens that schedule's settings. Not checked yet
MCP scans now support sign-in during a live scan using bearer token bearer token A credential that grants access to whoever presents it, without a separate proof of possession. Protecting the token matters because a stolen copy can be used by someone else. , API key (header or query parameter), username and password, OAuth client credentials, a login that returns a token, or a sign-in form session cookie — configured under Sign-in when scanning a live server.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Add an optional Access level field (e.g. Read-only analyst ) to an MCP scan to flag tools that exceed what the credentials should permit, such as write or delete tools reachable by a read-only account. Not checked yet MCP scan reports now include a Sign-in section showing whether the server rejects unauthenticated requests and requests with invalid credentials, and raise a finding when either is accepted. Not checked yet The Gateway-connected card is removed from the New assessment row on the Assessments page, which now shows four cards: Agent , Model , and MCP. Not checked yet
5 more in Everything
└──▷ BREAKING ON UPGRADE
!
The `Gateway-connected` card is removed from the `New assessment` row; existing Gateway-connected runs remain visible under `Recent runs` and can still be filtered, but no new Gateway-connected assessments can be started from that card.
Our best guess
QuilrAI adds continuous, scheduled red-teaming with adaptive attack generation, retest/regression checks, and SIEM SIEM Security information and event management, collecting logs from many systems and correlating events to find suspicious activity. Analysts use it to investigate alerts and incidents. or ticketing integration for findings.
Red-teaming assessments run on a schedule so testing repeats automatically as the target changes, turning a one-time test into a continuous control. Not checked yet New detection The Red Team Agent accepts a target's system prompt and connected tool list to design attacks tailored to that specific application. Not checked yet After a finding is fixed, Red Teaming retests the target to verify the fix and scheduled assessments continue checking that the fix holds. Not checked yet High-severity findings can be sent to a SIEM or ticketing system for security operations analysts to track remediation. Not checked yet
4 details in Everything
QuilrAI adds a local Snowflake MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. connector that runs on each user's computer with four environment variables and no Snowflake admin setup︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ TRY IT
Let a user connect their local AI app to Snowflake for read-only SQL exploration without requiring any Snowflake admin action.
copy
$ export SNOWFLAKE_ACCOUNT=myorg-myaccount
export SNOWFLAKE_USER=jsmith
export SNOWFLAKE_PASSWORD=<password-or-programmatic-access-token>
export SNOWFLAKE_WAREHOUSE=compute_wh
As an administrator, enable the local Snowflake MCP package for a user group so they can run read-only Snowflake queries through the QuilrAI gateway.
📍 1. Open the MCP Library.
2. Filter Type to Local package (stdio) and find Snowflake.
3. Select Review, check the package, and approve it.
4. Enable the tools you want and grant access to the relevant users or groups.
Connect Snowflake without admin setup by setting four environment variables — SNOWFLAKE_ACCOUNT, SNOWFLAKE_USER, SNOWFLAKE_PASSWORD, and SNOWFLAKE_WAREHOUSE — to run the local snowflake-labs-mcp (Python) package through the QuilrAI gateway.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Approve and configure the local Snowflake MCP package from the MCP Library by filtering on type Local package (stdio) , selecting Snowflake, and granting access to users or groups. Not checked yet Local Snowflake MCP runs read-only SQL: run_snowflake_query accepts only SHOW, DESCRIBE, and USE statements; the create_object, create_or_alter_object, and drop_object tools are listed but refuse to run. Not checked yet Local Snowflake MCP exposes tools for listing and describing database objects (list_objects, describe_object) and exploring semantic views (list_semantic_views, describe_semantic_view, show_semantic_dimensions, show_semantic_metrics, get_semantic_view_ddl, write_semantic_view_query_tool, query_semantic_view). Not checked yet QuilrAI now surfaces structured sign-in failure details — including a state, code, action, and detail field carrying Snowflake's own error message with credentials removed — when the local Snowflake package exits during startup. Not checked yet
+1 more
show less
QuilrAI adds two Snowflake connection paths: Snowflake-managed MCP (remote, requires an MCP server object and OAuth security integration in Snowflake) for Cortex Agents, Cortex Analyst, Cortex Search, SQL, and custom functions; and local Snowflake MCP (per-user, no Snowflake admin setup) for read-only SQL exploration. Not checked yet
6 details in Everything
QuilrAI adds Snowflake as an MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. provider with two connection modes: a managed server (OAuth or access token access token A credential that authorizes a client to use a service or API. It usually has limited permissions and a lifetime; anyone holding it may be able to use those permissions. ) and a local read-only package.
New integration Connect to Snowflake data via a Snowflake-managed MCP server, configured with a Snowflake OAuth security integration pointing to the QuilrAI callback URL or a role-restricted programmatic access token. Not checked yet Connect to Snowflake data via the local Snowflake package from the MCP Library, which runs read-only on each user's computer using their own Snowflake credentials. Not checked yet
2 details in Everything
QuilrAI adds token-saving transforms to MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. , including JSON compaction, HTML/Markdown stripping, and base64 removal, governed by a new Policy Engine path︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Prevent a noisy server from sending base64 blobs to the model by scoping a strip rule to that server alone.
📍 In the console, go to Govern › Policy Engine › MCP Gateway › Controls › Token Savings. Choose Strip base64 content , set Applies to: the target server, enable the switch, check Reads as, then Save to draft and publish.
Exempt a specific tool from JSON compaction while keeping it on for all other tools, using priority to let the Off rule win.
📍 In the console, go to Govern › Policy Engine › MCP Gateway › Controls › Token Savings. Create a rule for Compacts eligible JSON results , set Applies to: the specific tool, turn the switch Off, assign it a higher numeric priority than the global On rule, check Reads as, then Save to draft and publish.
Configure token-saving transforms for MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. Gateway tool results via Govern > Policy Engine > MCP Gateway > Controls > Token Savings, with per-rule priority and an Applies to scope (server, tool, person, Smart Group, agent, or route).︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Strip base64-encoded content from model responses — replacing it with a size note — so encoded payloads are no longer passed to the model. Not checked yet Review observed token-saving activity per control in Activity , and see response-token savings across servers in MCP Gateway Insights under Overall analytics > Overview. Not checked yet
3 details in Everything
QuilrAI MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. adds a Policy Engine mode for MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. guardrails with per-rule detection, scan profiles, and request/response actions︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Set a Block action on outbound tool responses for a specific MCP server to prevent sensitive data from reaching the AI client.
📍 In the console, go to Settings › AI Gateway › MCP Gateway, open the server's Configure › Guardrails section, set the Response action on the relevant data-risk category to Block, then save.
Create a fine-grained detection rule in the Policy Engine to block tool calls that match specific data types, without affecting unmatched calls.
📍 In the console, go to Govern › Policy Engine › MCP Gateway › Controls › Data & Adversarial Risks, choose a recipe or start a blank rule under Detection rules, set Applies to, choose the data types or detectors, set the action, check Reads as, Save to draft, then use Test › Try a situation or Replay activity to validate, and finally review and publish.
Configure MCP Gateway guardrails through the classic UI at Settings > AI Gateway > MCP Gateway, then the server's Configure > Guardrails section, to set per-direction (request/response) actions — Block, Redact, Mask, or Monitor — per data-risk and adversarial category.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Configure MCP Gateway guardrails through the Policy Engine at Govern > Policy Engine > MCP Gateway > Controls > Data & Adversarial Risks, which separates detection rules (findings, stage, and action) from scan-profile settings (which detectors run, category-specific actions, and a fallback action). Not checked yet Test candidate policies before publishing using Test > Try a situation or Replay activity , then review and publish. Not checked yet Review observed detections at Activity , and view flagged request and response content in Overall analytics > Data & security and MCP Gateway Insights with input/output DLP DLP Data Loss Prevention: a category of controls that inspect and block sensitive data from leaving an organisation via email, web, or removable media, giving cyber tools a policy enforcement layer over data in motion and at rest. filters. Not checked yet
4 details in Everything
QuilrAI MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. adds a tool-change approval queue that holds new and updated tools back from AI apps until an administrator reviews them.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Turn on the gateway-wide approval gate so that any new tool a connected MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. server starts offering is held for review before AI apps can call it.
📍 Settings › AI Gateway › MCP Gateway › Tool updates — enable New tools wait for approval
Override the gateway default for a single server so its tool-list changes are flagged for an administrator rather than applied automatically.
📍 Configure › Tools (on the server) › Upstream tool changes › 'Flag differences for an administrator to review' — Save server settings
Inspect and approve or dismiss a pending tool change — including schema diffs and disappeared tools — before it reaches callers.
📍 Tool updates (gateway header or server card) › Review › inspect tool names, descriptions, and schema differences › Approve or Dismiss
Enable a gateway-wide gate that hides newly offered MCP tools from AI apps and agents until an administrator approves them via Settings > AI Gateway > MCP Gateway > Tool updates and the New tools wait for approval switch.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Review queued tool additions, description changes, schema diffs, and disappeared tools in the Tool updates queue — accessible from the gateway header or a server card — before changes reach callers. Not checked yet
2 details in Everything
QuilrAI adds a Policy Engine to MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. that controls tool listing, calling, and result visibility as separate, priority-ordered steps︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Block a specific tool from both listing and calling so an AI agent cannot discover or invoke it, even if it has a cached tool list.
📍 Govern › Policy Engine › MCP Gateway › Controls › Invocation & Discovery › Tool calls
1. Choose the Block a tool recipe.
2. Set Applies to to the target server and tool name.
3. Confirm the rule covers both the Listed and Callable steps in the Reads as summary.
4. Click Save to draft , verify in Test › Try a situation , then publish.
Allow a set of tools to remain callable but require a human to confirm each invocation before it runs.
📍 Govern › Policy Engine › MCP Gateway › Controls › Invocation & Discovery › Tool calls
1. Choose the Allow and require confirmation recipe.
2. Set Applies to to the relevant server and tools.
3. Save to draft and use Replay activity in the Activity panel to validate matches before publishing.
Control tool discovery and invocation through the new Policy Engine panel at Govern > Policy Engine > MCP Gateway > Controls > Invocation & Discovery, which replaces the separate Discovery Visibility and Invocation entry points.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Decide access at three distinct steps — Listed (appears in discovery), Callable (call can run), and Result (result returned to client) — independently for tool calls, resource reads, and prompt fetches. Not checked yet Apply built-in recipes such as Allow tools on a server , Allow selected tools , Block a tool , or Block destructive tools , each with configurable Applies to scope covering server, tools, and caller conditions. Not checked yet Require human confirmation for callable tools using the Allow and require confirmation recipe, with the separate Human Confirmation control managing confirmation rules and exemptions. Not checked yet Match resource rules by URI, template, name, or MIME type; match prompt rules by prompt name; and use result rules to withhold unsuccessful or oversized results. Not checked yet
5 details in Everything
└──▷ BREAKING ON UPGRADE
!
Enabling the Policy Engine replaces the separate Discovery Visibility and Invocation entry points with the single `Govern > Policy Engine > MCP Gateway > Controls > Invocation & Discovery` panel; stored classic settings are affected — see 'Switching from classic settings'.
Our best guess
QuilrAI adds a Policy Engine mode for MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. controls with priority-based rule ordering and a Try a situation test workflow︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Restrict a destructive-tool policy to a specific Smart Group and verify the effective decision before going live.
📍 1. Go to Govern › Policy Engine › MCP Gateway › Controls
2. Select the 'Invocation & Discovery › Block destructive tools' control
3. Under the audience field, choose the target Smart Group
4. Go to Test › Try a situation, select a person in that group and the relevant server/tool, and inspect the result
5. Run Replay activity to check the candidate against recorded calls
6. Click Review and publish once intended and exempt cases behave as expected
Scope MCP Gateway controls to people or Smart Groups under Govern > Policy Engine > MCP Gateway > Controls, with exclusions for rules that should apply to everyone except specified groups or individuals.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Access decisions in the Policy Engine now use highest numeric priority with Deny winning ties, replacing the classic 'user rule applies last' order — confirmation and token-saving switches follow their own tie-breaking rules. Not checked yet Test effective policy decisions using Test > Try a situation, choosing a person and server/tool and inspecting the result before publishing. Not checked yet Validate candidate rules against recorded calls with Replay activity before committing changes. Not checked yet The Invocation & Discovery control covers listing, calls, and returned results — including the Block destructive tools policy, which can be scoped to a Smart Group. Not checked yet
5 details in Everything
QuilrAI adds Cohere, Perplexity, and Groq provider integrations, an external hooks API, Mistral OCR OCR Optical character recognition, converting text in an image or scanned document into machine-readable characters. It lets software search or process text that was stored as pixels. billing, SDK attachment scanning, and a full OpenAPI 3.1 OpenAPI 3.1 A specification standard for describing REST APIs in a machine-readable format, maintained by the OpenAPI Initiative. Cyber tools use it to auto-generate clients, documentation, and validation from a single source of truth. Inference API ref︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ TRY IT
Retrieve the Anthropic Messages family spec from the live Inference API reference to import or inspect gateway-specific headers and guardrail behavior for that client
copy
$ curl 'https://{region}.quilr.ai/llmgateway_inference_apis/v1/openapi.json?family=anthropic_messages'
Call your own HTTPS HTTPS HTTP carried over an encrypted TLS connection. It protects traffic in transit and lets a browser verify the server's certificate. endpoint on gateway traffic with the new external hooks API: pre_call hooks allow, flag, or block a request before the model call; post_call hooks do the same for non-streaming responses; on_complete hooks export finished requests in batches as {"records": [...]} with retries and a bounded queue︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Shape external hook calls with URL and header templates, client headers, bearer, basic, and API key auth, HMAC HMAC A keyed hash that proves a message came from someone holding a shared secret and was not altered. Webhooks and API request signing commonly use it. signing, a Quilr envelope or a custom body template, and a reply mapped from your own JSON Not checked yet New Management API key scopes: Manage hooks and Manage personal keys (issue, rename, re-expire, and revoke personal API keys on a user's behalf) Not checked yet Fetch the full OpenAPI OpenAPI A vendor-neutral specification for describing REST APIs in a machine-readable format, maintained by the OpenAPI Initiative. Cyber tools use it to auto-generate clients, documentation, and validation from a single source of truth. 3.1 Inference API reference live from GET /llmgateway_inference_apis/v1/openapi.json?family=<key>, covering OpenAI-compatible, Responses, Azure OpenAI, Realtime, Assistants, Anthropic Messages, Bedrock Runtime, Gemini, Vertex AI, rerank, Mistral, xAI, Sarvam, and TypeSafe client APIs Not checked yet Pin a live spec to one region with ?region=<value> on Inference and Management spec routes (for example ?region=guardrails-europe-1); the spec uses a single https://{region}.quilr.ai server so a Kong import never mixes regions Not checked yet
+5 more
show less
Import the spec into Kong with deck file openapi2kong; the Management API behind Kong section covers streaming, Realtime, Bedrock SigV4 SigV4 AWS's request-signing protocol that authenticates HTTP calls by hashing the request body, headers, and credentials into a signature; cyber tools use it to talk to AWS APIs without embedding long-lived secrets. , Vertex AI route settings, upstream retries off, and credential header passthrough Not checked yet QuilrAI now supports a full Cohere provider (cohere): Command and Aya chat on Chat Completions with streaming, tool calls, and JSON schema; embeddings embeddings Lists of numbers a model produces to represent the meaning of text, images or code, so similar items sit close together. They power semantic search and RAG. on /openai_compatible/v1/embeddings (float or base64) and /cohere/v2/embed (int8 int8 Eight-bit integers used to represent quantized model values. They save memory compared with floating-point formats and can speed up inference on supported hardware. , binary, and other types); rerank on /rerank/v1/rerank and /cohere/v2/rerank; and transcription on /openai_compatible/v1/audio/transcriptions Not checked yet Cohere's parse, tokenize, batch, embed-job, and dataset APIs are available on Cohere routes Not checked yet QuilrAI now supports a Perplexity provider (perplexity): Perplexity's Agent API on the Responses route for OpenAI, Anthropic, Google, xAI, and Perplexity models (including perplexity/sonar) with built-in web search; pplx-decider decision models on /perplexity/v1/decisions; and pplx-embed embeddings on /openai_compatible/v1/embeddings and /perplexity/v1/embeddings (int8 or binary vectors) Not checked yet QuilrAI now supports a Groq provider (groq): Chat Completions and Groq's stateless Responses API with streaming and tool calls; Whisper speech-to-text and speech translation; Orpheus text-to-speech (WAV) on /openai_compatible/v1/audio/* routes; and Anthropic Messages, Gemini, and Bedrock clients via any-to-any format translation Not checked yet
10 details in Everything
QuilrAI adds OCR OCR Optical character recognition, converting text in an image or scanned document into machine-readable characters. It lets software search or process text that was stored as pixels. endpoint support for Mistral Document AI on Azure AI Foundry, plus image-generation streaming with partial-image events︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ TRY IT
Stream an image generation through the gateway, passing OpenAI-specific fields like complexity and safety_identifier, to get partial images as they render.
copy
$ curl -N https://guardrails.quilr.ai/openai_compatible/v1/images/generations \
-H 'Content-Type: application/json' \
-d '{"model": "gpt-image-2.6-flare", "prompt": "A plain white square.", "complexity": "low", "safety_identifier": "user-hash", "stream": true, "partial_images": 1}'
Submit a document to the OCR endpoint for Mistral Document AI on Azure, passing the file as a base64 data URI.
copy
$ curl https://guardrails.quilr.ai/openai_compatible/v1/ocr \
-H 'Content-Type: application/json' \
-d '{"model": "mistral-ocr-latest", "document": "data:application/pdf;base64,<base64-encoded-pdf>"}'
QuilrAI now routes POST /ocr to Mistral Document AI deployments on Azure AI Foundry, accepting documents as base64 data: URIs; Mistral OCR is billed per processed page at the catalog per-page rate.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Image generations and edits now stream when the request sets "stream": true (or "true" as a multipart form field on edits), relaying OpenAI's partial_image and image_generation.completed or image_edit.completed events unchanged; token and spend counts come from the final completed event. Not checked yet OpenAI image-generation fields such as complexity, safety_identifier, and partial_images pass through the gateway to the upstream provider. Not checked yet Cohere's parse API is now served on Cohere routes and counts as the OCR family, with the same switches, limits, and policy rules as other OCR endpoints. Not checked yet Each gateway response now carries x-quilr-request-id matching the request_id of its log row, with base64 payloads omitted and logged bodies capped at 256 KiB by default. Not checked yet
+1 more
show less
Groq files and batches are not routed, and Groq has no legacy /completions support; Perplexity's Search and Orchestrator APIs are also not routed — only its embeddings embeddings Lists of numbers a model produces to represent the meaning of text, images or code, so similar items sit close together. They power semantic search and RAG. reach the embeddings route. Not checked yet
6 details in Everything
QuilrAI adds a Rate Limits API with shared counter scope, request guards, model limits, exemptions, and limit-response controls via JSON merge patch︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ TRY IT
Switch a gateway's rate-limit counter to shared mode so all gateway servers enforce a single coordinated limit via Valkey, then verify the change.
copy
$ curl -X PATCH https://your-gateway/api/rate-limits \
-H 'Content-Type: application/merge-patch+json' \
-d '{"counter_scope": "shared"}'
Configure rate limits across gateway servers with the counter_scope field, choosing per_server (default, each server counts independently) or shared (all servers count together via a Valkey counter store).︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Rate-limited requests return HTTP 429 with x-should-retry: false and no Retry-After header, telling clients not to retry. Not checked yet Apply a smart-group budget using the person's strongest (lowest-rank) group, or use a group budget set for separate budgets per group. Not checked yet
3 details in Everything
QuilrAI adds complexity-level routing, failover profiles, and routing-constraints APIs to its LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. gateway management surface︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ TRY IT
Create a complexity-level policy that uses AI classification to split requests into low/medium/high tiers, with token-count bounds as fallback, so cost-sensitive routes can redirect simple queries to a cheaper model.
copy
$ curl -X PUT 'https://guardrails-usa-1.quilr.ai/llmgateway/management/v1/controls/complexity-levels/eu-pool' \
-H 'Content-Type: application/json' \
-d '{
"description": "Support complexity",
"method": "ai",
"levels": {
"low": {"description": "Short factual questions", "max_tokens": 200},
"medium": {"description": "Everyday drafting", "max_tokens": 2000},
"high": {"description": "Multi-step reasoning or coding"}
}
}'
Add a failover rule that retries the same model on another provider region before giving up, limiting retries to two attempts.
copy
$ curl -X PUT 'https://guardrails-usa-1.quilr.ai/llmgateway/management/v1/controls/failover-rules/eu-fallback' \
-H 'Content-Type: application/json' \
-d '{"candidate_scope": "same_model", "max_attempts": 2, "fallbacks": [{"provider_label": "azure-eu", "model": "gpt-4.1-mini"}]}'
Dry-run a batch of routing control changes to validate the merged state before publishing anything to the gateway.
copy
$ curl -X POST 'https://guardrails-usa-1.quilr.ai/llmgateway/management/v1/controls/_batch' \
-H 'Content-Type: application/json' \
-d '{"ops": [
{"op": "put", "collection": "complexity-levels", "id": "eu-pool", "body": {"method": "length", "context_thresholds": {"low_max_words": 50, "medium_max_words": 300}}},
{"op": "delete", "collection": "complexity-levels", "id": "old-pool"}
]}'
Route LLM requests by named complexity levels — low, medium, high — using complexity conditions in ControlsRoutes, with AI-classifier or word/token-count bounds via the method field ('ai' or 'length') and context_thresholds (low_max_words, medium_max_words) as fallback.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Route requests by data type using data_type conditions (policy data-type names) in ControlsRoutes; scanned on every message, never combined with other conditions, no session route decision. Not checked yet Route requests by topic using topics conditions (route classifier, once per conversation unless per_message) in ControlsRoutes; route_decision accepts per_conversation, per_message, or escalate (complexity routes only). Not checked yet Control failover scope and retry attempts with candidate_scope ('same_model' or 'route') and max_attempts in failover objects, plus named fallback providers via provider_label and model. Not checked yet Batch-preview routing control changes without publishing via {collection: {id: resource | null}} or [{op: 'put' | 'delete', collection, id, body}] (also accepted as {ops: [...]}) — nothing is published, pinned, or sent upstream. Not checked yet
+1 more
show less
Receive non-blocking validation_warnings (including unsupported_route_capability and model_deprecated) on publish; repeated warnings are deduplicated with an occurrences count. Not checked yet
6 details in Everything
QuilrAI adds group budget sets to the Budgets API, letting teams assign per-smart-group LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. spend limits with configurable conflict resolution︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ TRY IT
Create a spend policy that gives employees $50/month and executives $500/month, charging only the highest-ranked group when someone belongs to both.
copy
$ curl -X POST "$API/budget-sets" \
-H "Authorization: Bearer $MANAGEMENT_KEY" \
-H "Idempotency-Key: monthly-ai-spend-by-group" \
-H "Content-Type: application/json" \
-d '{"label": "Monthly AI spend", "metric": "spend_usd", "limit": "50.00",
"window": {"kind": "calendar", "unit": "month"},
"resolve": "strongest",
"groups": ["employees", {"group": "executives", "limit": "500.00"}]}'
Switch an existing set so every group a user belongs to is charged independently, meaning the tightest limit wins — useful for enforcing hard per-team caps regardless of seniority.
copy
$ curl -X PATCH "$API/budget-sets/set_9c2e4b1a7f30" \
-H "Authorization: Bearer $MANAGEMENT_KEY" \
-H "If-Match: \"s0f1e2d3c4b5a6978\"" \
-H "Content-Type: application/json" \
-d '{"resolve": "strictest"}'
Check which budget set rules govern a specific user and whether any are conditional on the calling app, to debug an unexpected block.
copy
$ curl "$API/budget-subjects/user/alice@example.com?app=my-app" \
-H "Authorization: Bearer $MANAGEMENT_KEY"
Create a group budget set — one spend limit per smart group — with POST /budget-sets, specifying groups (up to 32 entries, each a name or {group, limit} pair), optional label (default set_<12 hex>), metric, limit, window, and applies_to.apps; the response includes set, budgets, revision, and etag.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Add a group to a set with POST /budget-sets/{set_id}/groups, passing {group, limit?}; remove one with DELETE /budget-sets/{set_id}/groups/{group} (URL-encode the name, e.g. virtual%3Asales); removing the last group deletes the entire set. Not checked yet Delete an entire group budget set and all its member budgets with DELETE /budget-sets/{set_id}. Not checked yet New budget-set etag format s<16 hex> is required on PATCH/DELETE of a set and DELETE of a set group, and optional when adding a group; the existing b<16 hex> budget etag and <version> grant etag formats are unchanged. Not checked yet Budget set writes respect new error codes: budget_set_not_found, budget_set_group_not_found, budget_set_exists, budget_set_group_exists, budget_in_group_set, budget_set_not_api_managed, quota_group_set_mismatch, quota_group_set_duplicate_group, and quota_group_set_exceeds_cap. Not checked yet
+2 more
show less
Dry-run batch operations now report sets whose resolution or groups would change under not_simulated.group_sets_changed. Not checked yet New GET /budget-events event types cover the full budget set lifecycle: budget.batch_applied, grant.superseded, and the standard budget.created, budget.updated, budget.deleted events, all filterable with the type parameter. Not checked yet
Create a group budget set — one spend limit per smart group — with POST /budget-sets, specifying groups (up to 32 entries, each a name or {group, limit} pair), optional label (default set_<12 hex>), metric, limit, window, and applies_to.apps; the response includes set, budgets, revision, and etag.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Add a group to a set with POST /budget-sets/{set_id}/groups, passing {group, limit?}; remove one with DELETE /budget-sets/{set_id}/groups/{group} (URL-encode the name, e.g. virtual%3Asales); removing the last group deletes the entire set. Not checked yet Delete an entire group budget set and all its member budgets with DELETE /budget-sets/{set_id}. Not checked yet New budget-set etag format s<16 hex> is required on PATCH/DELETE of a set and DELETE of a set group, and optional when adding a group; the existing b<16 hex> budget etag and <version> grant etag formats are unchanged. Not checked yet Budget set writes respect new error codes: budget_set_not_found, budget_set_group_not_found, budget_set_exists, budget_set_group_exists, budget_in_group_set, budget_set_not_api_managed, quota_group_set_mismatch, quota_group_set_duplicate_group, and quota_group_set_exceeds_cap. Not checked yet
+1 more
show less
New GET /budget-events event types cover the full budget set lifecycle: budget.batch_applied, grant.superseded, and the standard budget.created, budget.updated, budget.deleted events, all filterable with the type parameter. Not checked yet
1 more in Everything
QuilrAI adds a provider model review API and attachment scanning policy to the LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. gateway︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ TRY IT
Review and approve a newly discovered model on a shared provider, setting per-token prices at the same time.
copy
$ export API="$MANAGEMENT_URL/llmgateway/management/v1"
auth=(-H "Authorization: Bearer $MANAGEMENT_KEY" -H 'Content-Type: application/json')
# See what models are waiting for a decision
curl -s "$API/provider-model-reviews?status=pending" "${auth[@]}" \
| jq -r '.items[] | [.label, .app_name // "shared", .model_id] | @tsv'
# Approve one, with pricing
curl -s -X POST "$API/provider-model-reviews/Production%20OpenAI/decisions" "${auth[@]}" \
-H 'Idempotency-Key: approve-gpt-5-2-mini-001' \
-d '{"status": "approved", "models": ["gpt-5.2-mini"], "model_costs": {"gpt-5.2-mini": {"input_per_1m": 0.25, "output_per_1m": 2.0}}}'
Block office documents and strip images in transit while allowing PDFs up to 500 pages with Latin and CJK OCR OCR Optical character recognition, converting text in an image or scanned document into machine-readable characters. It lets software search or process text that was stored as pixels. — useful when your app should never receive binary attachments from users.
json
copy
{
"attachment_scanning": {
"ocr": "no_text_layer",
"ocr_scripts": ["latin", "cjk"],
"pdf_max_pages": 500,
"max_file_bytes": 20971520,
"max_request_bytes": 52428800,
"on_limit_violation": "block",
"on_macros": "strip",
"on_unscannable": "monitor",
"type_actions": {
"document": "block",
"spreadsheet": "block",
"presentation": "block",
"image": "strip",
"pdf": "allow",
"archive": "block"
}
}
}
Approve a newly discovered model for an app-owned provider when multiple apps share the same label.
copy
$ curl -s -X POST "$API/provider-model-reviews/Production%20OpenAI/app-decisions" \
-H "Authorization: Bearer $MANAGEMENT_KEY" \
-H 'Content-Type: application/json' \
-H 'Idempotency-Key: approve-gpt-5-2-mini-001' \
-d '{"app_name": "Support Bot", "models": ["gpt-5.2-mini"], "status": "approved"}'
Adds a provider model review workflow: list pending, approved, and rejected new provider models with GET /provider-model-reviews (filtered by status, provider, or app query parameters); read a specific provider's last model listing and all pending/approved/rejected models with GET /provider-model-reviews/{label} (optional app_name query parameter to disambiguate shared vs.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ app-owned providers, returning 409 app_name_required when multiple apps share the label); approve or reject new models on a shared provider with POST /provider-model-reviews/{label}/decisions (accepting status values 'approved', 'rejected', or 'pending' to restore rejected models, with optional model_costs per model and idempotency via Idempotency-Key header); and approve or reject new models on an app-owned provider with POST /provider-model-reviews/{label}/app-decisions (requiring app_name to scope to the app's own provider label), so admins control which newly discovered models become callable. Not checked yet Adds an attachment_scanning policy block: enable scanning for images, PDFs, and office documents with per-kind type_actions (allow, strip, or block) covering archive, audio, document, image, pdf, presentation, spreadsheet, text, and video; control OCR with ocr ('off', 'no_text_layer', or 'always') and ocr_scripts ('latin', 'cjk', 'korean', 'cyrillic', 'arabic', 'devanagari', 'tamil', 'telugu', 'thai', 'greek'), with file limits via max_file_bytes (default 20 971 520, max 536 870 912), max_files (max 1 000), and max_request_bytes (default 52 428 800, max 2 147 483 648); and set per-violation behaviour with on_limit_violation (default 'block' or 'strip'), on_macros (default 'monitor' or 'strip'), and on_unscannable (default 'monitor' or 'strip'). Not checked yet Configure Azure provider authentication headers with azure_auth_header — omit or use 'api-key' for the default, 'authorization_bearer' for Authorization: Bearer <key>, or any raw header name such as Ocp-Apim-Subscription-Key . Not checked yet Connect providers via gpu_connector_id or remote_connector_id fields on provider configuration. Not checked yet Filter the management audit log with actor, operation, resource, since, and until query parameters on the audit event listing endpoint; unknown parameters return 400. Not checked yet
Adds a provider model review workflow: list pending, approved, and rejected new provider models with GET /provider-model-reviews (filtered by status, provider, or app query parameters); read a specific provider's last model listing and all pending/approved/rejected models with GET /provider-model-reviews/{label} (optional app_name query parameter to disambiguate shared vs.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ app-owned providers, returning 409 app_name_required when multiple apps share the label); approve or reject new models on a shared provider with POST /provider-model-reviews/{label}/decisions (accepting status values 'approved', 'rejected', or 'pending' to restore rejected models, with optional model_costs per model and idempotency via Idempotency-Key header); and approve or reject new models on an app-owned provider with POST /provider-model-reviews/{label}/app-decisions (requiring app_name to scope to the app's own provider label), so admins control which newly discovered models become callable. Not checked yet Adds an attachment_scanning policy block: enable scanning for images, PDFs, and office documents with per-kind type_actions (allow, strip, or block) covering archive, audio, document, image, pdf, presentation, spreadsheet, text, and video; control OCR with ocr ('off', 'no_text_layer', or 'always') and ocr_scripts ('latin', 'cjk', 'korean', 'cyrillic', 'arabic', 'devanagari', 'tamil', 'telugu', 'thai', 'greek'), with file limits via max_file_bytes (default 20 971 520, max 536 870 912), max_files (max 1 000), and max_request_bytes (default 52 428 800, max 2 147 483 648); and set per-violation behaviour with on_limit_violation (default 'block' or 'strip'), on_macros (default 'monitor' or 'strip'), and on_unscannable (default 'monitor' or 'strip'). Not checked yet Configure Azure provider authentication headers with azure_auth_header — omit or use 'api-key' for the default, 'authorization_bearer' for Authorization: Bearer <key>, or any raw header name such as Ocp-Apim-Subscription-Key . Not checked yet Connect providers via gpu_connector_id or remote_connector_id fields on provider configuration. Not checked yet
1 more in Everything
QuilrAI: Set attachment size limits via max_file_bytes, max_files, max_request_bytes, and pdf_max_pages; handle violations with on_limit_violation.
└──▷ USE IT
Block spreadsheets and strip PDFs at the gateway while allowing all other attachment types — useful for apps where only certain document kinds are expected.
json
copy
{
"attachment_scanning": {
"type_actions": {
"spreadsheet": "block",
"pdf": "strip"
},
"on_unscannable": "strip",
"on_macros": "strip",
"ocr": "no_text_layer",
"ocr_scripts": ["latin"],
"pdf_max_pages": 50
}
}
Provision a scoped 90-day gateway key for a specific user so they can access the Support Bot app without sharing a shared credential.
copy
$ curl -X POST 'https://guardrails-usa-1.quilr.ai/llmgateway/management/v1/apps/Support%20Bot/self-service-keys' \
--header 'Idempotency-Key: issue-dana-laptop-cli-001' \
--header 'Content-Type: application/json' \
--data '{
"expires_in_days": 90,
"key_name": "laptop-cli",
"user_email": "dana@example.com"
}'
Rotate a user's key name and shorten its remaining lifetime when a team member changes roles — using If-Match to guard against concurrent edits.
copy
$ curl -X PATCH 'https://guardrails-usa-1.quilr.ai/llmgateway/management/v1/apps/Support%20Bot/self-service-keys/6b0e2c1a-4f3d-4c55-9a1e-0d2b7f8c9e10' \
--header 'If-Match: "9b2e4f0c7a1d"' \
--header 'Content-Type: application/json' \
--data '{
"expires_in_days": 30,
"key_name": "build-agent"
}'
Handle encrypted, unparseable, or remote-URL attachments with on_unscannable (values: monitor, strip; default: monitor); note scan failures (timeouts, scanner errors, text past scan limit) always fail open and never use this action. Not checked yet Handle Office document macros with on_macros (values: monitor, strip; default: monitor) and extract and redact document text with text_extraction and redact_documents_as_text. Not checked yet Issue self-service gateway keys per user via POST /llmgateway/management/v1/apps/{name}/self-service-keys with fields user_email, key_name, expires_in_days (max 3650), and idempotent retries for 24 hours using the Idempotency-Key header. Not checked yet List a user's self-service keys filtered by user_email and status (active, expired, revoked) with pages of 1–200 (default 50) and cursor pagination via next_cursor. Not checked yet Track key usage with last_used_at (most recent request in the last 90 days) and requests_30d on key metadata to identify stale keys; data can be up to 60 seconds old. Not checked yet
5 details in Everything
QuilrAI: Monitoring API adds /latency, /provider-health, and /requests/{request_id}/explain to show why a request was routed, blocked, limited, or failed over.
└──▷ TRY IT
Inspect why a specific request was blocked or failed over — useful when debugging guardrail or routing decisions in production.
copy
$ curl -X GET 'https://guardrails-usa-1.quilr.ai/llmgateway/management-admin/v1/requests/<request_id>/explain' \
-H 'Authorization: Bearer <management_key>'
Create, read, update and delete group budget sets and their group members via /budget-sets, /budget-sets/{set_id}, and /budget-sets/{set_id}/groups. Not checked yet Create and manage virtual smart groups, override a synced group's rank with priority, preview priority changes at /smart-groups/_priority-preview, and add or remove members via /smart-groups/{group_name}/members through the Smart Groups API. Not checked yet Manage access controls, response cache, cache warm, token saving, model visibility, conversation headers, error messages, complexity levels and prompt enforcement settings via the /controls/* endpoints under the Access and gateway features API — each write publishes a policy revision and requires the Policy Engine. Not checked yet Every *_at timestamp text field is UTC RFC 3339 with seconds and Z (for example 2026-11-05T10:00:00Z); numeric times such as completed_at and audit created_at use Unix seconds. Not checked yet Report spend, requests and tokens via the Usage API at /usage, including per-key last use. Not checked yet
+1 more
show less
List gateway users and read per-user app access, personal keys, last activity and usage via the Users API at /users and /users/{email}. Not checked yet
6 details in Everything
QuilrAI adds token-saving controls to its LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. Gateway, including request compression, tool-output cleanup, and a response cache configurable through the Policy Engine︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Enable token savings for a specific pipeline through the Policy Engine, compressing structured retrieval results without rewording prose.
📍 In the console, go to Govern › Policy Engine › LLM Gateway › Controls › Token Savings. Select the Turn on request compression recipe, set Applies to to your target scope (e.g., a specific application), enable the JSON compression section, leave prose shortening off, then Save to draft. Run Test, then Review & publish to make the rules live.
Reduce provider costs for a pipeline that repeatedly sends the same non-streaming requests by enabling the response cache.
📍 In the console, go to Govern › Policy Engine › LLM Gateway › Controls › Token Savings. Use the section add menu to add a Response cache rule, set Applies to to the relevant scope, enable the cache, then Save to draft. Run Test, then Review & publish.
Adds request-side token-saving controls: the JSON compression control compresses eligible JSON in requests before they reach the provider, the Markdown removal control strips Markdown formatting from requests before they reach the provider, and the prose-shortening control shortens prose in requests before sending (and may reword text). Not checked yet Adds tool-output cleanup controls: the Minify JSON tool outputs control removes whitespace from JSON tool outputs, a control cleans up tool outputs by removing color codes, progress bars, and repeated lines, and the Remove encoded content control replaces long base64 content in tool outputs with a size note so the model never receives that content. Not checked yet Adds caching controls: the response cache returns stored answers for eligible exact-repeat non-streaming requests without a new provider call or guardrail run, and Keep prompt cache warm keeps a provider's prompt cache warm without skipping the model's answer. Not checked yet
3 details in Everything
QuilrAI adds per-group budget sets, request guards, and a Policy Engine panel that owns all budget and rate-limit controls in one place︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
When you need different monthly spend allowances for different employee tiers, configure a per-group budget set so each Smart group has its own counter and the highest-ranked group governs users who belong to more than one.
📍 In the console, go to Govern › Policy Engine › LLM Gateway › Controls › Budgets & Usage Limits. Select Budgets & rate limits , create a new budget, set scope to the desired Smart groups, enter the per-group limits (e.g. $50 for Employees, $500 for Executives), set 'When someone is in several of these groups' to 'Their strongest group's budget applies (by rank)', then Save to draft › Test › Review & publish.
When a model has no catalog price and you want unknown-priced requests blocked rather than silently counted as $0, configure the fallback behavior in the Model prices tab.
📍 In the console, go to Govern › Policy Engine › LLM Gateway › Controls › Budgets & Usage Limits › Model prices. For the relevant provider and model, leave no price entry and set the missing-price action to Block the request (returns 403 quota_price_unavailable). Save to draft › Test › Review & publish.
Manage all spend, rate, token, and request controls from a single panel at Govern > Policy Engine > LLM Gateway > Controls > Budgets & Usage Limits, replacing the separate Rate, Token & Timeout Limits control.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Set per-group budgets that give each Smart group its own counter — for example $50/month for Employees and $500 for Executives — and choose between 'their strongest group's budget applies (by rank)' or 'every group's budget applies (strictest wins)' when a person belongs to multiple groups. Not checked yet Control group priority with the Rank column under Govern > Policy Engine > LLM Gateway > Groups; a lower number wins, equal numbers fall back to group name order, and the Strength column shows the resulting position. Not checked yet Manage group ranks and virtual groups programmatically via the Smart groups API, with the rank field on each group. Not checked yet Create virtual groups with New virtual group to hold a fixed member list that directory sync never overwrites. Not checked yet
+5 more
show less
Configure request guards — per-request token limits, timeout, and concurrency — from the Request guards tab inside the Budgets & Usage Limits panel. Not checked yet Define model prices per provider, model, and optionally per credential in the Model prices tab (USD per 1M input and output tokens); choose Block the request (403 quota_price_unavailable) or Count it as $0 for models with no matching price. Not checked yet Use the Exemptions tab to grant explicit exceptions to budgets or rate limits, and the Grants tab to add supplemental usage allowances. Not checked yet Configure budget alerts and customize the client-visible refusal message from the Alerts & response tab; webhook-alert changes save immediately without waiting for a policy publication. Not checked yet Use Test before Review & publish to validate limit rules, and use Search limits with All/Budgets/Rate limits filters to find existing configurations. Not checked yet
10 details in Everything
QuilrAI adds a Routing Groups & Fallbacks control in the Policy Engine to route LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. traffic by topic, data sensitivity, or prompt complexity with failover support︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Redirect requests that contain secrets or other sensitive data to a private or on-premises model instead of a public provider.
📍 In the Policy Engine, go to Govern › Policy Engine › LLM Gateway › Controls › Routing Groups & Fallbacks. Choose Start from a recipe, select 'Route sensitive data to a private model', configure your private model destination, then Save to draft and publish.
Validate that a new routing rule behaves as expected against recent live traffic before exposing it to production.
📍 In the Routing Groups & Fallbacks panel, use Test routing to confirm a targeted request routes correctly, then open Replay activity to compare the candidate rule against recorded activity before publishing.
Route LLM traffic across providers — OpenAI, Azure OpenAI, Bedrock, Anthropic, DeepSeek, Gemini, xAI, Mistral, Cerebras, Groq, Cohere, Oracle, Sarvam, Perplexity, and Vertex AI — using the new Routing Groups & Fallbacks control under Govern > Policy Engine > LLM Gateway > Controls > Routing Groups & Fallbacks.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Start a routing configuration from built-in recipes: Primary model with a backup , Route by topic , 'Route sensitive data to a private model', Small model for simple prompts , 'Three tiers: small / medium / large', and By message length only . Not checked yet Test a routing scenario in-panel with Test routing before publishing, or run a broader policy check via Test > Try a situation in the LLM Gateway Policy Engine. Not checked yet View per-route and per-app analytics over 24 h, 7 d, or 30 d — including conversations, requests, spend, cache read, added time, failures, upgrades, and fallbacks — from the panel's analytics tab. Not checked yet Configure failover defaults for routes that lack their own failover settings via the Failover defaults tab in the Routing Groups & Fallbacks panel. Not checked yet
+1 more
show less
Filter routes by type using All , Limits , Try in order , Content , and Watch only filters in the Search routes, models or groups bar. Not checked yet
6 details in Everything
QuilrAI adds model visibility controls to filter which models appear in model lists, scoped to apps, teams, or individual users︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Restrict a team to only specific providers or models by creating a visibility rule scoped to that team.
📍 In the Policy Engine, open the panel and select Add from a section's add menu. Choose the model visibility recipe, set the scope to the target team, configure allowed providers or models, name the rule, assign a priority and risk level, then Save to draft.
Configure model visibility rules in the Policy Engine to turn off listing entirely, restrict results to specific providers or models, hide models by name, or hide undated aliases.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Scope model visibility rules to an app, a team, or a person — or apply them globally. Not checked yet Each model visibility rule carries its own name, priority, and risk level, set from the Policies tab. Not checked yet
3 details in Everything
QuilrAI adds a Policy Engine for LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. Gateway identity and network trust controls, letting published rules govern who must prove identity and which networks may call︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Lock down which networks and callers can reach a specific LLM Gateway application by publishing an identity and IP allowlist rule through the Policy Engine.
📍 In the console, go to Govern › Policy Engine › LLM Gateway › Controls › Identity & Network Trust. Use the add menu in Allowed source IPs to add a CIDR range, set scope to the target Application or App tag, set the outcome to Required, then Save to draft and publish.
Override how caller identity is read for a specific application — for example, trusting a custom email header only for that app — without changing the global identity settings.
📍 In the console, go to Govern › Policy Engine › LLM Gateway › Controls › Identity & Network Trust › Identity capture. Use the add menu to create a rule, enable Trust X-User-Email header, set scope to the target Application, then Save to draft and publish.
Govern identity and network trust for the LLM Gateway through the Policy Engine at Govern > Policy Engine > LLM Gateway > Controls > Identity & Network Trust, setting who must prove identity, who must send a conversation ID, and which networks may call.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Use Identity capture rules to override per-application, per-person, or per-group how a caller's identity is read, with settings including Trust X-User-Email header , Token object-ID fallback , Forwarded identity-token headers , Extra conversation headers , Allowed identity domains , Preferred email claims , and Identity from request body . Not checked yet When the Policy Engine is active for the LLM Gateway, the app's identity requirements freeze and published rules apply instead; Allowed source IPs and Identity capture scope and outcome rules are saved to draft before publishing. Not checked yet Classic values saved through Edit anyway apply only after the Policy Engine is disabled, preserving a fallback path for apps that have not yet migrated to rule-based governance. Not checked yet
4 details in Everything
QuilrAI's SDK mode now scans inline images and documents on request checks, returning per-file attachment metadata alongside text findings︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ USE IT
Check a user-supplied PDF for policy violations before passing it to your LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. — inspect attachments.scanned and summary.incomplete_count before trusting an allow verdict.
python
copy
import base64, os
from pathlib import Path
def file_data_url(path, mime):
encoded = base64.b64encode(Path(path).read_bytes()).decode('ascii')
return f'data:{mime};base64,{encoded}'
payload = {
'messages': [
{
'role': 'user',
'content': [
{'type': 'text', 'text': 'Inspect these attachments.'},
{
'type': 'file',
'file': {
'filename': 'sample.pdf',
'file_data': file_data_url('sample.pdf', 'application/pdf')
}
}
]
}
]
}
import requests
resp = requests.post(
'https://guardrails-usa-2.quilr.ai/sdk/check',
headers={'Authorization': f'Bearer {os.environ["QUILR_SDK_API_KEY"]}'},
json=payload
)
check = resp.json()
if check.get('attachments', {}).get('summary', {}).get('incomplete_count', 0) > 0:
raise RuntimeError('Attachment scan incomplete — do not forward')
if check['status'] == 'blocked':
raise RuntimeError(check['message'])
# Use check['checked_messages'], not the original messages.
Gate an inline image on request-check verdict, handling both block and incomplete-coverage cases before forwarding to your model.
python
copy
import base64, os
from pathlib import Path
def file_data_url(path, mime):
encoded = base64.b64encode(Path(path).read_bytes()).decode('ascii')
return f'data:{mime};base64,{encoded}'
payload = {
'messages': [
{
'role': 'user',
'content': [
{
'type': 'image_url',
'image_url': {'url': file_data_url('sample.png', 'image/png')}
}
]
}
]
}
import requests
resp = requests.post(
'https://guardrails-usa-2.quilr.ai/sdk/check',
headers={'Authorization': f'Bearer {os.environ["QUILR_SDK_API_KEY"]}'},
json=payload
)
check = resp.json()
for item in check.get('attachments', {}).get('items', []):
if item.get('incomplete') or item.get('unscannable'):
raise RuntimeError(f'Attachment {item["id"]} not fully scanned')
if check['status'] == 'blocked':
raise RuntimeError(check['message'])
Enable attachment scanning for SDK request checks by turning on Scan attachments in the SDK app's Attachments settings, or via the equivalent published Policy Engine control — OCR OCR Optical character recognition, converting text in an image or scanned document into machine-readable characters. It lets software search or process text that was stored as pixels. , document text, and visual classification (Classify images plus at least one Image Risks type) all apply.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Attachment findings are returned separately from message-text findings in a new attachments field, with scanned, summary, and items[] sub-fields including items[].id, items[].path, items[].kind, items[].status, items[].reason, items[].stages_run, items[].ocr_used, items[].data_types, items[].image_labels, items[].action, items[].stripped, items[].incomplete, and items[].unscannable. Not checked yet SDK checks now surface a summary.incomplete_count field so callers can distinguish an allowed-but-partially-scanned result from a fully clean pass — scanner errors and timeouts fail open with action: 'allow' while coverage flags report the gap. Not checked yet When an attachment is outside the primary content field, the response now includes a processed_body field containing the complete sanitized input body (including primary text redactions); on a block, processed_body is null. Not checked yet Redact or partial-redact actions on attachments remove the entire affected attachment (rather than editing pixels or document contents) and return status: 'redacted' and action: 'redact' even when surrounding message text is unchanged. Not checked yet
+1 more
show less
Attachment blocks return the existing HTTP 200 SDK verdict with status: 'blocked' and an action code, keeping attachment error codes out of text entity placeholders. Not checked yet
Enable attachment scanning for SDK request checks by turning on Scan attachments in the SDK app's Attachments settings, or via the equivalent published Policy Engine control — OCR OCR Optical character recognition, converting text in an image or scanned document into machine-readable characters. It lets software search or process text that was stored as pixels. , document text, and visual classification (Classify images plus at least one Image Risks type) all apply.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Attachment findings are returned separately from message-text findings in a new attachments field, with scanned, summary, and items[] sub-fields including items[].id, items[].path, items[].kind, items[].status, items[].reason, items[].stages_run, items[].ocr_used, items[].data_types, items[].image_labels, items[].action, items[].stripped, items[].incomplete, and items[].unscannable. Not checked yet SDK checks now surface a summary.incomplete_count field so callers can distinguish an allowed-but-partially-scanned result from a fully clean pass — scanner errors and timeouts fail open with action: 'allow' while coverage flags report the gap. Not checked yet When an attachment is outside the primary content field, the response now includes a processed_body field containing the complete sanitized input body (including primary text redactions); on a block, processed_body is null. Not checked yet Redact or partial-redact actions on attachments remove the entire affected attachment (rather than editing pixels or document contents) and return status: 'redacted' and action: 'redact' even when surrounding message text is unchanged. Not checked yet
1 more in Everything
QuilrAI adds Groq, Perplexity Agent API, and Cohere provider support, plus Azure AI Foundry OCR OCR Optical character recognition, converting text in an image or scanned document into machine-readable characters. It lets software search or process text that was stored as pixels. and new vendor-specific API routes︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ TRY IT
Transcribe a recorded meeting through the Groq provider using Whisper on the gateway.
copy
$ curl https://guardrails-usa-2.quilr.ai/openai_compatible/v1/audio/transcriptions \
-F model=whisper-large-v3-turbo -F file=@meeting.wav
Run a web-grounded Perplexity Agent API query through the gateway with the built-in web search tool.
copy
$ curl https://guardrails-usa-2.quilr.ai/openai_responses/v1/responses \
-d '{"model": "openai/gpt-6-luna", "input": "What changed in the EU AI Act this month?", "tools": [{"type": "web_search"}], "max_output_tokens": 800}'
Extract text from a PDF via Azure AI Foundry Mistral Document AI OCR at the gateway endpoint.
copy
$ curl https://guardrails-usa-2.quilr.ai/openai_compatible/v1/ocr \
-d '{"model": "mistral-document-ai-2512", "document": {"type": "document_url", "document_url": "data:application/pdf;base64,<base64 PDF>"}}'
Adds new vendor integrations to the gateway: Groq models via https://api.groq.com/openai/v1 (chat, Responses create-only, speech-to-text whisper-large-v3-turbo/whisper-large-v3, speech translation to English at /openai_compatible/v1/audio/translations, text-to-speech WAV via canopylabs/orpheus-v1-english); Perplexity's Agent API at https://api.perplexity.ai (chat, Responses create-only, decision models pplx-decider-latest, pplx-decider-flash-latest, pplx-decider-v1.2, pplx-decider-flash-v1.2 at /perplexity/v1/decisions, and embedding models embedding models Lists of numbers a model produces to represent the meaning of text, images or code, so similar items sit close together. They power semantic search and RAG. pplx-embed-v1-0.6b, pplx-embed-v1-4b at /perplexity/v1/embeddings); Cohere models at https://api.cohere.com (/cohere/v2/embed, /cohere/v2/rerank, /cohere/v2/parse, /cohere/v1/tokenize, /cohere/v1/detokenize, /cohere/v2/batches/*, /cohere/v1/embed-jobs/*, /cohere/v1/datasets/*, with transcription via cohere-transcribe-03-2026 requiring language); Azure AI Foundry Mistral Document AI OCR deployments (mistral-document-ai-2512, mistral-ocr-*) at /openai_compatible/v1/ocr, billed at $3 per 1,000 pages via usage_info.pages_processed, requiring documents sent as base64 data: URIs; and Claude deployments on Azure AI Foundry (for example claude-opus-4-5) via an Azure Anthropic messages provider at base URL https://<resource>.services.ai.azure.com.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds pass-through support for vendor-native tools: Groq's browser_search tool ({"type": "browser_search"}) on Chat and Responses for gpt-oss models, billed at $5 per 1,000 searches and $1 per 1,000 page visits; and Perplexity's native web_search, fetch_url, and finance_search tools on Responses requests, returning search_results output items alongside the answer. Not checked yet Chat Completions, Anthropic Messages, Gemini and Bedrock client requests to Perplexity are now translated to the Agent API, including streaming and multi-turn tool calls. Not checked yet Perplexity embeddings embeddings Lists of numbers a model produces to represent the meaning of text, images or code, so similar items sit close together. They power semantic search and RAG. are now served two ways: OpenAI-style unit-length float vectors on the standard route and Perplexity's native quantized quantized Storing a model's weights at lower numeric precision, such as 8 or 4 bits instead of 16, so it needs less memory and runs faster. It trades a small amount of accuracy for fitting on smaller hardware. base64_int8 or base64_binary vectors at /perplexity/v1/embeddings. Not checked yet
4 details in Everything
QuilrAI adds an OpenAPI OpenAPI A vendor-neutral specification for describing REST APIs in a machine-readable format, maintained by the OpenAPI Initiative. Cyber tools use it to auto-generate clients, documentation, and validation from a single source of truth. document for the Inference API reference and a standalone POST /sdk/v1/check endpoint for pre-flight attachment scanning.
Run a standalone attachment scan before your own provider call with POST /sdk/v1/check using type: "request", then inspect the action field and forward the sanitized result from processed_body. Not checked yet Import the full Inference API reference as an OpenAPI document into your own API gateway to get every path, parameter, gateway-added header, and error code. Not checked yet
2 details in Everything
QuilrAI adds an audit log console with filtering, event inspection, pivot trails, and JSONL JSONL A text format where each line is a self-contained, valid JSON object, making it easy to stream, append, and process large datasets line by line without parsing a full JSON array into memory. or Excel export of sign-ins, configuration changes, and sensitive access︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Investigate who revealed or copied sensitive data in the last 7 days and export the evidence as JSONL for a ticket.
📍 In the console, go to Settings › Audit Logs. Set the period to Last 7 days , then select Filter (or press F) and set the activity type to Sensitive Access . Select the export button to open Export Center with those filters pre-filled, choose JSONL format, and run a one-time export.
Trace all actions taken during a specific sign-in session after a suspected incident.
📍 In the console, go to Settings › Audit Logs. Find the relevant sign-in event, select the arrow to open event details, then select View session activity to pivot to every action performed in that session.
Collect a ready-made export of admin activity for a compliance audit without manually configuring filters.
📍 In the console, go to Export Center and select the Audit trail quick export. Download the resulting file for submission as compliance evidence.
Adds a new Export Center to export audit log events as JSONL or an Excel workbook, with current period, filters, and searches pre-filled, runnable once or on a schedule, plus an Audit trail quick export for a ready-made export of admin activity.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Open the audit log in the console (requires the Read audit logs permission, with Export audit logs needed to export); view sign-ins, configuration changes, sensitive reads, and exports going back up to one year. Not checked yet Adds filtering of audit events by actor, Signed in with method (for example SAML SAML A standard for passing signed identity assertions between a sign-in provider and an application. It lets a user sign in through their organization's identity provider. or API key), activity type (including Sensitive Access to see who revealed or copied data), specific action, target type, outcome (Success, Failure, Denied), source, or IP address, with combined filters narrowing to events matching all criteria; search events by actor email, session, console page, target, request ID, IP address, browser, or event description using two separate search boxes; choose a time period from Last 24 hours , Last 3 days , Last 7 days , Last 3 months , Last 6 months , or Last 1 year , or a custom range with Select range ; and control row density with Rows per page set to 10, 25, or 50 events (default 25). Not checked yet Inspect individual events to see actor type, Signed in with , Target type , Target ID , Reason , Event ID , Source , IP address , Session fingerprint , Page , Browser information , Request ID , HTTP request , and HTTP status . Not checked yet Review before-and-after record snapshots in Changes (before → after) with line-by-line diffs; copy one side with Before or After , or copy the full event and both snapshots as JSON with Copy JSON . Not checked yet
+1 more
show less
Adds navigation from event details to related activity via Activity for this record , Activity by this actor , or View session activity (which keeps the current period and clears other filters), and to referenced records via buttons such as Open finding , Open conversation , Open user , Open agent , or Open inventory asset . Not checked yet
6 details in Everything
QuilrAI adds SAML SSO SAML SSO An authentication protocol that lets a user log in once with an identity provider and access multiple services without re-entering credentials, by passing signed XML assertions between parties. with enforced sign-in mode, audit logging of SAML SAML A standard for passing signed identity assertions between a sign-in provider and an application. It lets a user sign in through their organization's identity provider. events, and certificate rotation support.
New integration Set Enforce single sign-on to Enforced to route Google and Microsoft sign-ins through SAML, requiring all users to authenticate via the IdP IdP A service that authenticates users and supplies identity information to other applications. It is the sign-in authority behind many single sign-on systems. . Not checked yet SAML sign-ins appear in the audit log as Signed in with SAML , and changes to the SSO SSO Single sign-on, using one identity provider to sign in to multiple applications. It reduces separate passwords and centralizes account and access management. configuration page are also recorded there. Not checked yet Certificate rotation is supported: paste the new X.509 X.509 A standard defining the format of public-key certificates, maintained by the ITU-T, used by cyber tools to authenticate identities and establish encrypted connections over TLS and similar protocols. certificate immediately after activating it in the IdP to avoid sign-in failures. Not checked yet
3 details in Everything
QuilrAI adds Smart Groups — named, reusable people sets scoped to Policy Engine rules, gateway access, role assignments, and sharing︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Add a large team to multiple Smart Groups at once without manually selecting individuals — useful when onboarding a new department.
📍 On the Smart Groups list, select the CSV import option, choose your file (with an email column, up to 10,000 addresses), then search for and select up to 50 Smart Groups to import into. The import runs in the background; monitor progress with the circular arrow button next to the import indicator.
View a group's assigned V2 roles and effective V2 access capabilities in the member panel when Access Control V2 is enabled.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Smart Group names are limited to 120 characters (unique, case-insensitive), descriptions to 1,000 characters, and per-change membership operations to 1,000 people on creation or addition and 500 on removal. Not checked yet Access Groups tab (V1 roles only) shows platform access groups with their status and configured roles in a view-only tab, removed automatically when the organization migrates to Access Control V2. Not checked yet Smart Group changes are recorded in audit logs. Not checked yet
4 details in Everything
QuilrAI adds an Action Requests page to approve, reject, and revoke Browser Extension access justifications from a central console view.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Review and reject several pending Browser Extension requests at once, sending each requester an email explaining why their access was denied.
📍 1. Go to Govern › Action Requests.
2. Select the Pending tab.
3. Check the boxes next to the requests to reject (or use the header checkbox to select the whole page).
4. Select Bulk reject .
5. Enter a reason (up to 500 characters) — the same reason applies to every selected request.
6. Keep Email each requester selected so each person receives one email listing their rejected requests.
7. Confirm to save.
Revoke a previously granted approval when a user no longer needs access, immediately re-blocking the action and notifying the user.
📍 1. Go to Govern › Action Requests.
2. Select the Approved tab. If the approval is not visible, change the period filter to a longer range (up to Last 1 year ).
3. Find the row for the requester, application, and action, then select Revoke .
4. Enter an optional reason (up to 500 characters).
5. Keep Email the user selected to notify them.
6. Select Revoke to confirm.
Approve or reject Browser Extension justification requests individually or in bulk from the new Action Requests page, with an optional reason of up to 500 characters logged to the audit log and optionally emailed to the requester.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Revoke an existing approval from the Approved tab to immediately re-block the action for that person, moving their earlier requests to the Rejected tab. Not checked yet View Action Requests across three tabs — Pending , Approved , and Rejected — filterable by period (up to Last 1 year ), requester email, application name, or justification text. Not checked yet Requires the Read Browser Extension permission to view the page and Manage Browser Extension to approve, reject, or revoke; without Manage Browser Extension the page is view-only. Not checked yet Every approval, rejection, and revoke is recorded in the audit log as a Decide Action Approval event. Not checked yet
5 details in Everything
QuilrAI adds an MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. policy engine with simulate-before-publish workflows, version history, and traffic replay for LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. and MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. controls︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Block sensitive data from a contractor Smart Group in the LLM Gateway without affecting other users — test both matching and non-matching cases before publishing.
📍 1. Go to Controls › Data & Adversarial Risks and start a recipe for blocking sensitive data.
2. Set the Smart Group to your contractor group, choose the Request stage and sensitive data types, then Save to draft.
3. Open Test › Try a situation, select a Person in the contractor group, choose the AI model and Request type, add the sensitive data type under More details, and confirm the outcome is blocked .
4. Repeat with a Person outside Contractors and confirm their outcome is unchanged.
5. Open Replay activity, set a Time range, and use Advanced replay options to filter to contractor traffic. Run the check and inspect unexpected matches.
6. Click Review & publish to publish the change as the next version, then check the Activity tab.
Roll back a policy change that caused unexpected blocks by restoring a previous version from Version history.
📍 1. Open the affected control and go to Version history.
2. Select the last known-good version and compare it with Live version using the change summary and Source diff.
3. Click Restore to republish that version as the new active version.
4. Confirm the restored version number in Version history and monitor the Activity tab.
Author an MCP Gateway rule with caller and route conditions that the visual editor cannot fully express, using QuilrQL directly.
📍 1. Open Controls for the MCP Gateway area and choose Add rule.
2. Set Person, MCP server, and Tool targets, then click Edit technical source to open QuilrQL.
3. Write the advanced condition (e.g. caller, route, and operation filters) and read the Reads as preview.
4. Save to draft, then open Test › Try a situation, describe What is happening?, select the MCP server and Tool, add caller and route details, and run the test.
5. Publish via Review & publish when the simulated outcome is correct.
QuilrAI now supports MCP Gateway controls alongside LLM Gateway controls, letting you target Person , MCP server , and Tool in policy rules and test them with 'What is happening?' simulation.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Replay recent recorded traffic against draft rules using Replay activity with a configurable Time range and Advanced replay options to narrow the sample — without changing live traffic. Not checked yet Edit policy conditions and effects directly in QuilrQL via Edit technical source for logic the visual editor cannot express, while keeping the same draft/test/review/publish workflow. Not checked yet Test multiple scenarios at once with Test multiple situations to expand coverage before publishing. Not checked yet Watch post-publish outcomes per control in the Activity tab alongside LLM Insights and MCP Insights on the respective gateways. Not checked yet
5 details in Everything
QuilrAI adds a Policy Engine panel for MCP Server MCP Server A process that exposes tools, resources, and prompts over Anthropic's Model Context Protocol, letting an AI agent call external APIs or local services through a standardised interface. Access control, letting teams allow or deny agent, user, and group connections by server, route, or identity provider identity provider A service that authenticates users and supplies identity information to other applications. It is the sign-in authority behind many single sign-on systems. ︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Restrict a sensitive MCP server so only a specific team's Smart Group can connect, keeping all other callers denied by default.
📍 In the console, go to Govern › Policy Engine › MCP Gateway › Controls › MCP Server Access. Choose the recipe 'Let a team connect to a server', set the target server and the Smart Group under Applies to , set the outcome to Allow, then save to draft. Use Test › Try a situation to verify an allowed and a denied caller, then review and publish.
Block access to an MCP server through OneMCP while still allowing direct connections governed by other rules.
📍 In the console, go to Govern › Policy Engine › MCP Gateway › Controls › MCP Server Access. In the Hidden from OneMCP section, start a blank rule, set the target server under Applies to , save to draft, then review and publish.
Control which AI agents, Smart Groups, and people can connect to an MCP server — separately from permission to list or call its tools — via Govern > Policy Engine > MCP Gateway > Controls > MCP Server Access.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Hide an MCP server from OneMCP while letting other rules govern direct access, using the Hidden from OneMCP section in the same panel. Not checked yet Configure server access rules by server, person, Smart Group, agent, route, identity provider, or network, with the highest numeric priority winning and Allow breaking ties. Not checked yet
3 details in Everything
QuilrAI MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. adds an Analytics and Insights dashboard with traffic, security, and reliability views across connected servers︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Investigate why a specific MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. server is seeing elevated failure rates by drilling into its logs from the server card.
📍 In the MCP Gateway workspace, locate the server card, then choose Inspect › Logs to open that server's Activity view. Set the server scope and period to narrow the log range before reviewing failures.
Review and approve queued upstream tool changes before they reach clients — useful when a server changed its tool signatures and you want to validate before exposing them.
📍 On the Overview page, find the N servers changed their tools upstream notice, then select Review tool updates to open the pending changes. Clients keep the current tool list until you approve.
QuilrAI MCP Gateway now has a full-page Analytics and Insights section with Overview , Data & security , Reliability , and Servers & tools tabs for reviewing adoption, access maps, failures, and tool savings.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet A new Tool change watch feature queues upstream tool additions and changes for review, holding clients on the current tool list until changes are approved. Not checked yet Per-call metrics now surface on the Overview — calls in the period, the share routed through OneMCP, tokens saved, and success rate. Not checked yet Block and failure metrics are now available — calls the gateway refused, block rate, failed calls, and a comparison to the previous period. Not checked yet Server cards now offer Inspect > Logs to open that server's Activity view and a settings action scoped to exactly one server. Not checked yet
+1 more
show less
Adds Connectors for private-network MCP servers and REST APIs REST APIs A convention for building HTTP-based interfaces where resources are addressed by URL and manipulated with standard verbs like GET, POST, and DELETE, giving cyber tools a predictable way to integrate with external services. . Not checked yet
6 details in Everything
QuilrAI now publishes an API — 1 endpoint across 1 area: Api︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
Api (1 endpoint) — read︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet
1 detail in Everything
QuilrAI adds a Detection Models page with configurable risk thresholds for data and AI adversarial checks across LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. and MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. policies.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Tune PII PII Personally Identifiable Information — data that can identify a specific individual, such as names, email addresses, or SSNs. Cyber tools flag or redact it to limit exposure and meet privacy regulations. detection sensitivity so that low-signal signals like a person's name alone are caught and routed through Policy Engine rules.
📍 In the QuilrAI Console, go to Govern › Detection Models › Data Risks › Out-of-the-box › Contextual. Find the PII category row, open its Risk level dropdown and change it from Low to High. Expand PII to confirm the name subcategory (priority: Low) is now included in the detection scope.
Verify a jailbreak detection fires on a suspect prompt before wiring it into a live guardrail policy.
📍 In the QuilrAI Console, go to Govern › Detection Models › AI Adversarial Risks. Find the Jailbreak group, click Show techniques to review individual techniques, then click View & test. Paste a synthetic adversarial prompt and confirm the risk-level badge and technique match before referencing this detection in a Policy Engine rule.
Adds the Detection Models page under Govern in the QuilrAI Console, with two tabs — Data Risks and AI Adversarial Risks — as the central place to define what Quilr scans for and the default risk level of each finding.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds Out-of-the-box and Custom views under Data Risks , where built-in detections are split into Contextual (uses surrounding text) and Non-contextual (matches by format) sub-views. Not checked yet Adds contextual detection categories — PII, PHI PHI Protected Health Information: individually identifiable health data regulated under the US HIPAA law, whose strict handling requirements drive cyber tools to audit, mask, or restrict access to it. , PFI, PCI PCI A hardware bus standard that connects peripheral devices to a computer's motherboard; cyber tools targeting hardware-level forensics or memory analysis use it to access device registers and DMA regions directly. , Insurance Data, Auth & Secrets, Code Scripts and Queries — each with a configurable Risk level (None , Low , Medium , High ) that acts as a detection threshold: None detects nothing, Low fires only on High -priority subcategories, Medium on High and Medium , High on all three. Not checked yet Adds non-contextual detections for fixed-format entities — SSN, Aadhaar, PAN, passport number, phone number, email address, IBAN, UPI ID, card number, and CVV — each with an Enabled toggle. Not checked yet Adds AI Adversarial Risks tab covering Prompt Injection, Jailbreak, Prompt Context Corruption, Semantic Adversarial Prompts, Social Engineering Prompts, and Response Risks, each showing a risk-level badge and a Show techniques drill-down. Not checked yet
+2 more
show less
Adds View & test action on every category and adversarial group, letting practitioners run sample text against a detection before referencing it in a policy. Not checked yet Establishes a precedence model: an LLM Gateway app's Guardrails Risk level overrides the org-wide Detection Models setting, and when the Policy Engine is enabled the policy wins over both. Not checked yet
7 details in Everything
QuilrAI Policy Engine gains a full draft-to-publish workflow with simulation, replay, and rollback on LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. and MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. Gateways.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Verify a new scope-limited block rule before it touches live traffic by simulating a positive and negative case in the Policy Engine.
📍 1. On the Data & Adversarial Risks card, select Configure › add a Smart group scope for Contractors , pick Auth & Secrets , set action to block.
2. Select Describe a request . Add a user in Contractors and use Add detection to report Auth & Secrets — card should resolve to block.
3. Repeat with a user outside Contractors — card should resolve to monitor (or the prior value). If it shows block, the scope is wrong.
Measure blast radius of a draft rule against 30 days of real traffic before publishing, to catch unintended blocks.
📍 In the Policy Engine, with your draft open, select Replay › set window to 30 days › run. Inspect the would-be-blocked set to confirm only Contractors calls carrying Auth & Secrets appear.
Author a block rule in QuilrQL source for bulk or complex policy work that the card editor cannot express.
yaml
copy
policy block_request_secrets priority 900 {
request
data_type ("Auth & Secrets")
then {
dlp.action = block;
risk.level = critical;
}
}
Adds Describe a request (MCP: Describe a call ) simulation in the Policy Engine to show the winning value per control for a single request, with Add detection reporting a data type as found with a count per type.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds synthetic-case simulation: run up to 100 synthetic cases against a draft to read the engine's actual decision evidence — which rules matched, on which stage, and the call-level outcome. Not checked yet Adds Replay of recorded traffic against a draft: up to 90 days and 5,000 requests on the LLM Gateway, with filters by window, MCP, tool, user, and route on the MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. . Not checked yet Adds a shared draft workflow on the LLM Gateway and MCP Gateway tabs of the Policy Engine, where every card edit from every admin collects in one draft with a concurrency guard preventing silent overwrites. Not checked yet Adds Scope shortcuts on cards to add a User, Smart group, or Application condition with seeded priorities (900, 700, and 600) so narrower scopes win without manual numbering. Not checked yet
+6 more
show less
Adds Advanced policies > Advanced workspace with New draft from active revision , Suggested policies , Insert from catalog , Save draft , and an 02 Analyze step running Diagnostics, Simulation, and Historical Try before publishing. Not checked yet Adds a </> toggle on every policy to switch between the sentence editor and QuilrQL source view in both directions. Not checked yet Adds numbered revision publishing: all pending changes publish together as the next Revision N ; LLM Gateway publish accepts a message; MCP Gateway drafts can be renamed. Not checked yet Adds rollback: any earlier revision can be republished as a new revision, keeping the timeline forward-only and fully auditable, without affecting classic app settings. Not checked yet Supports condition operators including is inside CIDR, matches pattern, has entry, has count, is all of, and occurrence thresholds on Data found fields in the card editor. Not checked yet Adds an activity view rolling up governed calls, blocked calls, and tokens saved over the last 7 or 30 days; MCP Gateway attributes match counts per policy, while LLM Gateway reports tenant totals only. Not checked yet
11 details in Everything
QuilrAI adds AI-designed custom dashboards with KPI/chart widgets, filters, caveats, and shareable ?dashboard= links.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ TRY IT
Share a specific dashboard directly with a teammate who has access, without them having to search for it.
copy
$ https://app.quilrai.dev/console/observe/dashboards?dashboard=<dashboard-id>
Create a new AI-designed dashboard from the QuilrAI console when you need a custom view of your data.
📍 1. Go to Observe › Dashboards (page titled Custom dashboards ).
2. Click + Create dashboard .
3. Describe what you want to see; the AI designer asks follow-up questions.
4. Review the preview built on your own data.
5. Publish, choosing Organization visibility or keeping it private.
Adds ?dashboard= query parameter to dashboard URLs, enabling direct sharing of a specific dashboard with anyone who has access.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet New Observe > Dashboards section (titled Custom dashboards ) lets practitioners build dashboards by describing them in plain language to an AI designer, which asks follow-up questions and generates a preview on live data. Not checked yet Dashboards support KPI and chart widgets, a Filters panel with time-period selection and Apply filters , a Caveats section noting data coverage, and a Revise with AI prompt to iteratively update the layout. Not checked yet Dashboards can be published with Organization -wide or private visibility, and an Export option plus a more-actions menu are available on each dashboard. Not checked yet
4 details in Everything
QuilrAI adds an Agents view under Observe showing every AI agent, its skills, MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. servers, system prompts, models, and users across your estate.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Find risky or oversized system prompts across all observed agents to prioritise prompt hygiene work.
📍 In the console, go to Observe › Agents, open the System prompts tab, and sort by Risk or token size to surface prompts flagged with high risk or the largest compression savings.
Investigate which AI agents are reaching an MCP server and whether any calls are being blocked, to audit lateral-reach exposure.
📍 In the console, go to Observe › Agents, open the MCP servers tab, and review the Used by, Calls, Tools, and Blocked columns for each server.
Audit a specific user's agent activity — agents run, call volume, and blocked calls — to investigate anomalous behaviour.
📍 In the console, go to Observe › Agents, open the Users tab, locate the person of interest, and review their agents used, calls, blocked calls, and devices columns.
Adds Observe > Agents screen listing every AI agent observed across the estate, with columns for Source, Capabilities (observed and declared), Calls, Users, Governance, and Last seen.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds source-filter chips for Azure AI Foundry , Copilot Studio , Endpoint discovered , Endpoint runtime , MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. , and OpenAI Compliance to scope the agent inventory. Not checked yet Adds headline tiles for Agents observed , Observed calls , People , and MCP reach (with blocked-call counts) at the top of the Agents view. Not checked yet Adds Skills tab showing which skills agents use and how widely, as read-only usage evidence. Not checked yet Adds MCP servers tab showing which agents call which MCP servers, with columns for Used by, Evidence, Calls, Users, Tools, and Blocked. Not checked yet
+3 more
show less
Adds System prompts tab showing observed prompts with token size, potential compression savings, risk rating, and a top suggestion per prompt. Not checked yet Adds Users tab listing the people who run agents, with per-person columns for agents used, calls, blocked calls, and devices. Not checked yet Adds a per-agent drawer with five tabs: Overview , Users , Dependencies & Calls , Activity , and System prompt , surfacing identity, type, parent applications, sources, top users, and source instances. Not checked yet
8 details in Everything
QuilrAI gains an Observe > Users hub with five tabs covering AI usage, risk, deployment coverage, accounts, and Quilly coaching feeds.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Spot employees conducting work in personal AI accounts and immediately queue a Quilly agent to follow up on their findings.
📍 In the console, go to Observe › Users › Accounts. Filter the Account type column to Personal . Select up to 50 accounts and choose Activate Agent .
Audit Browser Extension rollout health — find users on stale extension versions or missing the Browser Utility before they create a coverage gap.
📍 In the console, go to Observe › Users › Browser deployment. Review the per-user table for version lag and Browser Utility status. Use Validate deployment for remediation steps.
Investigate off-hours AI activity for a specific user by opening their full profile and reviewing LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. Gateway requests.
📍 In the console, go to Observe › Users › All users. Filter by Off-hours actors . Click Full profile on the person card, then navigate to LLM Gateway › Requests.
Adds Observe > Users page with five tabs — All users , Browser deployment , Endpoint deployment , Accounts , and Quilly — giving a per-person view of AI usage, risk, and sensor coverage.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds All users tab with headline tiles (People , Flagged people , Off-hours actors , Activity ) and per-person cards showing apps, topics, posture per sensor, usage, active hours, risk, and origin. Not checked yet Adds Cards and Table layout toggle, saved views, Add filter , Refresh users , Columns , and Export controls on the All users tab. Not checked yet Adds a Full profile link on each person card that opens a profile drawer with sensor, directory, extension, and endpoint status, plus left-nav sections: Overview , Graph , Interactions , Inventory , Accounts , Origin & access , and gateway sub-tabs. Not checked yet Adds LLM Gateway sub-tabs (Connections , Requests , Usage & cost ) inside the person profile drawer. Not checked yet
+6 more
show less
Adds MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. sub-tabs (Connections , Tool calls ) inside the person profile drawer. Not checked yet Adds Browser deployment tab showing Browser Extension coverage, version lag, browser types in use, and Browser Utility status per user. Not checked yet Adds Endpoint deployment tab with headline tiles (Workstations , Enabled , Disabled , Without persona , Latest version ) and a table of Workstation, User, OS, Agent version, Status, and Last registered, with bulk Enable / Disable actions. Not checked yet Adds Accounts tab listing AI accounts people use with Account type (Personal or Corporate ), approval status, risk, activity, and first/last observed, supporting bulk selection of up to 50 accounts to Activate Agent . Not checked yet Adds Quilly tab as a feed of Quilly AI coach conversations split into Findings , Coach , and User initiated sub-feeds, each entry showing summary, user, control, status, action taken, tools used, and severity. Not checked yet Adds Activate Agent bulk action on both Accounts tab and All users tab to have a Quilly agent follow up on selected accounts or people's findings. Not checked yet
11 details in Everything
QuilrAI adds Findings & Interactions hub with investigation drawer, saved views, bulk triage, agent activation, and export center.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Audit a specific person's AI activity over the past week without leaving your filtered list — open the investigation drawer to replay exactly what they did and which policy fired.
📍 In the console, go to Observe › Findings & Interactions. Select the Interactions tab, set the date menu to Last 7 days , type the person's name in the search box, then click any row to open the investigation drawer. Open the Prompts & completions or Capture tab and use Flagged only to focus on policy hits. Click Copy thread to capture the transcript for your ticket.
Send follow-up messages to the people behind a batch of open findings — for example, to explain the policy they triggered and ask them to remediate — without manually contacting each one.
📍 In the console, go to Observe › Findings & Interactions. Use the Open toggle to show unresolved findings, apply Category and Outcome filters to narrow the set, then select up to 50 finding cards and click Activate Agent . In Configure agent , choose the Agent, set the Policy, Tone, Reminders (0-3), and Resolve within (e.g. 48 hours), then click Generate plan . Review the drafted plan, confirm each finding shows Ready , and click Start agent .
Persist a compliance-audit filter combination so the same filtered view of blocked findings from the LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. Gateway is one click away every morning.
📍 In the console, go to Observe › Findings & Interactions. On the Findings tab, set Sensor to LLM Gateway and Outcome to Blocked , choose the Table layout, and click Columns to add the columns you need. Then click Save new view and name it. The saved view appears as a chip next to All findings for instant access.
Adds Findings & Interactions page (under Observe > Findings & Interactions in the sidebar) as a unified hub showing AI activity across all sensors, with Findings and Interactions tabs.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds Bird's-eye , Cards , and Table layout buttons on Findings & Interactions to switch between a trend-summary view, a card queue, and a sortable row-per-item table — filters and the selected period carry across all three. Not checked yet Adds Group related conversations toggle on the Interactions tab to fold related records (such as multiple prompts in one short session) into a single row. Not checked yet Adds quick filters on Findings — Sensor , Person , App , Category , and Outcome — and on Interactions — Sensor , Person , App , Model , and Tool — plus a More filters panel that includes Triage status , Triage reason , Topic , Agent , and Device . Not checked yet Adds All / Open / Resolved toggle to show findings by triage state; Open surfaces the queue still awaiting a decision. Not checked yet
+4 more
show less
Adds Save new view to persist a combination of filters, columns, and layout as a chip beside All findings for one-click return. Not checked yet Adds investigation drawer (opened by clicking any card or row) with Summary , activity, Sensitive data , Context , and Details tabs; the activity tab is named by sensor — Capture (browser), Prompts & completions (LLM Gateway), Tool calls (MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. ), or Agent activity (Endpoint Agent). Not checked yet Adds Reveal values in the investigation drawer to show masked sensitive-data values in clear for authorized roles; each reveal is logged in Audit logs as Requested sensitive data reveal , and Copy thread is logged as Requested conversation copy . Not checked yet Adds Export action on Findings & Interactions that sends the filtered list to the Export Center for download. Not checked yet
9 details in Everything
QuilrAI adds an interactive Graph view mapping AI estate relationships across people, agents, MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. servers, data, and controls.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Trace which agents and MCP servers a specific person can reach, starting from their profile.
📍 In the console, go to Users › [select a person] › Graph section to open that person's relationship map showing their AI footprint.
Audit all agentic relationships in the estate — e.g. which agents reach a given MCP server — using a focused lens and sensor filters.
📍 In the console, go to Observe › Graph, select the Agentic lens, then use the sensor chips to toggle MCP and LLM data sources, and click expand on the MCPs category node to follow relationships.
Review an asset's connections to people, agents, and controls directly from Inventory.
📍 In the console, go to Inventory › [open an asset drawer] › Graph section to see that asset's relationship view.
Supports five graph lenses — Estate , People , Agentic , Risk , and Governance — each emphasising a different relational question.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds sensor chips to show or hide data from LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. , MCP, Endpoint, Browser, Copilot, GitHub, Foundry, and OpenAI sources within the graph. Not checked yet Surfaces a central Organization node with category nodes for Apps, People, Agents, MCPs, Skills, Models, Data, Devices, Plugins, Hooks, Permissions, Tool families, and Work (working directories and repositories). Not checked yet Adds a Period selector and + Add filter control to narrow the graph view. Not checked yet Embeds the same relationship Graph section inside individual person profiles under Users and inside asset drawers in Inventory . Not checked yet
5 details in Everything
QuilrAI console gains deep-link URL parameters, Bird's-eye layout, Export Center, and saved views across all list pages.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Open the Findings filter panel instantly from the keyboard to narrow results without reaching for the mouse.
📍 Press F on any Findings & Interactions list page to open the full filter panel, then select fields such as Sensor, Person, App, Category, or Outcome.
Adds ?person=, ?asset=, ?agent=, ?interaction=, ?dashboard=, ?workspace=, and ?manage= URL parameters that open the corresponding detail drawer directly, enabling shareable deep links to any drawer.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds a Bird's-eye layout on Findings & Interactions that shows summary tiles and charts for the current filters before drilling into rows. Not checked yet Adds an Export Center where exports triggered from any list page are collected, recurring exports are configured, and past runs are downloaded. Not checked yet Adds saved views that remember filters, columns, and layout for any list page, accessible as chips above the list via Save new view . Not checked yet Adds a keyboard shortcut (F) to open the full filter panel from anywhere on a list page. Not checked yet
+2 more
show less
Adds Compare: previous period option on pages such as Costs & Savings to show changes against the prior period. Not checked yet Adds a More filters / Filters > Add filter panel exposing the full field list per page, including sensor-specific fields. Not checked yet
7 details in Everything
QuilrAI adds a Syslog integration that forwards Extension findings via TCP TCP A network protocol that delivers a reliable, ordered stream of bytes between two endpoints. It detects lost data and retransmits it. , UDP UDP A network protocol that sends individual messages without guaranteeing delivery or order. Applications trade built-in reliability for less overhead and can add their own recovery. , or TLS in RFC 5424 RFC 5424 The IETF standard that defines the Syslog protocol's message format, severity levels, and transport rules, giving cyber tools a common structured log schema to parse and forward system events reliably. or RFC 3164 RFC 3164 The 2001 IETF specification that standardised the BSD syslog protocol, defining message format and UDP transport for system log data. Cyber tools use it to parse or emit legacy syslog reliably across heterogeneous infrastructure. format.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Forward QuilrAI DLP DLP Data Loss Prevention: a category of controls that inspect and block sensitive data from leaving an organisation via email, web, or removable media, giving cyber tools a policy enforcement layer over data in motion and at rest. findings to a TLS-secured syslog server using RFC 5424 framing with octet-counting, so rsyslog can reliably parse multi-line messages.
📍 In QuilrAI, go to Integrations › Available tab › click + Add on the Syslog tile, then fill in:
Syslog Server IP/Domain: syslog.corp.example.com
Syslog Server Port: 6514
Protocol: TLS
Message Format: RFC 5424
Message Framing: Octet-Count
Adds a Syslog integration supporting TCP, UDP, and TLS transport protocols to forward Extension findings to any syslog server.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Supports RFC 5424 (default) and RFC 3164 message formats, configurable per connection. Not checked yet Supports TCP Message Framing options — None (default), Octet-Count (RFC 6587 octet-counting), and Non-Transparent (RFC 6587 trailing-newline) — for compatibility with receivers such as rsyslog and syslog-ng syslog-ng An open-source log collector and router that ingests, filters, parses, and forwards log messages from many sources to many destinations, giving cyber tools a flexible, high-throughput pipeline for centralizing event data. . Not checked yet Delivers findings as a structured JSON payload under the quilr-siem-event app name, including browser context (name, version, os), user identity (username, accountname), application (name, url), and DLP check detail (id, name, mode, action_name, detections_original, detections_final). Not checked yet
4 details in Everything
QuilrAI adds a Triage Center with bulk-close suggestions, auto-resolve rules, activity undo, and detection tuning via learnings.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Suppress recurring false positives org-wide so the same low-risk content stops filling your findings queue.
📍 In the console, go to Observe › Triage center › Detection tuning. Click Run now to generate fresh learnings, then open To review . For each learning card, read the explanation, check Findings would be cleared , click Show examples to verify, tick the learnings you agree with, and click Apply learnings . Applied learnings resolve all matching open findings as False positive and suppress that content going forward.
Automatically close findings about test accounts without manual review, so your team only sees findings that need action.
📍 In the console, go to Observe › Triage center › Auto-resolve rules. Click Create a rule , select the saved condition that matches test-account findings, set the action to Resolve , and save. Choose whether the rule should also apply to already-open findings matching the condition. The rule runs in list order and logs every change to the Activity tab.
Bulk-close a batch of stale findings and immediately undo if the wrong findings were captured.
📍 In the console, go to Observe › Triage center › Suggestions. Open a suggestion card (e.g. People no longer active ), review the counts and Largest finding groups list, then click Resolve . To roll back, open the Activity tab, locate the bulk-close entry, and click Undo — this reopens every finding the bulk close resolved, except those changed manually afterwards.
Adds Auto-resolve rules tab to automatically resolve, review, or tag new open findings that match a condition, running rules in list order with every change logged in Activity .︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds Suggestions tab for bulk-closing open findings grouped by reason (e.g. apps now approved, people no longer active, blocked for 14 days), with a re-checked count and full undo from Activity . Not checked yet Adds Activity tab listing every bulk close, auto-resolve rule change, and undo with filters for period, type (All / Suggestion / Undo ), actor, and reason — plus View findings and Undo actions per row. Not checked yet Adds Detection tuning tab with Quick suggestions that generate plain-language learnings from recent findings; applying a learning resolves all matching open findings as False positive and suppresses the same content going forward. Not checked yet Adds Run now and Auto (automatic daily schedule with configurable Time of day , Time zone , and Findings per run ) controls for detection-tuning suggestion runs. Not checked yet
+3 more
show less
Adds Open learnings and Findings would be cleared counters in the Detection tuning header to preview impact before applying. Not checked yet Supports three triage states — Open , In review , and Resolved — filterable via the All / Open / Resolved toggle and the Triage status filter on the Findings page. Not checked yet Adds headline tiles (Suggestions ready , Resolved , Suggested to resolve , Resolved by reason ) with a 30-day / 90-day period toggle for queue overview. Not checked yet
8 details in Everything
QuilrAI adds a Google Workspace MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. with 42 tools spanning Gmail, Calendar, Drive, and Directory over customer-owned OAuth.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ USE IT
Opt in to Drive file-sharing for your deployment so agents can change file permissions via share_google_drive_file.
.env
copy
GOOGLE_ENABLE_DRIVE_SHARING=true
Install Google Workspace from the MCP Library and connect tenant-owned OAuth so agents can reach all four surfaces under one governed gateway boundary.
📍 In QuilrAI, go to Settings › AI Gateway › MCP Gateway, click Library, find Google Workspace, click Set up, enter the OAuth Client ID and Client Secret from Google Cloud Console, click Install, then Connect OAuth as an administrator and grant all 15 scopes at Google's consent screen.
Enables GOOGLE_ENABLE_DRIVE_SHARING=true environment variable to activate the otherwise-disabled share_google_drive_file tool for Drive permission changes.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds share_google_drive_file tool (disabled by default, destructive) for changing who can access a Google Drive file; grants to anyone require explicit confirmation. Not checked yet Adds Gmail tools: search_gmail_messages, get_gmail_messages, get_gmail_thread, read_gmail_attachment, list_gmail_drafts, get_gmail_draft, list_gmail_labels, sync_gmail_messages, save_gmail_draft, save_gmail_label, update_gmail_messages, send_gmail_message, trash_gmail_messages, delete_gmail_label, delete_gmail_draft. Not checked yet Adds Google Calendar tools: list_google_calendars, list_google_calendar_events, get_google_calendar_event, list_google_calendar_event_instances, get_google_calendar_availability, sync_google_calendar_events, save_google_calendar_event, save_google_calendar, respond_to_google_calendar_event, delete_google_calendar_event, delete_google_calendar. Not checked yet Adds Google Drive tools: list_google_drive_files, get_google_drive_file, list_google_shared_drives, read_google_drive_file, export_google_drive_file, list_google_drive_comments, list_google_drive_revisions, list_google_drive_permissions, sync_google_drive_changes, create_google_drive_file, save_google_drive_file, create_google_drive_comment, trash_google_drive_file. Not checked yet
+5 more
show less
Adds Workspace Directory tools via the People API: get_google_user_profile, search_google_directory, list_google_directory_people (read-only, own domain only, no Admin SDK). Not checked yet Supports incremental sync across Gmail (sync_gmail_messages), Calendar (sync_google_calendar_events), and Drive (sync_google_drive_changes) via sync-marker-based tools. Not checked yet Tags seven default-enabled destructive tools (send_gmail_message, trash_gmail_messages, delete_gmail_label, delete_gmail_draft, delete_google_calendar_event, delete_google_calendar, trash_google_drive_file) with the destructive annotation so operators can hide or require human approval as a class. Not checked yet Requires 15 Google OAuth scopes including restricted drive, gmail.readonly, gmail.compose, gmail.modify, and sensitive calendar.* and directory.readonly scopes; tokens lacking openid and userinfo.email are rejected outright. Not checked yet Provides structured JSON error responses with code, HTTP status, retryable flag, and next_action field for all tool failures. Not checked yet
10 details in Everything
QuilrAI MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. sits between AI apps and MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. servers, enforcing tool rules, guardrails, and logging every call by user and agent.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Point an AI client at your MCP Gateway instead of a raw MCP server to enforce guardrails and log every tool call.
📍 In your AI client (e.g. Cursor or VS Code), replace the MCP server URL with your Quilr gateway URL, e.g. https://mcpgateway.quilr.ai/github/mcp, and add your API token as the bearer credential.
Restrict which AI agents can reach sensitive MCP servers by configuring Allowed Agents.
📍 In the QuilrAI console, go to Settings › AI Gateway › MCP Gateway › Allowed Agents, add a user-agent keyword for the permitted client (e.g. cursor ), and select which MCP servers that agent may access.
Enable the Policy Engine to enforce centrally published guardrail and tool rules across all servers, overriding local settings.
📍 In the QuilrAI console, go to Settings › AI Gateway › MCP Gateway, open a server, navigate to the Settings tab, and enable the Policy Engine. The Tools, Guardrails, Token Saving, and Group & User Rules sections will show Policy Engine active and follow published policies.
Adds the MCP Gateway, a proxy layer between AI apps (Claude, ChatGPT, Cursor, VS Code) and MCP servers that checks every tool call against tool rules and guardrails, then logs the user, agent, and result.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds OneMCP, a single gateway URL that serves every MCP server a user is authorized to reach, replacing per-server URLs. Not checked yet Adds per-server Quilr gateway URL (e.g. https://mcpgateway.quilr.ai/github/mcp) that AI clients call in place of the upstream MCP server. Not checked yet Adds Allowed Agents configuration to restrict which AI clients (matched by user-agent keyword) may connect and which MCP servers each agent can reach. Not checked yet Adds Security Guardrails on tool arguments and tool results, with a Stopped by guardrails metric tracking refused calls, guardrail flags, failed calls, and p95 latency. Not checked yet
+12 more
show less
Adds Group & User Rules to apply per-smart-group or per-user overrides to tool access and guardrail settings. Not checked yet Adds Input Aliases to translate mismatched tool inputs from AI clients, surfaced via a quick fixes drawer. Not checked yet Adds Token Saving strategies to reduce token consumption on MCP tool calls. Not checked yet Adds API to MCP capability to turn a REST API REST API A web API design style where clients interact with resources over HTTP using standard methods like GET, POST, and DELETE, giving cyber tools a predictable, language-agnostic way to integrate with external services. (base URL + spec) into callable MCP tools via the API MCP server type. Not checked yet Adds Policy Engine that, when active, replaces local Tools, Guardrails, Token Saving, and Group & User Rules settings with centrally published policies. Not checked yet Adds API Tokens for direct (non-OAuth) client connections to MCP servers. Not checked yet Adds a User dashboard at mcpgateway.quilr.ai where end users sign in, connect accounts, and copy their gateway URLs. Not checked yet Adds MCP Library with an install-request queue, allowing users to request servers that administrators can approve. Not checked yet Adds per-server and workspace-level analytics including tool calls, blocked calls, guardrail flags, OneMCP share, tokens saved, success rate, p95 latency, users, and servers over time. Not checked yet Adds Connections view showing which users have connected to which servers and their individual tool call history. Not checked yet Adds Health tab covering gateway verdict, rejected requests, access denied, auth challenges, OAuth refreshes, upstream errors, and rejection reasons across the whole gateway. Not checked yet New servers default to all tools turned off, so no tools are reachable until explicitly enabled. Not checked yet
17 details in Everything
QuilrAI Workflow Agents: build, publish and run governed AI agents from console, chat, Slack or a schedule︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Navigate to Workflow Agents and create a governed AI agent that runs via Slack, with tool approvals and run limits enforced through your MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. .
📍 1. In the QuilrAI Console, go to Settings › AI Gateway › Workflow Agents.
2. Click + Create agent and set a name, System prompt, model (from Your models or a Quilr model), and select tools from your MCP connections.
3. Set Maximum turns and Run timeout (seconds) under run limits.
4. Click Connect Slack to add Slack as a trigger surface.
5. Publish the agent — it is now reachable via Slack mention or DM, Chat, Start a task, or a schedule.
Build a Team of specialist agents under a lead model so a single Slack mention draws on multiple agents and returns one combined answer.
📍 1. In the QuilrAI Console, go to Workflow Agents.
2. Click Build a team in the header.
3. Select two to six published agents and choose a lead model to combine their answers.
4. Publish the team — it appears on My agents and can be triggered from Chat, Slack or a schedule like any single agent.
Adds Workflow Agents to the QuilrAI Console, letting you create, publish and run AI agents that call tools via your organization's MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. connections and LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. Gateway.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Supports four agent trigger surfaces: the QuilrAI Console (Start a task ), Chat , Slack mention or DM, and scheduled runs. Not checked yet Agents can be assembled into a Team of two to six published agents under a lead model that combines their answers into one result. Not checked yet Agent results are returned as Markdown, JSON or a table, posted back to the surface where the run started. Not checked yet Supports five agent runtimes (Engine ): LangGraph (recommended), OpenAI Agents SDK, Claude Agent SDK , Google ADK , and CrewAI. Not checked yet
+5 more
show less
Every tool call is governed by MCP Gateway rules and guardrails, tool approvals, and per-agent Maximum turns and Run timeout (seconds) limits. Not checked yet Adds a Library tab of editable agent templates and a Usage tab showing runs, completion rate, tool attempts and duration per agent. Not checked yet Adds Connect Slack on the Workflow Agents page to add Slack as a tool for agent triggers. Not checked yet Agent versioning tracks every publish as a new Revision ; runs in progress keep the version they started with and earlier revisions can be restored. Not checked yet Access is re-checked on every run — model access, tool access and sharing — ensuring each call goes through the same gateways and logs as all other AI traffic. Not checked yet
10 details in Everything
QuilrAI adds MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. Threat Detection — static code/dependency scans and live tool-surface enumeration with threat modelling for MCP servers.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Vet an MCP server's repository for supply-chain risks and exposed tool abuse vectors before adding it to the MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. .
📍 In the QuilrAI console, go to Assessments › Red Teaming › MCP Threat Detection. Enter a public repository URL and/or a live MCP server address, tick the acknowledgement checkbox, then click Run deep scan . Review findings under Recent scans .
Adds live tool-surface enumeration for a running MCP server, performing a read-only inspection of the tools the server exposes.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Accepts a public repository URL, a live MCP server, or both as inputs in a single scan run. Not checked yet Lists completed and in-progress scans under Recent scans with findings and coverage details for review. Not checked yet
3 details in Everything
QuilrAI MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. gains per-server access control: restrict which AI agents, smart groups, and users can connect before any tool is listed or called.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Lock a sensitive MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. server so only a specific user can access it even when their smart group is denied — without touching any other server.
📍 In the QuilrAI console, go to Settings › AI Gateway › MCP Gateway › (server card) › Configure › General. Scroll to the Access control card. Add Contractors to Denied smart groups, add lead@example.com to Allowed users, then click Save settings in the footer.
Block access to unapproved or legacy MCP servers tenant-wide in a single Policy Engine rule, so no caller can reach them through the gateway regardless of group membership.
📍 In the QuilrAI console, go to Govern › Policy Engine › MCP Gateway. In the Session stage, open the MCP Server Access card and add a rule: when MCP name is any of Unapproved Notes or Legacy CRM , set MCP access to deny. Publish the revision to apply.
Restrict an MCP server so it is reachable only via OneMCP and not through a direct connection, by matching on route kind.
📍 In the QuilrAI console, go to Govern › Policy Engine › MCP Gateway. In the Session stage, open the MCP Server Access card and add a rule: when route kind is direct , set MCP access to deny. Publish the revision to apply.
Adds Access control card on each MCP server's Configure > General page to set Allowed agents , Allowed smart groups , Denied smart groups , Allowed users , and Denied users — denying everyone not matched before any tool is listed or called.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds MCP Server Access card (stage 1, Session) in Govern > Policy Engine > MCP Gateway with MCP access allow/deny effect, supporting match on MCP name , identity provideridentity provider A service that authenticates users and supplies identity information to other applications. It is the sign-in authority behind many single sign-on systems. , client IP, agent name, agent classification, route kind (direct, onemcp, workflow), tags, transport, and auth type. Not checked yet Adds OneMCP Features card in the same Session stage to toggle OneMCP dynamic tools and memory on or off per caller. Not checked yet Access control rules apply only to MCP Gateway traffic; direct client connections to an MCP server bypass these rules. Not checked yet
4 details in Everything
QuilrAI MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. gains a browsable MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. Library with one-click install, user install requests, and internal-network MCP support.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Approve a teammate's request to install an MCP and gate it to shared API-key auth — useful when centralising credential management across the tenant.
📍 1. Go to Settings › AI Gateway › MCP Gateway › Library
2. Under Requested by your team , find the pending request (shows requester name and time).
3. Click Set up on that MCP row.
4. Enter the Upstream API key, set Authentication scope to Shared by the whole tenant , configure placement and prefix, then click Install.
5. Go to Settings › Tools and enable the newly installed MCP's tools.
Register an internal MCP server hosted inside your private network so the Quilr gateway can reach it through your firewall.
📍 1. Allowlist the Quilr gateway IPs on your firewall, VPC security group, or reverse proxy.
2. Go to Settings › AI Gateway › MCP Gateway › Library.
3. Click Add MCP server and enter the internal server URL.
4. Complete sign-in configuration (API key or OAuth) and click Install.
Set up an OAuth-backed MCP from the library using your own OAuth app registration.
📍 1. Go to Settings › AI Gateway › MCP Gateway › Library.
2. Find the MCP and click Set up.
3. Copy the displayed OAuth callback URL and register it in the provider's OAuth app.
4. Enter the OAuth client ID and OAuth client secret, then click Install.
5. Connect the MCP once as an administrator via OAuth Connect.
Adds an MCP Library in Settings > AI Gateway > MCP Gateway > Library for discovering and installing provider-native and Quilr-built MCP servers without manually entering URLs.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Supports filtering MCP Library entries by Status (Installed, Not installed), Type (Remote (HTTP), Local package (stdio)), and Sign-in (OAuth, API key, OAuth passthrough, No sign-in). Not checked yet Provides per-MCP install actions: Install (no-credential MCPs), Set up (API key or custom OAuth app), Review (local packages), Continue setup , Settings , and Uninstall . Not checked yet Enables API-key-based MCP setup via Upstream API key with configurable Authentication scope (Shared by the whole tenant or Each user brings their own), key placement, and prefix — stored at the gateway and never shown again. Not checked yet Enables custom OAuth app setup by registering the displayed OAuth callback URL with the provider, then entering OAuth client ID and OAuth client secret . Not checked yet
+4 more
show less
Adds a user install-request workflow: users who lack install permission see Request instead of Install ; pending requests appear as a count on the Library button and in the Library queue row of the Tools reachable tile, and are listed under Requested by your team with requester name and time. Not checked yet Adds Add MCP server action for registering any MCP not in the library — by URL, REST API REST API A web API design style where clients interact with resources over HTTP using standard methods like GET, POST, and DELETE, giving cyber tools a predictable, language-agnostic way to integrate with external services. , or local package. Not checked yet Supports internal (private-network) MCP servers by allowlisting Quilr gateway IPs on firewalls, VPC VPC A logically isolated virtual network inside a public cloud provider's infrastructure, letting tools deploy resources with private addressing, controlled routing, and firewall rules without managing physical hardware. security groups, or reverse proxies, then adding the server with Add MCP server . Not checked yet After installation, MCP tools are activated via Settings > Tools. Not checked yet
9 details in Everything
QuilrAI MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. lets admins register MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. servers, govern tool access with guardrails, and monitor agent activity via a unified gateway URL.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ USE IT
Connect a non-OAuth AI client (e.g. a headless agent) to a specific MCP server using a bearer token bearer token A credential that grants access to whoever presents it, without a separate proof of possession. Protecting the token matters because a stolen copy can be used by someone else. and user identity header.
json
copy
{
"mcpServers": {
"quilr-mcp": {
"url": "https://mcpgateway.quilr.ai/<your-mcp-slug>/mcp",
"headers": {
"Authorization": "Bearer <your-token>",
"mcpuser": "user@company.com"
}
}
}
}
Register a remote MCP server through the gateway admin UI so agents can discover and call its tools.
📍 In the QuilrAI console, go to Settings › AI Gateway › MCP Gateway, click Add MCP server , choose Remote server , enter its Transport URL, then click Probe and continue .
Enable only specific tools on a registered server and add guardrails to block sensitive data before agents can call it.
📍 In the QuilrAI console, go to Settings › AI Gateway › MCP Gateway, open the server card, go to the Tools section and toggle on the tools agents may call, then go to Guardrails to configure block or redact rules, and click Save settings .
Adds Settings > AI Gateway > MCP Gateway to register MCP servers — supporting ready-made library integrations, remote servers (via Transport URL ), REST APIs REST APIs A convention for building HTTP-based interfaces where resources are addressed by URL and manipulated with standard verbs like GET, POST, and DELETE, giving cyber tools a predictable way to integrate with external services. converted to MCP, and local CLI packages.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds https://mcpgateway.quilr.ai/quilrone/mcp as a OneMCP endpoint that exposes every permitted MCP server to an AI agent through a single connection. Not checked yet Adds per-server https://mcpgateway.quilr.ai/<slug>/mcp gateway URLs for single-server connections, with Authorization: Bearer <token> and mcpuser header support for non-OAuth clients. Not checked yet Adds Settings > API tokens on each server card to generate tokens for clients that cannot use OAuth. Not checked yet Adds tool-level access control per server: enable individual tools agents may call, apply guardrails to block or redact sensitive data in tool arguments and results, restrict servers to specific agents, smart groups, or users via General > Access control, and set per-group or per-user rules via Group & User Rules . Not checked yet
+3 more
show less
Adds Token saving setting per server to compress tool results. Not checked yet Adds monitoring views — Overall analytics , per-server Logs , and tabs for Analytics (tool calls, blocked calls, guardrail flags, tokens saved), Activity (per-call user/agent/guardrail detail), and Health (rejected requests, access denials, upstream errors). Not checked yet Adds a Log Export API to forward gateway logs to an external data platform. Not checked yet
8 details in Everything
QuilrAI adds Costs & Savings dashboard with spend, token usage, savings techniques, attribution, and provider health across AI sources.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Identify which team or app is driving the most AI spend in the current period so you can prioritise cost-reduction conversations.
📍 In the console, go to Observe › Costs & Savings › Attribution. Set the metric to Spend , then group by Departments (or Applications ). Use the Filters control to narrow to a specific source if needed.
Find savings techniques that are not yet enabled and navigate directly to their configuration to switch them on.
📍 In the console, go to Observe › Costs & Savings › Savings. Review the ranked Settings to change list, then click Open settings next to any technique (e.g. text compression or smart JSON) to jump straight to its configuration page.
Spot provider-side failures that may be costing you traffic — useful when users report intermittent AI errors.
📍 In the console, go to Observe › Costs & Savings › Providers. Review the failed-request share and estimated blocked requests for each provider, and check the Last incident column for recent outages.
New Observe > Costs & Savings section shows organisation-wide AI spend in USD, token usage, and tokens already saved, broken down by source (LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. Gateway, MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. , Endpoint Agent, Browser Extension, and connected platforms).︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Attribution tab lets teams group usage metrics (Spend, Tokens, or Tokens saved) by Applications, Users, Models, Tools, Agents, Departments, Smart Groups, Sources, Usage types, Topics, or Repositories — with per-entry daily sparklines and period-over-period spend change. Not checked yet Savings tab surfaces a ranked Settings to change list of token-saving opportunities, each with an Open settings deep-link to the relevant configuration page. Not checked yet Savings tab shows per-technique breakdown: LLM Gateway techniques include provider prompt cache, text compression, markdown-to-text, and smart JSON; MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. Gateway techniques include smart JSON and HTML-to-text; Endpoint Agent contributes Claude compression. Not checked yet Per-app saving controls matrix shows which saving technique is on or off for each application. Not checked yet
+2 more
show less
Habits tab surfaces usage patterns (Long sessions, Session reuse after idle, Single sessions) with per-person impact, evidence, and token counts — designed for coaching workflows. Not checked yet Providers tab shows per-provider key health, request outcomes, failed-request share, estimated blocked requests, last incident, and live status to diagnose rate limits, auth failures, and provider errors. Not checked yet
7 details in Everything
QuilrAI LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. Gateway gains security guardrails covering PII PII Personally Identifiable Information — data that can identify a specific individual, such as names, email addresses, or SSNs. Cyber tools flag or redact it to limit exposure and meet privacy regulations. /PHI PHI Protected Health Information: individually identifiable health data regulated under the US HIPAA law, whose strict handling requirements drive cyber tools to audit, mask, or restrict access to it. /PCI PCI A hardware bus standard that connects peripheral devices to a computer's motherboard; cyber tools targeting hardware-level forensics or memory analysis use it to access device registers and DMA regions directly. redaction, adversarial-prompt detection, hallucination checks, and source-IP allowlisting.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Enable guardrails for a new app and switch Auth & Secrets from Monitor to Block before going to production, so API keys and passwords in prompts are rejected rather than just logged.
📍 In the QuilrAI console: Settings › AI Gateway › LLM Gateway › <your app> › Configure › Guardrails. Under Data risks , find Auth & Secrets , set Action to Block , then save.
Use the Policy Engine to redact Aadhaar numbers and block secrets for a support copilot app while only monitoring names — scoping rules to the specific application rather than globally.
📍 In the QuilrAI console: Policy Engine › LLM Gateway › Data & Adversarial Risks card. Add rule 1: When Application is Support Copilot and data found is Aadhaar Number / VID , then action Redact, Risk level High. Add rule 2: When Application is Support Copilot and data found is Name , then action Monitor. Add rule 3: When Application is Support Copilot and data found is Auth & Secrets , then action Block, Risk level Critical. Publish revision.
Restrict your LLM Gateway app to only accept calls from your corporate network CIDR CIDR A notation for a block of IP addresses, such as 10.0.0.0/24. The number after the slash says how many leading address bits identify the network. , rejecting all other source IPs at the gateway level.
📍 In the QuilrAI console: Settings › AI Gateway › LLM Gateway › <your app> › Configure › Guardrails › Source IP restrictions. Toggle Enabled on and enter 10.0.0.0/8, 203.0.113.10 in Allowed source IPs , then save.
Adds Guardrails tab in the app's Configure section with six parts: Default action, Data risks, Adversarial risks, Precision detections, Hallucination check, and Source IP restrictions.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds Adversarial risks guardrail with 13 categories including Prompt Injection Techniques , Jailbreak Techniques , Prompt Context Corruption , Semantic Adversarial Prompts , Social Engineering Prompts , System, Guardrail & Security Disclosure , Security Exploit & Payload Enablement , Cybersecurity Frameworks & Standards Mention , Response Risks , Hateful or Offensive Content , Violence & Harmful Content , Fraudulent or Illegal Activity Content , and Malicious Scripts (opt-in); each supports Block or Monitor . Not checked yet Adds Precision detections with a built-in catalog of more than 80 exact-match identifiers (SSN, Aadhaar, IBAN, IMEI, PUK code, and others), each independently switchable with its own action (Redact , Partial redact , Block , or Monitor ; default Monitor ). Not checked yet Adds Hallucination check that flags likely-fabricated responses at a configurable risk level (Low /Medium /High ; default Medium ) with Block or Monitor action; runs on non-streaming responses only. Not checked yet Adds Source IP restrictions guardrail that accepts gateway calls only from comma-separated IPv4, IPv6 IPv6 The current version of the Internet Protocol, standardized by the IETF, using 128-bit addresses to replace the exhausted IPv4 space. Cyber tools target it because modern networks run dual-stack or IPv6-only. , or CIDR values entered in Allowed source IPs ; calls from unlisted addresses are rejected. Not checked yet
+7 more
show less
Adds Custom Detection option to match user-defined identifiers via regex when built-in precision detections are insufficient. Not checked yet Adds Action mix panel that counts how many of the 20 categories (7 data + 13 adversarial) use each action or are off. Not checked yet Adds Scan tool-call arguments setting in the Policy Engine's Data & Adversarial Risks card to evaluate each tool call's arguments independently (supports Monitor and Block only). Not checked yet Adds Policy Engine Data & Adversarial Risks card for LLM Gateway, supporting scope by Everyone , People , Smart group , Application , or App tag ; model/provider/API surface/environment targeting; per-type findings thresholds (at least N); and language blocking. Not checked yet Extends guardrail endpoint coverage to Chat completions (including Bedrock Converse, Vertex Gemini, Anthropic via translation), Native Anthropic Messages , OpenAI Responses, Bedrock Runtime (boto3), Native Vertex / Gemini generateContent, embeddings embeddings Lists of numbers a model produces to represent the meaning of text, images or code, so similar items sit close together. They power semantic search and RAG. , speech-to-text/text-to-speech, Sarvam speech synthesis/transcription/translation/transliteration/language detection, and Copilot Studio ; OpenAI Realtime (websocket) is logged but not scanned. Not checked yet New apps start with all 6 data-risk categories on and 12 of 13 adversarial categories on (Malicious Scripts is off), default action Monitor , and precision detections/hallucination check/source IP restrictions off. Not checked yet Action resolution follows: category action → app default action → Monitor ; Set everything to default clears per-category actions so all categories follow the app default. Not checked yet
12 details in Everything
QuilrAI LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. Gateway V2 adds tenant-wide platform providers, a hosted model catalog at https://models.quilrai.dev/v1, scoped model API keys, and a browser Playground.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ TRY IT
Call a QuilrAI-hosted model directly from the CLI without provisioning your own provider account — useful for quick triage or ad-hoc analysis.
copy
$ curl 'https://models.quilrai.dev/v1/chat/completions' \
-H "Authorization: Bearer $QUILR_MODEL_API_KEY" \
-H "Content-Type: application/json" \
--data '{"model": "deepseek/deepseek-v3.2", "messages": [{"role": "user", "content": "Explain zero trust in one sentence."}], "max_tokens": 1024}'
Route QuilrAI-hosted models through a gateway app to apply guardrails and logging — configure the general provider pointing at the hosted catalog.
yaml
copy
base_url: https://models.quilrai.dev/v1
api_key: sk-quilrllm-...
models:
- deepseek/deepseek-v3.2
Create a scoped model API key and link it to specific allowed models so automated pipelines cannot call models outside the approved set.
📍 Go to Settings › AI Gateway › Models › API keys, click Create API key , enter a Key name (1–128 characters), select one or more Allowed models from the catalog, then click Create API key and copy the displayed sk-quilrllm-... key — it is shown only once.
Adds POST /chat/completions at https://models.quilrai.dev/v1 — an OpenAI-compatible endpoint for calling QuilrAI-hosted models directly with a sk-quilrllm-... model API key and Authorization: Bearer $QUILR_MODEL_API_KEY.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds model API keys (sk-quilrllm-...) scoped to specific allowed models from the hosted catalog, created at Settings > AI Gateway > Models > API keys; keys have no expiry, are recorded in the audit log, and are capped only by organization credit. Not checked yet Adds RBAC RBAC Role-based access control, where permissions are assigned to roles such as reader or administrator and users receive those roles. It makes access easier to manage than individual permission lists. V2 permissions llm.apps.create, secrets.reveal, and llm.apps.delete controlling model API key creation and revocation. Not checked yet Introduces platform providers — tenant-wide provider credentials configured once at Settings > AI Gateway > Models or via Provider configuration on the Settings > AI Gateway > LLM Gateway page and shared across any number of apps, with changes (disable, delete, credential update) propagating to every linked app. Not checked yet Adds support for gateway provider types openai, openai_responses, openai_assistants, openai_realtime (OpenAI); anthropic_messages, anthropic (Anthropic); azureopenai, openai_responses_azure, openai_assistants_azure, openai_realtime_azure, anthropic_messages_azure (Azure); bedrock, anthropic_messages_bedrock, bedrock_embeddings, bedrock_rerank (Amazon Bedrock); vertex_ai, gemini_chatcompletions (Google); deepseek (DeepSeek); sarvam (Sarvam); cohere_rerank, jina_rerank, voyage_rerank (Cohere/Jina/Voyage); general, general_rerank (Custom endpoint). Not checked yet
+5 more
show less
Adds a Models page (Settings > AI Gateway > Models) with four tabs — Models , API keys , Usage , and Playground — for managing the full model inventory, keys, credit spend, and live chat testing. Not checked yet Adds a QuilrAI provided models catalog view at Settings > AI Gateway > Models > Models, searchable by model ID or provider prefix, sortable by input/cached-input/output price, with per-row Chat access to the Playground. Not checked yet Adds a browser Playground at Settings > AI Gateway > Models > Playground supporting temperature (0–2), Top P (0–1), max output tokens (1–4,096), system and user prompts up to 16,000 characters each, and conversations up to 20 messages. Not checked yet Adds Usage tab at Settings > AI Gateway > Models showing remaining credit, spend, requests, tokens, and per-model throughput for QuilrAI-provided models. Not checked yet Enables routing QuilrAI-provided models through an LLM Gateway app by adding a general (Custom endpoint / Chat completions) provider with base_url set to https://models.quilrai.dev/v1 and api_key set to a sk-quilrllm-... model API key, applying the app's guardrails, routing, limits, and logs. Not checked yet
10 details in Everything
QuilrAI LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. Gateway lets teams create apps that proxy LLM traffic through a regional gateway URL, with multi-provider failover, per-app or shared platform credentials, and a Policy Engine for centrally enforced guardrails.
Swap base_url to guardrails-usa-2.quilr.ai/openai_compatible/ and set api_key to your Quilr key to route any OpenAI-compatible SDK through the gateway without other code changes. Not checked yet Create an LLM Gateway app via Settings > AI Gateway > LLM Gateway > Create App, choosing between Platform providers (shared team credentials, V2 console only) or App-only credentials (per-app isolation). Not checked yet Connect apps to QuilrAI-provided models by adding a Custom endpoint provider with the Chat completions API, base URL https://models.quilrai.dev/v1, and a model API key from Settings > AI Gateway > Models > API keys. Not checked yet Configure per-app Security Guardrails , Guardian Agent , Custom Detections , Rate and Token Limits , Routing , Token Saving , Prompt Store , Identity Aware , and Self-Service settings via the app card's Configure buttons. Not checked yet Enable a Policy Engine to override app-level guardrails, limits, routing, identity requirements, and Prompt Store enforcement with centrally published policies. Not checked yet
+3 more
show less
Inspect each request's model, provider, guardrail outcome, HTTP status, tokens, and latency in Activity > Requests via the app card's Logs view. Not checked yet Order providers for failover by ticking them under Available in the app wizard; the first ticked becomes Primary , and the gateway automatically fails over to the next enabled provider in order when the primary fails. Not checked yet Set Quilr key name and Initial key expiry under Key settings in the Create App wizard; leave expiry blank for a key that never expires. Not checked yet
8 details in Everything
QuilrAI Policy Engine docs reveal a unified card-based enforcement layer spanning Browser Extension, LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. Gateway, MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. , and Endpoint Agent.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Test what policy wins for a contractor calling a specific MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. tool before pushing a new revision live.
📍 In the QuilrAI Console, go to Govern › Policy Engine › MCP Gateway tab, then click Describe a call . Fill in the user (a member of the Contractors smart group), the MCP server, and the tool name. Every card collapses to the value that would win from the current shared draft — confirm onemcp.dynamic_tools is false and cache.mode is as expected before clicking Publish.
Lock down contractor sessions with a single QuilrQL policy combining OneMCP, memory, claims, and cache controls at the session stage.
📍 contractor_session_posture
session runs on session · priority 500
When Smart groups includes (ignoring case) Contractors
Then
OneMCP dynamic tools → false
OneMCP memory → deny
forward user claims → false
cache mode → none
Migrate an Endpoint Agent deployment from Basic policies to the card-based Policy Engine without recreating existing per-app rules.
📍 In the QuilrAI Console, go to Govern › Policy Engine › Endpoint Agent tab, then click Convert to Policy Engine . Review the Detection configurations and Application configuration sub-tabs for ChatGPT, Claude, Cursor, Copilot, Gemini, DeepSeek, Ollama, and LM Studio cards before publishing.
Adds Describe a request button (LLM Gateway tab) and Describe a call button (MCP Gateway tab) to preview which policy wins for a given request before publishing.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Introduces QuilrQL policy language with a source view for reviewing, diffing, or bulk-editing policies as exact text. Not checked yet Surfaces block_request_secrets example policy showing named fields: name, priority, stage, conditions, and effects — with priority 500 as the default for new policies. Not checked yet MCP Gateway advanced policies expose effects quota.minute, quota.hour, quota.day, quota.window, quota.timezone, quota.dimensions, quota.id, concurrency.limit, concurrency.ttl_seconds, and concurrency.dimensions at the request stage. Not checked yet MCP Gateway cache.mode effect (values: shared, tenant, or none) is available at the session stage under Capability Cache & Isolation. Not checked yet
+10 more
show less
Web Search Security card exposes web_search.zia_timeout_seconds, excluded_domains, url_overrides, and result_domain_action effects at the response stage. Not checked yet Token Savings card exposes token_saving.smart_json_compression, html_to_text, markdown_to_text, and text_compression effects at the response stage. Not checked yet MCP Gateway evaluates policy cards in four ordered stages: 1 Session (once per connection), 2 Discovery (per listed capability), 3 Request (before dispatch), and 4 Response (before result returns). Not checked yet Adds Convert to Policy Engine button on the Endpoint Agent tab to migrate from Basic policies mode to the card-based engine. Not checked yet LLM Gateway Policy Engine controls the following app settings sections when enabled: Security Guardrails, Hallucination Protection, Identity & Network Trust, Guardian Agent, Rate/Token/Timeout Limits, Token Savings, Routing Groups & Fallbacks, Prompt Store — each showing Controlled by Policy Engine with View policies and Edit anyway options. Not checked yet Policy Engine introduces a versioned draft-and-publish workflow: all card edits accumulate in a shared draft, publishing creates a numbered revision (Revision N ), and rollback republishes any earlier revision without altering classic settings. Not checked yet Introduces conflict-resolution rules: restriction wins over permission, priority settles single-value conflicts, risk level only climbs, and redact/partial-redact apply per data type without competing across types. Not checked yet Browser Extension controls table supports filtering by Posture (AI Risks, Data Risks, Device Risks, IT Support, MFA MFA Multi-factor authentication, requiring proof from different categories, such as a password and a hardware key, to sign in. It reduces reliance on a password alone. Risks, Password Hygiene) and Type , sorting by Recently modified , plus Export and Add control actions. Not checked yet Browser Extension control edit form exposes criticality (Very Low to Very High), mode (Monitor or Action), When this happens conditions, and Perform action configuration. Not checked yet MCP Gateway tool-matching fields include read_only, destructive, idempotent, and open_world annotations on the Tool condition group. Not checked yet
15 details in Everything
QuilrAI adds an Observe > Overview dashboard with Adoption, Agentic Estate, and Posture & Risk tabs for AI governance at a glance.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Run a weekly risk review: see what was flagged, how it was handled, and which assets need immediate attention.
📍 In the console, go to Observe › Overview, select the Posture & Risk tab, set the period to Last 7 days , then review Risk categories and How findings were handled . Click any finding category to drill into Findings & Interactions.
Find MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. servers bypassing the gateway and work through the remediation queue one by one.
📍 In the console, go to Observe › Overview › Agentic Estate tab. Under Control coverage , filter MCP servers by route Outside gateway . Use the Act now panel to open the flagged asset via Review asset , then advance with Next in queue .
Spot dormant licences and newly appeared unapproved AI apps across departments for an adoption report.
📍 In the console, go to Observe › Overview › Adoption tab, set the period selector to the desired range. Review Who's using AI for Dormant users, then inspect Across the organization flow chart filtered by New this period to identify new unapproved apps.
Adds the Observe > Overview dashboard with three tabs — Adoption, Agentic Estate, and Posture & Risk — and a period selector (e.g.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Last 7 days ) that applies across all tabs. Not checked yet Adds the Adoption tab, showing headline tiles for People using AI , AI interactions , Power users , and AI applications , plus breakdowns by usage mode (Chat assistants , Coding agents , MCP agents , API & service accounts , Other ) and a department/team/people flow chart marking sanctioned vs. unapproved apps. Not checked yet Adds the Agentic Estate tab, surfacing Agentic assets , Shadow AI , share of MCP servers through gateway, and High-risk assets , with an Act now queue and per-platform panels for OpenAI, Microsoft Copilot Studio, and Azure AI Foundry. Not checked yet Adds the Posture & Risk tab, displaying findings by category (PII PII Personally Identifiable Information — data that can identify a specific individual, such as names, email addresses, or SSNs. Cyber tools flag or redact it to limit exposure and meet privacy regulations. , adversarial prompts, auth and secrets, financial and health data) and handling outcome (Monitored , Justified , Redacted , Blocked , Failed ), plus an Estate today view of ungoverned or high/critical-risk assets. Not checked yet Adds Control coverage within Agentic Estate, categorising direct AI apps by approval status (Sanctioned , Unapproved , Needs review , Posture unknown ) and MCP servers by route (Outside gateway , Both , Gateway only ). Not checked yet
5 details in Everything
QuilrAI adds integrations hub pulling AI usage from Claude, OpenAI, Copilot, Azure AI, GitHub, and TrueFoundry, with SIEM SIEM Security information and event management, collecting logs from many systems and correlating events to find suspicious activity. Analysts use it to investigate alerts and incidents. /syslog/webhook forwarding.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Navigate to the integrations hub to connect a new AI platform source or SIEM destination.
📍 Console › Settings › Integrations
Adds Console › Settings › Integrations hub to browse, install, and manage integrations by capability.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Pulls AI usage and inventory from Claude.ai via the Anthropic Compliance API integration. Not checked yet Pulls AI usage and inventory via the OpenAI Compliance integration. Not checked yet Pulls AI usage and inventory from Microsoft Copilot Studio. Not checked yet Pulls AI usage and inventory from Azure AI Foundry. Not checked yet
+7 more
show less
Pulls AI usage and inventory from GitHub. Not checked yet Pulls AI usage and inventory from TrueFoundry. Not checked yet Forwards findings and audit events to syslog. Not checked yet Sends findings and audit events to a user-defined endpoint via webhook. Not checked yet Forwards findings and alerts to Microsoft Sentinel. Not checked yet Forwards findings and alerts to Splunk, Datadog, and Slack. Not checked yet Adds SAML SAML A standard for passing signed identity assertions between a sign-in provider and an application. It lets a user sign in through their organization's identity provider. and Okta sign-in integration. Not checked yet
12 details in Everything
QuilrAI Endpoint Agent adds per-device AI governance: monitors desktop chat apps, coding agents, local models, and MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. servers.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Navigate to the Endpoint Agent in the QuilrAI console to begin discovering and governing AI apps running on company devices.
📍 Console › Govern › Policy Engine › Endpoint Agent
Adds the Endpoint Agent, accessible via Console › Govern › Policy Engine › Endpoint Agent , to discover and govern AI running on company devices — including desktop chat apps, coding agents, local models, and MCP servers.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Provides per-app monitoring and guardrails through App Policies, letting teams set rules on individual AI applications detected on endpoints. Not checked yet Introduces an Agent Kill Switch to disable the endpoint agent per device or tenant-wide without a full redeploy. Not checked yet
3 details in Everything
QuilrAI adds a browser extension to monitor AI app usage, block sensitive data at the prompt, and guide users in real time.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Configure and validate the browser extension after deploying it across your fleet via Intune.
📍 Console › Settings › Browser Extension
Adds a browser extension that surfaces which AI apps employees use, intercepts sensitive data before it reaches AI prompts, and delivers in-context guidance to end users.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Supports deployment via Microsoft Intune, Jamf Pro, and Group Policy for enterprise-wide rollout. Not checked yet Introduces browser controls to monitor or act when a defined use case occurs in the browser. Not checked yet Introduces action requests, allowing administrators to approve or reject user justifications for blocked actions. Not checked yet Adds clipboard monitoring to detect sensitive content copied into AI prompts. Not checked yet
+3 more
show less
Adds file indexing as a browser-extension capability. Not checked yet Adds an agent kill switch to halt AI agent activity from the browser extension. Not checked yet Allows scope configuration to monitor all domains or work domains only. Not checked yet
8 details in Everything
QuilrAI adds Red Teaming suite covering gateway apps, MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. servers, agents, and multi-model comparison via console and API.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Red team an HTTP agent endpoint to surface attack paths attack paths A possible sequence of steps an attacker could take to reach a valuable target. It connects weaknesses, permissions and reachable systems rather than treating each finding separately. before promoting to production.
📍 In the console, go to Console › Assessments › Red Teaming, select Red team an agent , enter your HTTP agent endpoint URL, choose attacks from the Attack library, and run the assessment.
Compare resilience across multiple models by running identical attack suites against 2–8 candidates in a single session.
📍 In the console, go to Console › Assessments › Red Teaming, select Compare models , add between 2 and 8 model targets, then launch the shared attack suite to view side-by-side findings.
Scan an MCP server for static, dependency, and live tool-surface vulnerabilities before connecting it to an agent.
📍 In the console, go to Console › Assessments › Red Teaming, select Vet an MCP server , provide the server target, and run the MCP Threat Detection scan to review static and live findings.
Adds Console › Assessments › Red Teaming to run attack suites against gateway apps through their configured model.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds MCP Threat Detection with static, dependency, and live tool-surface scanning of MCP servers. Not checked yet Adds agentic red teaming against any HTTP, WebSocket WebSocket A protocol that upgrades an HTTP connection into a persistent, full-duplex channel, letting a server push data to a client without repeated polling. Cyber tools use it for real-time event streaming and live command output. , or voice agent endpoint. Not checked yet Adds model red teaming to run the same attack suite across 2 to 8 models simultaneously for side-by-side comparison. Not checked yet Adds LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. Intelligence Assessment capability for structured evaluation of model behaviour under attack. Not checked yet
+3 more
show less
Adds ability to turn red-team findings directly into detections and hardened prompts. Not checked yet Adds runs, findings, and schedules management for Red Teaming assessments. Not checked yet Adds an Attack library for browsing and selecting real attack techniques used in assessments. Not checked yet
8 details in Everything
QuilrAI: Adds Workflow Agents accessible via Console › Settings › AI Gateway › Workflow Agents , routing every model and tool call through your existing gateways.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Connect a Slack workspace to an agent so team members can trigger and chat with it directly from Slack.
📍 In the console, go to Console › Settings › AI Gateway › Workflow Agents, open your agent, then navigate to Slack options and connect a Socket Mode Slack app.
Set up a recurring scheduled run so an agent (e.g. a research or code review agent) runs automatically without manual triggers.
📍 In the console, go to Console › Settings › AI Gateway › Workflow Agents, open your agent, then under Share and manage configure a recurring schedule and assign groups or approvals as needed.
Supports running agents from the console, chat, Slack (via Socket Mode Slack app), or on a schedule with recurring runs. Not checked yet Enables sharing agents with teams via groups, approvals, and versioning. Not checked yet Provides library templates for common use cases including research, support, and code review. Not checked yet
3 details in Everything
QuilrAI MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. debuts as a control plane for AI agents: OneMCP single-endpoint aggregation, tool-level ACLs ACLs An access control list, a set of rules allowing or denying operations for particular users, services or network addresses. It decides who can use a resource. , human approval, tool change watch, security guardrails, Local MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. , and a Log export API.
Introduces MCP Gateway, a managed control plane that lets teams register MCP servers once and enforce who can call which tool across AI agents such as Claude, Cursor, and ChatGPT. Not checked yet Adds OneMCP, a single endpoint with dynamic tool calling tool calling A model's ability to answer with a structured request to run a named function or API, which the application executes and returns. It is how agents take actions. that aggregates multiple registered MCP servers behind one connection. Not checked yet Supports turning any API into a set of MCP tools via the MCP Library. Not checked yet Supports OAuth connect and OAuth permissions flows for allowing specific agents to authenticate with connected MCP servers. Not checked yet Adds API token support for allowing agents to authenticate with connected MCP servers. Not checked yet
+7 more
show less
Adds server-level and group/user access-control rules to restrict which agents can reach which MCP servers and tools. Not checked yet Adds tool visibility controls to show or hide specific tools from specific agents or groups. Not checked yet Adds human approval workflow for tool calls that require a human to sign off before execution. Not checked yet Adds tool change watch to alert administrators when a registered MCP server's tool surface changes. Not checked yet Adds security guardrails including web search security, claims forwarding, input aliases, usage quotas, concurrency limits, and token saving. Not checked yet Introduces Local MCP, allowing locally running MCP servers to be registered, packaged, and connected to AI apps through the gateway. Not checked yet Exposes a Log export API for exporting every tool call made through the gateway. Not checked yet
12 details in Everything
QuilrAI launches with browser extension, endpoint agent, LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. gateway, MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. gateway, red teaming, and open-source AgentGuard for enterprise AI governance.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Route a service's model calls through the LLM Gateway to enforce guardrails and track costs across all providers from one endpoint.
📍 In the Console, go to LLM Gateway › Quick start, then LLM Gateway › Providers and models to configure your providers (OpenAI, Anthropic, Azure, Bedrock, Vertex), and LLM Gateway › Security guardrails to enable data-loss and content policies.
Proactively find prompt-injection prompt-injection An attack where text the model reads, such as a web page, file or tool result, carries instructions that override the user's. It is the main security risk for agents with tools. and jailbreak exposures in a gateway app or agent before attackers do, using the built-in Red Teaming scheduler.
📍 In the Console, go to Red Teaming, select your target (gateway app, agent, model, or MCP server), and configure an on-demand or scheduled attack run to surface findings as detections.
Adds LLM Gateway — a single endpoint routing traffic to OpenAI, Anthropic, Azure, Bedrock, and Vertex with security guardrails, cost tracking, and provider/model management.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. — governed tool access for AI agents, connecting any MCP client or OneMCP to 400+ servers including GitHub, Slack, and Salesforce. Not checked yet Adds Red Teaming — attacks gateway apps, agents, models, and MCP servers on demand or on a schedule, and converts findings into detections. Not checked yet Adds Triage center (reachable at Observe › Triage center in the Console) for reviewing AI governance findings. Not checked yet Adds Browser Extension for AI governance across web-based AI apps (ChatGPT, Claude, Gemini, Copilot) in personal and enterprise accounts. Not checked yet
+6 more
show less
Adds Endpoint Agent for governing desktop AI apps, coding agents (Cursor, Claude Code, Ollama), and local MCP servers. Not checked yet Adds integrations pulling from Claude and OpenAI compliance APIs, Copilot Studio, Azure AI Foundry, and GitHub, and sending to Syslog, webhooks, and Microsoft Sentinel. Not checked yet Adds India data types to LLM Gateway guardrails for localized sensitive-data detection. Not checked yet Adds AgentGuard open-source desktop app (macOS Apple silicon, Ubuntu x86_64) that blocks secrets and PII PII Personally Identifiable Information — data that can identify a specific individual, such as names, email addresses, or SSNs. Cyber tools flag or redact it to limit exposure and meet privacy regulations. from leaving in prompts and tool calls, stops installs of compromised or vulnerable packages, and compresses file reads and shell output — no proxy or cloud relay required. Not checked yet Adds Workflow Agents support for building and sharing AI workflow agents with team and Slack integration. Not checked yet Adds MCP Library inside the MCP Gateway for discovering and connecting governed MCP servers. Not checked yet
Adds LLM Gateway — a single endpoint routing traffic to OpenAI, Anthropic, Azure, Bedrock, and Vertex with security guardrails, cost tracking, and provider/model management.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds MCP Gateway MCP Gateway A server that sits between MCP clients and one or more Model Context Protocol backends, routing tool calls and aggregating context sources so a single endpoint exposes many AI-agent integrations at once. — governed tool access for AI agents, connecting any MCP client or OneMCP to 400+ servers including GitHub, Slack, and Salesforce. Not checked yet Adds Red Teaming — attacks gateway apps, agents, models, and MCP servers on demand or on a schedule, and converts findings into detections. Not checked yet Adds Triage center (reachable at Observe › Triage center in the Console) for reviewing AI governance findings. Not checked yet Adds Browser Extension for AI governance across web-based AI apps (ChatGPT, Claude, Gemini, Copilot) in personal and enterprise accounts. Not checked yet
+5 more
show less
Adds Endpoint Agent for governing desktop AI apps, coding agents (Cursor, Claude Code, Ollama), and local MCP servers. Not checked yet Adds integrations pulling from Claude and OpenAI compliance APIs, Copilot Studio, Azure AI Foundry, and GitHub, and sending to Syslog, webhooks, and Microsoft Sentinel. Not checked yet Adds AgentGuard open-source desktop app (macOS Apple silicon, Ubuntu x86_64) that blocks secrets and PII PII Personally Identifiable Information — data that can identify a specific individual, such as names, email addresses, or SSNs. Cyber tools flag or redact it to limit exposure and meet privacy regulations. from leaving in prompts and tool calls, stops installs of compromised or vulnerable packages, and compresses file reads and shell output — no proxy or cloud relay required. Not checked yet Adds Workflow Agents support for building and sharing AI workflow agents with team and Slack integration. Not checked yet Adds MCP Library inside the MCP Gateway for discovering and connecting governed MCP servers. Not checked yet
1 more in Everything
QuilrAI LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. Gateway adds request-side token-saving strategies — Smart JSON compression, HTML-to-text, Markdown-to-text, and text compression.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
└──▷ HOW TO FIND IT
Enable Smart JSON compression and HTML-to-text for an app that sends tool results and web-scraped HTML, to reduce provider token costs with no code changes.
📍 Settings › Token Saving (under Optimization & policy) › turn on Smart JSON compression and HTML to text
Adds Smart JSON compression strategy that compacts eligible JSON objects and arrays, converting to TOON where it saves more tokens — up to ~20% savings — best for tool results and structured data.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄ Not checked yet Adds HTML to text strategy that strips HTML markup down to readable text before requests reach the provider. Not checked yet Adds Markdown to text strategy that strips Markdown syntax that costs tokens without adding meaning. Not checked yet Adds Text compression strategy that removes low-value prose and separator noise from long text while preserving meaning, leaving structured-looking lines untouched. Not checked yet Surfaces token-saving metrics in the app's Analytics tab and per-request in Activity > Requests. Not checked yet
+1 more
show less
Enables token-saving strategies through Settings > Token Saving (under Optimization & policy ) in the app UI; when the Policy Engine is on, the Token Savings card applies instead. Not checked yet
6 details in Everything
QuilrAI introduces Salesforce connectivity via two MCP MCP Model Context Protocol, a standard for connecting AI applications to external tools and data sources. A compatible server exposes capabilities an assistant can use through a common interface. server paths, selectable by agent use case.
New integration Supports connecting Salesforce to QuilrAI through two MCP server options, selectable based on agent requirements. Not checked yet
1 detail in Everything