Waymark is a free, open-source MCP server that lets Claude work on the code on your own computer, from claude.ai or Claude Code. It also remembers what it learned and asks you before it runs anything.
On a Sunday in November I gave Claude a strange job. Read an entire codebase, all 560 C# files, and write down how every feature actually works. I didn't want a summary. I wanted the real path, method by method, from the button or the endpoint to the result.
I typed the request into a chat window. Claude never got a zip file, a pasted snippet or a clone. It read the code where it lives, on my Mac, through a door I control. When it finished, my machine held 121 flows and 34 notes. Every step in them had been checked against the code before it was allowed to be saved.
More than once, Claude got it wrong. It claimed one method called another when it doesn't. The save was refused and the reply named the line, so Claude read the code again, fixed the flow and saved it.
The codebase was Waymark itself. Waymark is the door.
I've written about Waymark twice before, and both posts were feature lists: C# support, then Python and TypeScript, then PyPI and npm. All true, and all beside the point. This post is about the idea I never explained. Claude should work on your real code, across every repository you have, remember what it learned, and never run anything you didn't approve.
The three walls every AI coding assistant hits
I build a system made of several services: a C# backend, a Python worker, a TypeScript frontend. Each one lives in its own repository. My day looked like this: one editor window per service, one AI agent per window, and me carrying context between them by copy and paste.
Every assistant I tried hit the same three walls.
- It forgets. Each new chat explores the same feature from scratch: search, open, read, repeat. You pay for that exploration in tokens and minutes every time. A
CLAUDE.mdhelps until it drifts out of date, which happens the first week. - It guesses. Ask for code against a library and you get a method that existed two versions ago, or never existed at all. The model writes from memory. Your project runs whatever version the lock file pins.
- It can't safely touch your machine. Claude on the web can't see your files at all. An agent with a shell can see everything, and it can do anything without you noticing.
Most tools fix one wall. Waymark fixes all three behind one door, so all three fixes share the same index, the same approvals, the same audit trail and the same memory.
What Waymark is, in one paragraph
Waymark is a local MCP server: a small program on your Windows or Mac computer that gives Claude 35 tools. Claude reads your C#, Python, TypeScript and JavaScript through a syntax index, so it opens an outline and one method instead of whole files. It checks NuGet, PyPI and npm APIs at the exact version your lock file pins. It saves how each feature flows through your code and keeps notes on what the code doesn't say. It builds, tests and runs your projects through typed commands that wait for your approval. claude.ai reaches it through your own tunnel; Claude Code connects on localhost. Every call passes the same gates, has its secrets hidden and lands in an audit trail.
Think of a reception desk with a guard. Claude never walks into your computer. It comes to the desk with an ID you approved once and asks for specific things, such as the outline of a file, the signature of a package method or a build. The desk answers only what you switched on, hides any secret it recognises, writes every request in a logbook, and stops to ask you before anything risky.
Only a call that clears every check reaches a tool, and only a result that has been cleaned and recorded goes back to Claude.
What a real session looks like
The best demo I have is the one from the opening, because it really happened and it touched every part of Waymark. Here is what Claude did, in order.
-
waymark_guideloads the overview first: the tool groups, my own instructions, and a live snapshot of which workspaces are on and which operations ask. -
recalllists what's already known. Some old flows were badly ordered, and six were really how-tos. Claude deleted those six and saved their content as notes. -
code_skeleton,code_outline,code_methodread the structure, then only the members it needed. Not one whole file was dumped into the chat. -
memorisesaves a flow. Waymark parses every step, checks that it exists in the code now, and checks that each indented step is really called by the step above it. - A refusal. One save came back with: step 5
RiskGuide.GateOfis indented under step 1, butOnInitializedAsyncmakes no call toGateOf. The method is called from the page's markup, so Claude marked the link as a UI link and saved again. - Notes capture what code can't say. One says
VaultService.ResolveAsynchas no caller yet, and another says a doc table disagrees with the code about default settings.
Then, in the same chat, I asked whether I could now delete the CLAUDE.md files in my projects. Claude wanted to look at the disk first. No typed tool does that, so it wrote a short read-only find script and submitted it through cmd_shell.
Nothing ran. An approval card appeared in my Waymark Console with the script, its one-line purpose and the reason it asked. The reason was specific: .git/config, Directory.Build.props and a .csproj had changed since I last approved a command. Those are files a build can execute. Claude can't approve anything itself; only I can, on this computer. I was away from my desk, so I never answered. After ten minutes the request expired on its own and the Console recorded it as not run.
A normal working day is the same loop, only shorter:
- I ask for a change.
- Claude recalls the flow for that feature, so it doesn't search.
- It edits with
file_edit_lines. - It builds. A build runs without asking, and errors come back with file paths and line numbers, so it fixes and rebuilds until clean.
- Tests ask first. A desktop notification tells me, even with the admin page closed. I approve.
- Claude updates the flow if the path changed.
I review the diff and the live log. I rarely open the editor.
Memory that checks itself: flows and notes
The headline of v0.4 is that Claude now remembers your codebase between chats, and Waymark checks that memory against the code. There are two kinds.
A flow is one trigger to one outcome, saved as the methods a request passes through, in order. This is one Claude saved during that Sunday session:
Flow 'approval-desktop-notice' (id 123, v1) 7 steps. Links: 3 call it, 3 declared, 0 do not call. 1. ApprovalNudgeService.ExecuteAsync [trigger] 2. ApprovalNudgeService.WaitBeforeNudge [calls it] 3. ApprovalNudgeService.NudgeAsync [calls it] 4. PendingDecisionSource.CountAsync [declared: di] 5. ApprovalNoticeText.For [calls it] 6. MacDesktopNotifier.ShowAsync [declared: di] 7. WindowsDesktopNotifier.ShowAsync [declared: di] The next time anyone asks about desktop notifications, one recall call returns that path with file locations, and Claude reads only the step it needs. Three properties make flows trustworthy:
- Names, never code. A flow stores method names, so it survives edits and branch switches. A step that's missing on the current branch is marked as not on this branch, not deleted.
- Every link is checked. When a flow is saved or read, Waymark confirms each step still calls the next. A broken link shows as
DOES NOT CALL, so a wrong memory announces itself instead of misleading the next chat. - Edits warn. When Claude edits, moves or deletes a file that holds flow steps, the result carries a line saying which flow just broke, so Claude fixes the memory in the same task.
A note is one idea the code doesn't say: why it's built this way, a gotcha, a convention, a decision, a how-to. Notes attach to a flow, a step, a file, a member or the whole workspace. When the code under a note changes, the note shows may be stale until someone checks it. You and Claude both write notes, and Claude can only edit its own.
CLAUDE.md | Waymark notes and flows | |
|---|---|---|
| Goes out of date | silently | marked may be stale when its code changes |
| Scope | one file per repository | a step, a method, a file, a flow or a workspace |
| Who can change it | anyone, any line | you and Claude; Claude edits only its own |
| How Claude finds it | loaded whole, every session | searched by words, or by meaning if you turn that on |
| Survives a refactor | if someone remembers | links checked against the code on every read |
You don't have to start from zero. A workspace's Notes page has Import from CLAUDE.md, which splits your old file into one-idea drafts. Pin the few rules that must always apply and they go into the guide every agent reads. My advice: keep a two-line CLAUDE.md in each repository for clients without Waymark, saying: call waymark_guide, then recall before working on a feature.
Search by meaning is optional and off by default. With an OpenAI, Gemini or Voyage AI key, recall also finds flows and notes by what they mean, not only by their words. Only the text of notes and flows is sent to the provider, never file contents, and you can leave any workspace out. The key is stored encrypted on your machine.
Safety you can see, not safety you have to trust
Waymark has no sandbox, and it says so on its own Safety page. A test or a script you approve runs with your rights. Its job is to limit, show and record what Claude does on your real machine:
- Approvals happen only on your computer. The admin app listens on localhost. Claude can submit, wait and stop, but never approve, deny or change a gate.
- Every operation has a gate: Off, Ask or Auto. Builds run on their own. Tests, runs, installs, package changes and git changes ask. Every shell script always asks, and you can edit the script before approving it.
git reset --hard,cleanand branch delete are off. Nothing can force-push. - The drift check. Build files can execute code:
Directory.Build.*,global.json,nuget.config,conftest.py,package.json, git hooks. Waymark fingerprints them, and the first Auto run after any of them changes asks you once, naming the changed files. - Installs run no package code. Python installs use wheels only and never build the project. Node installs are
npm ci --ignore-scripts. - Secrets are hidden before they leave. Keys, tokens, JWTs, connection strings and anything you saved in the vault are replaced with markers in every tool result. Files like
.env,appsettings*.jsonand private keys can't be opened at all. - The tunnel only carries sign-in and tool traffic. The admin pages can never be reached from the internet.
- Pairing is a code you compare. A new Claude client shows a pairing code; you match it on your Approvals page. Tokens last 60 minutes, and you can revoke a client at any time.
- Everything is on the record. A live log shows every call as it happens. An audit trail keeps every call and decision for 90 days. Pause all stops every tool at once.
No more invented methods: real NuGet, PyPI and npm APIs
The rule Waymark teaches Claude is one sentence: a member that isn't confirmed at your pinned version does not exist.
When Claude needs a library, it calls pkg_find with a description ("retry policy", "chat completion") and the workspace. Waymark takes the version your project pins (the lock file for Python and Node, the project file for .NET), downloads that exact package over HTTPS, checks its integrity hash where the registry publishes one, indexes its public surface, and deletes the download. Nothing is installed, imported or run. pkg_expand then returns the exact signatures, overloads and the package's own docs.
| Ecosystem | Read from | Version from | Docs from |
|---|---|---|---|
| NuGet | the compiled assembly | .csproj, Directory.Packages.props | XML doc comments |
| PyPI | the wheel, plus its stub package when untyped | uv.lock, poetry.lock, pdm.lock | docstrings |
| npm | declaration files, else @types | package-lock.json, pnpm-lock.yaml, yarn.lock | JSDoc |
Published docs and blog posts can still explain how to use an API. They never override a signature Waymark confirmed.
The other half: a prompt that makes Claude check its work
Waymark gives Claude ways to check its work. The model still has to decide to use them. Left alone, a model is happy to recall a method signature from memory, say "this should work", and move on.
So the repository ships the system prompt I use for everything: prompts/expert-programmer.md. It's about a hundred lines that turn Claude into a problem solver rather than a code generator:
- Find the real problem first. If an ambiguity would change the design, the data model or anything hard to undo, Claude asks before writing code. Otherwise it takes the conventional option and says which assumption it made.
- Think in failure modes. Before non-trivial work it names the three to five likeliest ways the change fails in production. "Add a search bar" also means debounce, empty, loading and no-results states, keyboard access and length limits.
- Verify, don't recall. Package signatures come from Waymark's
pkg_tools at the version the project pins, and web search is used only for how to use them. A change is checked by building it and running the tests. Anything Claude couldn't run, it reports as not verified. - Deliver a pull request, not a snippet. Claude produces complete code with no placeholders, and lists every file it touched along with what those edits require in callers, registrations, config, migrations and tests.
- Be honest. Claude reports only what it actually did and checked.
This pairing is the part I'd call magic. The prompt alone tells Claude to verify, but all it can verify against is the web. Waymark alone gives Claude the tools, but nothing makes it reach for them. Together they close the loop. The prompt's last section routes package questions to pkg_find, questions about the computer to cmd_shell, and every change to a build and a test run.
You can see it in this article. The research behind it ran with that prompt installed. Claude found the earlier draft's claim of "about 1,990 tests" and checked it before reusing it: it counted 969 [Fact] tests and 1,012 [InlineData] rows in the test project. It dropped a sentence it had no way to check. When it finished mapping the codebase, it said plainly that it had not re-read every one of the 121 flows, instead of calling the job verified.
To use it, paste the file into claude.ai under Settings, Profile, or into your CLAUDE.md. The same folder has two skills: effort-mirror makes Claude do substantial work the way a senior engineer would plan it, and prompt-smith writes and edits prompts.
What's new since v0.2
| Area | What changed |
|---|---|
| Memory | Flows and notes, saved by Claude and checked against the code; recall and memorise tools; a Flows and a Notes page per workspace |
| Search by meaning | Optional, with your own OpenAI, Gemini or Voyage AI key; off by default |
| Instructions | Your own instructions per workspace, next to the host prompt every agent reads |
| Platforms | macOS 14 or later (Apple silicon and Intel), alongside Windows 10 and 11 |
| Editing | file_replace: find and replace across files, previewed as a plan, then applied all or nothing |
| Code search | Finds code by what it does, using up to 64 words from each member's body; React handlers and hooks are indexed as their own members |
| Approvals | Desktop notifications on Windows and macOS when something waits; a dot in the browser tab |
| Clients | --stdio mode for clients that start a server themselves |
| Sharing | Export a workspace's flows, notes and access rules as one file, and import it elsewhere |
| Audit | Optionally keep each call's full input and output for 1 to 30 days, opened in a side panel |
| Quality | About 1,980 test cases, run on Windows and macOS for every change |
| Prompts | The system prompt and skills I use daily, in the repository's prompts folder |
How it's built, for the curious
Waymark is a .NET 10 modular monolith: one program, built from projects with strict rules about who may know whom. Each module (Code, Packages, Files, Commands) depends only on Core, talks to the others through small in-process events, and ships its own guide for Claude. Only the Data project touches SQLite, and every write goes through one ordered writer, so there are no "database is locked" errors.
- Parsing: Roslyn for C#, tree-sitter for Python, TypeScript and JavaScript. Syntax only; nothing is compiled or executed.
- Storage: one SQLite file on your machine, with numbered migrations. The index stores structure and words, never lines of code.
- Admin UI: Blazor Server with MudBlazor, live over a socket, on localhost only.
- Protocol: the official MCP C# SDK, over HTTP for claude.ai and Claude Code, or
--stdio. - Secrets at rest: Windows DPAPI, or on macOS an AES-256-GCM key ring under a master key in your login Keychain.
The fastest way to learn the code is the way I did on that Sunday: add Waymark's own repository as a workspace and ask Claude to map it.
Get started in five minutes
Waymark is free and MIT licensed. You need git, ports 47100 and 47101 free, and, for claude.ai on the web, a free ngrok account. The installer adds the .NET 10 SDK if it's missing.
Windows 10 or 11
git clone https://github.com/patilprashant6792-official/waymark-local.git cd waymark-local install.cmd macOS 14 or later. Keep the clone outside Documents, Desktop and Downloads.
mkdir -p ~/source && cd ~/source git clone https://github.com/patilprashant6792-official/waymark-local.git cd waymark-local bash install.sh The admin page opens at http://localhost:47100. Then:
- Add a workspace: any project folder Claude may read. An empty folder works too.
-
Connect Claude Code with one command, then approve the pairing on the Approvals page:
claude mcp add --transport http waymark http://localhost:47101/mcp Or connect claude.ai: paste your ngrok address and authtoken on the Setup page. Waymark installs and starts ngrok itself and proves the address reaches your machine. Then add the connector address it shows in claude.ai under Customize, Connectors, and match the pairing code.
Ask Claude about your code and watch it on the live log.
Before you install, read docs/safety.md. Waymark gives an AI real access to your computer, and you should know exactly what that means.
FAQ
Can Claude on claude.ai access files on my computer?
Not by itself. With an MCP server like Waymark added as a custom connector, it can read and change the projects you add, through a tunnel you own, with every call gated and logged. Custom connectors need a Claude plan that allows them.
What is an MCP server?
The Model Context Protocol is the open standard AI apps use to call tools. An MCP server offers those tools. Waymark is one that runs on your own machine.
Is Waymark an alternative to Claude Code?
No, use both. Claude Code connects to Waymark locally in one command and gains cross-repository search, checked package APIs, flow memory and per-operation gates. claude.ai gains your machine.
Does my code get uploaded anywhere?
The index, the memory and the audit trail stay in one SQLite file on your computer. Only what a tool returns reaches your Claude chat, with secrets hidden first. Search by meaning, if you turn it on, sends the text of notes and flows to the provider you chose, never file contents.
Can Claude run commands without asking me?
Only what you set to Auto. By default builds and read-only operations run, tests and installs ask, and every shell script always asks.
Can Waymark replace my CLAUDE.md?
Mostly. Import it on the Notes page, pin the rules that must always apply, and keep a two-line CLAUDE.md that tells agents to call waymark_guide and recall first.
Which languages and platforms does it support?
C#, Python, TypeScript and JavaScript; NuGet, PyPI and npm; Windows 10 and 11, and macOS 14 or later. Not Linux yet.
What does it cost?
Nothing. Waymark is MIT licensed. You need a Claude plan, and a free ngrok account if you use claude.ai on the web.
One ask
I built Waymark to fix my own workflow, and I use it to build Waymark itself. If it breaks yours, tell me: the feedback button in the admin header opens a ready email in your own mail app. And if Claude keeps getting a package wrong, name the package and version in the comments. I'll run it through pkg_find and reply with what comes back.
patilprashant6792-official / waymark-local
Give Claude your Windows or Mac, under your control. Local MCP server for claude.ai and Claude Code: reads C#, Python, TypeScript and JavaScript, checks real NuGet, PyPI and npm APIs at your pinned versions, remembers how features flow, and edits, builds, tests and runs git or shell. Approve on your machine; secrets hidden. MIT.
Waymark
Give Claude your real codebase, not a guess of it.
Verified package APIs, a memory of how your code flows, and commands that wait for you.
From claude.ai or Claude Code, on your own Windows or Mac
Quick start · What it does · Why not just Claude Code? · Safety · All tools · Docs
Warning
Read this first. Waymark gives an AI assistant real access to this computer. What it reads can reach your Claude chat, and what it runs acts as you. Changes and commands wait for your approval by default, approvals can only be given on this computer, and secrets in tool results are hidden before they leave. None of that is perfect, so read docs/safety.md before you install, and see SECURITY.md to report a problem. This is early software, provided as is under the MIT License.
In one paragraph
Waymark is a local…











