**When Pathrule is not sure, it does not pretend.**

Two mechanisms carry that. One decides whether compiled knowledge is good enough to replace the source. The other takes the knowledge that should not be left to an agent's judgement out of the prompt entirely.

## The completeness gate

Compiling prose into structure can lose the part that mattered.

The concrete case is a memory that says to use one helper **instead of** another. Compilation can produce a clean, well-formed atom naming the winner, and drop the loser. The atom count is non-zero, the atom is grounded, everything looks correct, and an agent receiving it learns what to use but never learns what to avoid, which is the entire reason the memory was written.

So `atom_count > 0` is deliberately **not** the test.

Instead, before compiled knowledge is delivered in place of the source, a gate compares two things:

- the **source text**, as the person wrote it, and
- the **actual agent-facing delivery**, the exact text the agent will receive.

Not the atom's internal evidence. An atom can be grounded on a span that mentions the loser while the delivered projection keeps only the winner, in which case judging the atom passes and the agent still never learns what to avoid. The gate judges what arrives.

It checks, among other things:

- **Relationships.** If the source names something to avoid, the delivery has to still carry it.
- **Ordered procedures.** A single delivered unit cannot represent a sequence of steps.
- **Source coverage.** The delivery has to represent enough of the source's operational sentences.

### Deterministic, and fail-closed

There is **no model in the gate**. It is ordinary deterministic logic, so the same source and the same delivery always produce the same decision, and the decision can be reasoned about rather than trusted.

And it fails closed. When the compiled form does not clearly represent the source, the answer is not "probably fine". The answer is prose: the source knowledge is delivered instead.

```text
SUFFICIENT    -> compiled Agent IR
INSUFFICIENT  -> source knowledge
```

A smaller, tidier delivery that lost the operative clause is a worse outcome than a longer one that kept it, and the gate exists to pick the honest option rather than the impressive one.

## Deterministic enforcement

The second mechanism is about what should not be a suggestion in the first place.

Understanding what a paragraph means is work for a model. Making sure a forbidden action does not happen is not, and leaving it to one means depending on an agent weighing a sentence correctly on turn forty of a long session.

- A **CONSTRAINT** can be enforced by the runtime rather than delivered as advice. See [rules as guardrails](/docs/hooks/rules-as-guardrails).
- A **CHECK** can require that a verification actually happened before work is treated as complete.

**Some knowledge should not be a suggestion.** This is the line between a memory product and a runtime, and it is why the semantic layer and the enforcement layer are separate in the architecture rather than merged into one clever prompt.

## What Pathrule does not claim

It does not claim zero hallucinations. No system that involves a language model can claim that honestly, and a product that does is telling you something about its claims rather than about its architecture.

What it claims is specific and checkable:

- Compiled knowledge is **grounded** in the source, with paraphrase marked as paraphrase.
- Atoms the source does not support are **rejected** at validation.
- Delivery is chosen by a **deterministic gate** that reads the real delivery against the real source.
- When the gate is not satisfied, the system **falls back** to the source rather than delivering a confident approximation.
- Requirements are **enforced**, not merely mentioned.