source-proven
Complete PX command inventory
The page was compared with the live PX 0.1.175 command registry: 117 unique command names, zero missing, zero extra, and zero registration-status mismatches.
px-commands-all:0.1.175:117-of-117
PX Information Guide · Proven Inc
PX — Agentic Code Intelligence
What PX actually does for a company.
A plain-language field guide to the problem PX solves, what makes it different, how an agent experiences it, and every capability behind the product.
The one-sentence pitch
Say this first, before any feature list:
"Right now, every AI coding assistant your developers use — Cursor, Copilot, Claude Code, whatever — has to re-learn your entire codebase from scratch, every single time it's asked to do something. PX fixes that by pre-mapping the whole codebase once, so every AI tool your team uses gets instant, accurate answers instead of guessing or hallucinating."
Everyone is trying to make the model smarter. PX makes everything around the model smarter.
Reading code and understanding a codebase's structure are not the same skill. A model can read every line and still miss that a Delphi unit reaches a SQL routine three layers away, because that fact is not written in one file. It lives in the graph.
Precompute once
PX maps symbols, callers, callees, side effects, docs, changes, and cross-language boundaries once. Every agent inherits that structure instead of rebuilding it inside an expensive context window.
Not another RAG layer
Semantic and neural relevance help find meaning. Exact graph evidence establishes where code lives, what touches it, and which boundaries the answer actually covered.
Receipts, not confidence theater
An answer can carry the route that won, the evidence used, the known uncertainty, and the next bounded command. The reasoning path becomes inspectable and reusable by another agent.
One connected software system
PX can follow TypeScript to a Rust HTTP handler, onward to PostgreSQL, across messages, FFI, docs, tests, and repos. These are graph facts that a larger prompt does not automatically recover.
What the agent experiences
The agent does not need to memorize 117 commands. It starts with one question. PX selects the lane, returns evidence, and recommends the next safe step.
1. AskNatural-language question with exact anchors preserved.
2. RouteExact, graph, semantic, neural, docs, runtime, or recovery lane.
3. ComposeDefinitions, references, effects, boundaries, history, and current-tree evidence.
4. ReceiptWhat ran, why it won, what is covered, and what remains uncertain.
5. ContinueOne bounded next command instead of another blind repository search.
Where the token savings come from
PX's deterministic retrieval does not call a language model. It avoids repeatedly feeding the same discovery files into every agent session. The agent still uses model tokens to reason and write; it spends fewer of them rediscovering the repository.
The honest sales claim is structural: PX retrieval itself uses zero model tokens. The customer-specific savings percentage must be measured from real tasks, models, cache pricing, and repository size.
Customer savings model
avoided discovery tokens
× agent tasks per month
× input price per token
= avoidable discovery spend
Then measure the larger value: faster first useful answer, fewer wrong edits, and fewer repeated investigation loops.
× agent tasks per month
× input price per token
= avoidable discovery spend
Then measure the larger value: faster first useful answer, fewer wrong edits, and fewer repeated investigation loops.
The problem you're selling against
Every company using AI coding tools today has this exact pain, whether they've named it or not:
AI agents waste time "exploring"
Every session, the AI has to open files, search text, and guess how things connect — burning time and money re-discovering things it already "saw" last week.
AI agents make things up
When an AI can't find something, it often guesses instead of admitting it doesn't know — leading to confidently wrong code changes.
No one can check the AI's work
If an AI says "I checked X and Y," there's usually no way to verify that's actually true or see its reasoning.
Big, multi-team codebases are invisible
Nobody can quickly answer "did two teams build the same thing twice?" or "what will break if we change this?" across a large company's systems.
What to sell: the client-facing feature set lead with these
These are the commercial, sellable capabilities — described the way a non-technical buyer or a technical decision-maker (CTO, VP Eng) would understand them. Internal/LLM-runtime-only tooling is intentionally excluded below.
Instant Onboarding for AI Agents
The moment an AI tool touches a codebase, PX hands it a "here's everything you need to know" briefing — instead of the AI wasting the first 30 minutes exploring blindly.
Sells to: engineering leaders frustrated by slow AI ramp-up
Smart Question Routing
When someone (or an AI) asks a question in plain English, PX figures out exactly what kind of question it is and routes it to the right, precise answer — instead of the AI guessing which tool to use.
Sells to: teams tired of AI picking the wrong approach
Exact Code Map ("who calls what")
Instantly shows what calls a piece of code, what it calls in turn, and what would break if it's changed — the stuff developers normally spend hours in Slack and grep figuring out.
Sells to: any team doing refactors, audits, or onboarding new devs
Honest "I Don't Know"
If PX can't find something, it tells you exactly why — never used, not yet scanned, changed recently, or searched the wrong way — instead of a flat "no results" or a made-up answer.
Sells to: companies burned by AI hallucination before
Receipts On Every Answer
Every answer comes with a paper trail showing exactly what was checked and why — so a human can double-check the AI's work instead of blindly trusting it.
Sells to: regulated industries, compliance-conscious buyers
Safe-to-Automate Labels
Every capability is tagged as "safe to let the AI run on its own" or "needs a human to check first" — so companies can let AI move faster without losing control.
Sells to: companies nervous about giving AI too much autonomy
Cross-Language Tracing
Follows a single feature across the entire stack — the button click, the backend route, and the database query underneath — as one connected story, across different programming languages.
Sells to: companies with mixed tech stacks (frontend + backend + database)
Automatic Architecture Diagrams
Generates up-to-date system diagrams showing how everything fits together — without anyone manually drawing or maintaining them.
Sells to: teams that need architecture docs for audits, onboarding, or investors
Multi-Team / Multi-Repo Visibility
For larger companies with many codebases and teams, PX can answer questions across all of them at once — e.g. "did two teams build the same feature separately without knowing it?"
Sells to: enterprises, larger engineering orgs (10+ repos/teams)
Plan → Predict → Verify Workflow
Before an AI makes a change, PX can predict what might break and flag the risk level. After the change, it verifies the work actually matches what was planned.
Sells to: teams letting AI make real code changes, not just suggestions
Self-Updating Documentation for AI
Turns a company's existing docs into something AI tools can actually search and cite accurately, instead of ignoring outdated docs or making up "how things work."
Sells to: companies whose docs are messy, outdated, or scattered
Self-Health Check
PX can check itself and tell you if something's out of date or misconfigured — reducing the "why isn't this working" support burden.
Sells to: any buyer worried about maintenance overhead
What NOT to lead with internal / keep in back pocket
These exist in the tool but are tied to internal infrastructure (FoxFlow/Qwen/FDAG) or are deep internal plumbing. Don't put these in a sales deck unless a buyer specifically asks about running their own private AI model infrastructure.
| Internal capability | Why to keep it out of the pitch |
|---|---|
| FoxLLM / Qwen runtime tools | Tied to a specific internal AI model deployment, not a general buyer need |
| FDAG / Code Witness | Internal agent-memory and audit internals — too deep in the weeds for a first pitch |
| FoxGres fleet tools | Specific to one internal database fleet setup |
| Snapshot / diff / build / verify-index | Low-level internal maintenance plumbing, not buyer-facing value |
| Extract sub-commands (rust-refs, esm-refs, etc.) | These are the "how it's built," not "what it does" — mention only if a technical buyer asks how indexing works |
Objection handling (plain language)
"We already use Cursor/Copilot/Claude Code."
Good — PX isn't a replacement, it plugs in alongside whatever AI tool they already use, and makes that tool smarter and faster on their specific codebase.
Good — PX isn't a replacement, it plugs in alongside whatever AI tool they already use, and makes that tool smarter and faster on their specific codebase.
"Doesn't this cost a lot of AI tokens/API calls?"
The opposite — PX's core lookups don't use AI at all, so it actually reduces AI token spend by skipping repeated re-discovery work.
The opposite — PX's core lookups don't use AI at all, so it actually reduces AI token spend by skipping repeated re-discovery work.
"How do we know it's not making things up like other AI tools?"
Every answer comes with a receipt showing exactly what evidence was used, and it explicitly says when it doesn't know something instead of guessing.
Every answer comes with a receipt showing exactly what evidence was used, and it explicitly says when it doesn't know something instead of guessing.
"We're a small team, is this overkill?"
The core onboarding, question-answering, and code-mapping features help even a single small repo — the multi-team/enterprise features are optional upsells.
The core onboarding, question-answering, and code-mapping features help even a single small repo — the multi-team/enterprise features are optional upsells.
Who to sell this to
| Buyer type | What they care about | Lead feature |
|---|---|---|
| CTO / VP Engineering | Developer velocity, AI ROI | Instant onboarding + honest zero-results |
| Engineering managers | Faster refactors, safer changes | Code map + plan/predict/verify workflow |
| Compliance / security leads | Auditability, control over AI autonomy | Receipts on every answer + safe-to-automate labels |
| Enterprise IT / platform teams | Visibility across many teams and repos | Multi-team/multi-repo visibility + architecture diagrams |
Complete PX command reference 117 / 117 included
The sections above explain what a company buys. This reference shows the complete product surface behind it, including planned, router-only, and private runtime capabilities so nothing is hidden or rounded up.
Reflex The smallest surface an agent needs to begin.6 commands
px ask ◆
Ask in plain English; PX picks the lane and answers with evidenceThe answer arrives with a route receipt explaining why this lane won over the others. You can audit the tool's choice, not just its output.
available
px ai
Single AI entry point returning a structured answer envelope
available
px xray ◆
Every signal about a target, in one callBuilt for prompt economics: one invocation emits what an agent would otherwise gather across a dozen calls, each burning context.
available
px impact
What breaks if I change this?
available
px callers
Who calls this?
available
px brief ◆
Build a paste-ready worker briefing for owned targetsPackages callers, impact, contracts, diagnostics, and current-tree provenance before a worker starts.
available
Daily driver Definitions, context, effects, evidence, health, and recovery.31 commands
px explain-miss ◆
Is this empty result real, or did the index miss it?Every other code tool reports absence as fact. This is the difference between an agent that maps your architecture and one that invents it.
available
px mistakes
Common query mistakes plus recent misses in this repo
available
px next ◆
Given what just happened, what should I run next?PX is opinionated about its own use. The tool tells the agent how to keep going instead of leaving it to guess.
available
px init
Point PX at a fresh repo and get the exact setup path
available
px explore ◆
Orientation packet for an agent that has never seen this codeCold start is where agents waste the most context. This replaces an hour of blind exploration with one structured packet.
available
px agent
Generate or read a repo-specific agent briefing
available
px investigate
Answer a broad architecture question by composing several lookups
available
px callees
What does this call?
available
px effects
What side effects does this function actually have?
available
px context
Render a context brief sized for a coder or reviewer agent
available
px query
Direct query against the reference index
available
px xref
Search every indexed repository at once
available
px plan-change
Phased, safe plan for changing a symbol
available
px audit
Dead code, hotspots, coupling, overall health score
available
px doctor
Self-check that PX is installed, configured and current
available
px status
Repo path, index state and record counts
available
px stats
Index statistics
available
px refresh
Fast partial index update, no full rebuild
available
px rebuild
Full two-stage index rebuild in one command
available
px db-profiles
Database sources PX treats as truth for a project
available
px batch
Run several commands in one call
planned
px test-coverage
Which tests actually exercise this symbol
planned
px taint
Trace untrusted input to a sensitive sink
planned
px sbom
Dependencies you actually reach, not just declare
planned
px exposure
Input tracing combined with dependency reach
planned
px invariant
Rule checks over indexed facts
planned
px evolve
Risk for a file based on how it has changed over time
planned
px types
Type and scope at a source position
planned
px risk-forecast
Risk across everything changed since a given point
planned
px risk
Supply-chain and data-flow risk cockpit
planned
px repair
Turn failing logs into a repair plan — never applies it
planned
Change workflow Understand, plan, predict, constrain, verify, and hand off.24 commands
px simulate ◆
Predict what a change breaks, without touching codePredicted failing tests and a risk score before the edit exists. The review moves in front of the work instead of behind it.
available
px verify ◆
Check a finished edit against the index and return a verdictCross-checks the result against the plan that authorised it. An agent cannot quietly drift from what it said it would do.
available
px flow ◆
Run the whole chain in one call with linked receiptsReceipt lineage threads across all four steps, so the trail from question to verified change survives as one auditable object.
available
px products ◆
Report product boundaries that evidence or historical names could blurVerifies whether names such as PX Lite are agent-accessible products, proof-only boundaries, or retired aliases.
available
px understand
Symbols, call graph, impact and recent edits for a target
available
px plan
Ordered edit plan with rationale, risks and doc updates
available
px report-last-route ◆
The receipt showing why the last question routed as it didTurns a routing decision into a reproducible packet. When PX gets it wrong, you can prove how.
available
px calibrate ◆
Re-tune routing against the index's own ground truthThe system corrects its own routing from verifiable graph facts rather than accumulated heuristics. Harder to mislead, by mechanism.
available
px report-last-deep
Execution packet from the last deep run
available
px report-miss
Reproducible packet for a suspected miss
available
px report-last-miss
Re-render the most recent miss packet
available
px session
Session contracts, handoff gates and dispatch pre-checks
available
px fleet
Readiness packets across machines and repositories
available
px benchmark ◆
Quality benchmark suites for measuring PX itselfIncludes agent-lift: whether a weaker model outperforms its own baseline once PX is in the loop.
available
px feedback
Which commands actually helped, collected from agents
available
px tools
Record what worked, so the surface improves with use
available
px onboard
Onboarding flow shortcuts
available
px contradiction-court ◆
Check an agent's claims against the evidence it citedAdversarial review as a command. The agent's own citations are tested against its conclusions.
planned
px confidence-budget
Turn explicit risk inputs into a go / no-go verdict
planned
px permit
Does this proposed edit stay inside its boundary?
planned
px mission-pack
Execution-control pack for an autonomous agent
planned
px transitions
Did the suggested next step actually work?
planned
px about
Structured documentation for any single command
available
px audit-self
Check PX's own index for decay
planned
Analysis Whole-project architecture, comparison, health, and refactoring.14 commands
px recommend-refactors ◆
Ranked action list composed from every other signalNot a linter. It fuses coupling, hotspots, naming, dead code and impact into one prioritised list.
available
px path-deps ◆
How much of each dependency do we actually use?The question that decides upgrades, removals and vendor risk — and one almost nobody can answer without guessing.
available
px impact-rename
Mechanical rename, or a change of role?
available
px naming
Symbols that break their own module's style
available
px arch-patterns
Detect known architectural patterns in the codebase
available
px diagnostics
One query across every language server at once
available
px prospect
Rank files and clusters by likely buried value
available
px compare
Compare two projects and find what one can take from the other
available
px manifest
Extract what this project actually offers as capabilities
available
px estimate-refactor-loc
Blast radius, in lines, for changing a symbol
available
px c4
Generate C4-style architecture diagrams
available
px graph
Interactive call graph, directory tree and architecture views
available
px adapt
Scan repos for places a shared pack could apply
planned
px pack
Check a portable pack for structure and safety
planned
Documentation Documentation atlas, authority checks, and evidence packs.2 commands
px docs ◆
Documentation atlas, synchronization checks and context packsAnswers can be forced to reconcile with the project's own documentation, and out-of-sync docs are flagged rather than trusted.
available
px evidence
Ingest and inspect observed tool-run evidence
available
Language & boundary coverage Extractors and cross-language edges that build the graph.22 commands
px cross-lang-http ◆
Pair backend routes with the frontend callsites that hit themA TypeScript fetch to a Rust handler becomes one edge. Reconstructing that by hand is an afternoon of grep and Slack.
available
px cross-lang-sql ◆
Pair application queries with the database routines they callApplication code to stored procedure, across language boundaries. Where most 'full-stack' understanding quietly stops.
available
px cross-lang-ffi
Pair native functions with their JavaScript consumers
available
px cross-lang-message ◆
Pair message publishers with their subscribersEvent-driven systems are exactly where static analysis usually gives up. Literal channel names are paired; dynamic ones are honestly out of scope.
available
px pascal-refs ◆
Pascal and Delphi units and call sitesLegacy language coverage almost nobody offers — and the codebases most in need of an agent that understands them.
available
px atl-refs
SAP data-integration references
available
px extract
Parent command for every extractor
available
px index
Index a repository into the code graph
available
px references
Language-server-backed “who uses this symbol”
available
px call-refs
Function and method call edges across files
available
px type-extract
Type-aware signatures for every function
available
px rust-refs
Rust imports and type references
available
px esm-refs
JavaScript and TypeScript import edges
available
px js-truth
Resolver-backed JS/TS import truth, runtime and type-only
available
px java-refs
Java imports resolved through to files
available
px sql-refs
References from application code to SQL objects
available
px pg-functions
Database routine definitions and cross-references
available
px metal-refs
Application code to GPU kernel references
available
px script-refs
Shell script path references across the repository
available
px extract-effects
Side-effect facts across Rust, JS, TypeScript and Python
available
px extract-docs
Parse Markdown documentation into the graph
available
px agent-contracts ◆
Tests, fixtures, schemas and migrations as first-class referencesTreats the things that define correctness as part of the graph, not as files that happen to sit nearby.
available
Platform Shared serving, incremental build, integrity, and shell support.6 commands
px serve ◆
Expose the index as a JSON API for remote and multi-machine useTurns PX from a local CLI into shared infrastructure. Every agent on every host queries the same understanding.
available
px snapshot
File fingerprint snapshot for incremental rebuilds
available
px diff
Diff two snapshots to see what changed
available
px build
Build artifacts from the reference store
available
px verify-index
Structural integrity check on the index
available
px completions
Shell completion for every major shell
available
Routed capabilities Capabilities selected by the question router rather than memorized.7 commands
px session-prep
Worker briefing packet for an active session
routed
px reachable
Reachability evidence for database objects
routed
px phase-coverage
Coverage audit across capability phases
routed
px orphan-status
Extractors built but not yet wired into rebuild
routed
px file-claims
Which agent has claimed which file
routed
px c4-container
Which architectural container a symbol belongs to
routed
px type-signature
Type complexity signature lookup
routed
Internal runtime Private operator surfaces included for inventory honesty, not the public pitch.5 commands
px foxllm
Local model runtime bringup and operator cockpit
available
px qwen-nav
Deterministic model promotion navigator, read-only
available
px fdag-v3
Replay evidence and agent-memory inspection
available
px witness
Code-change receipts and graph packets
available
px foxgres-fleet
Database fleet versions and upgrade planning
available
No command matches that search.
Appendix: The full capability count for technical buyers
If a technically curious buyer (usually an engineer or CTO) asks "what's actually in this thing," this is what to tell them — without dumping raw internal command names into the conversation.
117total capabilities catalogued
91ready to use today
19catalogued for development
110/117can't touch or change code at all
The complete inventory is intentionally wider than the opening sales story. Buyers first see the outcomes; implementation teams can then inspect every available, planned, routed, and private operator surface without pretending they are all the same kind of capability.
- Reflex + daily driver: 37 commands for questions, orientation, graph lookups, recovery, and repo health
- Change workflow: 24 commands for understand → plan → simulate → verify, receipts, handoffs, and governance
- Analysis: 14 commands for architecture, comparison, refactoring, dependency use, and system health
- Docs + language boundaries: 24 commands for the documentation atlas, language extractors, and cross-stack edges
- Platform + routed + private runtime: 18 commands for serving, index integrity, routed capabilities, and internal operator needs
The complete command reference is included directly above. Exact CLI syntax, JSON schemas, and automation flags remain available in the engineering handbook for implementation teams.