Skip to content
5.1M+ mapped lines

Your AI breaks things it can't see

Pharaoh maps your entire architecture into a knowledge graph your AI queries before writing a single line.

Get started free See it work
Works with Claude · Cursor · OpenClaw · Codex · Any MCP client
claude code — pharaoh
▐▛███▜▌ ▜█████▛▘ ▘▘ ▝▝ Claude Code with pharaoh codebase intelligence
✳ Claude Code pharaoh connected

AI agents have a context problem. You tell them to build and they read 3,000 lines of irrelevant code before getting started. Pharaoh gives agents a map of your codebase - what connects to what, what breaks if you change it, what already exists - so your AI gets 10x further without hallucinating.

5,144,963
Lines of code analyzed
118,046
Functions mapped
17,025
Issues found

Full architecture context before line one

Your AI queries the full module context before writing a single line. Functions, dependencies, endpoints, env vars - the real system, not three random files.

Every change checks what it breaks

Before your AI touches shared code, it knows exactly what depends on it. Direct callers, transitive impact, affected endpoints and crons.

No more duplicate code

Your AI searches the entire codebase for existing functions before writing new ones. If it exists, it imports it. If it doesn't, it creates it in the right place.

Dead code found automatically

Unreachable functions, unused exports, orphaned modules - surfaced on every query. Your AI knows what to delete before your next PR.

The architecture gap

Your AI reads files. Pharaoh reads how they connect.

Without Pharaoh
With Pharaoh
Knows what depends on what
✗ Guesses
✓
Checks what breaks before changing code
✗
✓
Finds existing code before writing new
✗ Writes new
✓
Remembers your codebase between sessions
✗ Forgets everything
✓
Finds dead code in your repo
✗
✓
Verifies new code is wired in
✗
✓
Cross-references code across multiple repos
✗ One repo at a time
✓
HOW IT WORKS
1

Pharaoh maps your architecture

On every push, Pharaoh parses your code into a knowledge graph — functions, dependencies, module boundaries. No source code stored.

2

Your AI queries the map

Instead of reading files one at a time, your AI asks the graph: what connects to what, what breaks, what already exists.

3

Changes are informed, not guessed

One graph query replaces 20+ file reads. Your AI goes straight to the right files with full architectural context.

See exactly what gets mapped

Pharaoh's parser is open source. Every function extracted, every dependency traced, every module boundary detected. Verify it yourself.

View pharaoh-parser on GitHub →

Not another code search tool

Sourcegraph finds code. SonarQube lints code. Pharaoh tells your AI what happens when it changes code — blast radius, dependency chains, reachability from production entry points. The architecture layer that's been missing.

What developers ask their codebase
Refactor without fear
“What breaks if I refactor the auth middleware?”
Scope the blast radius
“Show me every caller of this function across all modules”
Stop reinventing
“Does a retry helper already exist somewhere in this codebase?”
Onboard in minutes
“What modules exist and how do they connect?”
Ship with confidence
“How risky is shipping this change to production?”
Delete dead code
“Which functions are never called from any entry point?”
Kill the clones
“Where is there duplicate logic I can consolidate?”
Catch spec drift
“What's specified in the PRD but not built yet?”
Plan the refactor
“Map the dependency chain before I extract this into its own module”
Find test gaps
“Which critical functions have no tests?”
Prep before you edit
“Show me everything about the payments module before I touch it”
Cross-repo intelligence
“Does our API repo have functions that drift from the SDK? Check both repos.”
Know your components
“What design tokens and UI components already exist?”
Refactor without fear
“What breaks if I refactor the auth middleware?”
Scope the blast radius
“Show me every caller of this function across all modules”
Stop reinventing
“Does a retry helper already exist somewhere in this codebase?”
Onboard in minutes
“What modules exist and how do they connect?”
Ship with confidence
“How risky is shipping this change to production?”
Delete dead code
“Which functions are never called from any entry point?”
Kill the clones
“Where is there duplicate logic I can consolidate?”
Catch spec drift
“What's specified in the PRD but not built yet?”
Plan the refactor
“Map the dependency chain before I extract this into its own module”
Find test gaps
“Which critical functions have no tests?”
Prep before you edit
“Show me everything about the payments module before I touch it”
Cross-repo intelligence
“Does our API repo have functions that drift from the SDK? Check both repos.”
Know your components
“What design tokens and UI components already exist?”

Get started in 60 seconds

One line of config. Full architectural context.

  1. 1. Add the MCP server to your AI tool
    $ npx @pharaoh-so/mcp
  2. 2. Authorize with GitHub and install the app
    First connection opens a browser window. Sign in with GitHub and install the Pharaoh app on your org.
    Install GitHub App →
  3. 3. Start building
    Your repos are mapped into a knowledge graph. Ask your AI about architecture — it actually knows the answer now.
    Open dashboard →

Frequently asked questions

Does Pharaoh store my source code?
No. Pharaoh stores structural metadata only — function signatures, file paths, import/export relationships, call edges, complexity scores. No source code, no comments, no string literals, no variable values. The parser is open source — you can audit exactly what gets extracted.
How long does initial setup take?
Under 5 minutes. Install the GitHub App, select repos, add the MCP endpoint to your AI tool. Pharaoh parses the codebase automatically. A 50K LOC TypeScript project maps in about 60 seconds.
How does the graph stay current?
A GitHub webhook triggers re-mapping on every push to your default branch. The graph is always within one commit of HEAD. You can also trigger a manual refresh from the dashboard.
What languages does Pharaoh support?
TypeScript and Python today, with full support for imports, exports, call chains, decorators, and barrel files. More languages coming — the parser is built on tree-sitter, which supports 100+ grammars.
How is Pharaoh different from Sourcegraph?
Sourcegraph answers "where is this code?" Pharaoh answers "what breaks if I change it?" Sourcegraph is search and navigation. Pharaoh is blast radius, dependency chains, and reachability from production entry points. Different tools, different questions.
How is Pharaoh different from CodeScene?
CodeScene analyzes file-level health using git history — complexity trends, code age, developer coupling. Pharaoh analyzes cross-module architecture using a knowledge graph — how modules connect, what depends on what, which functions are reachable from production. CodeScene is behavioral. Pharaoh is structural.
How is Pharaoh different from SonarQube?
SonarQube does line-level static analysis — bugs, code smells, security issues. Pharaoh does system-level structural analysis — blast radius, dead code via entry-point tracing, module boundaries. SonarQube looks at lines. Pharaoh looks at architecture.
Can Pharaoh work across multiple repositories?
Yes. Map multiple repos and your AI cross-references them automatically — finds duplicated code, catches when shared interfaces drift between services, and ensures changes in one repo align with implementations in others. No monorepo required. Each team member just connects to the same MCP endpoint.
Can I use Pharaoh with private repositories?
Yes. The GitHub App requests read-only access to repository contents. All graph data is tenant-isolated. Pharaoh never writes to your repository.
What happens if I cancel?
Your graph data is deleted. No lock-in — Pharaoh reads your code, it doesn't store it. Re-subscribing re-maps from scratch.
Do I need Pharaoh if I already use Claude Code or Cursor?
That's exactly who Pharaoh is for. Claude Code and Cursor are powerful, but they read files one at a time with no structural awareness. They don't know what depends on what, which functions are reachable from production, or whether the code they're about to write already exists somewhere else. Pharaoh gives them that context via MCP. Same tools, smarter decisions.
Is Pharaoh worth the subscription?
One prevented regression pays for months of Pharaoh. Without architectural context, AI tools introduce duplicate utilities, break downstream callers they can't see, and create exports that never get wired to entry points. Each of those costs hours of debugging. Pharaoh fixes the root cause — the AI's blind spot — for less than a single production incident.
Who built Pharaoh? Can I trust a small team with my code?
Trust shouldn't depend on team size — it should depend on architecture. Pharaoh never stores source code. Only structural metadata like function names and dependency edges. GitHub access is read-only. Tokens are encrypted with per-tenant keys. The parser is open source for full auditability. And if you cancel, your data is deleted — there's nothing to leak because there's no code to leak.

Pricing

One prevented regression pays for months.

Free
$0
8 core tools. Unlimited queries. No credit card.
  • Codebase Map
  • Module Context
  • Function Search
  • Blast Radius
  • Dependency Paths
  • TypeScript + Python repos
  • No source code stored
  • Encryption at rest
  • Read-only GitHub access
Get Started Free
Pro
$27/mo
All 16 tools. Find what's dead, duplicated, and drifting.
  • Everything in Free
  • Regression Risk
  • Check Reachability
  • Dead Code Detection
  • Consolidation Opportunities
  • Test Coverage Map
  • Vision Docs + Gaps
  • Cross-Repo Audit
  • Direct Slack line to the builder
Get Started →
PHARAOH © 2026
Parser Security Docs Manage Billing Terms & Privacy Blog
Open Source: pharaoh-parser · AI Codebase Boilerplate