Introduction

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

It learns two things. Workspace Intelligence learns how one project works: the decisions, constraints, verification requirements, fixes and procedures that a repository accumulates around its code. User Intelligence learns how you prefer to work, and comes with you to the next project. Both are understood by a model running on your own machine, and the part that matters for a specific task is compiled into knowledge an agent can use.

Pathrule is not a coding model. Claude Code, Codex, Grok, Kimi, Antigravity and OpenCode run natively in Pathrule Studio; Cursor, Windsurf, GitHub Copilot and other MCP compatible clients connect through Pathrule CLI. They stay the execution engines. Pathrule is what they start from, which is why switching engines does not reset what is known about the work.

For the whole architecture in one place, read the architecture overview.

What you write, and what Pathrule makes of it

Three kinds of content your team writes intentionally. These are inputs, and the authoring surface: they are what a person edits and argues about, not what an agent receives.

• Memory: a short markdown note that captures a decision, a schema gotcha, a postmortem, or a convention. Attached to a workspace path so it only surfaces when work happens nearby.
• Rule: a constraint the assistant must follow when working in a scope. Rules carry a priority (high, medium, low) that ranks how strongly they surface and an enforcement mode (advisory or strict); a strict rule can block a matching change before it lands, while an advisory rule rides along as context.
• Skill: a named procedure the assistant can invoke instead of re deriving the steps. Useful for recurring jobs like replaying a webhook, regenerating a fixture, or running a release checklist.

What Pathrule does not store: your source code. The cloud never indexes the repo, never reads files on disk, and never sends code to an LLM. Your codebase stays on your machine.

What an agent actually receives is not these documents. Each of them is compiled into typed knowledge, in eight primitives, and for a given task the relevant part of that structure becomes a compact Agent IR. Authority survives that step: a constraint arrives as a requirement and a remedy arrives as advice, rather than as two paragraphs of equal weight. Two of the primitives, CONSTRAINT and CHECK, are handled by the runtime rather than left to the agent to remember.

And what it derives

Those three are what your team writes. They are the smaller half of what the layer holds.

Around them sits a derived layer that nobody types. Every entry also exists as a computed representation of its meaning, which is how a Turkish prompt finds an English memory that shares no words with it. Every delivery is measured: which entries were sent, which the assistant actually consulted, how many tool calls the turn took and how many failed. Those measurements accumulate into weights per kind of work, a graph of the files your team changes together, a map of where an assistant keeps getting stuck, and judgements about which entries the code has moved past.

All of it comes from two sources: what your team wrote down, and what the work reported about itself. None of it comes from reading your repository. It is also the reason the same three files sitting in a directory do not behave the same way: a directory does not know what was delivered, what helped, or which files move together. See what Pathrule computes.

Surfaces, one cloud

Pathrule ships as two local runtimes against a single cloud workspace, plus a browser management console and a hosted Remote MCP endpoint for clients that cannot run a local runtime.

• Pathrule Studio (macOS). The native desktop app where you code with Claude Code, Codex, Grok, Kimi, Antigravity and OpenCode, author memories, rules and skills, and get path-scoped context delivered natively. Bundles the MCP server, the hook supervisor and the local cache.
• Pathrule CLI. The lighter terminal first surface for macOS, Linux, and Windows. It connects Cursor, Windsurf and GitHub Copilot, supports standalone Claude Code and Codex workflows, and runs the local MCP server, hook supervisor and cache.
• Pathrule Web at app.pathrule.io. The browser management console for your organization, members and roles, plans and billing, workspaces and usage. Cloud only, with no filesystem access; you write knowledge and run agents in Studio, not here.
• Remote MCP. A hosted endpoint at mcp.pathrule.io/mcp for cloud-only AI clients that cannot run a local runtime. They connect directly over streamable-http, with no install. It has no hooks, so it delivers context only.

They share the same workspace tree and MCP contract. Studio and CLI are the authoring and local delivery runtimes, while Web administers the organization around that shared cloud state. Hook-capable clients receive the cached slice through their native event model; Windsurf receives its bootstrap through a companion file and uses the same MCP tools for deeper context.

How a session feels

1. Your team writes a memory at a workspace path, for example /apps/api/payments.
2. You open Claude Code in ~/repos/main/apps/api/payments.
3. The hook supervisor reads the cached slice for that path and hands it to the editor before the first tool call.
4. The assistant sees the memory, the relevant rules, and any skills attached to that scope, and behaves like it already knew them.

There is no extra prompt to write, no extra MCP round trip mid task, and no global file that grows forever.

What to read next

• Architecture overview is the whole system in one page: the six layers, the lifecycle, and the vocabulary the rest of these docs depends on.
• Quickstart walks through installing a runtime, creating a workspace, writing your first memory, and watching the hook fire.
• Core concepts explains the difference between memories, rules, and skills, plus how path scope and priority work.
• Talking to Pathrule covers the other half: working with the intelligence directly rather than behind an agent.
• MCP overview covers the MCP tools the assistant uses to read and write content.