Pathrule

Your agents change. What they learn shouldn't leave with them.

Pathrule learns how your workspace works and how you work, compiles that knowledge on your own machine, and gives every coding agent what it needs for the task.

Talk to Pathrule in Studio, or let it work behind Claude, Codex and the agents you already use.

Pathrule Studio on macOS, with the project tree on the left and a new task in the composer
Download for macOSCLI for any platform
Meet Pathrule

Supported AI agents

  • Claude Code
  • Codex
  • Grok
  • Kimi
  • Antigravity
  • OpenCode
Grok
Codex
Claude

Coupons live on the lineItem, never on the order total. I will add the discount there and run your checklist before finishing.

Pathrulerelease-checklistCheckout Field MapPricing rounding noteCoupons only on lineItem

The agent can change. The intelligence stays. What your workspace and you have taught Pathrule lives in Pathrule, so switching agents changes who does the work, not what is known about it.

Features

Claude, Codex and four more engines in Studio

Cursor, Windsurf and Copilot through the CLI

Use your existing AI subscriptions

Workspace

Coupons only on lineItem

Constraint, /src/checkout

@repo/ui consumes dist/

Fixed here 3 times

Migration verification

Check, before completion

You

Small steps over rewrites

Repeated corrections

Options before implementation

On architectural changes

Targeted verification

Unless the workspace asks for more

The workspace teaches Pathrule the project. You teach Pathrule how you work. Decisions, constraints, fixes and procedures stay with the repository. Your working preferences come with you to the next one. Every agent starts with both.

Features

Workspace Intelligence learns the project

User Intelligence learns how you work

Compiled for the task, not dumped in the prompt

Pathrule does not just remember. Knowledge is observed, understood, compiled for the task, enforced where it must not be optional, verified against what actually happened, and learned from.

  1. 01

    Observe

    Instructions, corrections, decisions, agent sessions, past failures and the fixes that worked are all evidence, and all carry where they came from.

  2. 02

    Understand

    A local model reads that narrative knowledge and works out what it actually means for the work: what is forbidden, what must be verified, what is preferred, what is merely true.

  3. 03

    Compile

    Meaning becomes structured knowledge, then a compact representation for one task. The interpretation happens once, at write time, not on every prompt.

  4. 04

    Enforce

    Constraints and checks are handled by the runtime rather than left to the agent's memory of a paragraph it read earlier.

  5. 05

    Verify

    What was delivered, what the agent consulted, and how the turn went are all recorded, so the effect of a piece of knowledge is a measurement.

  6. 06

    Learn

    Evidence accumulates. Repeated corrections strengthen a working preference, a fix that keeps applying earns its place, and knowledge the code has moved past loses ground.

Codex
Claude Code
Grok
Codex

I found an edge case where discounts could bypass line-item validation. I fixed the issue and verified the tests. This may be useful context for future checkout changes.

12/12tasks done the way the workspace expectsWithout Pathrule, 3 of 12. Same agent, same prompts, same repositories.
13-30xsmaller knowledge payloadCompiled task-scoped delivery vs the same knowledge as prose.

Claude could finish the work either way. What changed was whether it finished the way the workspace already knew it should be done. The knowledge existed; the difference is whether it reached the task.

Identical repositories, identical prompts, scoring frozen before the run. The payload figure is about the knowledge payload, not total token usage. Methodology

You Why do we use getEnv() here?

Pathrule This workspace moved environment access behind getEnv() after direct access bypassed validation in three separate changes. It is a constraint on /src, not a style preference.

You Prepare the auth migration, but don't start it yet.

Pathrule Two workspace constraints affect this migration. I'll prepare a plan around them and leave the implementation untouched.

You Why does Claude keep running so many tests?

Pathrule You've corrected this several times. I'll treat targeted verification as your default, unless the workspace requires a broader check.

Talk to the intelligence behind your agents. Pathrule Studio is where you ask why a decision exists, teach Pathrule how you work, inspect what the workspace has learned, and direct the agents from the same place.

Features

Ask, teach, correct, inspect

Plan and delegate work to agents

See why a piece of knowledge was used

Inside Pathrule Studio

Pathrule is not one feature. It is a system of layers: what understands, what it learns about the project, what it learns about you, what enforces it during a run, and the two places you work with it.

Pathrule IntelligenceWhat does all of this mean?Understands workspace and user knowledge on your device and compiles it into structured, task-specific guidance.Workspace IntelligenceHow does this project work?Learns the decisions, constraints, fixes, procedures and context that make one repository behave the way it does.User IntelligenceHow does this person work?Learns how you prefer to work from the instructions, corrections and decisions you make, and carries that between projects.Pathrule RuntimeDid the agent actually get it, and follow it?Delivers compiled knowledge before the first tool call, enforces constraints and checks deterministically, and records what happened.Pathrule StudioWhat does Pathrule know, and what should it do?The interface to the intelligence: ask it why a decision exists, teach it how you work, inspect what the workspace has learned, and direct agents.Pathrule CLIHow do I get this in a terminal?Brings the same intelligence, the same local model install and the same runtime into terminal and headless workflows.

The whole architecture, on one page

One shared understanding across Studio.

Chat

Every surface draws on the same intelligence. Give an agent a task, switch models, move into design, and the compiled knowledge for the work follows rather than being explained again.

Explore

CodexResets in 5d 23h18%
Give it a task...
Isolated branch

Task

Tasks can come directly from what is happening in your product, giving agents concrete work to act on.

Explore

Fix Studio reconnect retry behavior

Pathrule Signals1d

Fix workspace validation blocking new chats

Watching production1d

Design

Design happens inside the same workspace knowledge your agents work from.

Explore

Figma

Product work does not live in one place. Pathrule connects the surfaces where you think, design, and execute, so work can continue without losing what came before.

Workflow loop

Pathrule surfaces stay connected to each other. Work can move between Design, Tasks, Chat, and Context without rebuilding the surrounding understanding every time.

A change in Design can become a Task, and the agent working on that Task can continue with the relevant product context already available. Explore the workflow loop

DesignTasksChatContext

Where Pathrule is different, and where it overlaps.

Every product here gets the ticks it has earned. Your coding agent and your editor already scope rules by path and load them before the first tool call. Those rows are ticks for them, not for us.

How Pathrule compares with Claude Code's own memory, Cursor, ByteRover and Mem0, including the rows where they do the same thing.
CapabilityPathruleintelligence layerClaude Codeauto memory + rulesCursorrules + memoriesByteRovercontext treeMem0memory API
Architecture
Knowledge is compiled into structure, not delivered as proseYesNoNopartialPartialpartialPartial
Requirements rank above advice in what the agent receivesYesNoNoNoNo
Critical rules enforced by a runtime, not only stated in a promptYespartialPartialpartialPartialNoNo
Your knowledge is understood on your own machineYesNoNopartialPartialNo
What it learns
Learns how you prefer to work, not only what the project knowsYespartialPartialpartialPartialNopartialPartial
What it learns about you follows you to the next repositoryYesNoNoNopartialPartial
Learns which knowledge actually helped, per kind of workYesNoNoNopartialPartial
Scope and delivery
Scoped to the path you are editingYesYesYespartialPartialNo
Arrives before the first tool call, without the agent askingYesYesYespartialPartialNo
One knowledge source available to multiple agent vendorsYespartialPartialNoYesYes
The work itself
Parallel agents in isolated checkoutsYespartialPartialYesNoNo
Tasks that arrive with their context preparedYesNoYesNoNo
Runtime incidents mapped back to code and tasksYesNoNoNoNo

Official documentation checked 1 October 2026. Claude Code 2.1.287 was inspected locally; Cursor, ByteRover and Mem0 were not runtime-tested. Sources and review scope appear on the linked comparison pages. Compare sources and methods

Signals

live
checkout.submit crashed×3
Payment retry exhausted2m
Coupon rejected on lineItem5m
Checkout completed12m

Fix checkout.submit crash on payment retry

Pathrule Signalsnow

Context usually starts with people. Signals lets the product contribute too. Runtime events can become useful input for the agents working on the product.

Features

Product events become agent context

Runtime issues stay connected to the relevant work

Signals can create Tasks for agents to act on

Your workspace

Shared with the team
apps/webCheckout Field Map
apps/api
checkoutCoupons only on lineItem
pricingPricing rounding note
.githubrelease-checklist

What one person teaches the product, the whole team can build on. Share knowledge across your team, so every agent can work with what your product has already learned.

Features

Shared memories, rules, and skills

Relevant knowledge across teammates

Keep agents aligned as the product evolves

Built to understand your product. Designed to protect it.

Local intelligence

Your workspace is understood where it lives. Pathrule Intelligence runs its inference on your own machine, and Pathrule never scans, indexes or uploads your source code.

Your machine

src/

412 files

.env

1 file

node_modules/

9,204 files

What Pathrule stores

MemoriesRulesSkills

Open source

Inspect the core yourself. Pathrule's core is open source, so you can see how context reaches your agents or run it on your own terms.

github.com/pathrule/core

Scoped knowledge

Knowledge stays in scope. Product knowledge follows workspace and project boundaries, so agents receive what belongs to the work at hand.

How scoping works

Workspace

24 items

Project

9 items

apps/api/checkout

Coupons only on lineItemCheckout Field Map

Common questions.

What is Pathrule?

Pathrule is the intelligence layer between you, your workspace and your coding agents. It learns how a project works and how you prefer to work, understands both on your own device, and compiles what a specific task needs into knowledge an agent can use.

What is Workspace Intelligence?

The layer that learns how one project works: the architecture decisions, constraints, verification requirements, fixes that worked, procedures and context that a repository accumulates around its code. It stays with the workspace instead of with the session that discovered it. See Workspace Intelligence.

What is User Intelligence, and how does Pathrule learn how I work?

The layer that learns how you prefer to work, from the instructions you give, the corrections you repeat and the approaches you accept or send back. It builds working preferences with the evidence behind them, not a psychological profile, and a single event does not become a preference. See User Intelligence.

Can I correct what Pathrule has learned about me, and does it follow me to another repository?

Yes to both. Everything User Intelligence holds is visible in Studio with the evidence behind it, and you can correct it, teach it directly, override it or remove it. It is scoped to you rather than to a workspace, so it comes with you to the next project while Workspace Intelligence changes with the repository.

What happens when my preferences conflict with project rules?

The project wins where correctness is at stake. A constraint or a required check is a hard requirement of the workspace and is not dropped because a personal preference would be more convenient. User Intelligence shapes how the work is done; it does not redefine what done means.

What is Pathrule Studio, and is it another AI chat app?

No. Studio is the interface to Pathrule's persistent intelligence, workspace knowledge and agent runtime. You can ask why a decision exists and get the decision and the incident behind it, teach Pathrule how you work, inspect what the workspace has learned, and direct the agents. Studio runs Claude Code, Codex, Grok, Kimi, Antigravity and OpenCode on the same workspace; Cursor, Windsurf and GitHub Copilot connect through Pathrule CLI.

Is Pathrule another coding model? Does it replace Claude or Codex?

No to both. Pathrule does not write your application code. Claude, Codex and the rest stay the execution and reasoning engines, and you keep using the subscriptions you already have. Pathrule is what they start from, and it is why switching engines does not reset what is known about the work.

Does Pathrule run AI locally? Does it send my code to its own AI servers?

Pathrule Intelligence inference runs on your own machine, from a model installed once and shared by Studio and the CLI. Pathrule does not index your repository, scan your files or upload your source code. Pathrule does have cloud services for accounts, teams, billing, sync and model distribution, and any coding agent you run keeps its own provider boundaries. The security page keeps those three separate.

Is Pathrule an AI memory tool?

Memory is one of its sources. A memory records what was true when it was written; the intelligence layer is what works out what that means and whether it matters for the task in front of an agent. Memories, rules, skills, corrections and runtime evidence are inputs. Task-specific compiled knowledge is the output.

Do I have to write all of this by hand?

No. You can write memories, rules and skills yourself, and Pathrule also learns alongside the work. When an agent discovers something worth keeping, it is proposed with the evidence behind it and saved once you accept it.

What happens when Pathrule is not sure?

It falls back rather than guessing. A deterministic gate compares what would actually be delivered against what the source said, and when the compiled form does not represent it well enough, the source knowledge is delivered instead. See safety and fallback.

Does Pathrule save tokens?

It makes the knowledge payload much smaller: compiled task-scoped delivery of a narrative memory measured 13 to 30 times smaller than the same knowledge as prose. That is a claim about the knowledge payload only. Pathrule does not claim to reduce an agent's total token usage, and how we measure says why.

Is Pathrule free?

Yes for solo developers. Studio and the core product experience are free for individual use. Team and Business plans add capabilities for shared workspaces and organizations.

Explain it once.

Pathrule is free for solo developers. Your first memory takes a minute.

Download for macOSRead the docs