Skip to content
[CODEBASE INTELLIGENCE FOR AGENTS]

Agents ship invisible bugs.Pharaoh catches them
so your users don't.

Equip your agents with a map of your codebase. Catch critical bugs before they ship.

Get started free

Your first repo is free. No credit card.

Ask about PharaohChatGPTClaudePerplexity

The problem

Agents work from fragments of your codebase. As your project grows, they get lost – and still produce code that looks right. Invisible bugs compound, vulnerabilities ship, and your users find them first.

The solution

Give agents the map.
Skip the file hunt.

Pharaoh maps your functions, modules and dependencies so your agents can get to the relevant code sooner.

  1. Connect your repo.

    Pharaoh builds a persistent map of your functions, callers, and dependencies.

  2. Give agents the map.

    Claude queries it through MCP, then reads the files it needs.

  3. Keep building.

    Push to your default branch and Pharaoh refreshes the map. No config files or per-repo setup.

Architecture benchmark

Same questions.
Less waiting.

2.5×faster answers
Without Pharaoh 33.4s
With Pharaoh 13.6s
average per questionseconds
65%less API spend
Without Pharaoh 17.0¢
With Pharaoh 5.9¢
average per questionUSD cents
Average per architecture question in the Pharaoh benchmark
Per questionWithout PharaohWith Pharaoh
Time33.4 seconds13.6 seconds
API cost17.0¢5.9¢
Expected answer items found100%100%
Methodology

Individual tasks in the same benchmark averaged 37.3s → 11.0s for blast-radius checks (3.4× faster), 12.5s → 5.8s for function lookup (2.1× faster), and 37.3s → 12.0s for entry-point tracing (3.1× faster). Function lookup compares an agent using Grep and Read with an agent using Pharaoh’s function search; these are complete agent-answer times. Tracing used an average of 15 file-tool calls without Pharaoh and 1 map query with Pharaoh, across three runs per condition.

Architecture questions on Pharaoh’s TypeScript repository, using Claude Opus 5.5. Three runs per question, with and without Pharaoh. The same model and file tools, scored against expected items from TypeScript compiler answer keys. These are average results for structural questions, not every coding task.

Costs use metered API pricing. On a fixed subscription plan, the benefit is less waiting and potential usage headroom; your subscription bill does not automatically fall.

See the benchmark →

See what Pharaoh brings to your code.

Try it on your code

Use Cases

Build faster.Ship with confidence.

Refactor, build, review, and debug with context
that reaches across your codebase.

See the blast radius before you change shared code. Get affected callers, routes, jobs, and database operations in one query.Blast radius · 37.3s → 11.0s

Migrate PriceQuote across our codebase.

get_codebase_map · commerce-platform
6 apps214 modules24,800 functions
  • web-app/
  • checkout-api/
  • billing/
  • refunds/
  • workers/
  • shared/
get_blast_radius · PriceQuote
28 affected callersacross 4 apps
├ checkout-api / price.ts12
├ billing / invoice.ts8
├ refunds / estimate.ts5
└ workers / reconcile.ts3
shared/price.ts · migrate the contract
- type PriceQuote = number;+ type PriceQuote = {+   amount: number; currency: string+ };
Update callers to use quote.amount.
Verify the affected flows
checkout
billing
refunds
reconciliation
28 callers migrated.4 application flows verified.
28 callers · 4 flows verified

Skip the grep → read → grep loop. Ask for a function and get its file, signature, and module in one lookup.Function lookup · 12.5s → 5.8s

Add subscription upgrades.

pharaoh_recon · subscriptions
Existing upgrade path found.
Follow the implementation already in this app.
Read only the relevant implementations
billing/plans.ts:42changePlan()
billing/invoices.ts:18createInvoice()
payments/charge.ts:67chargeCustomer()
Reuse the existing billing path
changePlan(account, nextPlan)└ createInvoice(account, proration)  └ chargeCustomer(invoice)
Preserve the payment guarantee
await chargeCustomer({  invoiceId: invoice.id,  idempotencyKey: invoice.id});
Reuse the invoice key on every retry.
Upgrade creates one invoice
Retry does not charge twice
1 map query→3 targeted reads
Upgrade verified · billing reused

Start every subagent with a map of the codebase. Split work at module boundaries so API, UI, and tests can move in parallel.

Build password reset in parallel.

SHARED CONTRACT
POST /auth/reset{ email } → { sent }
API
api/auth/reset.tstoken + email delivery
UI
app/reset/page.tsxrequest + success states
Tests
tests/auth-reset.tsrequest through token use
WORKING IN PARALLEL
◆ API
▲ UI
● Tests
◆ API ✓▲ UI ✓● Tests ✓
↓ integrate against the shared contract
✓ Integration passedRequest → email → token → password resetAPI, UI, and tests verified together.
API + UI + tests · integration passed

Review how changed code behaves across the whole application. Trace leaked keys to client code, find missing auth checks, and catch dead or duplicate code.

Review the latest checkout changes.

☥
Map changed code + affected pathsSecurity, privacy, and tests share the context.
[security]verified
POST /webhooks/payments
└─ processEvent() → updateSubscription()

HIGHUnsigned events can change subscriptions.

[privacy]verified
checkout → logRequest() → production logs

MEDCustomer email reaches the log sink.

[tests]gap found

Unsigned-event regression test is missing.

✓ Review complete2 verified findings · 1 regression gapSignature check + regression test ready to plan.
2 verified findings · 1 test gap

One map query finds the routes, webhooks, and jobs that reach a failing function.Tracing · 37.3s → 12.0s · 15 tool calls → 1

Fix checkout after session expiry.

pharaoh_recon · checkout, sessions
CheckoutUIsubmit
├ API /checkout401
├ refreshSession()200
├ retryRequest()401
└ sessionStoragenew token
Inspect refresh and retry together
auth/refresh.ts:31token stored ✓
api/retry.ts:57stale argument
api/retry.ts · cause found
const token = getToken();await refreshSession();return retry(token); // expired
The retry still receives the old token.
Read the refreshed token before retrying
- return retry(token);+ return retry(getToken());
Expired session refreshes
Retry uses the new token
Checkout regression passes
Fixed api/retry.ts
Checkout regression passes

Follow reachability from production entry points. Surface whole chains of unused functions, exact duplicates, and complex code with no direct test links.

Audit this codebase. Where should I start?

75% verified18 / 24 priorities · 6 remaining
CODEBASE OVERVIEWNOWPREV.
Dead-code candidates4.8%5.2%
Duplicate clusters47
Untested recovery paths35
Exposed credentials1 !0
FIRST PRIORITY · EXPOSED CREDENTIAL
Payment secret reaches the browser. billing.ts:12 → client entry → public bundle PAYMENT_API_KEY = ••••••••
› Move server-side → rotate → verify.Audit saved · 6 prioritized actions
6 open priorities · first fix identified

Free on your first repo.

Every analysis tool on your first repo. Upgrade when you need more.

Free

$0

Your first repo. No credit card.

  • Every analysis tool
  • One live repo, updated with your default branch
  • TypeScript, JavaScript + Python
Get started free

Personal

$27/mo

For your personal GitHub account.

  • Every personal repo live
  • Your agents search across your repos
  • PR Guard on your pull requests

Pays for itself if you save5 minutes a weekAt $75/hour.

Get started free

Team

$99/mo

For one GitHub organization.

  • Every organization repo live
  • Everyone in the org, one bill
  • Cross-repo context + PR Guard

Pays for itself if you save19 minutes a weekAcross the team, at $75/hour.

Get started free
How this works

These figures show the time you would need to save for the plan to pay for itself at your chosen hourly value. Team counts the total across all members. Monthly price ÷ hourly value × 60 ÷ 4.33 weeks, rounded up to a whole minute. Use the same currency as the plan prices. This is a break-even calculation, not a prediction of time saved.

A few more answers.

How do I get started?
Install the GitHub App, choose your repositories and connect your coding agent from the guided setup. Your first map builds automatically; setup shows progress, with timing depending on repository size and the mapping queue.
I installed it. How do I connect my agent?
Installing the GitHub App maps your code, but your agent still has to connect to the map. Open setup and pick your agent. Claude Code takes one terminal command, and Cursor, Codex, VS Code or any other MCP client connects with the Pharaoh URL and a GitHub sign-in. Setup shows when your agent is connected.
Does it work with my coding agent?
Pharaoh works alongside Claude Code, Cursor, Codex and other MCP clients. It gives your agent a persistent map of functions, dependencies and detected callers to use alongside its existing code search.
What languages does Pharaoh support?
TypeScript, JavaScript and Python. Pharaoh maps functions, imports and detected call relationships; dynamic behavior and framework configuration can leave gaps.
Can I use it with private code?
Yes. You choose which GitHub repositories Pharaoh can read; it cannot push commits or edit your files. Temporary clones are deleted after mapping, and the stored graph contains structural metadata rather than source files or function bodies. Security details.
How does the map stay up to date?
Pushes to your default branch automatically queue a refresh. Results show the last completed map and its refresh time, covering pushed code on that branch rather than local edits or unmerged branches.
What do Free, Personal and Team include?
Free keeps one repository live with every analysis tool and no credit card. Personal covers your authorized personal repositories; Team covers one GitHub organization and its members. Both paid plans add cross-repo queries and PR Guard. Compare plans.
Will Pharaoh lower my API bill?
Pharaoh can reduce the file reading and token use needed to answer structural questions; our benchmark measured 2.5× faster answers and 65% lower API spend. Results depend on the task and repository, and a fixed subscription plan does not automatically become cheaper. See the comparison.
What happens if I cancel?
Cancel through Manage billing; paid access continues until the end of your billing period. You then return to Free with one live repo; other maps become inactive and are scheduled for deletion after 30 days.
Works with Claude · Cursor · OpenClaw · Codex · Any MCP client

Developer stories

Less spend. Less waiting.
More building.

  • The difference I’d notice is the waiting. About 14 seconds instead of 33. Ask how the code connects, get the answer, keep going.

    Per architecture question

    Sam H.CEO / Greenlight Essentials

  • For five engineers, about $1,166 less API spend a month would make this an easy call. The faster answers are a bonus.

    5 engineers · 100 questions each / workday

    Henry B.Founder / Levanto

  • I’m building solo, so every tool has to earn its place. About $233 less in API spend a month would cover Personal with room to spare.

    Solo · 100 architecture questions / workday

    Joe D.SWE / Freelance

  • It’s all the little pauses. Across three engineers, those could add up to about 35 hours less waiting a month. Less time watching a spinner, more time in the editor.

    3 engineers · 100 questions each / workday

    Panesh J.CEO / Intelliminds AI

  • We tried a couple of open source options before a friend suggested Pharaoh. It plugged straight into OpenClaw. Our repo mapped in seconds. Eight engineers, no new workflow to learn.

    8 engineers · OpenClaw

    Richard V.Founder / Hobble

  • I was skeptical, so I checked the open source parser. One map for Claude and Codex. We switch between them on the same monorepo. No extra process for either of us. Never going back.

    2 engineers · Claude + Codex · Monorepo

    Zach W.CEO / Titan

Try it on your own code.

Map your first repo free. Ask the question you would normally spend time tracing through files.

Get started free

Every analysis tool. One live repo. Free.