Architecture overview

Pathrule is the intelligence layer between you, your workspace, and the coding agents you run.

That sentence is doing specific work, so it is worth unpacking one clause at a time. Between you and your agents, because part of what Pathrule keeps is how you prefer to work, not facts about the code. Between your workspace and your agents, because the rest is what one repository, and the team around it, has learned about itself. A layer, because it is not inside any agent: switching from Claude Code to Codex changes who executes, not what is known.

What Pathrule is not: a coding model, an IDE or an agent runtime. It does not write your application code, and your coding agent keeps its own model provider.

The shape of the system

        YOU                        YOUR TEAM
         |                             |
         v                             v
 USER INTELLIGENCE   WORKSPACE INTELLIGENCE   TEAM INTELLIGENCE
  (your machine)     (memories, rules,        (Pathrule Cloud,
                      skills, findings)        human-verified)
         \                   |                    /
          \                  v                   /
           +-------->  TASK-SCOPED DELIVERY  <--+
                             |
                             v
        Claude Code / Codex / Cursor / Copilot / Windsurf

Several sources of knowledge converge. For a given piece of work, the part that matters for that path and that prompt is selected, ranked and delivered to the agent through the mechanism its client supports.

Foundation and clients

The CLI, the VS Code extension and the local MCP server are the surfaces you install. Pathrule CLI, Pathrule for VS Code and Remote MCP describe each one.

The lifecycle

Six stages. Each one is something you can observe in the product, not a diagram.

Observe. Work produces evidence: the memories, rules and skills people and agents write, the findings agents record about the code, the activity agents log, and what was delivered to which session.

Understand. Pathrule works out what that evidence means for future work, and on your machine it does so without a model: a decision you state in a prompt is saved in your own words, a lesson a failing command taught is kept once, and a preference you voice to an agent is checked against what you actually typed before it is kept. On Pathrule Cloud, Team Intelligence analyses team evidence into suggested patterns, and the Cloud model tier reads the prompts Pathrule's phrase rules found nothing in. Anything inferred stays a suggestion until a person approves it.

Compile. Knowledge is rendered into the files Claude Code and Codex read at the paths it governs, such as .claude/rules/pathrule/ or AGENTS.md, and into a local index the hooks read; Cursor, Windsurf and GitHub Copilot reach it through MCP. See compilation.

Deliver and enforce. For each task, the knowledge that applies to the path and the prompt is selected, ranked and delivered within a per-prompt budget, with anything that does not fit listed by title. A rule can carry an executable constraint; once a person has approved it, the pre-tool hook can block a matching edit in clients whose hooks support that. A written requirement alone does not create a blocking check.

Verify. Pathrule records what it delivered and which entries the agent then went on to read, so the effect of a piece of knowledge can be measured rather than assumed.

Learn. What agents actually used informs what is brought forward next time. Stale knowledge can be flagged for a refresh. On Cloud, team patterns move from draft to suggested to verified, or are rejected or expire, and only verified ones reach agents.

Words that are not synonyms

The rest of these docs depends on keeping these apart.

• Memory is what was recorded. A note about a decision, written at a moment in time.
• Knowledge is what that record means for future work, with the evidence that supports it.
• Intelligence is the system that decides what knowledge matters and when.
• Context is the answer for one task: what matters, here, now.
• Finding is a conclusion an agent recorded about the code. It is advice, checked against the code on every delivery, and never becomes a rule on its own.
• Suggestion is something Pathrule or an agent inferred that a person has not approved. It is not trusted.
• Verified knowledge is something a person approved.
• Rule is a constraint a person set for a scope. Its executable form is enforced only after a person approves it.
• Delivery is what actually reaches the agent for one task. Agent IR describes it.

A memory is an input. Context is an output. Neither is the product.

Where to go next

• Workspace Intelligence: scope, authority, sources, lifecycle.
• User Intelligence: what it learns from your own words, what you control, and why project requirements still win.
• Project learning: findings agents record from your code, shared as advice.
• Knowledge IR: how the kind and authority of each piece of knowledge survive delivery.
• Compilation: what Pathrule writes into the files your agents read.
• Proposed Knowledge: everything that waits for a person before it is trusted.
• Agent IR: what an agent receives for one task.
• Safety and fallback: what Pathrule does when it is not sure.

The open package boundary

Pathrule's foundation is open source under Apache-2.0 at github.com/pathrule/pathrule: the protocol, Agent IR, the local knowledge store, retrieval and ranking, the hooks, the local MCP server, the host, the CLI, the Local Console and the VS Code extension. It runs with no account, no network service and no model on your machine, and the CLI is published on npm as @pathrule/cli.

Pathrule Cloud, with team workspaces, sync, the web console, Remote MCP and the Cloud model tier, is proprietary. These docs describe what it does for you, not how it is built.

See Open source core for the details.