Your AI assistants forget. Pathrule remembers.
Store your rules, decisions and conventions once. Pathrule automatically routes the right ones into every AI session, scoped to the files you're working on.
Pathrule
Claude Code
Cursor
Codex
Windsurf
GitHub CopilotEvery AI session starts from zero.
Your team's knowledge exists. Your AI just doesn't receive it.
So every developer re-explains the same standards, in every tool, in every session. The context resets the moment the work begins.
Five tools. Five different answers.
The problem isn't memory.
It's delivery.
Knowledge lives on the path it belongs to.
And the path is how Pathrule routes it to your AI. Pin a memory, rule or skill to any folder, and every agent working there gets exactly that, plus what it inherits from above.
Before the first tool call.
The right context arrives before the AI touches your code.
- 1You ask.
Make a change, the way you always would.
- 2Pathrule activates.
It selects the context that matters for this task.
- 3The agent begins.
Rules, memories and skills arrive automatically.
It grows as you work.
You barely maintain it. The knowledge accumulates from the work itself, not from a second job of writing docs.
When a decision, a tricky fix or a gotcha the AI keeps hitting comes up mid task, your assistant proposes saving it. You never have to remember to.
One nod and it lands as a memory, rule or skill on the path it belongs to. Nothing is saved without your okay.
Pathrule ranks knowledge by how it is actually used and delivers the most valuable first, to every assistant on the team.
Everyone starts with the same context.
Multiple developers, multiple AI tools, every session working from the same team knowledge.
One workspace, shared by the team
The same memories, rules and skills, attached to every part of your codebase.
Priya added a rule
Marcus updated a memory
Lena added a skillEdits sync to everyone
Update the knowledge once, the whole team gets it.
Same context, every tool
Every AI client works from the same shared knowledge.
AlexClaude CodeCLEAR
NadiaCursorOVERLAP
KenjiCodexCLEAR
HannahClaude CodeCLEARRealtime presence, version-aware writes.
Every write carries a version token and an actor. A realtime channel streams node activity to the rest of the team, so two agents editing the same node hit a conflict modal, not a silent overwrite. Three-way merge is one click away when the agents disagree.
Delivering the right context is real engineering.
Storing your memories, rules and skills is the easy part. Getting exactly the right ones to the AI, fast, on every prompt, is where the work is.
It weighs every candidate, then sends the best few.
Pathrule scores your knowledge by where you are, what changes together, what is recent, and what it means, then ships only the top matches.
Sized to your intent.
A quick tweak gets a little. A big change gets more.
Found by meaning, not just keywords.
Semantic search runs on your machine or in the cloud.
Run a skill by name.
Force a known procedure into the turn.
Bring back past work.
Pull in what the team already did.
A fraction of the tokens.
Only the slice that matters ships to the model.
~85% fewer tokens, every prompt.
The engine is open source.
Pathrule's core, the path-scoped memory, rule and skill engine, runs on your machine for free and is yours to read. Pathrule Cloud adds the team layer: sync, AI curation, and live collaboration.
Runs fully local
Embedded SQLite at ~/.pathrule. No account, no infrastructure, works offline.
The same context engine
Path-scoped get_context, the router, and the ranking formulas. Identical MCP tools to Pathrule Cloud.
Semantic search, your key
Bring a Voyage or OpenAI key and the core recalls by meaning, right on your machine.
Apache-2.0, fully readable
Inspect exactly how routing and ranking decide what your agent sees.
Start with knowledge, not an empty workspace.
Patterns are curated packages of memories, rules and skills, pre-scoped to the paths they belong to. Add one and your assistant starts the project already knowing the conventions the stack needs.
::pathrule:package:nextjs-app-routerIt lands pre-scoped, on the right paths
Every piece is written onto the path it belongs to, so your assistant picks it up exactly where the work happens.
Pre-scoped to the path
Each piece lands where it belongs, so your assistant only sees it where it is relevant. No global file to grow.
One token, whole bundle
Paste a reference token and Pathrule writes every memory, rule and skill onto the matching paths at once.
Yours after import
Imported pieces become ordinary workspace content. They evolve with your project, and a single call removes them.
Go deeper.
Docs, updates, and the thinking behind Pathrule, plus enterprise when you roll it out across the org.
Documentation
Install Pathrule and learn the model: memories, rules, skills.
Changelog
What shipped, release by release.
Writing
Notes on context, agents, and craft.
Security
Your code stays on your side.
Enterprise
SSO & SAML, audit logs, and dedicated support, deployed however your security team needs.
Talk to usQuestions, answered.
How Pathrule ships, what it touches on your machine, and how it keeps team knowledge scoped and secure.
- How does Pathrule ship: desktop, web, or CLI?
- All three, plus a Remote MCP option. Pathrule Web runs in any browser at app.pathrule.io, Pathrule Desktop is a native macOS app you can download from its macOS app page, and Pathrule CLI runs on macOS, Linux and Windows with SSH-friendly device-code login. A hosted Remote MCP endpoint also serves cloud-only AI clients. They share one cloud, one workspace tree and one MCP surface.
- Why does Pathrule Web need the CLI?
- Pathrule Web is cloud-only by design: it manages workspaces, content, billing and team admin from any browser. Anything that touches your machine (installing an AI client, syncing companion files, running hooks, reading the local repo) needs a runtime. Pathrule CLI is that runtime. Web pairs with a local CLI daemon over a scoped localhost bridge so the browser never gets raw filesystem access.
- Does Pathrule read my source code?
- No. Pathrule does not index your repo, scan files, or upload source. The cloud only stores the typed content your team writes (memories, rules, skills) plus the small structural metadata needed to route it.
- How does the agent actually receive the context?
- Through PreToolUse and UserPromptSubmit hooks. The hook reads a precomputed index from a local cache, formats the path-scoped slice for the current working directory, and returns it as system context for that tool call. No extra MCP round trip in the agent loop.
- How is Pathrule different from putting everything in CLAUDE.md?
- CLAUDE.md is a single static file the agent loads every session. Pathrule routes by path and intent: a UI tweak on /apps/web gets a minimal payload, while a discovery prompt unlocks a deeper one. Same source of truth, different shape per call.
- Do we have to write all of this by hand?
- No. You can author memories, rules and skills directly in the web app, desktop or CLI, but most of them accumulate as you work: when something is worth keeping, your assistant proposes it and writes it once you confirm. Maintenance stays close to zero, so the knowledge base grows without a second job of writing docs.
- What happens when Claude Code or Cursor ship native memory?
- Each tool's native memory stays inside that tool. Pathrule sits one layer above: the same memories, rules and skills reach Claude Code, Cursor, Codex, Windsurf and GitHub Copilot from one place. As long as a team uses more than one assistant, or ever switches between them, the knowledge has to live somewhere neutral and portable. That neutral layer is the point, so a native feature in any single tool does not replace it.
- What does Pathrule do on the cloud side?
- It works in two layers. The routing and base ranking that pick which memories, rules and skills to surface are open source and run locally, so you can read exactly how they decide. On top of that, the cloud edition adds a learning layer: it tracks which knowledge actually helped on similar work and re-ranks future results, so the most valuable surfaces first and sessions stay sharp instead of noisy. Your source code never leaves your machine; only the team-written memories, rules and skills are stored.
- How are permissions enforced?
- Every read and write runs against row-level security policies in Postgres, written against the signed-in user's JWT. A compromised client cannot widen its own access because the database does the final check. The same RLS policies apply whether the request comes from Pathrule Web, Pathrule Desktop or Pathrule CLI.
Stop teaching your AI the same things twice.
Install Pathrule and let every session start with your team's context.