The Rule-of-Two Breaker
The Rule-of-Two breaker is the mechanical core of input guardrails. It does not read the wording of a message to decide whether it is an attack. It reasons about what a session has done: a call is dangerous when two risky conditions already hold and the session now reaches a third — it has read from an untrusted source, it holds sensitive data, and it is now using a tool that can send data out or change something. Any two of those on their own are ordinary work; all three together is the shape of an exfiltration.
The Three Facts
The breaker tracks three facts about each session as it runs. They are visible to policy authors as session.*, connector.*, and tool.* attributes — see the Attribute Reference.
Source trust
Every connector has a trust setting on its configuration:
| Trust | Meaning |
|---|---|
| Untrusted (default) | Content from this connector may have been authored by someone outside your control. Reading it marks the session untrusted. |
| Trusted | Content from this connector comes from a source you govern. Reading it does not mark the session untrusted. |
A connector is Untrusted until you decide otherwise. Marking one Trusted requires a reason, which is recorded, so the decision is attributable. You can also override trust for an individual tool on a connector when a single connector mixes governed and ungoverned content.
Once a session reads from an untrusted source, it stays untrusted for the rest of its life — a later read from a trusted source does not clear it.
Sensitivity
Tool reads carry a sensitivity tier from your data classification — the same tiers your flow and classification policies use. A session's sensitivity only rises: once it has read Confidential data, it is treated as holding Confidential data for every later call, whatever else it reads afterward. The breaker's standard rule treats Confidential and above as sensitive.
The sink
Each tool is annotated with the kind of sink it represents — what it can do with data:
| Sink | Example |
|---|---|
external_comms | Sending an email, posting to a chat channel, calling an outside API |
state_change | Writing to or deleting from a system of record |
execute | Running a command or code |
credential | Handling a secret |
none | A read; it takes data in but sends nothing out |
A read is not a sink, so retrieving data never trips the breaker on its own. The breaker acts only when the session reaches a sink after the two risky reads.
What the Breaker Does
The breaker is delivered as a Guardrails (Rule of Two) group of starter rules you adopt from the Policies area. You adopt them in Observe first — where each records what it would have done, with a dry-run match count against your own traffic — and promote to Enforce when you are satisfied. The three rules are:
| Rule | When it acts | What it does |
|---|---|---|
| Hold on the Rule of Two | The session is untrusted, holds Confidential-or-above data, and reaches an external-communications or state-change sink | Holds the call and raises an approval for the session's supervisor |
| Stop a hostile session's external send | Content the session read was identified as hostile, and it reaches an external-communications sink | Stops the call outright |
| Hold an untrusted execution | The session is untrusted and reaches a code-execution sink | Holds the call and raises an approval |
When a call is held, nothing is forwarded — the email is not sent, the write does not happen — until a person approves it. When a call is stopped, it ends at the gateway and the target is never contacted. In both cases the agent receives a verdict, never the rule that produced it, so an agent cannot learn the guardrail's shape and work around it.
Trust is a separate axis from wording. A message full of imperative language from a Trusted source never sets the untrusted condition, so the breaker does not touch it. Guardrails are built to catch the dangerous data flow, not to flag assertive text.
The Approval a Person Sees
When the breaker holds a call, it raises an approval for the session's supervisor — the same approval experience used elsewhere in AgentPass, carried to the supervisor's phone. Two things make a guardrail approval different.
It carries evidence. The approval names the facts that caused the hold: the untrusted source the session read from, the sensitive data it holds, the destination the call is headed to (the email recipient, the URL host, the repository), and the kind of sink. The approver decides on what actually happened, not on a bare "approve this?" prompt. The evidence is composed by the gateway from what it observed; model-generated text is never presented as if it were signed fact.
It is bound to the approver's device. The decision is signed with the supervisor's own passkey, and the signature covers the specific action and its evidence with a one-time value, so an approval cannot be replayed against a different call. The record shows the decision was that person's, made on their device.
High-risk sinks carry a shorter approval window than ordinary holds, so a held exfiltration cannot sit open indefinitely.
See Approving and Denying Agent Actions for the supervisor's side of an approval, and Setting Up Your Approval Passkey for the one-time device setup.
What the Breaker Does Not Judge
The breaker is deliberately mechanical. It keys on trust, sensitivity, and the sink — not on what a message means. Reading the intent of a message, and scoring whether content looks like an injection attempt, is the job of the optional judges, which add advisory signal and never change the breaker's decision.
Related
- Input Guardrails Overview — how the breaker fits with the other controls
- How Policies Are Evaluated — Observe versus Enforce, priority, and first match
- Alerts and Containment — what happens to the record when the breaker acts
- Attribute Reference — the
session.*,connector.trust, andtool.sinkattributes