Probably AGI

Enterprise context economics / editable scenario

Stop paying models to rediscover your company.

Saved today$16,096The rediscovery meter starts running with the first agent task.
Saved this month$489,600Repeated repository-reading costs compound across every developer.
Saved this year$5,875,200Input context the enterprise no longer has to purchase again and again.
Scenario estimate2,000 developers, 400 coding-agent tasks per month, 120K discovery tokens per task, 60% PX context reduction, and an $8.50 blended input-token price. Change every assumption below.
Same infrastructure, every scale
Deterministic demo replay / captured Delphi evaluation

Give it a codebase
you do not speak.

PX is not a bigger search box. An agent asks one hard question and PX composes the investigation: exact symbols, Pascal references, call graph, neural meaning retrieval and reranking, SQL literals, documentation authority, architecture boundaries, impact, and a reusable receipt.

One front door -> 345 registered actions -> one bounded answer
Claude logoClaude Code + PX / captured evidence replay
repository dataEssence language Delphi / Object Pascal scale 370K LOC / 62,631 symbols proof class captured evaluation
❯ claude
Human CLI is captured formatted output. Agent JSON is the captured machine envelope from the same question. Local checkout paths are redacted; the graph and takeaway are interpretation, not stdout.
What the agent received

A repository map, generated agent surfaces, documentation atlas, evidence coverage, and one bounded first investigation.

Run next px ask --space dataEssence --json "Which forms bypass CodeBL and access udmDatabases directly?"
PX self-composed evidence route
interpreted evidence graph 0 nodes / 0 paths active
question + arbitration
specialized evidence lanes
coverage + receipt
Questioninput
natural_languageanchors.extract()intent.frame()
Route Courtjudge
routes.compete()winner = evidenceweaknesses.keep()
Exact graphstructural
definitionscallers + refs
Pascal lanelanguage
uses + inheritsforms + units
Neuralmeaning
embedding.search()rerank by intent
SQL seameffects
tables + literalsqueries + writes
Impactradius
tests + effectschange forecast
Evidence horizoncoverage
indexed truth+ current bytesabsence calibrated
Receipthandoff
next.runproof.saved
Route winnerarchitecture_flow
Composed actions7
Evidence classesexact / graph / literal
Coveragebounded answer + next move
Language becomes an implementation detail.

The same agent contract can traverse Delphi, Rust, TypeScript, SQL, Java, Python, and cross-language boundaries without teaching the model a new navigation ritual.

The graph is exact. The neural lane understands meaning.

PX uses structural evidence where exactness exists, embedding retrieval and reranking where names fail, and never lets neural similarity silently become proof.

The answer survives the model.

Coverage, weaknesses, selected lanes, evidence pointers, and the next bounded command become a receipt another agent can continue.

Repository knowledge plane / generated and governed

One scan.
A living atlas.

PX does not stop at code symbols. It ingests the repository's Markdown corpus, binds documentation sections to code and architecture surfaces, and generates agent-ready projections that live outside curated human docs.

The agent asks one question. PX composes exact graph + neural meaning + docs authority automatically.
$ px docs bootstrap --repo /workspace/company --space company --write-db --atlas --all-formats --json one bounded pass
Repositorycode, Markdown, routes, symbols, and boundaries
Sectionsheadings, links, claims, provenance, and authority
Bindingsdocs connected to symbols, files, systems, and changes
AtlasASCII, Mermaid, JSON, HTML, and system cards
Agentcompact context, conflicts, gaps, citations, and next action
generated isolation _docs/px/architecture/atlas.ascii.md
_docs/px/architecture/atlas.mermaid.md
_docs/px/architecture/atlas.json
_docs/px/architecture/atlas.html
what the next agent receives

px ask --with-docs returns the relevant code, the governing documentation, contradictions, coverage limits, and the next safe command instead of making every model reconstruct the company from raw files.

Generated docs stay separate.

PX writes machine-generated projections under _docs/px/, preserving curated human documentation and recording provenance instead of mixing both truth classes.

Documentation can be tested.

health, coverage, orphans, validate, claims, reconcile, and fs-check expose drift instead of letting old prose quietly govern agents.

No command memorization tax.

px ask routes into docs, graph, neural retrieval, current-tree evidence, or a composed investigation. The receipt tells the agent why and what to run next.

Independent review / actual code + outputs inspected

A different
category
of tool.

Honestly? This is a different category of thing than what most of the market is shipping right now.

Claude logo Codex logo Cursor logo GitHub logo Gemini logo JetBrains logo
External reviewer opinion
Product claims remain independently testable

Here’s the gap

Every major coding agent right now — Claude Code, Cursor, Copilot, Codex, Devin — solves the same problem the same way: bigger context windows, better retrieval, smarter grep. They’re all racing to make the model better at reading your repo. That race has a hard ceiling because reading code and understanding a codebase’s structure are not the same skill. A model can read every line of a 2-million-token monorepo and still not know that changing this Delphi unit breaks a downstream SQL trigger three layers away, because that fact is not in the text — it is in the graph.

What makes PX different

PX is not another RAG-over-code tool. It precomputes the graph once — callers, callees, cross-language boundaries, side effects, docs bindings, change history — and then lets an agent ask a single question and get back an exact, receipted answer instead of a pile of chunks to reason over. That is the real unlock: it moves the cost of understanding a codebase from “every agent pays it every time” to “pay it once, every agent after that inherits it for free.”

The receipt system

The receipt system is the part that should actually worry competitors. Nobody else is doing “here’s why this route won, here’s the evidence, here’s what’s uncertain, here’s the next bounded command” as a structural discipline. Most agent tools either give you a confident-sounding answer or nothing. PX’s whole “zero results are not proof” philosophy — checking the evidence horizon and literal fallback before declaring absence — is the difference between an agent that hallucinates architecture and one that says “I don’t know yet, here’s how to find out.”

The demo that sells itself

The cross-language boundary tracing is the demo that sells itself. Tracing a TypeScript fetch() call through an HTTP boundary into a Rust axum handler into a plpgsql function is exactly the kind of thing that takes a human engineer an afternoon of grep and Slack messages to reconstruct, and PX does it as a reviewed, structured edge in a graph. That is not a feature other tools have — it is a category of fact other tools do not even represent.

Where to temper the hype

The “hundreds of capabilities” framing undersells it once you know the real number. At review time the registry held 115 total and 87 runnable, because an honest number is more impressive to a technical buyer than a rounded one. A control plane that tells you exactly what is safe to auto-run versus what needs a human is selling discipline, and discipline sells better with precision than with “hundreds.”

Live generated ratchet: this page currently reads 116 command families, 90 runnable, and 345 registered actions. The earlier count remains attributed to its review snapshot.

Net take

The market is optimizing model intelligence. PX is optimizing the thing sitting next to the model — the substrate it operates on. That is not an incremental feature, it is a different bet entirely. If the agent-lift benchmark data holds up — PX making a weaker model outperform a stronger one without it — that is the number that turns “smarter context is the advantage” from a tagline into something a VC or an enterprise buyer can underwrite.

Pay once to understand the system. Let every agent inherit the graph, the meaning, and the proof.

The market helps agents find, write, and scan.
PX governs what they know.

This is not a fake winner-take-all chart. Coding agents, navigation, semantic retrieval, and static analysis are excellent at their advertised jobs. PX sits beside them and turns their evidence into an explicit route, coverage horizon, recovery contract, and reusable receipt.

Industry capability demonstration

Strong tools.
One remaining agent problem.

Choose a category. The live path shows what the industry surface contributes, where agent certainty can outrun evidence, and what PX adds without replacing the underlying tool.

Evidence moving through the agent stack
AI coding agents

Plan. Edit. Run. Patch.

The final answer can still hide which retrieval path ran, where context ended, and whether a claim exceeded the evidence.

PX makes the route, target identity, coverage, weaknesses, and next recovery step machine-readable.
PX evidence circulation

A question becomes a visible judgment.

The agent does not choose from a command wall. PX frames the question, arbitrates the lanes, preserves the evidence horizon, and returns one bounded continuation with a receipt another agent can reuse.

QUESTION natural language ROUTE COURT claim / evidence weakness / score EXACT + GRAPH symbols / callers NEURAL meaning / recovery DOCS authority / drift RUNTIME observed truth REPAIR typed recovery HORIZON covered / partial absence meaning NEXT 1 step
Industry surfaceGenuine strengthRemaining agent problemPX's role

Cursor logoJetBrains logoCursor / JetBrains AI

Project-aware AI context and semantic codebase indexing.

Retrieved context is optimized for answering, without an independent evidence horizon or typed zero-result meaning.

Expose route choice, coverage, weaknesses, and recovery before context becomes a conclusion.

GitHub logoGitHub Copilot

Repository research, plans, code changes, tests, commits, and pull-request workflows.

Autonomous execution is not the same as a reusable proof of why those files were inspected.

Give any agent the same route receipt, evidence horizon, brief, and verification packet.

Sourcegraph

Large-scale search and precise cross-repository code navigation; SCIP can provide compiler-derived definitions and references.

Navigation is one evidence lane. Agent tasks also cross docs, dirty bytes, SQL, HTTP, runtime, planning, and post-edit verification.

Compose those lanes and never call a partial index complete.

CodeQL / Semgrep

Queryable program models, data and control flow, security rules, reachability, and vulnerability triage.

Purpose-built analyzers are not a general agent entry, recovery, workflow, or evidence-lineage layer.

Route work to the analyzer, retain its proof class, and connect findings to impact, docs, tests, and closeout.

PX

Question framing, deterministic route arbitration, cross-lane composition, current-tree labels, typed recovery, and receipt-bearing workflows.

PX does not write the patch, replace compilers, or magically prove runtime behavior. It is only as strong as its connected sources and courts.

Make every agent faster to ground, harder to fool with partial evidence, and able to hand the next agent a reusable proof packet.

Competitive honesty: PX combines ideas that exist elsewhere: code graphs, semantic retrieval, static analysis, documentation search, and agent tooling. The differentiator is the product contract around them. Independent head-to-head productivity and accuracy benchmarks remain unknown; this page does not manufacture them.

Captured PX question graph / Delphi evaluation

Many questions.
One living map.

Fourteen real repository questions stay visible at once. PX connects each question to the route family that understood it, then to the bounded continuation handed to the agent. Click any question to inspect its exact path.

questions route families next commands recovery paths
Question → route → bounded continuation 14 questions
Selected question
Route
Run next

Incidental discovery / enterprise product contract

PX answers.
Then it notices.

While answering one question, PX already encounters evidence around it: duplicated capability, graph-unreachable code, contradictory facts, ambiguous targets, and architectural drift. Most tools discard that peripheral evidence. The target contract preserves it without hijacking the task.

Current / evidence substrate existsTarget / automatic capture heldRead-only observation
Ordinary question$ px ai --space company "who calls prediction_confidence?" --json
Requested answer

Caller path returned with a bounded continuation.

The agent receives the answer it asked for, its evidence horizon, and the next safe command.

Incidental finding

Two colliding definitions surfaced beside the answer.

PX does not guess or silently merge them. The proposed capture lane records the collision, confidence, locations, and cleanup recommendation.

Notice

Reuse evidence the ordinary query already fetched. No separate audit crawl.

Classify

Duplication, unreachable code, contradictory evidence, or architectural drift.

Triage

Interrupt only when urgency is high and the finding touches the active task.

Preserve

Append an evidence-linked observation to the truth layer. Never auto-promote it to truth.

Compound

Batch lower-urgency findings into closeout so the next agent inherits the signal.

Target structured observation

Every query becomes a free architecture audit.

The enterprise payoff is not another warning feed. It is model-independent organizational learning: every agent can leave behind a compact, attributable observation that future work can test, supersede, or resolve.

{
  "finding_type": "ambiguous_target_collision",
  "locations": ["router.rs:181", "forecast.rs:64"],
  "confidence": 0.94,
  "first_observed_by": {
    "command": "px ai",
    "question": "who calls prediction_confidence?"
  },
  "urgency": "medium",
  "action": "batch_at_closeout",
  "recommendation": "Resolve identity before impact analysis",
  "mutation_performed": false
}
No silent fixes. Observation and recommendation only.No flow interruption. Unless urgency is high and task-local.No extra hunt. Near-zero marginal cost from evidence already fetched.No fake truth. Append-only finding, confidence, provenance, and supersession.

Evidence,
not acreage.

95.7% measured context reduction across 5 real repository questions. Each line compares broad source-file context with the compact PX evidence payload.

Measured comparison / select a row above

who uses prepare_clean_head_snapshot

53.4%
BeforeComplete source context
3,844

          
AfterPX evidence payload
1,792

          
Input context removed2,052 tokens
PX routeWhoUses / hit
Measured latency545 ms

The complete agent surface

345 agent actions.
One front door.

Agents start with px ask --json. PX composes from 116 direct command surfaces plus validated continuations for exact graph work, docs authority, planning, verification, index truth, languages, runtime evidence, and fleet operations.

Start, route, recover

ask

Natural-language router with evidence receipts and one bounded next step.

px ask --space myrepo --json "What breaks if CheckoutService changes?"

PX / agentic code intelligence

Smarter models are inevitable.
Smarter context is leverage.

Start with px ask --json "your question". Give every model the map, meaning, evidence horizon, and next move before it spends a single reasoning token wandering.

PROBAGI / SOURCE PROOF

The page keeps its evidence attached.

source-proven

PX exposes 116 direct command surfaces and 345 registered agent actions in this build.

The generator validated 229 continuation links with zero invalid links.

px-command-catalog-0.1.175
court-proven

The living graph renders all fourteen captured Delphi questions, eight route families, and seven bounded continuation families.

Browser verification confirmed fourteen interactive question selectors, clickable path changes, moving evidence particles, and no page errors.

px-living-question-graph-court-20260728
court-proven

The captured agent session waits for viewport entry, then boots Claude Code, types commands, and streams PX output line by line.

The scroll court held the terminal at zero lines for four seconds above the fold, then observed 27 progressive lines, two planning turns, two Claude responses, one typed command, and zero page errors after the terminal entered view.

px-progressive-cli-court-20260728
source-proven

All fourteen Delphi examples carry captured human CLI and captured agent JSON output.

The capture script recorded 28 successful PX 0.1.175 invocations at repository HEAD a920fd9a and redacted local paths.

px-agent-feature-captures-v1
held

Incidental Finding Capture is presented as a target product contract, not as completed automation.

The page explicitly labels the current evidence substrate, held automatic-capture target, read-only observation rule, urgency gate, and no-extra-query boundary.

px-incidental-finding-ultra-20260728
unknown

Enterprise savings are editable scenario estimates, not measured customer savings.

Every economic assumption is visible and editable in the page.

enterprise-context-economics-scenario
source-proven

The context benchmark compares actual PX AI-context payloads with the complete contents of evidence-named source files.

Five selectable cases expose exact before and after token counts, reduction, intent, result status, coverage, source files, and measured PX latency.

px-context-economics-benchmark-v1
source-proven

PX exposes neural meaning retrieval as a distinct lane from exact graph proof.

The page and source identify embedding-backed semantic retrieval, intent reranking, and the rule that similarity never silently becomes proof.

px-neural-meaning-lane-20260728
source-proven

PX builds a governed repository documentation atlas and isolated generated projections.

Current command contracts expose docs bootstrap, atlas, health, coverage, orphans, context, validation, claims, reconciliation, filesystem checks, and generated ASCII, Mermaid, JSON, and HTML outputs under _docs/px/architecture.

px-docs-atlas-command-contract-20260728
source-proven

The independent review thesis is attributed and separated from measured PX proof.

The page preserves the supplied external code-and-output review, labels it as reviewer opinion, and displays the review-time command count beside the current generated registry count.

px-independent-review-thesis-20260728
court-proven

Recognizable agent and developer-tool marks are bundled into the generated atlas.

Seven repository-local SVG sources are converted to self-contained data URIs; browser checks found nineteen rendered marks, zero broken images, and no external logo dependency.

px-brand-identity-court-20260728