How knowledge compounds
Pathrule is a loop, not a filing cabinet. Context is delivered before work, knowledge is captured during it with your approval, and the cloud surfaces the most valuable first.
It is easy to read Pathrule as a place to file memories, rules and skills by hand. That is the smallest part of it. The point is a loop that runs against real work and gets better the more the team uses it.
The loop has three moves: deliver, capture, score. They repeat every session.
Deliver before the work
Before the assistant makes its first tool call, the path-scoped slice of your team's knowledge is already in context. You do not paste it, and the assistant does not have to go looking for it. Working in /apps/api/payments surfaces what is pinned there, plus what it inherits from the paths above. This is the delivery side most people see first, and it is covered in How hooks work.
Capture during the work
Knowledge does not have to be written in a separate sitting. Most of it accumulates from the work itself.
While the assistant works, it watches for things worth keeping: a decision you just made, a fix for a problem it kept hitting, a convention it had to be told, a gotcha that wasted time. When it finds one, it proposes saving it as a memory, a rule or a skill on the path it belongs to.
Two properties matter here:
- You stay in control. The assistant writes via the MCP tools only after you confirm. Nothing is saved without your approval, and Pathrule never edits or deletes your knowledge on its own.
- Upkeep stays close to zero. Because capture rides along with normal work, the knowledge base grows without a second job of writing docs. You can still author directly in Studio or through an MCP client whenever you want to.
Score, so the best surfaces first
Ranking happens in two layers. The routing and base ranking that decide which candidates surface are open source and run locally, so you can read and even modify exactly how they choose. The cloud edition adds a separate learning layer on top: it tracks which knowledge actually helped on similar work and re-ranks future results, so the most valuable surfaces first. Sessions stay sharp instead of noisy, and entries that have gone stale or stopped matching anything are raised as suggestions for you to review. See Suggestions and self-audit for how decay is surfaced.
Learning changes order, not eligibility. An entry still has to clear the relevance floor for the current request. A memory that helped several migrations cannot enter an unrelated design turn merely because it has a strong history.
How noise stays out of the prompt
The loop is deliberately selective. General documentation is offered for review instead of imported as live instruction by default. Capture requires approval. Path scope limits where an entry can surface, and the relevance floor still applies inside that scope.
Delivery and use are measured after that. Self-audit raises stale, conflicting, unused or path-invalid knowledge as suggestions. Repairs are versioned and reversible, so the team can improve the set without losing its history.
The result is a small set of narrow, reviewable decisions and gotchas, not a repository-wide documentation dump. How Pathrule proves hard claims documents each gate and its test contract.
Why the loop is the product
A static file or a single tool's built-in memory can do delivery. What compounds is the loop: every task can leave the team a little smarter, and the next session starts from that.
The compounding is not abstract. Each pass through the loop leaves behind something the next pass can use: a measured record of what was delivered and how the turn went, a weight per kind of work, a relationship between two files that keep changing together, a failure attached to a path. What Pathrule computes lists each of those layers and what feeds it. Written entries alone do not compound, because nothing about them changes when the work goes well or badly.
Because the knowledge lives outside any single agent, it is portable. The same memories, rules and skills reach Claude Code, Codex, Grok, Kimi, Antigravity and OpenCode in Studio. Cursor, Windsurf and GitHub Copilot receive that knowledge when connected through Pathrule CLI. A native memory feature inside one tool does not replace this, because that memory stays inside that tool. The lasting value is the accumulated team knowledge, not any individual rule or prompt file.