Skip to content
Pathrule

pathrule.iomain

Pathrule

changelog

DocsGet started

Every change,
dated.

Changes to Pathrule’s knowledge layer, local tools, agent integrations and Signals. The history keeps updates relevant to the current product.

October 2026

ShipOct 17

Pathrule 1.0 is open source at github.com/pathrule/pathrule

The foundation is one public repository under Apache-2.0: the protocol, Agent IR, the local knowledge store with retrieval and ranking, the hooks, the local MCP server, the host, the CLI, the Local Console, the VS Code extension and the Pathrule Cloud client, eleven packages released together as 1.0.1. It runs with no account, no network service and no model on your machine, and npm i -g @pathrule/cli installs it. Pathrule Cloud, with team workspaces, sync, the web console, Remote MCP and the Cloud model tier, stays proprietary. See Open source core.

PerfOct 17

PathruleBench: 2.7 times fewer input tokens at 2,000 items of team knowledge

PathruleBench gives the same coding agent the same team knowledge through CLAUDE.md files or through Pathrule, over eight sessions of four turns, and checks 26 memory probes with tests and structural checks. At 2,000 items, Claude Code with claude-sonnet-5-5 read 2.7 times fewer input tokens and cost about 55% less a chain with Pathrule, in Python, Go and TypeScript, and passed more of the probes. The Pathrule arm is the open-source CLI in local mode. The gap opens from 1,000 items, and the conditions where the channels tie are published too. Fixtures, scenarios, checks and every chain are at github.com/pathrule/benchmark; the reading is in How we measure.

ShipOct 17

Knowledge is captured from your own words, with no model on your machine

A decision you state in a prompt, with "from now on", "we decided", "always" or "never" in any of thirteen languages, is saved at the workspace root exactly as you wrote it. A lesson a failing command taught, a flag or an environment variable that made it pass later in the session, is saved once. A preference you voice to an agent is checked against what you typed, waits as a candidate, and becomes active when you say it again or state it as lasting. A sentence that says where code lives is marked as of writing, and when an edit writes a value a newer decision replaced, the hook quotes the decision at that edit. All of it reads the shape of your words and commands, never a model, so it works the same in every language. See How knowledge compounds and User Intelligence.

ShipOct 17

Statement capture on Cloud workspaces, paid from AI Credits

On a Cloud workspace, the Cloud model tier reads the prompts Pathrule's phrase rules found nothing in and keeps a decision you meant to last, still in your words. It is paid from AI Credits at one credit per ten prompts or part, under pricing contract 1.2.1. Local workspaces are unaffected: nothing there runs a model. See Pricing and Security.

InfraOct 13

Pathrule Cloud brings knowledge and access onto one backend

Pathrule Cloud runs on Cloudflare for shared knowledge, content history, semantic retrieval, accounts and workspace services. Remote MCP is at https://cloud.pathrule.io/mcp and the console remains at app.pathrule.io. Every operation checks your current session and workspace access; remote grants are bound to one approved workspace. The console reads workspace and billing state from the Cloud API. Local mode remains accountless. See Remote MCP and Security.

ShipOct 12

Inspect and edit local knowledge in your browser

Run pathrule ui to open the Local Console. Browse and search local workspaces, create and edit memories, rules and skills, restore archived items and inspect activity without an account. The console is served on your machine and uses the same local knowledge store as the CLI. See Local Console.

ShipOct 12

Local Signals has a console and a verification loop

Local Signals groups runtime errors and events by environment, fingerprint, code path and release. Read groups in pathrule ui or through the agent tools, record a fix, and wait for successful coverage in a newer release before calling it verified. Standalone collectors remain supported, and Pathrule Cloud adds managed ingestion and retention. Instrumentation stays opt-in and requires approval of the specific changes. See Signals.

UXOct 12

A terminal view of your workspace knowledge

The CLI’s interactive terminal view now brings workspace status, knowledge browsing and setup guidance together. Read-only diagnostics name the next useful command, while machine-readable output remains available with --json. The terminal manages Pathrule knowledge and integrations; your existing coding agent performs the coding work.

FixOct 12

Compiled knowledge keeps its source and scope

The Intelligence v1 update tightens checks on compiled requirements, required verification and remedies. A compiled entry must remain grounded in its authored source and scope. When the checks cannot establish that, Pathrule falls back to the source text. Findings remain advisory and changed source files cause them to be held back until revalidated.

ToolsOct 10

Native integrations for Claude Code and Codex

The CLI can connect Pathrule through Claude Code and Codex’s native plugin channels as well as settings-based hooks. The integrations use the same workspace knowledge and local runtime. You can inspect a proposed setup before applying it, diagnose installed integrations and repair Pathrule’s entries. See Native agent integrations.

ShipOct 2

Agents can see a map of everything your workspace knows

Agents can inspect a map of the workspace’s memories, rules and skills through Pathrule’s knowledge map tool. They can explore related knowledge, find gaps and check which neighboring entries may need attention after an edit. The same knowledge tools are available through the CLI’s local MCP server and the VS Code extension.

ShipOct 2

An approved memory reaches agents in its shorter compiled form

An approved compiled memory can now stand in for the full source text in prompt hooks and the knowledge files Pathrule writes for supported clients. Before substituting it, Pathrule checks that the compiled form still covers the source. If it does not, the source prose is delivered instead. The decision is deterministic and calls no model.

ShipOct 2

Agents learn your project as they work, and the whole team gets what they learn

What an agent worked out by reading your code used to disappear when its session ended, so the next agent, or a teammate's, had to work it out again. Now an agent that reaches a conclusion from the code can save it along with the files it is based on, and every agent in the workspace receives it from then on. When those files change, the finding is held back until an agent confirms it again, so nobody is handed an answer about code that no longer exists. Findings arrive as advice to check, never as rules, and whoever recorded a finding can retract it for the whole team at once. With GitHub access, agents can also learn from past review discussions on the repository without storing the comments. None of this needs a model or writes anything into your repository, and a cloud workspace shares only the finding and where it came from.

September 2026

FixSep 15

The CLI stops telling you to install an older version

Once a day the CLI checks whether a newer version exists and prints a one line notice if so. Users on a current CLI could be told that an older release was available, with a command that would have downgraded them. The notice now appears only when a genuinely newer version exists, and it stays silent whenever it cannot tell.

FixSep 15

A rule you rewrote stops enforcing the sentence you removed

When Pathrule proves a rule can be checked mechanically, the check is tied to a specific sentence in that rule. After the rule was rewritten, the check could keep enforcing a sentence the rule no longer contained. Checks are now verified against the rule as it currently reads every time they apply, and a check whose sentence is gone simply stops applying, so what is enforced always matches what the rule says.

August 2026

ShipAug 25

The Patterns catalog now covers one hundred fifty development problems

The public catalog at pathrule.io/patterns grew from eighty five packages to one hundred fifty. The new set concentrates on problems developers repeatedly search for and debug in production, including SQL performance, mobile lifecycles, browser rendering, queues, cloud runtimes, observability, Git workflows, local and fine-tuned models, enterprise identity and machine credentials. The catalog remains deliberately mixed across framework, frontend, backend, billing, infrastructure, workflow, AI and security work, and every package is still a path-scoped bundle of rules, memories and repeatable skills rather than a generic topic summary. The package, website and offline import bundle move onto the same version so the new patterns are available wherever a Pathrule client imports them.

ShipAug 25

The Patterns catalog now covers eighty five stacks

The public catalog at pathrule.io/patterns grew from fifty eight packages to eighty five. The new bundles deepen security, AI, billing, workflow, frontend and infrastructure coverage, and add focused guidance for file uploads and Spring Boot. Each package carries path-scoped rules, memories and repeatable skills instead of a generic checklist, with dedicated icons or brand marks on the site. The offline bundle that serves pattern imports moves to the same release, so ::pathrule:package:<slug> can reach the full catalog from every client as the release train rolls forward.

ShipAug 25

Past work and co-change warnings reach your coding agents

Related past work and hints about files that usually change together now reach coding agents through Pathrule context. Optional hints are isolated from core knowledge delivery, so a missing hint does not prevent memories and rules from arriving.

ShipAug 25

Pathrule tells you when two memories say the same thing

Duplication was the one gap in knowledge maintenance with no detector. The same decision written twice in different words was delivered twice, spent your context budget twice, and drifted apart when only one of the two copies was updated. Suggestions now flag duplicate knowledge as its own kind, separate from a conflict: a conflict is two statements that cannot both be true and is resolved by deciding, while a duplicate is the same fact said twice and is resolved by merging. The detector is deliberately strict and flags only entries that say the same thing, so knowledge that merely looks alike is left alone and the list stays worth reading.

ShipAug 25

The Patterns catalog now covers fifty eight stacks

The public catalog at pathrule.io/patterns grew from forty three packages to fifty eight, adding AI and security alongside the existing framework, frontend, backend, billing, infra and workflow families, and every page got a clearer title and description. The offline bundle that serves pattern imports moved to the same version, so ::pathrule:package:<slug> reaches the new packages from every client rather than only from the website.

ShipAug 24

Relevance now decides the form, not just the order

Pathrule now spends context in proportion to how well something fits your request. The best matches arrive as full, ready-to-use content, and other relevant knowledge arrives as a short reference your assistant can open when it turns out to matter, so nothing useful is left out for want of room. Skills are offered by name rather than handed over unasked, rules no longer crowd out the memory your task needed, and a rule you marked strict always arrives in full.

ShipAug 24

Ask two things at once and get knowledge for both

A prompt that asks two separate things now gets the right knowledge for both, instead of a blend that fits neither, with no added wait. Single-part questions are unchanged, and the context used grows with the question rather than with the size of your workspace. Relevance also holds across the languages you write in, so a team working in a language other than English gets the same quality of context.

ShipAug 24

Your agents know who is the reference for what

Every person on your team now has a profile that answers one question: who is the reference for which area. A short version of it reaches every agent at the start of a session, so agents address you by name and point to an area's owner when a decision touches it instead of deciding for them. Areas come from the work and knowledge your team already produces and fade when someone moves on. Decision authority is never guessed from activity: you declare it yourself. The Members panel shows your profile exactly as an agent reads it, you can replace a derived list with your own, and a profile set to private is left out of everything your team and its agents can read. Profiles carry areas and declared scopes only, never opinions about a person.

SecurityAug 24

Tighter access to backend services

A security pass tightened access to Pathrule's backend services, including the scheduled maintenance around billing and account lifecycle, and automated checks now verify that access directly. Nothing changes in how you use Pathrule.

ShipAug 22

Retrieval learns from every turn, and the selection stays the same size

Pathrule now learns from how each turn goes and uses that to improve what it sends next time, with nothing asked of the assistant, so it works the same in every client you connect. What it learns is specific to the kind of work, and it only reorders knowledge that already fits your request, never adding something that does not. A workspace that has been learning for months delivers better context than it did on its first day, without using more of it.

ShipAug 22

Your assistant's dead ends become a map

Some files are simply harder for an assistant to work in, and the reason is rarely the code: a path in your instructions that moved, a generated file that should not be edited, or a directory the agent has no permission for. Pathrule now notices where assistants repeatedly fail and shows the files they struggle with most and how, grouped the same way across your whole team. It records only that a failure happened, never the command or the error text, and guidance that keeps showing up in turns that go badly is gradually offered less often.

UXAug 11

Pathrule no longer takes over your instruction files

Opening an existing project used to mean Pathrule rewriting the agent instruction files it found. It does not any more. Your CLAUDE.md, AGENTS.md and rule files stay yours: Pathrule writes into a clearly bounded region of its own and leaves everything around it untouched, and it can restore that region if it is edited or removed by hand. It also measures what it actually delivered into a turn, so the value it claims is something you can check rather than take on faith.

FixAug 11

Sharper recall of the knowledge that matters

A round of correctness work on retrieval means the context Pathrule delivers is closer to what you would have chosen yourself. Path-scoped lookups pick the right place when several could match, related work from earlier sessions is chosen for real relevance rather than recency, and fewer near misses reach the top of suggestions and search results. See how retrieval works.

FixAug 11

Connecting from a cloud client stops re-asking for consent

Using Pathrule from a hosted client no longer reopens the authorization page every time the connection restarts. The approval you already gave is reused, so a cloud agent picks your workspace back up instead of parking on a consent screen. See MCP overview.

July 2026

PerfJul 2

Agents update your knowledge with small edits, not full rewrites

An assistant can update a memory, rule or skill by appending text, replacing a passage or replacing a section, instead of resending the entire body. These targeted edits reduce the payload and preserve unrelated content through Pathrule’s MCP tools.

June 2026

ShipJun 23

Pathrule Web is now your management console

Pathrule Web at app.pathrule.io manages organizations, members, roles, billing, workspaces and usage. Knowledge is authored through your coding agent’s MCP tools, the CLI or the VS Code extension. The console does not run coding agents or need access to your local repository. See Pathrule Web.

FixJun 14

Open a set-up folder in VS Code and connect with one click

A folder already attached with the Pathrule CLI is recognized by the VS Code extension, which can connect to the existing workspace with one click. A signed-out user is offered sign-in, and the create step is guarded against accidentally creating a second workspace for the same folder.

PerfJun 13

Your AI gets only the knowledge each prompt needs

Pathrule selects relevant memories and rules for each prompt and offers skills by name unless explicitly invoked. Path scope works without an embedding provider; semantic ranking adds meaning-based retrieval in Cloud mode or with a provider you configure locally. Delivery uses the channels each client supports, including hooks, instruction files and MCP. See how retrieval works.

ShipJun 9

Add a Pattern to your workspace with one token

Patterns import into a workspace through the local MCP runtime. Use ::pathrule:package:<slug> to request a dry-run preview, check the proposed paths and stack fit, then approve the import. Imported entries become workspace knowledge. Remote MCP does not expose pattern-import tools; use the CLI or VS Code integration. See the import guide.

ShipJun 9

Pathrule Patterns: a public catalog of ready-to-use knowledge

Patterns are curated packages of memories, rules and skills, each pre-scoped to the path it belongs to, so your AI assistant applies it only where it is relevant. The public catalog at pathrule.io/patterns spans frameworks, frontend, backend, billing, infra and workflow, every package first-party and Apache-2.0. Each pattern page shows the full bundle grouped by path, a derived contents summary, and a one-click manual copy that works today, plus a clean markdown view so AI assistants can read the bundle directly. Adding a new pattern is one entry in the open @pathrule/patterns package. See Patterns documentation.

ShipJun 7

Pathrule now supports GitHub Copilot

GitHub Copilot joins Claude Code, Cursor, Codex and Windsurf as a first-class target. One setup reaches Copilot across VS Code agent mode, the Copilot CLI and the coding agent: Pathrule registers its MCP server, writes a path-scoped protocol into .github/copilot-instructions.md, ships skills Copilot can invoke, and registers a hook that delivers the matching slice of your team's memories and rules before the first tool call, so a strict rule can block a non-compliant change before it lands. The same memories, rules and skills you already use everywhere else drive Copilot too, with no separate knowledge base. See Pathrule for GitHub Copilot.

ShipJun 7

Pathrule ships as a VS Code extension

Pathrule is now a full client inside your editor, for VS Code, Cursor and Windsurf. Install it from the Visual Studio Marketplace or Open VSX. The open folder is the workspace and the active file is the path: a knowledge tree follows your editor, and memories, rules and skills open as ordinary markdown tabs that save back to Pathrule with conflict-safe handling instead of silent overwrites. It runs in two modes behind one UI, local with no account or signed in for the team layer, the same split as the CLI, and shares one identity with it. A single command connects Copilot agent mode, Claude Code, Cursor, Codex and Windsurf and injects the hooks, with a doctor to verify the setup. See the VS Code surface docs for the full tour.

ShipJun 6

The local Pathrule foundation is open source

Pathrule’s local foundation is Apache-2.0. It includes path-scoped knowledge, a SQLite store, the local MCP server and client integrations. Local mode needs no account or cloud service. Pathrule Cloud is proprietary. See Open source for the current boundary and source availability.

May 2026

ShipMay 21

Pathrule learns which memories actually help your AI

Pathrule records which memories an agent consulted and uses that evidence to improve ranking for similar work. Useful entries can move forward without adding more context. These learning records are separate from the prompt text Cloud ranking uses.

ShipMay 21

AI context now sees co-change hints and past work episodes

When the AI is working on a file, Pathrule tells it which other files in your workspace usually change with it. When you are fixing a bug, refactoring, debugging or exploring the code, it also adds a short summary of related past work. The matching test, the translation file and the previous attempt at the same screen no longer slip past the agent.

ShipMay 21

Proactive co-change nudge in focused context

When the file you are working on usually changes together with another file that has not come up in the session yet, Pathrule can now add a one-line reminder to your assistant's context. It only appears when it is likely to help, so most sessions stay quiet.

ShipMay 21

Memories can serve multiple paths

A single memory often applies to more than one part of a project, such as an authentication note that matters both in your API folder and in your app's login screen. The memory editor now lets you list every workspace path the memory should surface for, and the AI session pulls it in at all of those locations.

ShipMay 21

AI can flag stale memories back to the team

An agent that finds knowledge contradicting the current code can request a refresh with its reason. The refresh waits for review and can be resolved through the CLI or MCP refresh tools; it does not silently rewrite the team’s knowledge.

ShipMay 20

Pathrule CLI runs on macOS, Windows and Linux

A single npm i -g @pathrule/cli now installs a complete local Pathrule runtime on macOS, Windows and Linux. The CLI sets up the Pathrule MCP server and hooks for your AI clients, carries a custom PATHRULE_HOME and your corporate proxy settings into their configuration, and works on Windows out of the box. Install and uninstall are tested on every platform before each release.

ToolsMay 19

Pathrule listed on the Model Context Protocol registry

Pathrule’s hosted MCP listing introduced direct knowledge access over Streamable HTTP. The current endpoint is https://cloud.pathrule.io/mcp, with workspace-bound authorization and a narrower catalog than local stdio. See Remote MCP.

ShipMay 11

No more duplicate memories, rules and skills

Pathrule now prevents accidental duplicates when AI assistants try to add the same skill, memory or rule twice. If a workspace had duplicate skills with the same name, only the most recent copy is kept, so your AI client's skills folder no longer shows several variants of the same one. New writes are checked before they land: an exact match blocks the write and points to the existing record, while a near-match surfaces as a soft suggestion so the assistant can extend an existing note instead of creating a parallel one.

FixMay 11

Workspaces match folders with any letter casing

Pathrule now resolves your project folder to the same workspace even when the path on disk uses different letter casing than the one you originally connected, so your AI client always gets the right context on macOS and Windows. Symlinked and aliased folders now resolve to the same workspace automatically too.

PerfMay 4

Smarter memory discovery

Broad questions now find related team memories before the AI falls back to raw file search. Short Turkish and English prompts are handled better, even when the useful note lives deeper in the project.

FixMay 4

Parent folders see child knowledge

Asking from a repo root or parent package is less likely to miss a memory attached to a more specific folder. Pathrule now points the assistant toward the right lower-level notes instead of going silent.

PerfMay 4

Managed background memory indexing

Pathrule Cloud can prepare existing and new memories for meaning-based retrieval in the background, without a separate embedding-provider key on each team member’s machine.

ShipMay 4

Safer semantic hints for AI tools

When Pathrule finds a memory that might fit your task, your AI tool is now told to read it before relying on it, instead of treating its title as the answer.

ShipMay 4

Release confidence checks

Every update now goes through broader checks before it reaches teams, covering context quality, handoffs to AI tools and direct skill calls.

PerfMay 4

Smarter context routing

Pathrule is better at judging how much project context a request needs, and returns deeper context only when the work calls for it.

ShipMay 3

Controlled project history

Teams can ask Pathrule for relevant prior work on demand with a history hint. Ordinary prompts stay clean, and history is labeled as context rather than a rule.

ShipMay 2

Skill packages

Skills can now carry supporting files, not just a single instruction body. Teams can review package snapshots, keep external packages read-only, and edit manual packages in place.

PerfMay 2

Cleaner context retrieval

Reduced irrelevant root-level context, so the AI now gets a smaller, more explainable context bundle for the same task.

April 2026

ShipApr 30

Explicit skill invocation

Engineers can now call a workspace skill directly from a prompt. Pathrule resolves the exact team skill and injects it only for that turn.

PerfApr 30

Quieter prompt context

Pathrule now separates strict reminders from advisory context, reduces repeated injections, and keeps root-level summaries out of ordinary tasks.

InfraApr 27

Billing and workspace lifecycle

Subscription state, workspace archive flows, delete safety, and owner-only billing controls now follow one account lifecycle model.

ToolsApr 26

More consistent AI client behavior

Pathrule now keeps supported AI clients closer in behavior, so the same workspace knowledge reaches the assistant regardless of where the engineer starts.

ShipApr 20

Just-in-time file context

When a prompt clearly references a file, Pathrule can deliver the matching team memory locally before the assistant starts exploring.

PerfApr 20

Slimmer context responses

When your assistant asks for context again in the same session, the response is now smaller and less repetitive. It receives the most relevant item without the same surrounding context being repeated.

FixApr 18

Stale path scope on rapid switches

Fixed an issue where switching files quickly could occasionally carry the previous path's reminder into the next task. Each task now gets the reminders for the path you are actually working in.

ShipApr 12

Unified context request

One context request now chooses a lightweight, focused or deep answer based on the task, replacing several older ways of asking for workspace knowledge.

March 2026

ShipMar 28

Activity intelligence

Per-task activity is summarized into the next session's handoff, so the assistant picks up where the team left off without re-discovery.

FixMar 25

Search ranking on non-Latin titles

Fixed an issue where memory titles in Turkish, Japanese and Cyrillic were matched less reliably than body text. Searching for them now works as reliably as the rest of your memories.

ToolsMar 5

Codex CLI integration GA

Codex can now read the same Pathrule workspace knowledge and permissions as the other supported AI coding tools.

SecurityMar 1

Build artifact hardening

Hardened Pathrule's release builds and how they connect to the services they depend on.

February 2026

FixFeb 18

Activity log silently dropped at high rates

High activity sessions could occasionally drop non-critical events under pressure. Pathrule now preserves the events and delays delivery instead.

ShipFeb 12

Team workspaces

Organizations can share workspace knowledge with role-based access. Current Cloud access is controlled at organization and workspace level; private workspaces require explicit membership. See Roles and permissions.

January 2026

ShipJan 28

Pre-run context delivery

Path-scoped memories and rule reminders can arrive before the assistant's first action, reducing the need for extra lookup steps.

ToolsJan 22

Cursor integration

Cursor can now use the same Pathrule workspace knowledge and permission model as other supported AI coding tools.

ShipJan 4

Rules with priority and scope

Rules now carry a scope, a priority (high, medium, low) that ranks how strongly they surface, and an enforcement mode. Strict rules require attention before risky actions, while advisory rules travel with the relevant task context.