Probably AGI

Chapter 01 / Why PX / Enterprise context economics

Stop paying models to rediscover your company.

Outside review / code + output inspected
The market is chasing bigger context windows to understand code. We sat back and asked: what if the codebase could talk back and become just as smart?

Precompute the graph once. Give every agent exact structure, neural meaning, documentation evidence, uncertainty, and the next bounded move.

Independent review excerpt / claim remains benchmarkable Read the full thesis ↓
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
Product experience02

What an agent
actually experiences.

Watch PX take an unfamiliar repository from one natural-language question to exact code, neural meaning, governed documentation, a living route graph, and one bounded next command.

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 + JetBrains AIAI coding environments

Project-aware AI context, semantic indexing, editing, and agent workflows close to the developer.

Retrieved context is optimized for answering. It does not independently establish which evidence lane ran, what was covered, or what an omission means.

PX exposes route choice, target identity, coverage, weaknesses, and a bounded recovery step before context becomes a conclusion.

GitHub CopilotAutonomous coding agent

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

Autonomous execution is not an independent, reusable proof of why those files were inspected or where the evidence ended.

PX gives any agent the same route receipt, evidence horizon, worker brief, and verification packet.

SourcegraphSearch + code navigation

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

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

PX composes those lanes and will not silently translate a partial index into complete evidence.

CodeQL + SemgrepStatic analysis + security

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

Purpose-built analyzers are excellent at their questions; they are not a general agent entry, recovery, workflow, or evidence-lineage layer.

PX routes work to the analyzer, retains its proof class, and connects findings to impact, docs, tests, and closeout.

PXAgent evidence control plane

Question framing, deterministic route arbitration, cross-lane composition, current-tree coverage 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
Enterprise proof contract03

Why a company
can trust it.

PX does not turn retrieval into certainty by magic. It exposes route choice, evidence boundaries, contradictions, incidental findings, measured context reduction, and the exact recovery path when proof runs out.

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
Complete technical surface04

Everything PX
puts behind one door.

The sales story ends here and the technical reference begins: every registered agent action, grouped by purpose, searchable without asking an agent to memorize the command wall.

345 registered actionsVersioned publication evidence

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 capability inventory

The 115-command atlas is generated from the PX command inventory and verified against the current complete AI guide.

sha256:0b9825997ccb2f2be626b89a884d3ef02fa92918c68dd5d6ecbba62f4b6ae6f0
source-proven

Registered command relationships

The generator validated 229 registered related-command transitions with zero invalid or missing Clap entries.

px-related-validation:229-of-229
packaged

Industry comparison

Competitor capabilities are framed from their official documentation and separated from PX interpretation.

official-docs:cursor-jetbrains-copilot-sourcegraph-codeql-semgrep
unknown

Independent productivity superiority

No independent controlled benchmark yet proves universal accuracy, speed, token, or cost superiority.

px:independent-head-to-head-benchmark
held

Public reachability

This state advances only after Ghost publication and public rendering readback.

probagi:px-agent-feature-atlas:live-readback