Fyver Interceptor  /  Overview

Welcome to Fyver Interceptor

One policy layer for every agent that touches your enterprise data.

Your agents keep doing their work — in Salesforce and ServiceNow — and the Interceptor checks every tool call against the rules you write, before anything happens.

Take the tour

Five screens, in the order that makes sense. Each stop tells you what you'll see before you go. This is a look-around tour — take your time.

  1. 1
    Overview — the big picture

    You see whether everything is okay right now: how many calls were checked, what was blocked, and what is waiting for a person.

  2. 2
    Interceptor stream — follow a call all the way

    Follow one call the whole way: an agent makes it, a policy judges it, and the decision lands right next to it — allowed, blocked, or held for a person.

  3. 3
    Policy studio — where policies are created

    This is where you create the policies — the rules that say which calls may go through, which are blocked, and which need a person's approval first.

  4. 4
    Approvals — when a person decides

    You see the calls that were held instead of going through, waiting for someone to allow or block them.

  5. 5
    Audit log — everything that happens, on record

    The permanent record of everything that happens in Fyver Interceptor — every call and its decision, every policy change, every sign-in: what happened, and when.

  6. Help Center — every screen, explained

    Each stop has a full guide in the Help Center — what the screen offers you, and how to use it. The setup route lives there too, under How to.

Try out

A policy is a rule that decides what happens to a call: let it through, block it, or send it to a person for approval. Write your first rule, or test a call and watch a policy decide — in either order, as often as you like. Nothing here goes live, and nothing is installed into your Salesforce org.

Create your first policy

Start from a template — a high-value approval when money moves, a PII export block when data leaves — and make it yours. It lands in Policy Studio, where you'll see it in the list with the rest of your policies.

Test a call

Compose a call yourself — pick the agent, the tool, and the arguments — and see how your policies judge it, before it ever happens for real. No policies of your own yet? A starter set is loaded for you, so your first test has something to judge.

Ask your internal AI

About your numbers, or how anything here works — it answers from your console's facts and the Help Center, and only about this product

Need help?

Read the guides

Every screen, every step — short guides you can scan in a minute.

Ask us

Stuck on a step? Write to us and we'll point you in the right direction.

Email us →

Health overview

Your agents' health at a glance — six KPIs, each measured against the KPI you set · last 24 hours

Live protection
Tool calls inspected
Policy blocks
Awaiting approval
Tool drift alerts
Source changes
Suspended agents
AI insightsSee what your internal AI makes of this window.

Threats blocked

Last 7 days

Recent decisions

Policy outcomes in real time

Agent / toolDecisionPolicyTime

Highest-risk agents

Decision breakdown

Policy coverage

covered
Protected tools
Uncovered tools

AI insights

Your internal AI reads the console's numbers and tells you what changed — in plain words.

From your internal AI

The brief — written from the numbers, never used to decide anything

No brief for this window yet. Press Generate brief and your internal AI will read the numbers and write one — it works in the background, so you can leave and come back.

Ask your internal AI

About the numbers on this page, or how anything in the console works — it answers only about this product

Needs attention

Picked out by the console from this window's calls

Your KPIs

How the limits you set are holding — the same KPIs the Overview judges

The numbers behind it

Computed by the console — the facts the brief is written from

Interceptor stream

Inspect every agent-to-tool decision and the policy path behind it.

Following
Agent / toolIdentityDecisionLatencyPolicyTime

Policy studio

Write the rules that decide what your agents may do, test them here before they count, and see every policy in the order it is judged.

Suggested drafts

Policies your call data is asking for — every draft starts switched off

Policies

Policies are evaluated top to bottom — the first one that matches decides the call. Each policy has one outcome — to branch, clone a policy and give the copy a different condition or outcome. One outcome per policy keeps every decision traceable to the exact policy (and version) that made it. Each policy's own version rides in its name; use a policy's History button to see its past versions. Every decision comes from a policy on this list — never from a model.

IDNameAdapterTool patternDecisionPriorityStatusActions

Policy simulator

Test any policy — practice only, nothing goes live

This is a simulator — practice only. Nothing goes live, no real calls are made. Fields marked * are required — and gray text inside a field is only an example: a field showing gray text is still empty.
ESCALATE — human approval required

Matched P-01 · amount exceeds $500 threshold. No downstream call was made.

Agents & MCP servers

All your agents and MCP servers in one place — deploy a guardrail, see what each one can call, and spot anything that changed.

Approval queue

High-impact actions waiting for a human decision.

Drift alerts

Schema changes detected by catalog sync — a human reviews each one: ignore it as benign, or resolve it once fixed.

ServerToolDetectedSchema change (old → new)StatusReviewed byNote

Source pins

Interceptor source hashed at sync time — a change means someone edited the code

PlatformSourceHashSizeFirst seenLast seenLast changed
Not synced yet.

Audit & compliance

A permanent record of every call, the policy that judged it, and who approved what — kept so it can be shown to an auditor.

Audit readiness

Loading…

—Audit entriesEvery decision and admin action, hash-chained — the evidence behind SOC 2, ISO 27001 and EU AI Act record-keeping.
365dRetention windowEvidence kept for a full audit cycle — the archive is never deleted.
—Decisions · 30dEvery decision traced into the chain — backs the EU AI Act “Decisions traced” status
SOC 2 controlsChecking…▸
ISO 27001Checking…▸
EU AI Act logsChecking…▸
NIST AI RMFChecking…▸
GDPRChecking…▸
Internal AI policyChecking…▸

Evidence ledger

Cryptographically chained entries

Entry Event Actor Control IntegrityTimestamp

Retention by design

Hot / warm / cold tiering

🔥 Hot

Recent events in the live table — fast queries, full indexes.

🌡️ Warm

Archive table in Postgres — queryable, out of the hot path.

❄️ Cold

Signed JSONL exports with chain verification — auditor-ready.

Designed for compliance: SOC 2 CC7.2 (system monitoring retained), ISO 27001 A.8.15 (logging), GDPR Art 5(1)(c) (data minimisation via configurable windows) + Art 17(3)(b) (audit log retained under legal-obligation basis). The audit table is never deleted — integrity over convenience.

Adapters

This is where your platform connections live. Each adapter connects one platform to Fyver Interceptor: calls come in from the platform, Fyver Interceptor decides what may happen, and the adapter carries the decision back.

Settings

Everything about this console itself — who it connects to, who can sign in, and how it behaves. Secrets are always masked.

Your account

Username—
Role—
Two-factor authentication—
Display name
Email
Current password
New password
Changing your password signs out your other sessions.
Salesforce environments

Only one environment is active at a time. The adapter reads the active one per request — no restart needed. Switching environment requires re-running OAuth connect for that org.

Add environment
ServiceNow connections

Only one connection is active at a time. The broker reads the active one per request — no restart needed. Create an OAuth app in ServiceNow (System OAuth → Application Registry), then fill in the client ID/secret below. Redirect URI to register: https://console.fyver.ai/adapter/servicenow/callback

Add ServiceNow connection
Console users

admin: full access · approver: approve + view · viewer: read-only. All users must complete TOTP two-factor authentication at sign-in.

Global settings
Company info

Your company name appears in the sidebar; your company details head reports and evidence exports — so anyone reading them knows whose evidence it is and who to contact about it. Leave the name blank and the console uses the neutral name Fyver Interceptor.






The platforms your agents run on. The console only shows tabs, adapters and connections for the ones you pick — a platform you don't have never appears.

Internal AI

The console's internal AI writes the words around the numbers: the brief on the AI insights page and the explanation line on suggested policy drafts. It runs inside your stack by default — a local model (llama3.1:8b) that downloads itself the first time it is used, so nothing leaves your stack at all. The console computes every number itself; the internal AI only receives the finished facts — call counts, agent and tool names, and wait times. Call arguments and record content are never sent to it. It writes for a person to read: it never decides, approves, or changes anything. To have a different model do the writing, point the internal AI at your own provider below. To turn the internal AI off, save the provider fields empty.




Notification channels

Outbound alerts for escalations, drift, and block bursts. A channel only fires when it is enabled — rules below decide which events use which channel. Email uses the SMTP settings from the console environment (SMTP_HOST etc.).

Rules

Health KPIs decide WHEN something counts as a problem; these rules decide WHERE the alert goes and how often it may repeat. Which events notify through which channel. block.burst fires when one tool is blocked N times within M minutes. Dedup: the same event notifies at most once per window.

Recent notification log
Health KPIs

Define what healthy means for your organization. Each Overview stat card is judged against one of these KPIs: the card shows the number, its limit, and the window it was judged in. A KPI breaches when its current value is over its threshold — or under it, for coverage. A breach of a warning KPI means Needs attention; a critical one means At risk. Breaches notify once on transition (healthy → breach) through the health.threshold rules in Settings → Notifications, deduped per KPI. Defaults ship enabled — edit, disable, or delete any of them.

Caller roles

Roles for the people running agents (e.g. Salesforce users) — this is the "who" in who-can-do-what. Assign a user's platform ID to a role, then write policies with a user_role condition. Distinct from Settings → Users, which governs console access.

Single sign-on (OIDC)

Let your team sign into the console with Okta, Microsoft Entra ID, or Google Workspace. Password login keeps working alongside SSO. Create an OIDC app on your IdP first, then paste the details below — the redirect URI to register is .

IdP group → caller role mapping

This table says which IdP group earns which caller role — people are managed in your IdP, not here. At every SSO login, the IdP sends the person's groups and the console grants the mapped roles automatically. The roles are for policy decisions when that person runs agents — they are not console access (signing into this console is a separate thing). Leaving the group removes the role at the next login; roles assigned by hand in Caller roles are never touched. Google sends no groups, so there is no sync for Google — assign those by hand. SSO users are keyed by their lowercase email.

MCP API keys

A key for an MCP client — an AI app that connects to this console as its MCP server. Issue one key per client, copy it (it is shown once), and paste it into that client's own MCP configuration as the Bearer key for this console's /mcp address — for example an Authorization: Bearer … header in the client's MCP server entry. It does not go into Salesforce or ServiceNow — that is the invoke token, a different key for the other direction. A key's scope is all servers by default; narrow it to named servers after issuance. Rotate issues a replacement: the old key keeps working for 24 hours, then expires on its own. Revoke is the kill switch — calls with that key fail immediately.

Invoke token

The shared secret your platforms use to prove their calls come from you. The new value is shown once when you rotate it. The old value keeps working for 24 hours after a rotation, so both platforms can move with zero downtime. Revoke is the kill switch: every platform call fails until a new token is rotated in.

How rotation works
  1. Click Rotate token. The new token appears once, with a Copy button — copy it now. It is never shown again.
  2. Update the token in both places — Salesforce and ServiceNow, where you stored it during setup.
  3. Grace period (24 hours): the old token keeps working for 24 hours after a rotation, so both tokens are accepted while you update the platforms. Nothing breaks mid-move. After 24 hours only the new token works — the status line below shows exactly when the old one stops.
  4. First rotation: the first time you rotate, this page takes over managing the token — after that, rotate here whenever you need a new one.
Revoke — the kill switch

Revoke wipes every active invoke token at once, immediately. Every platform call then fails until you rotate in a new token. It asks twice on purpose — this is the emergency stop, for a leaked token or an instant cutoff. To recover: Rotate, copy the new token, update both platforms.

Try it yourself
  1. Rotate, then trigger a call from a platform that still has the old token — it goes through (grace period).
  2. Update both platforms with the new token, then trigger another call to confirm the new token works.
  3. Revoke, confirm calls now fail, then Rotate and update both platforms to recover.
Data retention

Hot/warm/cold tiering. Old events move from hot to the warm archive; notification history rolls; audit records export to signed JSONL (the audit table itself is never deleted — hash chain integrity).

Database backups

On-demand pg_dump backups. For scheduled backups, add a cron job on the host.

Schedules

In-app scheduler — runs daily at the set time (server local time). No cron needed.

Maintenance stats
Maintenance history
Table sizes

Help Center

How-to guides and frequently asked questions.

Start here — the route, shown firstThe whole setup route, shown as a map — six steps, what each one needs, and where it really happens — before you do any of it.

This panel is a map of the whole route, shown before you do any of it. Each step below says what it is, what you need ready, and where it happens — and "Show me how" walks you through it.

Read it like a map, not a to-do list: nobody does this in one sitting. Real setup happens in pieces, over time — some of it in Salesforce, some in this console, some on a command line. You don't have to do any of it now — this is what you'll need to learn.

  1. 1
    Get your invoke token

    The console issues a token, and Salesforce shows that token on every call the guards make — it's how the console knows a call really comes from your org.

    You need: Admin access to this console.

    Where it happens: This console → Settings → Invoke token.

    Show me how
    1. Open Settings → Invoke token.
    2. Click Rotate.
    3. Copy the token shown on screen — it's shown in full only at this moment. Copy it now and keep it somewhere safe — you'll paste it at step 3. If you lose it, rotate again to get a new one.
  2. 2
    Install the Fyver Interceptor package

    The package puts the Apex guard classes into your Salesforce org — they're what ask this console for a decision before an agent acts.

    You need: A Salesforce admin login.

    Where it happens: The Salesforce AppExchange, then your org's Setup.

    Show me how
    1. On the AppExchange, open the Fyver Interceptor listing and click Get It Now. Sign in with your Salesforce admin login, and pick the org to install into — a sandbox or Developer Edition org is a good first try.
    2. Choose Install for Admins Only, check the acknowledgement box, and click Install. It takes a few minutes, and you'll get an email when it finishes.
    3. Check it landed: Setup → Installed Packages — you should see a row for Fyver Interceptor.
  3. 3
    Create the credential

    A Named Credential in Salesforce holds two things: your console's address, and the token from step 1. The guards use it to reach the console — the token is never typed into code.

    You need: The token from step 1, and your console's address.

    Where it happens: Salesforce Setup → Named Credentials.

    Show me how
    1. Setup → Named Credentials → the External Credentials tab → New. Name it Fyver_Interceptor_Credential — copy the name exactly, underscores included — choose Custom as the protocol, and Save.
    2. On that credential, add a principal named Fyver_Interceptor. On the principal's permission-set mapping (Fyver Interceptor Access), add an authentication parameter named InvokeToken and paste your token from step 1 as its value.
    3. Back on the Named Credentials tab → New: name it Fyver_Interceptor, choose the external credential you just made, and paste your console's address as the URL — the address only, nothing after it.
    4. On that same form: Generate Authorization Header stays unchecked, and Allow Formulas in HTTP Header must be checked — that check is what lets Salesforce send the token with each call.
    5. Give yourself access: Setup → Permission Sets → Fyver Interceptor Access → Manage Assignments → add your own user.

    Names must match exactly — copy them, never retype. The install runbook in your Fyver packet has every field, in order.

  4. 4
    Give your agent its Fyver Config record

    The record ties a Salesforce agent to its Fyver ID, so the policies you write land on the right agent.

    You need: The agent's API name — for the built-in examples, Account_Researcher and Refund_Concierge.

    Where it happens: Salesforce Setup → Custom Metadata Types → Fyver Config. One honest shortcut: when you later deploy from this console, the console creates this record for you — doing it by hand is only for the manual route.

    Show me how
    1. Setup → Custom Metadata Types → Fyver Config → Manage Records → New.
    2. Name the record with the agent's API name — underscores, no spaces: Account_Researcher, not "Account Researcher".
    3. Agent ID: paste the agent's Fyver ID from its card in this console (Agents & servers). Leave the Named Credential field blank — blank means "use the default" from step 3.
    4. Save, and repeat for each agent.
  5. 5
    Connect this console to your org

    The console signs in to your org, so it can see your agents, flows, and tools — and so the deploy at step 6 knows where to go.

    You need: A Salesforce admin sign-in for that org.

    Where it happens: This console → Settings → Connections → Salesforce.

    Show me how
    1. In Salesforce: Setup → External Client Apps → your Fyver app → OAuth Settings — copy the Consumer Key and Consumer Secret in full.
    2. In this console: Settings → Connections → Salesforce — paste both, Save, then Reconnect and finish the Salesforce sign-in in the popup, as an admin of that org.
    3. Read the status line: it should say connected and name this org. Signing into the wrong org is silent — always check the name.
    4. Then go to Agents & servers → the Salesforce server card → Sync catalog, so the console picks up the org's tools.
  6. 6
    Deploy the guardrail

    From your agent's card, the console pushes the Apex guard — and any Flow guards you pick — into the environment you connected. The dialog names that environment and its address before you confirm, so you always know where it will land.

    You need: Steps 1–5 done.

    Where it happens: This console → Agents & servers → your agent → Deploy guardrail.

    Show me how
    1. On the agent's card, click Deploy guardrail. Check what's selected and the environment named at the top, then confirm.
    2. Flow guards arrive as drafts — activate each one in Salesforce Setup → Flows.
    3. In Agentforce Builder, point the agent's actions at the guards instead of the original flows.
    4. Run a test call and watch it appear in the Interceptor stream — allowed, blocked, or held for a person, with the policy that decided it named next to it.
The starter set — loaded for your first testA demo agent plus six starter policies, already built — run a simulation and watch a policy decide.

The prebuilt Salesforce set that ships with the product — a demo agent plus six starter policies, the same rules as the Salesforce package (TOP Flows + Apex dispatcher). Open Test a call on the Welcome page when you have no policies of your own yet, and the console adds them (the first time) and opens the simulator with the sample call already running: a $600 refund, escalated for approval on the spot. You feel how the Interceptor works in minutes instead of building from zero.

What loads

  • Demo agent agt_sf_demo ("Demo Agent", Salesforce Agentforce)
  • PB-01 High-value refund approval — escalate salesforce.*refund* over $500
  • PB-02 PII export block — deny *.export* over 100 records, or PII to an untrusted destination
  • PB-03 Allow account reads · PB-04 Allow contact reads · PB-05 Allow opportunity reads — the safe read baseline
  • PB-06 Allow small refunds — allow salesforce.*refund* of $500 or less (PB-01 takes the ones over $500), so a simulation can end in an allow too

Good to know

  • The set loads once, automatically: rows already present are left alone, so it never loads twice.
  • The demo agent lives in Agents & servers like any other — it is console-side only and has no platform agent behind it.
  • Nothing is installed into your Salesforce org — installing the real package is a separate guided flow. There is no ServiceNow prebuilt set yet.
  • The set is the fallback behind Test a call in Try out: when you have no policy of your own yet, it's what lets you run one right now.

When you're ready to start for real, Step 3 · Deploy — how to start, further down the Welcome page, shows the whole route first — the Welcome page itself never deploys anything.

Test a call Compose a call yourself — an agent, a tool, its arguments — and see which of your policies decides it, before it ever happens for real.

The Policy simulator, in Policy Studio, judges a call you compose against your real policies — and shows its work. Nothing is sent anywhere: the call never happens. It is how you check a policy before a real agent ever runs into it.

  1. Go to Policy studio and find the Policy simulator panel.
  2. Pick the agent. The policies that judge the call are the ones scoped to that agent, plus any scoped to every agent.
  3. Type the tool name, and the call's arguments as JSON.
  4. To test a caller-role condition, add the caller's roles in the Caller roles field.
  5. Click Test a call.

Read the result from the top: the decision, the policy that made it, and the evaluation chain under it — every policy that was considered, in order, and for each skipped one, why (a different agent scope, a tool pattern that doesn't match, a condition that isn't met). If no policy matches, the call is allowed by default — the chain shows that too.

Your first test is the exception: with no policies of your own yet, the console loads the starter set and runs its sample call against the Demo Agent, so you can watch a policy decide right away. Every test after that is yours — your agent, your call, your policies.

Set up two-factor authentication (TOTP)A password alone never signs anyone in — every console user needs a 6-digit code.

Two-factor authentication is enforced for every console user, as part of setup — a password alone never signs anyone in. The console guards every agent call in your estate; a stolen password must not be enough to reach it.

At your first sign-in

  1. Download Google Authenticator on your phone first (App Store · Google Play). Any standard authenticator app works, but Google Authenticator is the recommended one — no guessing which app to use.
  2. Scan the QR code the console shows you.
  3. Enter the 6-digit code to confirm.

If the code is rejected

The code changes every 30 seconds. If it says "Invalid code", check that your phone clock is accurate.

Lost your authenticator?

Ask a console admin to reset your two-factor in Settings → Users (Reset 2FA) — you'll enroll again at your next sign-in.

SSO users

You sign in through your identity provider (Okta, Entra ID, or Google), which already verified you with its own MFA — no second code in the console.

Add a console user Give a teammate sign-in access to this console, with the role that matches their job — admin, approver, or viewer.

Console users are the people who sign in here. They are not caller roles: a console user's role decides what they can do in the console; a caller role decides what their agent calls may do.

  1. Go to Settings → Users and click Add user.
  2. Enter their name and email, and pick a role: Admin — everything, including settings and deploys. Approver — works the approval queue and reviews activity. Viewer — read-only, for auditors and reviewers.
  3. Save. The user signs in with the email you entered.

One protection is built in: the last active admin can never be suspended, deleted, or demoted — the console refuses, so you cannot lock yourself out of administering it.

Connect Salesforce / ServiceNowConnect your platform in Settings, then sync its catalog so the console learns your tools.

Connecting a platform gives the console its own sign-in to your org or instance, so it can read your tools and deploy guardrails. You do it once per environment, in Settings.

  1. Go to Settings → Connections and open your platform's tab — Salesforce or ServiceNow.
  2. Enter the org or instance URL, and the client ID and client secret from the connected app you created on the platform side.
  3. Click Save, then Connect — Reconnect on an existing connection — and finish the platform sign-in in the window that opens, as an admin of that org.
  4. Read the status line: it should say connected and name the org you meant. Signing into the wrong org is silent, so always check the name.
  5. Go to Agents & servers, open the platform's server card, and click Sync catalog. The console pulls every tool definition, pins a hash of each one for drift detection, and makes the tools available to your policies and the simulator.

A connection can be saved as a draft with fields missing, but it cannot be activated until the URL, client ID, and client secret are all present — the console refuses and names the missing field.

Rotate the invoke token Replace the token your orgs use to call this console — the old one keeps working for 24 hours, so nothing breaks mid-change.

The invoke token is the secret your Salesforce org and ServiceNow instance present when they call this console. Rotate it when someone who knew it leaves, on a schedule your security policy sets, or any time you suspect it has been seen.

  1. Go to Settings → Invoke token and click Rotate.
  2. Copy the new token right away — it is shown once. (Lost it? Rotate again.)
  3. Paste it where the old one lives: the credential in your Salesforce org, and the connection in ServiceNow.

The old token keeps working for 24 hours after a rotation, so you can update each org in turn without dropping calls. After 24 hours it stops working on its own. Revoke is the immediate version: the token dies at once, and connected orgs cannot call until you rotate and update them — use it when a token is actually compromised.

Register an agentGive your agent its Fyver ID — the same string your dispatcher passes on every call.

Registering an agent gives it the internal agent ID that the console will judge its calls under. Do this before you deploy its guardrail: a call that arrives under an ID the console never issued is rejected as unbound, with no silent passthrough and no mystery traffic.

  1. Go to Agents & servers and click + Register agent.
  2. Enter the agent's ID — for example agt_sf_029 — and a name you will recognize. The ID is a contract: when the agent's guard is generated, this exact ID is built into it, and the guard presents it on every call.
  3. Save. The agent appears as a card on the page, ready for policies and a guardrail.

From then on, scope any policy to this agent with the policy's Agent field; a policy scoped to every agent covers this one too. Because the ID travels with the deployed guard rather than with anything the caller supplies at call time, the agent never has to state who it is — and it cannot present itself as a different agent.

Register an MCP server Point the console at your own MCP server, so its tools are checked by your policies like any other agent call.

An MCP server you register stays yours — it runs where it runs today. Registering it tells the console where it lives, so calls to its tools pass through the Interceptor and are judged by your policies first.

  1. Go to Agents & servers and click + Register MCP server.
  2. Give it a name you will recognize, and its endpoint URL.
  3. Save. The console connects and reads the server's tool list — the server appears in Agents & servers, with its tools in the catalog.

From then on, its tools show up in Policy Studio's tool patterns, so you write policies for them the same way as for any platform tool. Calls arrive under the console's MCP client identity, so a policy that should judge only these calls can be scoped to it. If the tool list changes later, the change shows up as drift — same as a platform agent's.

Write your first policyStart from a template, set the pattern and priority, then prove it in the simulator.
  1. Start from a template, not a blank form. In Policy studio, hit New policy and pick one: "High-value approval" when money moves, "PII export block" when data leaves the building.
  2. Set the tool pattern with wildcards — salesforce.*refund* catches every refund-shaped call.
  3. Choose the decision. Escalate when a human should make the call.
  4. Set the priority. Policies are evaluated top to bottom and the first match decides — lower numbers evaluate first, so your tightest rules go on top.
  5. Prove it before you ship it. Flip to the Simulator, pick the agent and tool, and watch the evaluation chain show exactly which policy fires and why.
  6. Save once the chain shows the decision you intended.

Every policy carries its own version — it rides in the policy's name everywhere the policy is shown, and its History button holds the past versions.

Deploy the guardrailOne click pushes the interceptor code to Salesforce or ServiceNow.

Deploying the guardrail pushes the guard code from the console into your platform, so the agent's calls are checked before they run. You deploy from the agent's own card.

  1. Go to Agents & servers and find the agent's card.
  2. Click Deploy guardrail. The dialog names the environment it will deploy into, and that environment's address — check both before you confirm.
  3. Choose what goes out: the Apex guard deploys as one group, and Flow guards are individually selectable in the same deploy.
  4. Confirm. The console pushes the code — Apex classes into Salesforce through the Tooling API, Script Includes into ServiceNow through the Table API — updating files in place by name, so re-deploying refreshes the same files instead of piling up duplicates.
  5. Click Deploy history on the card to see the record of every deploy: when it ran, who ran it, and what changed.

Deploy again whenever a newer guardrail version is available, and for each new agent you register. Flow guards arrive in Salesforce as drafts — activating each one in Setup → Flows is the step that turns it on.

Approve or deny a requestApprove once, and only once — a grant can’t be replayed or stolen.

When a policy escalates a call, the call waits in the Approval queue until a person decides. Nothing about the call proceeds while it waits.

  1. Open the Approval queue. Each waiting request shows the agent, the tool it tried to call, the exact arguments it tried to pass, the policy that escalated it, and the evaluation chain explaining how it got there.
  2. Read the arguments, not just the tool name. Approvals are per call, and the same tool can be reasonable with one set of arguments and wrong with another.
  3. Click Approve or Deny. Approve issues a one-time grant: the agent's immediate retry of that same call succeeds, and only that retry — the grant is used up the moment it is spent, so it cannot be replayed, shared, or spent on a different call. Deny ends the call outright, and the denial appears as a red entry in the Interceptor stream.

Either way, the decision, who made it, and when are written to the audit log. Decided requests stay available in the queue's History tab, so any decision can be revisited and explained later.

Map agent identitiesEvery agent has two identities — the Fyver ID and the platform agent — and the console keeps them matched for you.

Every agent has two identities, and the console keeps them matched for you.

The two identities

  • The Fyver ID (e.g. agt_sf_017) — the identity the guardrail passes on every call.
  • The platform agent (e.g. Account_Researcher in Salesforce).

How the match is kept

  • You never type the platform name into the console.
  • When you sync the catalog, the console reads the platform's own records and fills in any link that is missing.
  • When you deploy a guardrail, it writes the agent's record on the platform side if it is not there yet.
  • A link is never overwritten or moved — if the platform record already points at a different agent, both sides are left alone.

Why it matters

Policies and the audit log work with the Fyver ID, so the match is what ties a platform agent's calls to the right policies and the right name in the audit trail. An agent's card reads Verified once its link is confirmed, and Agent ID not linked until then — that label is about the link, never a risk judgment.

If a match ever looks wrong

Fix the agent's record on the platform side (in Salesforce, its Fyver Config record) and sync the catalog — the console follows the platform.

Set up notificationsAdd a channel, check the rules, send a test — alerts for escalations, drift, and block bursts, delivered where your team already works.

Notifications have two halves: Health KPIs decide when an alert is worth sending, and Settings → Notifications decides where it goes. This card covers the second half.

  1. Go to Settings → Notifications and add a channel: email, sent through your SMTP settings; Slack, through an incoming webhook URL; a generic webhook such as PagerDuty, Opsgenie, or Teams; or an ITSM ticket — a ServiceNow incident, created through the Table API.
  2. Click Send test on the channel and confirm the test message arrives. Do this for every channel before you rely on it.
  3. Check the rules below the channels. Escalation created, Drift detected, and Block burst are enabled by default. Each rule's Threshold reads "Set in Health KPIs", because the limit that trips the rule lives there, not here.

When a real event fires, the alert carries a deep link to the approval queue or to the event itself, and the notification is recorded on the event, where you can see it in the Interceptor stream's event detail. The notification log in the same tab keeps every send, so a missed alert can be traced afterwards.

Check agent health — the Health KPIsEvery number on the Overview is judged against a limit you set — never a bare number.

Every number on the Overview is judged against a limit you set — never a bare number. A Health KPI is that limit's definition: one signal, one window, one threshold, and one severity.

How a card is judged

  • Each Overview card carries its KPI: the number, a dot (green within its limit, amber or red over it), and the limit with its window.
  • A KPI breaches when its current value is over its threshold — or under it, for coverage.
  • A warning breach means Needs attention; a critical one means At risk.

The defaults (ship enabled)

  • Open drift alerts — over 0, critical
  • Oldest approval wait — over 60 minutes, warning
  • Uncovered tools — over 0, warning
  • Suspended agents — over 0, warning
  • Policy coverage — under 90%, warning
  • Policy blocks — over 50 blocks in the window, warning

Windows

The Overview's window selector drives the page: a windowed KPI like Policy blocks is counted and judged in the window you pick, while the limit that fires notifications stays the one in its definition. KPIs that describe right now (drift, oldest wait, uncovered, suspended) are marked now instead of a window.

Notifications

When a KPI crosses from healthy to breach, the console fires a health.threshold notification once, through the rules in Settings → Notifications (deduped per KPI) — never on every page view. An hourly background check catches breaches even when nobody opens the Overview. The limit lives in Health KPIs; Notifications only decide where the alert goes.

Define your own

In Settings → Health KPIs: add, edit, disable, or delete any KPI — pick a signal, a window (1 hour, 24 hours, 7 days, or 30 days), a threshold, and a severity.

Pin your interceptor sourceHash the guardrail source itself, so a quiet code edit can’t bypass the check.

Source pins protect the guardrail itself. The console keeps a hash of the guard code it deployed; if anyone later edits that code inside your platform — for example, to remove its check with the console — the next comparison exposes the edit.

  1. Go to Drift alerts and scroll to Source pins.
  2. Click Sync Salesforce Apex, or Sync ServiceNow scripts. The console pulls the guardrail source — the Apex classes or the Script Includes — and pins a hash of each file as the known-good version.
  3. Sync again after every guardrail deploy, so the version you just deployed becomes the pinned one.

From then on, any sync that finds a file whose contents no longer match its pin flags the file as changed and raises a drift notification. The Overview's Source changes card shows the current count at a glance. Pinning changes nothing in your org; it only records what the console last saw, so an edit made outside a deploy cannot pass quietly.

Deploy guardrail vs Sync catalog — when to use whichDeploy pushes code out; sync pulls tool definitions in and fills in agent links. Deploy first, then sync.

The two actions move in opposite directions, and the order matters.

Deploy guardrail pushes code out — from the console into the platform. It installs the guard: Apex classes into Salesforce, Script Includes into ServiceNow, together with the configuration that points the guard at this console. Use it when you first set an agent up, and again whenever a newer guardrail version is available.

Sync catalog pulls definitions in — from the platform into the console. It discovers the tools that exist on the platform, so your policies and the simulator can refer to them, and it pins a hash of each tool definition — the pinning is what makes drift detection possible later. Use it right after a deploy, and again whenever someone adds or changes tools on the platform side.

On Salesforce, a sync does one more job: it reads the org's Fyver Config records and fills in any missing agent identity links — the match between an agent's Fyver ID and its Salesforce name, which is what turns the agent's card to Verified. A link that is already recorded is never overwritten; a name held by a retired agent is released and re-linked; and if a name cannot be linked, the sync result says why.

The rule of thumb: deploy first, then sync. Deploy puts the guard in place; sync teaches the console what the guard can intercept. A sync without a deploy gives you a catalog of tools nobody is checking; a deploy without a sync leaves your policies with no tool names to match against.

Suspend or delete a policyDelete only suspends — restore in one click, or delete forever when you’re sure.

In Policy Studio, deleting a policy does not destroy it. Delete and suspend are the same safe action, and it works in two steps:

  1. Click Delete on a policy. The policy is suspended: it stops matching calls immediately, and it moves to the Suspended tab.
  2. To bring it back, open the Suspended tab and restore it. The policy returns with its settings and its version history intact, and starts judging calls again.
  3. Only when you are certain a policy should never come back, open the Suspended tab and choose Delete forever. The console asks you to confirm first, because from there the policy cannot be restored.

The two-step path is deliberate. A policy deleted by accident in the middle of an incident never leaves your agents unprotected while you sort it out — the whole time, it sits one click away in the Suspended tab.

Verify the audit chainRecompute every hash from genesis and name the first break.

The audit log protects itself with a hash chain: every entry carries a hash of its own contents and of the entry before it, so changing or removing an entry breaks the chain at that point. Verification is how you prove the chain is still intact.

  1. Go to Audit & compliance.
  2. Click Verify chain. The console recomputes every hash from the first entry forward and checks every link between entries.
  3. Read the result. A clean pass means no entry has been altered or removed since it was written. A failure names the first broken entry, says whether the entry's own hash or its link to the previous entry failed, and shows the timestamp recorded on it.

Run it whenever you need evidence that the record is untouched — before an audit, or after any maintenance on the console's database. If a failure follows a legitimate database migration rather than tampering, Rebuild chain recomputes the chain in order; it sits behind a confirmation prompt, so it cannot happen by accident.

Investigate history with reportsThe dashboard stops at 30 days — the archive doesn’t. Find any call, any time.

The dashboard stops at 30 days — but the data is kept much longer. When something went wrong last month, you need the exact calls, not a summary.

Find old calls

In the Interceptor stream, filter by agent, tool, decision, and policy, and pick a date range (Last hour / 24 hours / 7 days / 30 days / All time / Custom range). The stream queries the live table plus the archive, so a deny from two months ago is findable by agent + tool + range.

Two different exports

  • Export CSV (in the stream, or from a report) downloads exactly the filtered set with full columns — args summary, trace ID, timestamps — in a dated file. That's investigation.
  • Export evidence downloads the raw signed audit log — the tamper-evident ledger for auditors, not the event list.

Generate report in Audit & compliance builds a summary over the same filters — total events, counts by decision, agent, and policy, plus the filtered events themselves. The summary numbers always match the event list. In a report, each call names the policy that judged it with the version that judged it — the version at call time, not today's.

How far back

Set by retention (Settings → Backup & retention): events move from the live table to the archive after the hot window (default 90 days), and the archive is never deleted.

Set up Okta SSOOIDC app in Okta, groups claim in the authorization server, provider in Settings → SSO.
  1. In Okta Admin: Applications → Create App Integration → OIDC → Web Application.
  2. Set Sign-in redirect URIs to the redirect URI shown in Settings → SSO (https://your-console/api/auth/sso/okta/callback).
  3. Grant type: Authorization Code (+ Refresh Token if you want it).
  4. Gotcha: Security → API → Authorization Servers → default → Access Policies — if it's empty, add a rule allowing the Authorization Code flow, or logins fail with "Policy evaluation failed".
  5. Groups claim: in the same Authorization Server, Claims → Add Claim: name groups, token type ID Token, value type Groups, filter Matches regex .* — without this, group → role sync sees no groups.
  6. Back in the console's Settings → SSO, add provider okta: issuer https://your-org.okta.com/oauth2/default, paste Client ID + Secret, enable.
  7. Map IdP groups to caller roles in the mapping table.
Set up Google Workspace SSOCreate an OAuth client in Google Cloud, register it in Settings → SSO, and assign caller roles by hand — Google sends no groups.

Google Workspace sign-in has two halves: an OAuth client on Google's side, and a provider record on the console's side. Set them up in this order:

  1. In Settings → SSO, note the redirect URI shown for Google — it ends in /api/auth/sso/google/callback, under your console's address.
  2. In Google Cloud Console, go to APIs & Services → Credentials → Create Credentials → OAuth client ID and choose Web application. Paste the redirect URI into Authorized redirect URIs and create the client.
  3. Back in Settings → SSO, add the Google provider: issuer https://accounts.google.com, and paste the Client ID and Client Secret from the client you just created.
  4. Tick Enabled and save. The console refuses to enable a provider until the issuer, client ID, and client secret are all present, and names what is missing.
  5. Test in a second browser or a private window: the sign-in page now offers Google, and signing in with a Workspace account lands you in the console.

One Google difference to plan for: Google does not send group membership with a sign-in, so the group-to-role sync that works with Okta and Microsoft Entra ID has nothing to read. Assign caller roles by hand in Settings → Caller roles for people who sign in with Google.

Set up Microsoft Entra ID SSOApp registration in Entra ID, groups claim for sync, provider in Settings → SSO.
  1. In Azure Portal → Microsoft Entra ID → App registrations → New registration.
  2. Set the Redirect URI (Web) to the URI from Settings → SSO (https://your-console/api/auth/sso/entra/callback).
  3. Go to Certificates & secrets → New client secret and copy the value.
  4. For group sync: Token configuration → Add groups claim (Security groups or All groups), and make sure the Group ID is emitted — you map those group IDs (Object IDs) to caller roles in the console.
  5. In the console's Settings → SSO, add provider entra: issuer https://login.microsoftonline.com/{tenant-id}/v2.0, paste the Application (client) ID + secret, enable.
Back up and restore policiesExport the JSON to git, or roll any policy back to any version in one click.

Policies have two independent safety nets: version history for a single policy, and export for the whole set.

Roll one policy back. Every create, edit, and delete is saved as a version. Click History on any policy in Policy Studio to see its versions — who changed it, what changed, and when — and roll back to any earlier version in one click. The policy's name in the list shows its current version, so you always know which version is the live one.

Back up the whole set. Use Export in Policy Studio to download every policy as one JSON file. Keep that file with your own records — in a git repository, for example — or use it to promote the same policies into another environment. Import reads the file back, and imported policies arrive disabled, so you can review them in the list before any of them starts deciding calls.

Between the two, no policy change is ever truly lost: versions undo individual edits, and an export restores the set exactly as it stood when you took it.

Add a caller roleName it <function>_<level> — only if a policy will treat it differently.

A caller role names a level of authority for the people running your agents — e.g. support_agent, support_manager, support_admin. Without roles, a policy can only say "this agent can do this." With roles it says "this person, through this agent, can do this" — a support agent runs refunds within limits; only a manager approves the $5,000 one.

Naming: <function>_<level>

  • Function is the business area — support, finance, billing…
  • Level is one of: agent (a regular employee, works within limits), manager (approves escalations), or admin (full scope in that function).
  • The role key can't be renamed afterwards — only the display name and description — so get the key right the first time.

Two rules that save confusion

  • No hierarchy is built in: a manager must be given both support_agent and support_manager — the engine doesn't infer one from the other.
  • Only create a role if a policy will treat it differently — otherwise it adds noise, not control.

Add one (console admin only)

  1. Settings → Caller roles → + New role.
  2. Give people the role: assign them on the same page by their platform user ID, or map IdP groups in Settings → SSO — membership then syncs on every login.
  3. Reference the role in a policy's Caller roles restriction. A role does nothing until both halves exist: someone has it, and a policy checks for it.

Role conditions are fail-closed: a caller with no roles never matches a role-restricted policy. And note: caller support_admin is not the console admin — one governs agent actions, the other governs console access.

Map IdP groups to caller roles Let group membership in Okta, Microsoft Entra ID, or Google decide who gets which caller role — synced at every sign-in.

Assigning caller roles one person at a time works, but if your people already sit in groups at your identity provider, map the groups instead: membership there decides roles here, and nobody keeps two lists in step by hand.

Set up SSO for the provider first — group mapping rides on it. Then:

  1. Go to Settings → SSO and find the IdP group → caller role mapping table.
  2. Add a mapping: the group key, exactly as your provider knows it, and the caller role it grants. What "exactly" means depends on the provider — Okta: the group's name. Microsoft Entra ID: the group's Object ID. Google: sends no groups, so mappings cannot apply — assign those users manually on the Caller roles page.
  3. Save. The mapping takes effect at each member's next sign-in.

How it behaves: your identity provider is the source of truth, and membership is re-checked at every sign-in — someone who leaves the group loses the role at their next login. Roles granted this way count for policy decisions when that person runs agents; they never grant access to this console. Manual assignments on the Caller roles page are separate and are never touched by the sync — on the Caller roles page, each member row shows where the role came from.

OverviewYour agents' health at a glance — six KPIs, each measured against the KPI you set.

The Overview is your agents' health, not raw counts: every number is measured against the KPI you set in Settings → Health KPIs. In one glance you know whether your agents are behaving — and the dot on each card (green within its limit, amber or red over it) says so before you read the number.

Under the cards, a one-line AI insights teaser carries the single most important change in the window you picked — blocks rising on a tool, or a tool no policy covers — and takes you to the AI insights page. That page is where the console's internal AI talks: a written brief about what changed, what needs attention under it, and the computed numbers at the bottom as evidence. The Overview itself stays numbers-only, on purpose: cards for limits and health, words on the AI's own page.

The cards

  • Tool calls inspected — every intercepted call in the window.
  • Policy blocks — calls a policy stopped.
  • Awaiting approval — calls a human needs to review.
  • Tool drift alerts — tool definitions that changed since they were pinned.
  • Source changes — interceptor source files modified.
  • Suspended agents — agents on hold; all their calls are denied.

Click any card to drill down — inspected and blocks jump to the stream, awaiting approval opens the queue, drift opens the drift page, suspended opens Agents & servers.

Below the cards

  • Threats blocked — the trend of blocked calls over time.
  • Decision breakdown — the mix of allow / block / review decisions; click a row to open just those calls in a report.
  • Highest-risk agents — which agents draw the most fire. The number beside each name is a score from 0 to 100: the share of that agent's own calls in the window that were blocked or held for review. A name turns red when its blocks pass the flag limit; clicking it opens that agent's calls in a report.
  • Policy coverage — how much of your tool inventory any policy governs, judged against your coverage limit — with the split by platform underneath, so you can see which platform the uncovered tools belong to. Click Uncovered tools to see exactly which tools have no policy yet, and start one from there.

The window

Switch the time window (1h / 24h / 7d / 30d) to zoom in on an incident or out for the board. Windowed numbers are counted in the window you pick; each card still shows the limit it is judged against.

AI insightsThe internal AI's own page — it tells you what changed, in words; the numbers sit underneath as evidence.

This is where the console's internal AI talks. The rest of the console shows you cards and numbers; this page leads with the brief — a short written account of the window you pick, in plain words: what changed, what stands out, what to look at. Press Generate brief and it is written in the background, from numbers the console computed itself.

Needs attention is the console's own picking-out, not the AI's: tools whose blocks are rising, and tools no policy covers yet. When nothing qualifies, it says so — a quiet window makes a short page. Select any line — or a tool's name in it — to jump straight to the calls behind it in the Interceptor stream, already filtered to that tool and window.

Your KPIs shows the health KPIs you defined in Settings, judged exactly as the Overview judges them — each row carries its value, its limit, and the window it was judged in, worst first. Select a row to go to the screen that owns it: Policy blocks opens the blocked calls themselves. When a KPI is over its limit, the brief says so in words at the top of this page.

The numbers behind it are the same computed facts the brief was written from — call totals against the window before, the busiest agents and tools, how approvals flowed. They are evidence, printed underneath; the Overview's cards remain the place for limits and live health. The brief never decides, approves, or changes anything — it is a reading aid, and generating one is recorded in the Audit log.

Ask it. The chat box on this page — and on the Welcome page — answers questions in plain words: about these numbers, or about how anything in the console works. For how-to answers it draws on the Help Center's own pages, and it answers only about this product. It cannot change anything; it only reads and explains. The conversation is yours, stored in your console, and you can clear it at any time.

WelcomeWelcome is the starting point for a new admin: what Fyver Interceptor is, a tour of the screens, and a place to practice before anything is real.

Welcome is where a new admin starts. It shows you what Fyver Interceptor is and lets you practice safely, before you change anything real. The route to a protected agent lives in the Help Center's Start here guide — shown as a map, so you can take it in pieces, at your own pace.

Take the tour walks you through five stops, one per screen. Each stop introduces a screen before you visit it, so you always know what you are looking at when you get there. The tour keeps track of the stops you have visited.

Try out is practice. Create your first policy, or test a call — in either order, as often as you like. Nothing you do here goes live in your org.

When you are done here, Go to Overview moves on to the console itself. If you would rather not land here at sign-in, choose Don't show this again — Welcome stays in the sidebar whenever you want it back.

Interceptor streamThe Interceptor stream shows every call your agents made and what was decided, with the reason behind each decision.

The Interceptor stream is the complete record of what your agents tried to do and what the console decided. Come here when something went wrong, or when someone asks why a call was blocked: instead of guessing, you can point at the exact call and the exact decision.

Each row is one call: which agent made it, which tool it called, the decision — Allowed, Blocked, or Review — the policy that decided it, and when it happened. Click a row to open its evaluation chain: every policy the console checked, in order, why each one was skipped (wrong agent, pattern did not match, condition not met, policy off), and which one finally decided.

A row marked Rejected is different: the call arrived with a missing or wrong invoke token, so it was turned away before any policy saw it — no policy is named, because none was consulted. Rejected rows are kept on purpose: a misconfigured org, or someone probing the console, shows up here instead of vanishing. Repeated attempts from the same source are recorded at most once a minute.

You can filter by decision, agent, tool, and policy, and pick a date range — last hour, 24 hours, 7 days, 30 days, all time, or a custom range. The search covers the archive as well as recent calls, so a decision from two months ago is just as findable as one from a minute ago.

Export CSV downloads exactly the set you have filtered. For a summary instead of rows — totals and counts by decision, agent, and policy — generate a report in Audit & compliance.

Policy studioPolicy studio is where you create the policies that decide what your agents may do, and test them before they go live.

Policy studio is where policies are created — the center of Fyver Interceptor. A policy is a rule that decides what happens to a call: let it through, block it, or hold it for a person's approval. The policies you write here are what your agents live under.

The list is the complete rulebook, shown in the order the console reads it: top to bottom, and the first policy that matches a call decides it. Each policy has one outcome — to branch, clone a policy and give the copy a different condition or outcome; one outcome per policy keeps every decision traceable to the exact policy (and version) that made it. Each policy carries a tool pattern (for example "salesforce.*refund*"), an action — Allow, Deny, or Escalate — the agents it applies to (all of them, or one named agent), and an optional condition, such as an amount over 500. Tabs filter the list by platform.

You don't have to start from a blank page: new policies begin from templates for the cases most teams meet first — a high-value approval when money moves, a block on data leaving, change control.

Before a policy governs real calls, prove it behaves: the simulator runs a sample call against your real policies and shows you the decision — which policy matched, and why the ones above it didn't. Nothing in the simulator touches a live agent. When a policy needs adjusting, its History shows every earlier version, and you can roll back to any of them. Export and Import move policies between consoles as a file, so a rulebook you built once can travel.

Agents & serversAgents & servers lists every agent this console governs and the MCP servers behind them, platform by platform.

Agents & servers is the inventory of everything this console governs: your AI agents, and the MCP servers that provide their tools. If you want to know what agents exist, what each one can call, and whether its guardrail is actually in place, this is the page that answers.

Platform tabs split the page — All, Salesforce, ServiceNow — and under each, agents, MCP servers, and tools are grouped separately. An agent card shows its status and whether the console has confirmed its link to its platform identity: Verified means the link is confirmed; Agent ID not linked simply means the agent's Fyver ID is not yet matched to its platform identity — it is not a risk judgment.

Each card shows one fixed value and the agent's real traffic. Fyver ID is the console's own ID for the agent, issued when it was registered — the one value on the card that never changes. Everything else is counted from the agent's recorded calls: Last ran as is the platform user on its most recent real call, and Last caller roles are the roles assigned to that user on the Caller roles page — the same caller roles your policies check. The two always describe the same call — the last one. Earlier calls, and the other users the agent has run as, are in the Interceptor stream and the Audit log: the card is the summary, the ledger is the detail. Last seen is its most recent real call, Tool scope is how many different tools it has called in total, and 24h calls is its real calls in the last 24 hours. Simulator tests are not traffic — they never move these numbers. A runs-as user is also recorded at registration, as part of the agent's record; it is not shown on the card unless the calls disagree with it — if the agent was registered as one user but its calls run as another, the card says so.

From an agent's card you can deploy its guardrail — the console installs the guard into the platform for you — and read its deploy history. Suspend stops every call from that agent at once: while suspended, calls are denied before any policy is checked, the attempts are still recorded, and Reactivate restores normal judging whenever you are ready. An agent that is no longer used can be retired; its record and history are kept. Nothing on this page is ever deleted.

MCP servers are registered here, and Sync catalog pulls a platform's live tool definitions in and records them, so Drift alerts can warn you if a definition later changes. Each server shows its tool count, when it was last scanned, and whether its tools still match what was recorded.

Approval queueThe Approval queue holds the calls a policy paused for a person's decision; each approval can be used exactly once.

The Approval queue is where a call waits when a policy says a person should decide. Instead of letting a high-risk action go through — or blocking it outright — the console pauses it here, and the agent waits for your answer.

Each item shows the full context you need to judge: which agent, which tool, the arguments it was called with, the policy that escalated it, and how long it has been waiting. The count in the sidebar keeps the queue visible from anywhere in the console.

The Background button on a pending approval adds the wider picture, computed from recorded calls at the moment you open it: the agent’s usual pattern over the last 30 days, anything about this call that stands out against it, and how similar calls were decided before — and by whom. It is facts only: it never recommends approving or denying. The decision stays with the person.

Approving is deliberately one-time. An approval issues a grant the agent can spend exactly once: its retry goes through, and the grant is used up, so an approval cannot be replayed later or reused for a different call. Denying blocks the call outright, and the denial appears as a red entry in the Interceptor stream.

The History tab keeps every request that has been decided — who approved or denied it, when, and under which policy — and every decision is written into the permanent record in Audit & compliance. This is the page an auditor will ask to see: the proof that a person, not just a machine, approved the actions that mattered.

NotificationsAlerts for the events that can’t wait for someone to check a dashboard.

Notifications decide where an alert goes when something happens that cannot wait for someone to check a dashboard: an escalation sitting unapproved is an agent stuck mid-task, and unseen drift is a change running unreviewed.

The division of labor is strict. Health KPIs decide when — the limits live there. This page decides where and how often: which channel each kind of event goes to, whether the rule is on, and how soon it may repeat. That is why the health threshold rule carries no limit of its own here: it fires when a KPI crosses the limit set in Settings → Health KPIs.

Four events can fire. Escalation created — a call is waiting for a person's approval. Drift detected — a tool definition or a guardrail's source changed. Block burst — one tool blocked a set number of times within a set number of minutes, usually a misconfiguration or someone probing. Health threshold — a KPI flipped from healthy to breach.

Alerts go out by email (using the console's mail settings), to Slack through a webhook, or to a generic webhook such as PagerDuty, Opsgenie, or Teams, or into your help desk as a real ticket — a ServiceNow incident, or webhook mode for anything else. Every alert carries a link straight to the approval queue.

So the channel stays bearable, the same event notifies at most once per window — 60 minutes by default. Every attempt, sent, failed, or held back as a duplicate, is listed in the log on this page, filterable and sortable; and each notification is also recorded on the event itself, so an escalation opened in the Interceptor stream shows which channels fired.

Caller rolesCaller roles let a policy treat people differently: the same agent can do more for a manager than for someone junior.

A caller role is a job title this console knows a person by. It lets the same agent behave differently in different hands: a support agent and a support manager might both run the Refund Concierge, but only the manager should approve a $5,000 refund. With roles, a policy can say: this person, through this agent, may do this.

A role works only when two halves meet: here, you give it to a person by their platform user ID; in Policy studio, a policy carries a caller-role condition naming the role. Either half alone does nothing — which is why each role card shows Used by N policies, so you can see whether the second half exists.

A person gets a role two ways. You can assign it by hand on this page; the row is then labeled Manual. Or it can arrive by SSO group sync: an identity-provider group is mapped to the role in Settings → SSO, and the role is granted automatically at sign-in. Synced rows are labeled SSO group sync and managed at the provider: removing one here does not stick — the next sign-in adds it back.

The assignment only works if the ID is exactly the one the platform sends with the call. On Salesforce it is the user's ID from Setup → Users (it starts with 005); on ServiceNow, the user's sys_id. A value that does not match exactly means the person never gets the role — and nothing warns you. Role checks fail closed: a caller with no matching role never passes a policy that requires one.

These are not console users. Caller roles belong to the people who run agents on your platforms; Settings → Users governs something different — who can sign in to this console.

SSOSign in with Okta, Entra ID, or Google — one OIDC protocol, no SAML.

SSO lets your team sign in to this console with the identity provider they already use — Okta, Microsoft Entra ID, or Google Workspace — instead of another password. Multi-factor is enforced by the provider, and one protocol (OpenID Connect) covers all three — no SAML to configure.

Setup takes three values from the app you create at your provider — the issuer, the client ID, and the client secret — pasted here. The form shows the redirect address to register in that app. A provider cannot be switched on until all three are present — the console refuses and names what is missing — but a half-finished one can be saved as a disabled draft. Password sign-in keeps working alongside.

At first SSO sign-in, a person's account is created automatically, or linked to an existing console account when the provider confirms the same email. There is no second code in the console — the provider's multi-factor check covers it.

SSO also feeds Caller roles: a provider group can be mapped to a role, applied at every sign-in. The provider is the source of truth — joining the group grants the role, leaving it removes the role at the next sign-in. Granted roles are for policy decisions (what a person may do when running an agent), not for console access, and assignments made by hand in Caller roles are never touched by the sync.

What you paste for a group depends on the provider. Entra ID sends group Object IDs, copied from the group's page in Entra admin. Okta sends group names, typed exactly as in Okta's Directory. Google sends no groups at all — with Google, caller roles are assigned by hand.

Drift alertsDrift alerts warns you when a tool definition or a guardrail's own source changes after it was recorded.

Drift alerts is your early warning that something your agents depend on has changed without you approving it. An agent is only as trustworthy as its tools: if a tool's definition changes quietly — a new parameter appears, a behavior changes — that can be an honest update, a breaking change, or an attack. This page makes sure you hear about it from the console, not from an incident.

When a server's catalog is synced, the console records every tool definition. Later scans compare the live definitions against that record. A tool that was added, removed, or modified is flagged here with a before-and-after view, so you can see exactly what changed rather than take anyone's word for it.

The watch goes one level deeper, to the guardrails themselves. The console also records the source of your deployed guards; if someone edits that source — for example, to remove the check a guard makes before acting — the tool definitions still look normal, but the source record no longer matches, and the change is flagged here.

When an alert lands, review the difference, then either accept it — recording the new state as the approved one — or investigate before anything relies on it. How often each server is re-scanned is set per server on Agents & servers; set it to manual if you would rather scan on demand.

Audit & complianceAudit & compliance is the permanent record of everything that happens in this console, ready to prove it to an auditor.

Audit & compliance is the permanent record of everything that happens in this console — not only the decision on every call, but every change a person makes: a server registered, a policy deleted, a key rotated, a sign-in. Nothing happens off the record, and the record is never deleted.

The ledger is built so that tampering shows. Each entry is linked to the entry before it, so editing or removing a record breaks the chain from that point on. Verify chain checks the whole ledger and tells you exactly which entry broke and why; Rebuild chain repairs the links after a legitimate migration.

There are two ways to take the record out. Generate report builds a summary over the range and filters you choose — total events, counts by decision, agent, and policy, plus the events themselves. Export evidence downloads the raw signed log for an external reviewer. The report is for your investigation; the evidence is for the auditor.

Below the ledger, six compliance frameworks — SOC 2, ISO 27001, EU AI Act, NIST AI RMF, GDPR, and your internal AI policy — each expand to the controls being checked and their live status. Those statuses are computed from what is actually in this console — audit entries, users, policies, agents — so if something degrades, the status changes with it. When an auditor, a customer, or a regulator asks you to prove what your agents did and who allowed it, this page is where the answer lives.

AdaptersAdapters is where your platform connections live — each adapter carries calls between one platform and the console.

Adapters is where your platform connections live. Each adapter connects one platform to Fyver Interceptor: calls come in from the platform, Fyver Interceptor decides what may happen, and the adapter carries the decision back. Your policies sit above all of it, unchanged, whichever platform an agent runs on.

Each adapter card shows the live status of that platform's connection, with Connect, Test, and Disconnect for managing it. Sync catalog pulls the platform's tool definitions into the console, where Agents & servers and Drift alerts can work with them. On Salesforce, it also fills in agent identity links from the org's Fyver Config records — the matches behind the Verified badge on agent cards. View setup opens the step-by-step guide written for that platform, in that platform's own places.

You only see adapters for the platforms your company actually runs — that choice is made once, in Settings → Company info. A platform you don't have does not appear here, so this page is always a picture of your own estate, never a catalog of possibilities.

SettingsSettings is where you configure this console itself — its connections, its users, and how it behaves.

Settings is where this console itself is configured: who it connects to, who can sign in, and how it behaves. Come here when the console itself needs to change — a new connection, a new colleague, a different limit. This card is the map; every tab below has its own help card with the full story.

  • Connections — the Salesforce and ServiceNow environments this console works with.
  • Invoke token — the token your platforms show on every call; rotate or revoke it.
  • Users — who can sign in to this console, their role, and their two-factor.
  • Health KPIs — the KPIs your Overview numbers are judged against.
  • Notifications — where alerts go when something needs a person.
  • Caller roles — the job titles a policy can check for the person running an agent.
  • MCP API keys — keys for MCP clients that connect to this console.
  • SSO — sign in with Okta, Entra ID, or Google instead of a console password.
  • System — settings that apply to the whole console.
  • Backup & retention — how long data is kept, and backups of the database.
  • Company info — your company record, and the platforms your agents run on.

Secrets are masked everywhere in Settings: what you cannot see on the screen cannot be read over your shoulder either.

Settings · ConnectionsYour Salesforce and ServiceNow connections — fill them in, set one active.

Connections holds the platforms this console talks to: your Salesforce environments and your ServiceNow connections. This sign-in is what lets the console see your agents, flows, and tools — and it is what Deploy guardrail uses to know where a guard should go.

For each environment you fill in the org URL, the client ID, and the client secret, then Save. Fields marked * are required to activate: a half-filled connection can be saved as a draft, but Set active is refused until everything required is there, and the refusal tells you exactly what is missing.

One connection is active at a time. The active one is the org the console works with right now; switching to another needs no restart. Because signing in to the wrong org is silent, the status line always names the connected org — check the name before you deploy anything.

You only see the platforms your company runs on. Which platforms appear here is chosen in Settings → Company info → Platforms, so a Salesforce-only company never sees a ServiceNow form.

Settings · Invoke tokenThe token your platforms show on every call — rotate it, or revoke it as a kill switch.

The invoke token is how this console knows a call really comes from your platform. Your platform shows the token on every call its guards make; a call without it — or with a token that has been revoked — is not trusted.

Rotate makes a new token and shows it once: copy it at that moment, because it is never shown in full again. The old token keeps working for 24 hours, so you can update the credential on the platform side without a gap in protection.

Revoke is the kill switch: the token stops working immediately. Use it when a token may have leaked. Calls carrying it fail from that moment, until you rotate and hand the platform a new one.

The token belongs in the credential on the platform side — on Salesforce, the Named Credential from your setup; the exact fields are in your Fyver packet. It is never typed into code. And it is not the MCP API keys: those face the other way, letting an MCP client connect in to this console.

Settings · UsersWho can sign in to this console, their role, their two-factor, and their history.

Users is where you control who can sign in to this console. These are console accounts — not the people who run your agents; those are covered by Caller roles.

Each account has one of three roles. An admin can do everything, including Settings. An approver decides escalations in the Approval queue. A viewer can look at everything and change nothing. The username is the sign-in name; the email is required, because password recovery goes there.

Every sign-in is a password plus a six-digit code from an authenticator. The list shows each person's two-factor status at a glance — green when it is on, red when it is off — and if someone loses their authenticator, Reset 2FA lets them enroll again at their next sign-in.

Each user's email shows whether it has been verified. When an account is created, and whenever an email changes, the console sends a code to that address; the owner enters it to confirm the address is theirs — in Settings → Your account, or, for an admin, right on their own row in this Users list — and an admin can resend the code from any user's row. Password recovery uses the email on file either way — verification is how you know the address is right before the day it is needed.

Each user's History shows their sign-ins, including the failed ones, and every change to their account: created, role changed, password or two-factor reset, suspended, reactivated. Two protections cannot be switched off: the console always keeps at least one active administrator — the last one cannot be suspended, deleted, or demoted — and you cannot suspend yourself.

Settings · Health KPIsThe limits your Overview numbers are judged against — signal, window, limit, severity.

Health KPIs are how you define "healthy" for the numbers on the Overview. A KPI is four things together: a signal (what is counted), a window (the period it is counted over), a limit (the line it should stay within), and a severity (how serious crossing the line is). Without them, an Overview number is just a number; against the KPI you set, it becomes a judgment.

A KPI breaches when its value goes over its limit — or under it, for coverage. A warning breach reads as Needs attention; a critical one reads as At risk. A KPI about right now is judged now; a windowed KPI is judged inside its window, and the window is always printed next to the number on the card, so what you see is always what was judged.

When a KPI flips from healthy to breach, a health notification fires once. The limit lives here; where that alert is delivered is decided in Settings → Notifications — the two pages work as a pair.

The defaults are a starting point, not the answer. Add, edit, disable, or delete KPIs until the Overview judges your agents by the standards your own team would use.

Settings · MCP API keysKeys for MCP clients connecting to this console — shown once, rotated with 24-hour grace, revoked to kill.

An MCP API key lets an MCP client — for example, an AI assistant on someone's desk — connect to this console and use the MCP servers registered here. The calls it makes are judged by your policies, exactly like any other call the console sees.

The key goes in that client's own MCP configuration, as its sign-in credential. It does not go into Salesforce or ServiceNow: those platforms use the invoke token, which faces the other way. The invoke token proves a call comes from your platform; an MCP API key proves a client may connect to this console.

A new key is shown in full only when it is issued or rotated — copy it at that moment; afterwards only its first characters are visible. Rotate issues a new key and lets the old one keep working for 24 hours, then stop on its own, so a client can be updated without downtime. Revoke is the kill switch: the key stops immediately.

Each key's scope is set on its row: all registered servers, or a restricted list — so a key handed to one team need not open every server you run.

Settings · SystemConsole-wide settings — including the encryption key that protects every stored secret.

System holds the settings that apply to this console as a whole. They do not change per environment: the active environment only chooses which org the console is connected to, and environments themselves are managed in Connections. Every row here says in plain words what it does.

One row deserves care before you touch it: the encryption key. It protects every secret the console stores — connection credentials, SSO secrets, two-factor secrets. Change it, and everything protected by the old key becomes unreadable: every stored secret has to be entered again. The console warns you and asks for confirmation before such a change goes through, and setup is not complete until a key is set.

The rest are working adjustments: how often the console re-reads your platforms' tool catalogs (which is how drift gets noticed), this console's public address, how many calls per minute it accepts, which argument fields are hidden in the stream and in reports, and how many database connections it keeps open.

Settings · Backup & retentionHow long data is kept, and database backups — stats and history read one and the same record.

Backup & retention holds two different jobs: how long data is kept, and how the whole database is copied so it can be recovered.

Retention decides what stays close at hand. Events older than the hot-retention period move to the archive, where they stay searchable from the Interceptor stream. Old notification rows are deleted once they pass their limit. Audit entries are exported to files when a segment fills — the audit record itself is never deleted.

Backups are copies of the entire database. Backup now takes one immediately; a schedule takes one automatically, every day at the time you set. Every completed backup is written into one record in the database: manual runs carry the name of the person who ran them, automatic ones are labeled Scheduled by scheduler.

Maintenance stats and Maintenance history both read that same record, so the two can never disagree about when the last backup ran or who ran it. History can be filtered by date and sorted by time, event, or who ran it — when an auditor asks how you protect the evidence itself, this tab is the answer.

Internal AIThe console's own AI — it runs inside your stack, writes the brief and the draft explanations, and never decides anything.

The internal AI is the console's own writer. By default it is a model that runs inside your stack — there is no Fyver AI service behind it, and nothing leaves your stack. It lives on the stack's own private network, which nothing outside the stack can reach. It writes the short brief on the AI insights page and the explanation line on suggested policy drafts, and it answers your questions in the chat box on the AI insights and Welcome pages — about the numbers, and about how the console works, which it answers from the Help Center's own pages. Always from numbers the console computed itself and pages the console ships.

Base URL, Model and API key point the internal AI at a provider of your own instead of the in-stack model. The API key is stored as a secret and never shown again — type a new one to replace it, or tick Remove the saved API key and Save to disconnect. Whichever model does the writing, it receives the same finished facts each time: the window's call counts, decision totals, agent and tool names, and approval wait times. Never call arguments, record content, or anything a caller typed. Writing is recorded in the Audit log, and it changes no policy, approval, or setting. Saving the provider fields empty turns the internal AI off. The in-stack model file (about 4.7 GB) downloads the first time the internal AI is used, so the first brief can take a few minutes to appear.

Writing a brief runs in the background: press Generate brief and carry on — the finished brief appears on the AI insights page when it is ready, however long the model takes. Nothing waits on it, and it is never on the path of a decision.

Settings · Company infoYour company record — and the platforms switch that decides which tabs the console shows.

Company info is your company record, collected once — in the first-run wizard, and edited here afterwards: company name, contact person, contact phone, email, and address, plus the platforms your agents run on.

The name is not decoration. It appears in the sidebar, at the head of reports, and on evidence exports: this is your console and your evidence, and both should carry your company's name. If you leave it blank, the console uses the neutral name "Fyver Interceptor" — it never invents a company or fills one in for you.

Platforms is the switch that shapes the whole console. Tick the platforms your agents actually run on, and the console shows tabs, adapters, and connections only for those: a platform you don't have never appears anywhere — no greyed-out tab, no teaser. At least one platform must stay selected; the console will not let you untick the last one.

Come here when your company details change, or when you start running agents on a second platform and want its tabs to appear.

Why do my calls always get denied?Usually the catch-all is deciding them — every policy above it passed. Three scenarios cover most cases.

Policies are read top to bottom, and the first one that matches a call decides it. Each policy has exactly one outcome — Allow, Deny, or Escalate. If a call matches nothing above it, the call reaches the catch-all near the bottom of the list — the policy whose tool pattern is just * — and if that policy is set to Deny, the call is denied. That is the design working: a call no policy claimed is refused, not waved through.

Scenario 1: the call is missing something the condition needs. A refund policy that escalates refunds over 500 cannot judge a call that carries no amount — the condition has nothing to test, so the policy passes and the catch-all denies the call. Nothing is wrong with the policy; the call was never one it could decide. Test the same call with the amount included and the policy takes it.

Scenario 2: you expected one policy to do two things. A policy that matches gives its one outcome; a policy that does not match gives nothing — there is no “else” inside a policy. If you wrote “refunds over 500 → Escalate” and expected smaller refunds to be allowed by the same policy, the smaller refunds fall past it to the catch-all. The else is another policy: clone the first one, change the copy's condition, set its outcome to Allow, and keep it above the catch-all.

Scenario 3: the policy never sees the call. The tool name does not match the policy's pattern, or the policy is scoped to a different agent. The call goes past untouched. Widen the pattern or the scope — or accept that this policy was never meant for this call.

Why one outcome per policy? So every decision traces back to the exact policy — and the exact version of it — that made it, and so one branch can be suspended without touching the other. Branching lives in the list: one policy per outcome, in the order you want them tried.

To find your scenario, run the call in the Policy Studio simulator and read the evaluation chain: every policy gets a line saying what happened to it, and a call that lands on the catch-all comes with a pointer to the closest policy and what to change.

Does Fyver Interceptor use AI?Yes — one internal AI that reads and writes. It never decides.

Yes — in one place, and never in a decision. The console's internal AI reads numbers the console has already computed and writes about them: the brief on the AI insights page, the one-line explanations on suggested policy drafts, and its answers when you ask it a question — about the numbers, or about how the console works, which it answers from the Help Center's own pages.

By default it runs inside your stack — a model on your stack's private network, which nothing outside the stack can reach — and it receives only finished counts, agent and tool names, and wait times. Never call arguments, never record content. You can point it at a provider of your own instead; what it receives does not change.

Every allow, deny, and escalate is still made by a policy you wrote and approved — the next question covers that side. The AI explains; the policies decide.

Does Fyver Interceptor use AI to make decisions?No. Every decision is made by a policy you wrote and approved — the same call always gets the same decision.

No. Every allow, deny and escalation is made by a policy you wrote and approved. The same call always gets the same decision, and the audit trail names the exact policy — and the version of it — that made it.

A model asked to judge agent actions works on probability. Even one that is right 99% of the time lets the other 1% through, in both directions — good calls blocked, bad calls waved on — and afterwards it cannot tell you exactly why it decided, or which calls it got wrong.

Every rule here can be tested before it ever runs. When a call is judged, the deciding policy is a fact you can point to — not a guess you have to trust.

Other products have Ask and Steer outcomes. Why does Fyver Interceptor only have Allow, Deny, and Escalate?Ask has a home here — Escalate, decided by a person who is not the requester. Steer does not: reshaping a call mid-flight breaks the one thing the record must guarantee, that it matches what was asked for.

Ask. Their Ask pauses the session and asks the person sitting in it to confirm. That works when an employee is driving an agent by hand. Production agents run with nobody in the session — started by a schedule, a record change, or another system — so there is no one there to ask. Escalate is the same idea, finished: the call waits, and a person with approval authority — never the requester — decides it in the Approvals queue.

Steer. Steer reshapes the action as it runs — a smaller amount, fewer fields, a different destination. The agent asked for one thing; something else happened, and nobody approved the action that actually ran. Afterwards the record cannot tell a clean, true story. Here, a policy allows the action as asked, refuses it, or sends it to a person — the record always matches the request.

If a call should run smaller, write that as policy: allow refunds under a limit, escalate anything above it. The boundary is written down, testable in the simulator before it ever runs, and named in the audit trail when it decides. The flexibility lives in your policies, where it can be inspected — not in a mid-flight edit nobody signed.

Why does the order policies are evaluated in (priority) matter?The first policy that matches a call decides it — and nothing below that policy is even read. Priority is that reading order.

When a call comes in, the console reads your policy list from the top, in priority order — the lowest number is read first. The first policy whose tool pattern and condition both match the call makes the decision, and evaluation stops there. Policies below the match are never read for that call. Priority is not a score or a strength; it is simply the order of the reading.

That is why placement surprises people. A broad policy sitting above a specific one takes the calls the specific one was written for: an "allow every refund" policy above your manager-approval policy would approve the $2,000 refund itself, and the approval policy would never see it. It is also why the catch-all sits at the very bottom (priority 999): its pattern matches everything, so anywhere else it would end the reading early and leave every policy below it dead.

To watch the order at work, run the call in the Policy Studio simulator: the evaluation chain lists the policies in the order they were read and stops at the one marked MATCHED — policies below it do not appear, because they were never read. If the wrong policy is deciding a call, the fix is usually the order: give the policy you want read first a lower Priority number, so it sits above the one taking the call.

What happens when no policy matches?Allowed — and logged. Unmatched traffic passes through with a full audit trail.

The call is allowed, and the decision is logged like any other.

Fyver Interceptor enforces the policies you wrote; it does not block calls on its own. When a call reaches the console and no enabled policy matches it — because of the agent it came from, the tool it targets, or the conditions you set — the console allows it and records the full evaluation in the Interceptor stream and the audit log. That record is useful: unmatched traffic shows you exactly where your coverage has gaps, so you can write the policy that should have decided it.

If an agent is sensitive enough that nothing should pass by default, add a catch-all policy for that agent: a low-priority deny on the * pattern, scoped to that agent. Then everything is blocked except what an earlier, more specific policy explicitly allows.

What does "Agent ID not linked" on an agent mean?The agent's Fyver ID is not yet matched to the agent in its platform. The link comes from the agent's Fyver Config record in Salesforce, picked up when the catalog is synced.

The badge is about the agent's ID — not about the agent itself, and not about an MCP server (MCP servers carry their own badges, Verified and Drift, which describe their tool definitions). Every agent has two identities. One is the Fyver ID — the console's own ID for the agent; your policies and the audit log work with that ID. The other is the agent's identity in its platform — the agent as Salesforce or ServiceNow knows it. An agent's card reads Verified once the console has matched the Fyver ID to that platform identity and recorded the link. Agent ID not linked means that match has not been made yet — nothing more.

The agent still works while its ID is unlinked: it can be registered, given policies, and tested in the simulator, because all of that runs on the Fyver ID. The link matters for attribution — it is what ties a platform agent's calls to the right agent, and the right name in the audit trail. The badge is not a warning: the agent is not broken, not blocked, and not risky. It reports the link, never a judgment about the agent.

How the link is made: in Salesforce, the agent's Fyver Config record pairs its Salesforce name with its Fyver ID. Running Sync catalog reads those records and fills in any missing link — a link that is already recorded is never overwritten, a name held by a retired agent is released and re-linked, and if a name cannot be linked, the sync result says why. Deploying the guardrail creates that record for an agent whose Salesforce name the console already knows.

How does the console know which agent is calling?Fyver gives each agent its own internal ID, because the calls that reach the console do not carry one.

Calls that reach the console do not say which agent they came from. The connection an agent's tools run over — MCP — does not pass a caller identity along with a call, so the console cannot learn who is calling from the call itself.

That is why Fyver Interceptor creates an internal agent ID for each agent when you register it. The guard that is deployed for that agent carries the agent's internal ID with every call it sends to the console, and the console decides each call under that ID — the policies scoped to it are the ones that judge the call.

The console accepts only IDs it issued itself. A call that arrives with an unknown ID is rejected as unbound, and a call cannot present itself as a different agent, because the ID it carries is the one built into its own deployed guard — not something the caller types in.

Why didn't my policy match?Read the evaluation chain — nine times out of ten it’s priority order or one wildcard short.

Do not guess — read the evaluation chain. Every call the console decides, live or in the simulator, records the full ordered walk through your policies: each policy that was checked, and for every policy that did not fire, the exact reason it was skipped.

The reasons you will see are the only ones there are:

  • Disabled — the policy is off, or suspended.
  • Agent scope — the call came from an agent the policy is not scoped to.
  • Pattern — the call's tool name does not match the policy's tool pattern.
  • Condition — the pattern matched, but a condition on the policy evaluated to false.

Open the call in the Interceptor stream and expand its evaluation chain, or re-run the same call in the simulator, where the chain is shown as each policy is tested. In practice, most non-matches come down to two causes: an earlier policy matched first — policies are evaluated top to bottom and the first match decides — or a tool pattern that is one wildcard short of the name the call actually used.

How does drift detection actually work?SHA-256 hashes at sync time, re-checked on every scan — added, removed, or modified trips an alert.

When a server's catalog is synced, the console pins a SHA-256 hash of every tool definition it pulls — the tool's name, its parameters, and their types. From then on, drift detection is a comparison: on the server's scan interval, the console pulls the definitions again and compares each one against its pinned hash.

Three kinds of difference raise a drift alert, with a before-and-after diff attached:

  • Added — a tool exists on the platform that nobody approved.
  • Removed — a tool your agents rely on has disappeared.
  • Modified — the name is the same but the definition changed, so a call that was safe under the old schema may not be under the new one.

The server stays flagged as drifted until you review the change in Drift alerts and accept or reject it. You set the scan cadence per server in Agents & servers; an interval of 0 turns automatic scanning off and leaves scans manual, to run whenever you choose.

Are the compliance badges real?Yes. Every status is computed live from your own system data — click a badge to see the controls it stands on.

Yes. The badges on the Audit & compliance page are not labels applied in advance; each one is computed from the live state of your own console. Every framework shown — SOC 2, ISO 27001, the EU AI Act, the NIST AI Risk Management Framework, GDPR, and your internal standard — expands when you click it to list the exact controls behind the status and how each control is doing right now.

The checks read real system data: how many audit entries exist and whether the chain verifies, how many users are registered and protected, how many policies are active, and how many agents are governed. If something a framework depends on stops working — audit logging halts, for example — the badge turns amber on its own.

What this means for you: a green badge is a statement you can defend in front of an auditor, because you can open it and show the control-level evidence underneath it, generated from the system as it stands today.

Does the console run my business logic?Never. Three decisions — allow, deny, escalate — and your logic stays in your platform.

No. The console never runs your business logic, and it never executes the tool call itself.

For every call, the console makes exactly one of three decisions — allow, deny, or escalate for a person's approval — based on the policies you wrote. The call then runs in your platform, by your agent and your tools, exactly as it would have without the console in the path. Your logic stays under your change control, and your data stays inside your platform's boundary; call arguments are inspected to make the decision, not kept as a copy of your business data.

That separation is deliberate. If changing a business rule required a change to the console, the console would become a bottleneck in your delivery process; if the console held your data, it would become part of your compliance scope. The console judges calls at the boundary and leaves everything behind the boundary yours.

How does tenancy work?One Docker stack per customer. No shared anything, so nothing can cross.

Each customer runs in a silo of their own: one complete Fyver Interceptor stack per customer, with its own database, its own connections, and its own sign-ins. Nothing is shared between customers — no shared database, no shared sessions, no shared storage — so there is no path by which one customer's agents, policies, or call records could appear in another customer's console.

Inside your own silo, you separate your own worlds with environments. You can connect a development, a test, and a production org as separate connections, and policies are scoped per connection, so a rule you write for a test org never judges a call from production.

What this means for you: isolation is a property of how the product is deployed, not a setting you have to remember to turn on. Your data boundary is the boundary of your own stack.

Salesforce says "invalid_client" — how do I fix it?Your stored Consumer Key or Secret doesn’t match the External Client App — verify, regenerate, reconnect.

The Consumer Key or Consumer Secret saved in this console no longer matches the External Client App in your Salesforce org, so Salesforce rejects the sign-in before it starts. This usually happens after the secret was regenerated in Salesforce, or when values from a different app were pasted in.

Fix it in this order:

  1. In Salesforce Setup, open External Client Apps, then your Fyver app, and open its Consumer Key and Secret.
  2. Compare the Consumer Key with the one saved in this console under Settings → Connections → Salesforce.
  3. If the secret was ever regenerated, or you are not certain the saved one is current, copy both values from Salesforce and paste them into the console, replacing what is there.
  4. Click Save, then click Reconnect and finish the Salesforce sign-in.

Reconnect by itself cannot fix this error: it re-runs the sign-in using whatever credentials are saved. The saved values have to be right first.

Salesforce says "expired access/refresh token" — how do I refresh?Reconnect in Settings → Connections — that issues a fresh access + refresh pair.

The console refreshes its Salesforce access token on its own, using the refresh token it stored when you connected. You only see this error when the refresh token itself has stopped working — most often because access was revoked for the connected app, or the app's refresh token policy in Salesforce changed.

To fix it:

  1. Go to Settings → Connections → Salesforce.
  2. Click Reconnect and complete the Salesforce sign-in. This runs the connection flow again and stores a fresh access token and refresh token pair.
  3. Read the status line after reconnecting: it should say connected and name your org.

If the error keeps coming back, open the External Client App in Salesforce Setup and check its Refresh Token Policy: refresh tokens must be allowed to live long enough for the console to keep using them between your visits. Your agents' calls are still judged while the token is lapsed — they reach the console from your org, not through this connection. What pauses is the console's own work in your org: catalog syncs and guardrail deploys.

I lost my authenticator app — how do I sign in?Ask a console admin to reset your two-factor — and keep two admins for exactly this reason.

You cannot reset your own two-factor authentication. That is deliberate: the reset has to come from another administrator, so a stolen password alone is never enough to strip the second factor off an account.

Ask any console admin to do this:

  1. Open Settings → Users and find your account.
  2. Click Reset 2FA on your row.
  3. You then sign in with your password, and the console asks you to enroll again — you scan a fresh code with your new authenticator app. Need the app? Download Google Authenticator from the App Store (iPhone) or Google Play (Android) — any standard authenticator app works, but Google Authenticator is the recommended one.

This is why every installation should keep at least two active admins, and why the console protects the last one: the last active administrator cannot be suspended, deleted, or demoted. If a sole admin loses their authenticator, there is no self-service way back in — recovery then means direct database access by whoever operates the stack.

Where do I see console user login history?In the Audit log — every console sign-in, successful or not, is recorded in the evidence ledger.

Every console sign-in is written into the evidence ledger on the Audit & compliance page, as part of the tamper-evident audit chain. A successful password sign-in appears as Console login, a failed attempt as Console login failed — with the username that was tried, so you can spot someone guessing passwords — and a single sign-on as SSO login. Type Console login in the ledger's search box to see just the sign-ins, and sort by Timestamp or Actor to review them in the order you need.

For a quick check, Settings → Users shows each user's last sign-in time. The complete history lives only in the ledger: audit entries are never deleted, so the sign-in record reaches back to the console's first day.

How far back can I investigate history?As far as the archive reaches — hot retention only moves events, it never deletes them.

As far back as your archive reaches — which, for events, is everything the console has ever recorded.

Two stores are searched together whenever you use the Interceptor stream or a report: the live events table and the events archive. Retention, under Settings → Backup & retention, only moves events from the live table into the archive once they pass the hot-retention age — 90 days by default, settable from 7 to 3,650 days. Moving is all it does: archived events stay fully searchable by agent, tool, decision, and policy, and retention never deletes the archive.

The audit log goes further: it is never deleted at all, and it is protected by a hash chain. The management history of the console — who created, changed, suspended, or removed what, and when — stays available and verifiable for as long as the console runs.