DeepintShield has a free Developer plan and two paid self-service plans, Team and Business. You can start on Developer and upgrade at any time from inside the app. This is what each plan gives you in plain words.

1.1 What Team adds on top of Developer

• Unlimited guardrail policies and the built-in machine-learning detectors (DeBERTa, RoBERTa, BERT) that catch prompt injection, jailbreaks, toxicity and personal data.
• Partner safety providers: AWS Bedrock Guardrails, Google Model Armor, Azure Content Safety, or your own webhook.
• Cost savings: semantic cache, cheap-first routing, prompt compression, RAG trimming and summarization. Provider prompt caching, request coalescing and the guardrail cache are on every plan, including Developer.
• Model routing rules and the Load Balancer (adaptive routing) across provider keys.
• RAG security: filter the documents your AI reads before they reach the model.
• Agentic policy core: write and publish access policies for AI agents and MCP tools.
• Save your work in the Playground: prompts, sessions and versions. Running prompts without saving works on every plan.
• Alerts to e-mail, Slack or a webhook. Log exports to S3, GCS, BigQuery or Snowflake.
• 30-day log history, 10 seats, 100 virtual keys.

1.2 What Business adds on top of Team

• Full agent security: agent registry and identities, tool integrity checks, tool grants, blueprint code scans, enrolment policies, signed AI bill of materials (AIBOM).
• Human-in-the-loop approvals: risky agent actions wait for a person to approve them.
• Agentic extras on top of Team's policy core: temporary delegation, the Enforcing/Advisory switch and blueprint protection, and the Advanced relationships editor.
• Agentic observability: run traces, Langfuse enrichment and LLM-as-judge scores.
• Agentic cache for repeated safe tool results.
• Accuracy controls: all three Hallucination Control tabs and all three Consistency tabs (golden answers, request trace).
• OWASP Agentic Top-10 checks and 7 industry domain packs (banking, healthcare, insurance, enterprise copilot, customer support, development assistant, agentic runtime).
• Monitoring integrations: OpenTelemetry, Prometheus and Grafana.
• 90-day log history, 30 seats, 500 virtual keys, 25 workspaces.

2.1 Create your account

1. Open https://app.deepintshield.com in your browser. You will see the sign-in page.
2. Click the Create account tab on the right.
3. Type your first name, last name, organization name and choose your industry.
4. Type your work e-mail address and create a password. The password needs 8 or more characters, one capital letter, one number and one special character.
5. Tick the box to confirm you are 18 or older and agree to the Terms and Privacy Policy.
6. Click Create account.

2.2 Verify your e-mail

1. Open your e-mail inbox and find the message from DeepintShield.
2. Click the verification link in the e-mail.
3. You will return to the sign-in page with the message "Email verified". Sign in with your e-mail and password.

2.3 Your first look at the app

After you sign in you land on the Analytics → Overview dashboard. The left menu is the same on every page. Here is what each part does.

2.4 The setup checklist

A small Continue setup button sits in the bottom-right corner. It opens a 7-step checklist that follows the same order as sections 3, 5 and 6 of this guide. Each step has a Go to step button that takes you to the right page, and a Mark done link.

Think of it like folders: a tenant is the big folder (for example "Production"), and a workspace is a folder inside it (for example "Support bot"). Everything you create later belongs to one workspace. A new account starts with one tenant and no workspace, so create a workspace first.

3.1 Create a tenant

1. In the left menu open Governance Hub → Tenants.
2. Click New tenant (top right).
3. Type a name, for example Production, and an optional description.
4. Click Create tenant. The new tenant appears in the list and in the tenant switcher.

3.2 Create a workspace

1. Open Governance Hub → Workspaces.
2. Click New workspace.
3. Type a name, for example Support bot. The tenant is filled in for you.
4. Click Create workspace. It becomes your active workspace right away.

3.3 Switch tenant or workspace

Use the two boxes at the top of the left menu. Click the first box to pick a tenant; the second box then lists that tenant's workspaces. The pages below change to show that workspace's data.

3.4 Invite people to the app

People who need to sign in to the DeepintShield app are added in Governance Hub → User Manager. (End users of your application are different; they are "Members" in section 6.)

1. Open Governance Hub → User Manager and click Add user.
2. Type the person's e-mail address.
3. Choose a role: Admin can change everything in the workspace; Viewer can only look at dashboards, logs and traces.
4. Click Send invitation. They receive an e-mail with a link to create their password.

Only the person who created the organization (the owner) can change the plan. Upgrades happen inside the app and take effect immediately after payment.

4.1 Open the plan window

1. Look at the bottom of the left menu. On the free plan the button reads Upgrade Plan with a DEVELOPER badge.
2. Click it. The plan window opens with three cards: Developer, Team and Business.

4.2 Choose currency and billing period

1. At the top right of the window pick USD or INR. If you pay with an Indian card choose INR; Indian cards cannot be charged in USD.
2. Pick Monthly or Annual. Annual saves about 17% (you pay for 10 months).
3. Read the card for the plan you want. The prices update as you switch.

4.3 Accept the terms and pay

1. Tick the box I have read and agree to the Terms and Conditions and Privacy Policy. The upgrade buttons turn on only after you tick it.
2. Click Upgrade to Team or Upgrade to Business.
3. A secure payment window (Razorpay) opens. Enter your card details and confirm. Do not close the browser tab while it processes.
4. When payment succeeds the window closes, the badge in the left menu changes to TEAM or BUSINESS, and every feature of the plan is switched on. A signed PDF copy of the agreement is e-mailed to you.

4.4 See and manage your billing

Open Account Settings (your name in the left menu) and click the Billing tab. Here you can see your plan, the next billing date, request usage, seats and the projected total. Use Manage payment to change the card and Cancel subscription to stop renewing. A downgrade takes effect at the end of the current billing period, so you keep what you paid for.

4.5 Monthly extras: requests over the allowance and extra seats

Your plan price covers a monthly request allowance and a number of seats. Anything above that is billed separately as monthly extras, after the month ends. There is no logging fee and no markup on what you pay your AI providers.

1. On the Billing tab, the Monthly extras card shows this month's requests against your allowance, your current seat count, the unit prices and an estimate of the extras including tax. The estimate is not a bill; it reads zero until your first paid month has been recorded.
2. After the month ends the invoice appears in the invoice list. Click Pay on its row to pay through a secure Razorpay link. An invoice for zero is marked paid automatically.
3. Indian customers can switch on Enable AutoPay instead. You approve a separate UPI mandate with a per-invoice limit (₹15,000 by default, or a lower amount you choose) and each month's extras are collected automatically. The mandate lasts one year. Invoices above your limit still come as a payment link.
4. Paying an extras invoice never changes your plan. If you cancel, the base plan stops renewing but extras already used remain payable.

4.6 If an invoice is not paid

Using more than your allowance never switches your account off; only an unpaid invoice does, and only after reminders. The Billing tab shows the outstanding amount, the due date and any restriction that is in force.

A provider is a company whose models you call, for example OpenAI, Anthropic, Google Gemini or AWS Bedrock. You give DeepintShield the provider's API key once; your applications then use a DeepintShield Virtual API Key instead and never see the real provider key.

5.1 Add a provider key

1. Open Model Hub → AI Providers.
2. In the provider grid click the provider you want, for example OpenAI. Providers with a green tick already have a key.
3. Click Add new key (top right).
4. Give the key a name, paste the provider API Key, and optionally choose which Models this key may serve. Leave Weight at 1 unless you add several keys and want to split traffic.
5. Leave Use for Cache on so cached answers can be served for this key.
6. Click Save. The key appears in the Configured keys table with an Enabled switch.

5.2 Add a custom or self-hosted provider

Running your own model server such as vLLM, Ollama or SGLang? Click CUSTOM at the top of the provider grid, give it a name, choose the Base Format it speaks (usually OpenAI-compatible), enter its Base URL, switch on Is Keyless if it needs no key, and leave the allowed request types on. Then add a key exactly as above if one is needed.

5.3 Model Registry

Model Hub → Model Registry lists every model available through your providers, with its price per token and recent usage. Use it to check a model name before you put it in code. Models are called as provider/model, for example openai/gpt-4o-mini; a bare name like gpt-4o-mini also works and is resolved from this registry.

5.4 Usage Controls (rate limits and budgets per model)

Set a request limit or spend limit on a specific model so one busy app cannot run up your bill.

1. Open Model Hub → Usage Controls and click Add Model Limit.
2. Choose the provider and model, then set requests or tokens per minute/hour/day and, if you like, a monthly budget.
3. Click Create Limit.

5.5 Price Adjust and Model Overrides

Price Adjust applies a multiplier to a model's price so the cost shown in your dashboards matches what you actually pay or charge internally: 1.0 leaves it unchanged, 0.8 is a 20% discount, 1.2 is a 20% mark-up. Model Overrides lets you silently replace one model with another (for example send every gpt-4o request to gpt-4o-mini in a test workspace).

5.6 Model Routing rules

Routing rules send a request to a different model or provider based on a condition, such as the user, a header or the model name. Open Model Hub → Model Routing, click New Rule, add one or more conditions, pick the Target model and an optional Fallback, then Save Rule.

5.7 Load Balancer

Access & Credentials → Load Balancer shows how traffic for each Virtual API Key is spread across provider keys and whether each key is healthy. Click the gear icon on a row to change the strategy (weighted random, round robin, least load, or adaptive).

A Virtual API Key (VK) is the key your application uses. It is tied to one workspace, to the providers you allow, to a budget and to safety policies. Members are the end users or applications you want to track and limit; Teams group members and share a budget.

6.1 Add a member

1. Open Access & Credentials → Members and click Add Member.
2. Type a name (for example billing-app or a person's e-mail).
3. Optionally set a monthly budget and a rate limit (per hour or per month).
4. Click Create Member.

6.2 Create a team

1. Open Access & Credentials → Teams and click Add Team.
2. Name the team and add the members you created.
3. Optionally set a shared team budget. Click Create Team.

6.3 Create your Virtual API Key

1. Open Access & Credentials → Virtual API Keys and click Add Virtual Key.
2. Type a Name, for example support-bot-prod.
3. Under Guardrail Policies pick the safety policies this key must follow (you can come back after section 8).
4. Leave Automatic Cache and Semantic Cache on to save money on repeated questions.
5. Under Key Rotation keep the default (a new key value every 90 days with a 7-day grace period) or choose Manual only.
6. Scroll down: add the providers this key may use (and optional fallback order), any MCP clients, a budget and rate limit, and assign the key to a member or team.
7. Click Create. Copy the key that starts with sk-ds- and store it safely. It is shown once.

6.4 Send your first request

Use your new key exactly like a provider key, but point your client at DeepintShield. Here is a request from the command line:

curl https://app.deepintshield.com/v1/chat/completions \
  -H "Authorization: Bearer sk-ds-your-virtual-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4o-mini",
    "messages": [{"role": "user", "content": "Say hello in one sentence."}]
  }'

You get a normal OpenAI-style JSON answer. The request also appears in Analytics → AI Logs within a few seconds, with its latency, tokens, cost, cache result and guardrail decision.

These examples target Python SDK 2.8.3, aligned with DeepintShield Server 2.8.3. To install this exact SDK release, run pip install "deepintshield==2.8.3".

The deepintshield Python package is the easiest way to route your code through the gateway and to call guardrails, RAG security, MCP tools and agent governance directly. It works with Python 3.10 or newer. All examples below use your Virtual API Key from section 6.

7.1 Install

pip install deepintshield

# add only the integrations you use, for example:
pip install "deepintshield[openai]"
pip install "deepintshield[openai,anthropic,langgraph,mcp]"

7.2 Tell the SDK about your key

Set one environment variable. The SDK reads it automatically and talks to app.deepintshield.com by default.

export DEEPINTSHIELD_VIRTUAL_KEY="sk-ds-your-virtual-key"
# optional, only for a self-hosted gateway:
# export DEEPINTSHIELD_BASE_URL="https://gateway.your-company.com"

7.3 Your first guarded chat call

from deepintshield import DeepintShield

with DeepintShield.from_env() as shield:
    with shield.openai() as client:              # native OpenAI client, routed through DeepintShield
        response = client.chat.completions.create(
            model="openai/gpt-4o-mini",
            messages=[{"role": "user", "content": "Hello"}],
        )
        print(response.choices[0].message.content)

The gateway applies your configured guardrails, budgets, logging and eligible caching to this call. For models that need Responses, use client.responses.create(...); changing the model name does not change the API method. Section 7.5 shows GPT-6 Astra.

Use the OpenAI client as the primary inference client across all 29 gateway providers. Change the provider/model request argument, for example anthropic/claude-sonnet-4-5, while keeping the same virtual key and base URL. Provider keys and cloud configuration stay on the gateway. Use the operation the model supports: text, embeddings, images, audio, or video. Model inventory and account access determine availability.

Source builds containing the 9 September integration update also expose shield.async_openai() and shield.openai_config(). Native frameworks keep orchestration: LangChain/LangGraph keep graphs, LlamaIndex keeps retrieval and indexing, and existing Agentic identity and tool policies still apply. Install and test only the framework extras used by your application; current optional dependencies may require separate environments.

7.4 The unified chat helper

For a model that supports Chat Completions, use shield.chat(...). This helper sends Chat Completions requests; it does not switch to Responses based on the model name. Streaming is one extra argument.

from deepintshield import DeepintShield

shield = DeepintShield.from_env()

# one-shot answer as a dictionary
answer = shield.chat(
    model="openai/gpt-4o-mini",
    messages=[{"role": "user", "content": "Give me three tips for writing clear e-mails."}],
    temperature=0.2,
)
print(answer["choices"][0]["message"]["content"])

# streaming: print each chunk as it arrives
with shield.chat(model="openai/gpt-4o-mini",
                 messages=[{"role": "user", "content": "Explain caching in two lines."}],
                 stream=True) as stream:
    for chunk in stream:
        print(chunk)

7.5 Keep your existing OpenAI code

You can use the native OpenAI SDK directly. Point it at DeepintShield and use your sk-ds- key. Provider-qualified model names select any supported gateway provider:

import openai

client = openai.OpenAI(
    base_url="https://app.deepintshield.com/openai",     # was https://api.openai.com/v1
    api_key="sk-ds-your-virtual-key",              # was your OpenAI key
)
print(client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Hello"}],
).choices[0].message.content)

For GPT-6 Astra, use the native Responses API. Astra requires Responses when function tools are present and does not support reasoning_effort="none". A virtual key's MCP bindings can add tools even when your Python call has no tools argument. The same responses.create method works on the client returned by shield.openai().

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://app.deepintshield.com/openai",  # local: http://localhost:8080/openai
    api_key=os.environ["DEEPINTSHIELD_VIRTUAL_KEY"],
)
response = client.responses.create(
    model="gpt-6-astra",
    input="Hello",
    reasoning={"effort": "medium"},
    max_output_tokens=2048,
)
print(response.output_text)

Responses uses input instead of messages, max_output_tokens instead of max_completion_tokens, and reasoning={"effort": "medium"} instead of reasoning_effort. Read response.output_text instead of response.choices[0].message.content. Keep function results and returned reasoning items in the Responses continuation when implementing a tool loop.

import anthropic

client = anthropic.Anthropic(
    base_url="https://app.deepintshield.com/anthropic",
    api_key="sk-ds-your-virtual-key",
)
message = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=200,
    messages=[{"role": "user", "content": "Hello"}],
)
print(message.content[0].text)

The Anthropic example is an optional provider-native path for features needing Anthropic's protocol. The same role applies to shield.bedrock() and shield.genai(). Keep OpenAI as the primary common inference client, and validate optional native features after that path. Framework binders retain native orchestration and do not remove enrollment or tool-approval requirements.

7.6 Check a prompt against your guardrails yourself

Sometimes you want the safety verdict without sending the prompt to a model, for example before saving user text. Ask the guardrails directly:

result = shield.evaluate_guardrail(
    stage="input",                       # input | output | action | mcp | rag
    input="Please summarize this support ticket",
    model="gpt-4o-mini",
    provider="openai",
    metadata={"ticket_id": "T-100"},
)
print(result.decision, result.reason, result.mode)
if result.blocked:
    print("This text is not allowed by policy")

# the same idea for agents: check what goes in, what a tool is about to do, what comes out
shield.agent.check_input("user message")
shield.agent.evaluate_tool(name="ledger_read", args={"account": "A-7"}, action_class="read")
shield.agent.check_output("assistant response")

Blocked calls show up in AI Guardrails → Findings (section 8).

7.7 Protect what your AI reads (RAG security)

If your app looks up documents and puts them in the prompt (RAG), send the retrieved pieces to DeepintShield first. Only the pieces your policy allows come back.

from deepintshield import build_chunk

chunk = build_chunk(
    content="Refunds take five business days.",
    chunk_id="chunk-17",
    document_id="refund-policy",
    source_id="support-kb",
    trust_score=95,
    acl_tags=["support"],
)

allowed, raw = shield.rag.filter(
    query="How long do refunds take?",
    chunks=[chunk],
    source_id="support-kb",
    requester="alice@example.com",
    requester_role="support",
)
# use only `allowed` when you build the prompt

# LangChain / LlamaIndex users: wrap the retriever once and forget about it
retriever = shield.rag.guard_retriever(vectorstore.as_retriever(), source_id="support-kb")
documents = retriever.invoke("How long do refunds take?")

7.8 Call MCP tools through the gateway

Register your MCP servers in Agentic → MCP Registry (section 10). Your code then opens one governed session and every tool call is checked and logged.

Use the exact gateway-qualified tool name returned by discovery and arguments that match its input schema. An empty tool list is valid: the session currently exposes no tools. Check the DeepWiki connection in MCP Registry, then select it and its tools under Virtual Keys → MCP Configurations → Allowed Tools for the key used by this script. This example checks every discovery page before calling DeepWiki. A listed tool still needs authorization when called.

SDK 2.8.3 reports valid remote tool-call rejections as mcp_execution_failed and discovery failures as mcp_discovery_failed; malformed responses remain mcp_protocol_error. Canonical policy and approval codes remain unchanged.

import asyncio

from deepintshield import DeepintShield, DeepintShieldError
from mcp.types import TextContent

shield = DeepintShield.from_env()


async def main() -> None:
    try:
        # The yielded object is an initialized official mcp.ClientSession.
        async with shield.mcp.connect() as session:
            listing = await session.list_tools()
            tool_names = {tool.name for tool in listing.tools}
            while listing.nextCursor:
                listing = await session.list_tools(cursor=listing.nextCursor)
                tool_names.update(tool.name for tool in listing.tools)
            print(sorted(tool_names))

            tool_name = "DeepWiki-ask_question"
            if tool_name not in tool_names:
                print("DeepWiki is unavailable for this virtual key. Check its MCP configuration and allowed tools.")
                return

            result = await session.call_tool(
                tool_name,
                arguments={
                    "repoName": "facebook/react",
                    "question": "What is Suspense?",
                },
            )
            # connect() translates any failed tool result into a coded
            # DeepintShieldError before call_tool() returns.
            for part in result.content:
                if isinstance(part, TextContent):
                    print(part.text)
    except DeepintShieldError as exc:
        if exc.code == "mcp_tool_approval_required":
            print("The MCP action is waiting for approval.")
        elif exc.code == "mcp_tool_authorization_denied":
            print("The MCP action was denied by policy.")
        elif exc.code == "mcp_tool_authorization_unavailable":
            print("MCP authorization is temporarily unavailable.")
        else:
            print(f"DeepIntShield error [{exc.code}]: {exc.description}")


asyncio.run(main())

7.9 Govern an AI agent (LangGraph example)

Give the agent a name and create the client before you build your graph. The SDK then registers the agent, sends each tool call to the policy engine and stops on a deny. Your LangGraph code stays ordinary LangGraph code.

import operator, os
from typing import Annotated, TypedDict
from langgraph.graph import END, START, StateGraph
from deepintshield import DeepintShield

shield = DeepintShield(
    virtual_key=os.environ["DEEPINTSHIELD_VIRTUAL_KEY"],
    agent_name="refund-agent",           # or set DEEPINTSHIELD_AGENT_NAME
)

class State(TypedDict):
    account_id: str
    events: Annotated[list[str], operator.add]

def read_account(state: State) -> dict:
    return {"events": [f"read {state['account_id']}"]}

def notify_owner(state: State) -> dict:
    return {"events": [f"notified owner of {state['account_id']}"]}

builder = StateGraph(State)
builder.add_node("read_step", read_account)
builder.add_node("notify_step", notify_owner)
builder.add_edge(START, "read_step")
builder.add_edge("read_step", "notify_step")
builder.add_edge("notify_step", END)
app = builder.compile()

print(app.invoke({"account_id": "acct-42", "events": []}))

The first run of a new agent stops with the code agent_registration_pending. That is expected: open Agentic → Work Queue, review and approve the agent (section 11), then run again. Other frameworks work the same way: LlamaIndex, AutoGen, PydanticAI, OpenAI Agents SDK, AWS Strands, Google ADK and Temporal. LiteLLM completion calls use the provider gateway path; Agentic checks apply to actual tool execution.

7.10 One-line framework binders

chat_model   = shield.bind("langgraph").model("gpt-4o-mini")
embedder     = shield.bind("langgraph").embedder("text-embedding-3-small")
llama_llm    = shield.bind("llamaindex").llm("gpt-4o-mini")
pydantic_llm = shield.bind("pydanticai").model("gpt-4o-mini")

7.11 Handling errors

Every DeepintShield-owned failure raises DeepintShieldError with a short code. The codes you will meet most often:

Guardrails are the safety rules that check every prompt going in and every answer coming out. A policy is a named set of checks with an enforcement mode. You attach policies to Virtual API Keys, so different apps can have different rules.

8.1 The Policies page

Open AI Guardrails → Policies. The top cards count your policies, enabled policies and findings. Below, the Policy Workspace has four tabs: Policy Catalog (your saved policies), Policy Editor (create or edit), MCP Security and RAG Security.

8.2 Create a policy

1. Click New Policy (green button, top right).
2. Type a Policy Name. Leave Domain Pack empty for now (domain packs are a Business feature, see 8.3).
3. Under Applicable Scopes keep Input and Output ticked. Add Action, MCP or RAG if the key also serves agents, tools or document retrieval.
4. Choose the Enforcement Mode: Block stops the request; Redact removes the sensitive part and lets the rest through. Start with Block for input and Redact for output if you handle personal data.
5. Keep Execution Mode = Sync (the check finishes before the request continues). Async checks in the background without delaying the request, and Shadow only records what would have happened, which is the safest way to try a new policy. Keep Sampling Rate = 100 and Timeout = 150 ms.
6. Under In-tree ML Detector pick a model: DeBERTa (most accurate), RoBERTa (balanced) or BERT (fastest).
7. Under All Checks click Add on every check you want, for example LLM01 Prompt Injection and LLM02 Sensitive Information Disclosure. They move to Selected Checks. Use the filter chips: OWASP 2025, OWASP Agentic 2026, Domain, Custom.
8. Scroll to the bottom and click Create Policy. Then click Publish so the policy becomes live. Every later change creates a new version; use Rollback to return to an older one.
9. Open Access & Credentials → Virtual API Keys, edit your key and add the policy under Guardrail Policies.

8.3 Domain packs and OWASP Agentic checks

On the Business plan the Domain Pack drop-down offers ready-made check sets for banking (BFSI), healthcare, insurance claims, enterprise copilot, customer support, development assistant and agentic runtime protection. The OWASP Agentic 2026 filter adds checks for agent-specific threats such as goal hijack, tool misuse and excessive agency. Pick a pack, review the checks it added, and publish.

8.4 Policy Catalog

The Policy Catalog tab lists every policy with its scope, stages, mode, pack and version. Click a row to see its summary and use Open Editor to change it.

8.5 AI Models (detectors and fine-tuning)

AI Guardrails → AI Models shows the detector models that run inside DeepintShield (no provider call, no token cost) and lets you fine-tune them. On the Detectors tab tick the detectors you want active (prompt injection, jailbreak, toxicity, hate speech, content moderation, PII and extended PII) and click Save selection. The Fine-tune (LoRA) tab lets you upload a CSV of examples to teach a detector your own patterns and phrases.

8.6 Safety Providers (Bedrock, Model Armor, Azure, webhook)

If you already use a cloud safety service you can plug it in as an extra check.

1. Open AI Guardrails → Safety Providers and click New Provider.
2. Choose the type: AWS Bedrock Guardrails, GCP Model Armor, Azure Content Safety, DeepintShield Models or a Customer-Owned webhook.
3. Fill in the credentials the form asks for, then click Test. A green result means the connection works.
4. Click Save. Then bind the provider to a policy in the Policy Editor.

8.7 Findings

AI Guardrails → Findings is the list of everything a policy caught: the stage, severity, outcome and the check that fired. Use the filters at the top to narrow it down. Three tabs separate Policy Findings, AI Model Findings (detector hits) and RAG Findings.

8.8 Guardrail Metrics

Analytics → Guardrail Metrics turns the findings into charts: how many requests were checked, blocked or redacted, how long checks took, and separate tabs for Runtime Signals, Agentic & Tools, RAG, Safety Providers, AI Models and Multimodal.

8.9 MCP Security

The MCP Security tab of the Policies page applies guardrails to tool calls made through MCP servers: each tool call and each tool result is classified before it reaches the agent. Your policies already run the shared checks here. To add MCP-specific limits, pick the policy, click Add Rule to restrict a server, tool, identity or destination domain, then click Save Rules. Recent MCP traces and findings are listed underneath.

8.10 RAG Security

The RAG Security tab protects the documents your AI retrieves. First register each document source with Register RAG Source (name, connector, index name, sensitivity, trust level, ACL tags) and click Create Source. The Source Inventory then shows each source's trust level, health and chunk count, with Quarantine and Release buttons. Every retrieved chunk gets a trust score and an injection score, and the policy decides to allow, warn, redact, quarantine or block it. Use the SDK call from section 7.7 to send chunks for checking.

Open Cost Optimization in the left menu. Every tab is a switch you can turn on for all or some Virtual API Keys. Each switch shows the plan it needs: provider prompt caching, request coalescing, the guardrail cache and parallel tools work on every plan, while semantic caching, cascade routing, compression, RAG optimization and summarization need Team. Click Save changes after you change anything. Only the fields you changed are sent; the gateway checks the values and keeps your other settings as they were, and if it cannot apply a change it puts the previous settings back.

9.1 Caches

1. Provider Prompt Caching: the SDK adds supported cache hints and the gateway applies your workspace policy. Repeated eligible prefixes can cost less; the selected model's cache read and write rates determine the savings.
2. Semantic Caching: turn it on to answer repeated or very similar questions from memory instead of calling the model. Choose the embedding provider and model, and keep the Similarity Threshold at the default 0.88 (higher means "only very close matches"). This switch controls semantic caching only; the other tabs keep their own settings.
3. Under Apply to virtual keys leave All virtual keys or pick specific ones.
4. Click Save changes.

9.2 Intelligent Routing

Two switches live here. Request Coalescing (recommended, keep it on) merges identical requests that arrive at the same moment into one provider call. Intelligent Cascade Routing sends easy requests to a cheaper model first and escalates only when needed: turn it on, click + Add tier at least twice (a cheap tier such as gpt-4o-mini and a premium fallback such as gpt-4o), pick the classifier virtual key, then Save changes. The cascade only reroutes traffic for keys inside its Apply to virtual keys scope. Batch Eligibility Analysis reports which requests could use a provider batch endpoint; it does not send batches.

9.3 Prompt Optimization

Compresses long prompts before they reach the model, using a small model that keeps the meaning. Good for chat history and long documents.

9.4 RAG Optimization

Re-ranks the retrieved documents and keeps only the most relevant ones, so fewer tokens go to the model. Max chunks is a hard limit on what is forwarded, even when the reranker is unavailable, and retrieval context placed in the system message is detected too.

9.5 Summarization and Parallel Tools

Summarization shortens long conversations automatically. Parallel Tools lets the gateway run independent tool calls at the same time to cut latency.

9.6 See how much you save

On Analytics → Overview, the Summary, Cache and Cost Opt tabs use the selected time window and filters. Cost shows the available cost total, and Estimated Gateway Savings shows the estimated savings from caching and optimization. Cost cards and graph totals stay numeric; a cost with no recorded amount displays as $0.00.

Savings Rate is estimated gateway savings divided by cost plus estimated gateway savings, multiplied by 100. For example, $3 of cost and $1 of savings gives 25%. The rate displays 0.0% when that baseline is zero or negative. Savings can be negative when cache writes or optimization calls cost more than the estimated amount avoided.

Estimated Agentic-Cache Savings is shown separately from gateway savings. Use it to review the Agentic cache's own events; do not add the two as one request total. It is hidden when the selected request filters cannot be applied to that series.

AI agents call tools (search, databases, e-mail, MCP servers). DeepintShield decides for every tool call whether it may run. The Agentic section of the left menu is the control room. On the Team plan you can register MCP servers, write and publish access policies, check and grant access, and see every decision. The Business extras are in section 11.

10.1 Register an MCP server

1. Open Agentic → MCP Registry and click New MCP Server.
2. Type a name, the server URL and pick the transport (usually HTTP (Streamable)). Add authentication if the server needs it.
3. Click Create. The gateway connects, lists the server's tools and shows them in the table.
4. Add the MCP client to a Virtual API Key (section 6) so your app can use it through the gateway.

10.2 Check and grant access (Guided access)

Open Agentic → Policy & Access. The Guided access tab answers one question: "Can this agent, acting for this user, use this tool?" Pick the agent, the user (or "Agent directly"), the resource and the tool, then click Check access. If the answer is no and it should be yes, click Grant access and choose how long the grant lasts. The Temporary delegation section (create, renew, revoke) is a Business extra; on Team it shows the plan it needs.

10.3 Runtime policy

The Runtime policy tab holds the big switches. Enforcing blocks anything the policy denies; Advisory only records what would have been blocked (use it briefly when you migrate). Blueprint protection scans an agent's code the first time it appears and again when it changes. Click Save after a change. On Team you can read every setting and edit the external context policy (OPA or Cedar); the Enforcing/Advisory switch and Blueprint protection are Business extras and are labelled with the plan they need.

10.4 Activity

Agentic → Activity shows every Run (one workflow execution), every Decision (allow, deny, approval required, with the reason) and Trends over time. This is the first place to look when an agent stops working: the reason code tells you exactly which check failed. The Audit tab lists every relationship change: who granted what to whom, and when.

10.5 Agentic and MCP analytics

Analytics → Agentic and Analytics → MCP chart decisions, governed tools and MCP tool calls. Analytics → MCP Activity is the raw log of each MCP call.

With Business the Agentic section becomes a full security platform for agents. Below is every page and what to do on it the first time.

11.1 Work Queue: your daily inbox

Agentic → Work Queue collects everything that needs a human: new agent registrations, action approvals, code reviews of changed agents, drift events and run incidents. Work through it from the top: click Review on a row, read the details, then approve or deny. The OWASP Agentic coverage badge shows how many of the 10 threat categories your policies cover.

11.2 Assets: agents, tools, actions and discovery

1. Open Agentic → Assets. The Agents tab lists every agent that has been seen or registered, with its status.
2. To add an agent before its first run, click Create agent. Type the short name (the same value you set as agent_name in code), a display name, the framework and model, an optional version and owner, then click Register agent. Otherwise the agent registers itself on first run and waits in the Work Queue. Registering grants nothing by itself; access comes from policies and grants.
3. The Tools and Actions tabs list what agents may call. Each tool carries a sensitivity level and an integrity posture (flag, approval or block when its behaviour drifts from its declared contract).
4. The Discovery tab shows agent networks found automatically from live traffic; unregistered agents appear as shadow entries.
5. Click Export AIBOM to download a signed inventory of every tool and action (CycloneDX format) for your auditors.

11.3 Tool grants and tool integrity

When an agent asks for a tool it is not yet allowed to use, the decision appears in the Work Queue. Approve it Once, for the Session, or Always, or Deny. A grant is bound to the tool's behaviour fingerprint, so if the tool starts doing something different the grant no longer applies and the Tool Integrity Engine flags, pauses or blocks it according to the tool's posture.

For an individual action approval, the pending call has not executed. After approval, resume the same tool call with the same arguments; changing arguments requires a new approval. A denial remains blocked. Check Activity → Runs for the execution status and linked decision.

11.4 Identities and identity providers

Agentic → Identities is the directory of users, groups, roles, permissions and service accounts your policies refer to. Use Add user or Import from Entra to fill it. The Identity providers button lets you connect Microsoft Entra Agent ID (or another OIDC or SPIFFE issuer) so each agent proves who it is with a signed token. Click Test to verify, then Save.

11.5 Enrolment policies

Agentic → Enrolment decides what happens when an unknown agent shows up. Click New policy, pick the identity provider and the agents it applies to, choose the risk level and what is auto-approved, then Save policy. Agents that arrive with a verified identity and match a policy are enrolled automatically; the rest wait in the Work Queue.

11.6 Blueprint scans (code review of agents)

Before a new or changed agent may run, the SDK sends a redacted copy of its code and DeepintShield scans it for risky patterns. Open Agentic → Blueprint scans (or the Code review rows in the Work Queue) to see the findings and approve or reject. A redeploy that adds no new finding is admitted automatically.

11.7 Human approvals for risky actions

Write-like actions (for example "send e-mail" or "update record") can be set to require a person. The agent pauses, the item appears under Policy & Access → Action approvals and in the Work Queue, and a reviewer clicks Approve or Deny. The SDK receives the code mcp_tool_approval_required while it waits. Approvals need Business on the Action approvals page and in the embedded tab under Policy & Access alike.

11.8 Advanced relationships

Policy & Access → Advanced relationships opens the relationship model behind the decisions (who can do what to which object). Most teams never need to edit it. If you do, the Model tab has the editor with Validate and Publish model, Tuples holds the facts, Assertions are your tests and Changes is the history.

11.9 Agentic observability

Every run in Agentic → Activity → Runs opens into a timeline of steps, tool calls and scores. Business adds Langfuse enrichment (model, tokens, cost per step), a platform tool-integrity score and sampled LLM-as-judge scores for intent and quality. Traces can also be exported to OpenTelemetry back-ends (section 13).

11.10 Agentic Cache

Analytics → Overview → Cache and the Agentic cache pages show a second cache that stores safe tool results after a decision, so repeated agent steps do not call the tool again. It is on by default; the Settings page lets you change TTL, threshold and what must never be cached.

12.1 Hallucination Control

Two parts: Control changes the request before it reaches the model (a grounding system prompt and a lower temperature) so the model invents less; Configuration scores the answers afterwards on faithfulness, relevance, coherence, helpfulness and citation precision.

1. Open Hallucination Control → Configuration. Switch on Hallucination evaluation and tick the detectors you want: Faithfulness, Answer relevance, Coherence, Helpfulness and Citation precision. Helpfulness uses a small judge model through one of your virtual keys, so pick the key and a cheap model (gpt-4o-mini works well). Streaming answers are scored once the stream completes. If you untick every detector, nothing is scored.
2. Under Performance set the Sample rate (10% is recommended so only a share of answers is scored), pick the virtual keys it applies to and click Save.
3. Open Hallucination Control → Control. Switch on the techniques you want: Stay grounded, Don't make things up, Require sources, Hedge when unsure and Reduce randomness (caps the temperature at 0.4 by default). Choose the Strictness, pick the keys and click Save.
4. Optional: open Ground Truth, click Download template CSV, fill it with questions and correct answers, then Upload filled CSV and Save ground truth. Scores are then measured against your own answers. The template has an optional vk_id column; leave it blank to use the Apply records to dropdown. An upload replaces only the keys named in that file, and Clear all references empties the corpus.
5. Watch the results on Analytics → Overview → Hallucination.

12.2 Consistency

Consistency makes sure the same question gets the same approved answer every time.

1. Open Consistency → Policy & Modes and pick a mode: Off, Exact-Match, Semantic, Semantic + Pinned or Strict Deterministic. Start with Semantic. Strict Deterministic also sends temperature 0, seed 42 and top-p 1 whenever it has to call the model.
2. Set the Semantic match threshold (default 0.93), the Scope (tenant, application, route or per-user) and how long answers stay fresh (default 72 hours). Save.
3. Open Consistency → Golden Registry to upload approved answers (CSV). These are served word for word when a matching question arrives. Each upload is a new version; if two people save at the same time the second save is refused, so reload and try again.
4. Use Consistency → Request Trace to see, for any request, whether the answer came from an exact match, the semantic cache, a pinned answer or the model. It also says why a request was not eligible: Consistency reuses answers for ordinary (non-streaming) chat requests only; streaming, Responses API and tool calls always go to the model.

13.1 Dashboards

Analytics → Overview has tabs for Summary, Cache, Cost Opt, Hallucination, Consistency, Teams, Providers, Models, MCP and Load Balancer. Use Filters and the time picker (top right) to focus on one key, team or model. Compare cost cards and charts with the same filters, and allow new requests a moment to finish logging before refreshing.

13.2 AI Logs

Analytics → AI Logs is the full list of requests. Turn on Live updates to watch traffic as it happens. Each row shows time, type, message, provider, team, model, latency, cache result and guardrail decision. Click a row for the complete request and answer.

The Total Cost card shows the cost amount for this range. Open a request to inspect its cost and token details, including provider cache usage when recorded. MCP Activity also displays numeric costs. A $0.00 display fallback does not add a new provider price to the stored record.

13.3 Exports

Open Analytics → Exports to send logs to your own storage.

1. Click Create Export. Choose On demand or a schedule, the time range, the format (JSON or CSV) and the destination (S3, GCS, BigQuery, Snowflake or local download).
2. Tick the log types you need (AI Requests, AI Errors, MCP & Agents Logs and so on) and any filters.
3. Click the create button. The export appears under Recent Exports with a download link when it is ready.

13.4 Alert Channels

1. Open Analytics → Alert Channels and click Add Channel.
2. Type a name, choose the Type (Slack incoming webhook, e-mail, or a signed webhook) and paste the destination.
3. Pick the Minimum severity and tick the Events you want: guardrail blocked a request, budget exceeded, rate limit hit, plan allowance threshold, agentic action denied, human approval required, tool integrity divergence.
4. Click Create channel. Alerts are throttled so a busy loop cannot flood the channel.

13.5 Integrations: OpenTelemetry and Prometheus

Open Analytics → Integrations. On the Open Telemetry tab enter your collector endpoint (gRPC or HTTP), choose the GenAI extension if your back-end supports it and click Save OTEL Configuration. The Prometheus tab enables the /metrics endpoint (metric names start with deepintshield_) and a Pushgateway for short jobs. A sample Grafana dashboard is provided.

13.6 Logging Controls

Governance Hub → Logging Controls is set per workspace. Enable Logs turns logging on or off, Disable Content Logging keeps only usage numbers (latency, cost, tokens) and drops prompt and answer text, and Log Retention Days sets how long rows are kept, up to your plan maximum (30 days on Team, 90 on Business). You can also list request headers to capture into log metadata. Click Save Changes.

14.1 Profile and security

Open Account Settings → Profile. Here you can update your name and e-mail, Enable MFA (a 6-digit code at sign-in, strongly recommended), generate a personal access token for scripts, and Download my data.

14.2 Appearance

Account Settings → Appearance switches between light, dark and system theme.

14.3 Legal

Account Settings → Legal keeps the signed copies of the terms you accepted at purchase, with their version numbers.

14.4 Updates

The version badge at the bottom of the left menu shows Update when a new feature release is available for your organization. Click it to open the Updates page and switch the release on when you are ready.

14.5 Playground

Playground lets you write a prompt, pick a provider and model, and run it through the gateway with all your settings applied, which is the quickest way to test a new guardrail policy. Running prompts works on every plan, including Developer. Saving prompts, sessions and versions needs Team or Business; on Developer those buttons and the Cmd+S / Ctrl+S shortcut are disabled and say why. If a configuration requires a virtual key, you can enter one for the run; it is never stored with the prompt.

Choose a provider and model, then review the available operation and input controls. The source integration update includes text, embeddings, reranking, OCR, image generation/editing, speech, transcription, and video, according to provider/model capability metadata. Unknown models remain selectable with an explicit operation choice when their task is unknown. The model list has no 1,000-model cutoff. When you switch models, previous model settings are cleared while streaming preference is preserved; saved chat sessions retain their stored settings. Missing parameter information does not invent sampling or reasoning defaults.

The selected model's catalog profile determines whether the Playground sends Chat Completions or native Responses requests. Both support streaming and tool conversations where the model supports them. Continue the same session for tool results and follow-up messages so the provider's conversation and tool-call identifiers are preserved.

14.6 Getting help

• Documentation: https://aidocs.deepintshield.com (also linked from the left menu).
• E-mail: support@deepintshield.com. Team plan replies within 24 hours, Business within 12 hours.
• Sales and Enterprise questions: sales@deepintshield.com.