The Agent IR is the boundary between everything Pathrule knows and one execution by one agent.

The boundary matters. It is **knowledge to Agent IR to rendered delivery**, not a query joined onto a prompt. What an agent receives is a compiled artefact for the task in front of it, and the shape of that artefact is a design decision rather than whatever the database happened to return.

## What it carries

For one task, in one scope, the atoms that apply, with their type and authority intact.

A REMEDY arrives with the condition that triggers it, the corrective action, and how strongly the source claimed it worked. A SELECTION arrives with the context, the preferred choice and the alternatives the source named. A PROCEDURE arrives with its steps in order. A CONSTRAINT arrives as a requirement.

## What it deliberately leaves out

Everything that does not improve the execution.

No persistence metadata. No lifecycle or debug fields. No raw memory bodies. No identifiers the agent has no use for. An atom's provenance reference travels with it, because a delivery has to be joinable to what happened afterwards, but it is not shown to the agent.

## Three properties that are load-bearing

**Type is preserved.** A remedy is delivered as a remedy. Flattening it to "remember this" throws away the thing that made it useful, which is that it describes a condition and a response rather than a general instruction.

**Authority is encoded, not flattened.** Advisory guidance renders into a clearly subordinate section rather than being concatenated after a hard rule at the same weight. An agent reading the delivery can tell a requirement from a suggestion, because the representation said which was which.

**Nothing semantic happens at delivery.** The interpretation ran once, at write time. Compiling the IR and rendering it are pure and deterministic and make no model calls, so the delivery is reproducible and fast enough to land before the agent's first tool call.

## Engine-neutral

The IR never branches on which agent is about to run. It renders as neutral markdown, and the per-engine envelope is applied afterwards by whichever channel that client supports. Claude Code, Codex, Cursor and Copilot receive the same compiled knowledge through their own native mechanism; see [how hooks work](/docs/hooks/how-hooks-work).

This is what makes agent independence structural rather than aspirational. There is no Claude-shaped knowledge and no Codex-shaped knowledge, only the compiled representation and the envelope it ships in.

## Size

On narrative memories, the compiled task-scoped delivery measured roughly 104 to 234 tokens where the same knowledge as prose took about 3,000: a **13 to 30 times smaller knowledge payload**.

Two honest bounds on that number. It is a knowledge-payload figure and not a claim about an agent's total token usage; the same measurement found the smaller injection did not reduce total tokens, and [how we measure](/docs/start/how-we-measure) says so. And it is a narrative-memory result: a memory that is already a single-sentence convention is near-atomic to begin with, and compiling it saves almost nothing.