- the tools, prompts and resources a connector lists, including their descriptions and parameters;
- what a member’s assistant sends a connector: a tool call’s arguments, a prompt’s arguments, the value a completion is for, and the address of a resource it reads;
- everything a connector sends back: tool results, prompts, resources, completions, errors, and the log messages and progress updates it sends while answering.
[REDACTED]; for this rule,
Block or Log usually serves better than Redact.
Rules read structured content, such as a tool call’s arguments, as the text
it holds: every string, member name and number, one after another with a line
break between them. A pattern that can cross a line break, such as one that
allows any whitespace between two words, can match across two values. One
that can’t, as no credential pattern can, doesn’t find a value split across
two, such as a key sent in two halves.
Admins still see what a connector actually lists, including anything
guardrails hide from assistants, in workspace settings and the API’s
connector catalog.
Workspace admins manage guardrails in Settings → Guardrails.
Local connectors run on members’ own machines, and their traffic never reaches
Conduit, so guardrails don’t check it. Conduit’s own tools aren’t checked
either.
What a guardrail is
A guardrail has a name, a list of rules, and an action. It matches when any of its rules matches. Rules come in three kinds:
Managed rules cover:
- Secrets: leaked API keys, access tokens, private keys and passwords, using gitleaks’ default rules with their keywords, entropy checks and allowlists. A rule runs only on content that contains one of its keywords, as gitleaks runs it.
- Injection and tool poisoning: instructions hidden in tool descriptions, prompt injection, coercive instructions, credential harvesting, data exfiltration, and code, command, script and SQL injection, using the YARA rules from Cisco’s MCP Scanner.
- Hidden text: invisible characters, bidirectional overrides, Unicode tag characters, and look-alike letters that mix Latin with Cyrillic or Greek.
- Personal data: email addresses, phone numbers, US Social Security numbers, payment card numbers (checked with the Luhn checksum) and IBANs (checked with their country’s length and checksum).
nocase and fullword modifiers, and
conditions built from those strings (and, or, not, defined, any of,
all of, none of, N of or N% of, and references to earlier rules,
private ones included). Conditions can also read where and how often a string
matches: counts (#a), offsets (@a[i], $a at 10, $a in (0..100)) and
lengths (!a[i]), with arithmetic and comparisons over them, and for loops
over a range, a list of numbers or a set of strings. These count matches as
YARA does. Offsets are into the text being checked as Conduit reads it:
hidden characters removed and compatibility forms replaced, with the values
of a call joined by newlines. As in YARA, a regular expression’s match counted
or measured is at most 1,024 bytes long (a text string’s is as long as the
text), and at most 1,000,000 matches of a string are counted.
Conduit’s answer differs from YARA’s in a few cases, most of them where
YARA’s depends on how it splits an expression internally:
- A string that only matches across more than 1,024 bytes still matches
(
$a), though it has no counted matches (#ais 0). In YARA it doesn’t match at all; in Conduit, padding text past the limit doesn’t hide what a rule looks for. - When two alternatives of a regular expression both match at the same
offset, Conduit always reports the first alternative’s match, where YARA
sometimes reports the other’s. In
abc,/abc|ab/is 3 bytes long; YARA can say 2. - A
fullwordstring matches when any of its matches from an offset is a whole word. YARA sometimes checks only one of them, so it can find nothing where Conduit finds a match:/foo(b|bar)/ fullwordmatchesfoobarin Conduit, not in YARA. - YARA reads text as bytes and Conduit as characters, so outside ASCII a
.or a character class matches a whole character rather than one byte. - YARA counts the 1,024-byte limit from a piece of the match it finds first, not always from the start, so a long match can be cut differently.
- A repetition count over 1,000 (
a{0,1100}) is refused when you save. - YARA repeats
+over a group that begins with an optional element only once, so/xyzw(a?b)+/matches 5 bytes ofxyzwbbbbin YARA and all 8 in Conduit. - A lazy repetition inside a lazy counted one (
(a|a{1,2}?c){0,2}?) can match a different alternative in YARA. nocasematches the Unicode case variants of a letter (kmatches the Kelvin sign), where YARA folds ASCII letters only.- Conduit accepts a few things YARA refuses:
(?:...)groups, a string no condition uses, a loop variable reusing an outer one’s name, and a percentage of strings outside 1–100% (over 100% never holds).
+
and +?): saving a rule that adds one is refused. A guardrail already saved
with one keeps running and can still be renamed or switched to another action,
and testing runs such a rule as a saved one runs.
Modules, includes, global rules, hex strings, the wide, xor and base64
modifiers, file sizes (filesize), byte reads (uint32 and the like),
bitwise operators and floating-point numbers are refused when you save, with
the rule that uses them named. So is a rule that would match when a string is
absent, since it would match almost everything. In a regular expression, byte
escapes such as \xC3\xA9 match the character their bytes spell in UTF-8
(here é); escapes that don’t spell whole characters, or that sit inside a
character class, are refused, since text never holds a lone byte.
What happens when a rule matches
The guardrail’s action decides what happens to a tool call, and to what a prompt or completion request sends:
A blocked call returns an error that names the guardrail, never what it
matched. A match disguised with invisible characters or special letter forms
is masked as it’s written, the disguising characters included. If a
redacting guardrail matches something redaction can’t mask, such as a tool’s
name or a match that spans two values, it blocks instead.
A prompt’s arguments and the value a completion is for are masked or
blocked the same way before the request reaches the connector; a blocked
completion comes back empty. A resource address that matches a blocking or
redacting guardrail is refused before it’s read, since an address can’t be
masked.
Anything else a blocking or redacting guardrail matches is withheld:
- A tool, prompt or resource whose definition matches is left out of what the connector lists, so no assistant sees it. Members’ tool lists on Home and the API’s connector catalog leave it out too; admins still see every tool when editing a policy.
- A prompt or resource whose content matches is refused when it’s requested.
- A completion that matches comes back empty.
- An error whose message matches is replaced by one naming the guardrail.
- A log message a connector sends while answering is dropped, and a progress update loses its message (its progress still shows).
Create a guardrail
- In Settings → Guardrails, select Create guardrail.
- Name it. The name appears in members’ error messages and in the audit log.
- Choose its action.
- Add rules with Add rule: built-in (managed) rules, a regular expression, YARA rules to paste, or YARA files to upload. A managed rule’s View definition action shows how it’s written.
- To check the rules before you save, select Test rules and paste sample text. You see which rules match, where, and what redaction would leave.
- Select Create guardrail.
If a guardrail can’t run
Guardrails fail closed. If a stored guardrail can no longer run, for example because a release stopped shipping a managed rule it uses, Conduit refuses the workspace’s connector traffic rather than let it through unchecked. The guardrails page names the guardrail and the problem. Turn it off to restore traffic, then fix or delete it. A guardrail whose rules take longer than 15 seconds to compile can’t be saved. If one that’s already saved takes that long to compile, for example while the server is under heavy load, the workspace’s traffic is refused for about a minute and then Conduit compiles it again. If the server is too busy to compile your rules when you save or test them, you’re asked to try again shortly; your rules aren’t rejected. A YARA condition that reads counts or offsets takes longer the more often its strings match, and afor loop takes longer the more it iterates. Checking a
piece of text allows work in proportion to its length, up to about a quarter
of a second of processing for the YARA rules of all the workspace’s blocking
and redacting guardrails together, and a quarter of that for its logging
ones. A condition that only checks which strings matched ($a and not $b,
2 of them) takes the same time on any text and always runs.
When a blocking or redacting guardrail needs more, the text is refused rather
than let through unchecked, and the member is told a guardrail’s rules take
too long to check it: a loop over every pair of a string’s matches in a long
text, say, or megabytes of text made of little but the phrases the rules look
for. A logging guardrail that runs out records that in the audit log and lets
the text through, without taking time from the guardrails that block. If a
guardrail blocks the text anyway, it’s blocked as usual. A tool, prompt or
resource definition that can’t be checked is left out of listings. Testing a
guardrail on such sample text says so too, checking the guardrail on its own
with the time its action allows. A blocking or redacting guardrail shares
that time with the workspace’s others, so it can run out on text it tested
clean on.
Audit log and telemetry
Every match is recorded in the workspace’s audit log (Settings → Audit Log) asguardrail.blocked, guardrail.redacted or guardrail.matched (for a
logging guardrail), with the guardrail, the rules that matched, the tool,
prompt or resource, and the member. It never includes the matched text. Content
a guardrail’s YARA rules took too long to check is recorded the same way,
marked too_costly and with no rules: as guardrail.blocked for the
blocking or redacting guardrail whose rules took the time, with whatever
else matched beside it, and as guardrail.matched with the outcome
too_costly when a logging guardrail let it through unchecked. A
tool, prompt or resource definition that keeps matching is recorded once per
version of it, not on every listing, and as Conduit’s own finding rather than
any one member’s.
A logging guardrail that matches routine traffic adds one audit log entry per
matching call, and the audit log is kept indefinitely, so a broad logging
guardrail on a busy workspace grows it quickly. Matches in the log messages and
progress updates a connector sends during one call, and in the definitions of
one listing, are recorded up to a fixed number each; past that they’re still
withheld, just not recorded again.
The guardrails list shows each guardrail’s matches over the last 30 days and
when it last matched. Select the count to open the audit log on that
guardrail’s history: its matches and every change to it.
Creating, changing and deleting guardrails is recorded as
config.guardrail.created, config.guardrail.updated and
config.guardrail.deleted, with each rule’s kind and name but never its
pattern or YARA source.
The same events go to your telemetry exporters, and a
blocked tool call’s error type is denied_guardrail.
Limits
- A workspace can have up to 50 guardrails, each with up to 100 rules.
- A regular expression can be up to 4 KB, and YARA source up to 256 KB.
- Base64 media isn’t checked: image and audio content, and resources whose
type is an image, audio, video or font. Any other base64 resource is
decoded and checked, whatever its type (none,
application/octet-stream,application/x-sh). Text is checked as text, skipping the odd byte that isn’t valid text. A binary file, such as a PDF or an archive, is checked only for the runs of plain text it contains (16 characters or more), so compressed content inside it isn’t checked. - Saving and testing guardrails is rate-limited per workspace.
- Withholding a tool’s definition hides the tool from listings, but a
client that already knows its name can still call it, directly or through
call_tool. The call’s arguments and result are checked like any other call’s. - A redacting guardrail can mask text values only. A match in a JSON member name or number (a card number sent as a number, for example) can’t be masked without changing the data’s shape, so the call is blocked instead.

