RGI reasons better over time — and knows when not to decide.
Graph engineering, typed machine decisions (jev), and recursive self-improvement are all moving fast —
and all reaching for the same missing capability: an enterprise system that doesn't just act, but
reasons better over time, and knows when not to decide. That capability needs a name. Recursive Graph
Improvement — RGI: a system reasons over a live graph of how the business decides — not prompts, not
weights — and improves how it reasons from every verified outcome, recursively, under a law.
Proof
+3 to +21pp across five copilots, 500 verified decisions each · 9,826 gate evaluations, 0 violations Measured
Status
Pilot-stage · no production customers · controlled experiments on synthetic streams
The offer
Engine open, Apache-2.0 — test it on a frozen twin of your own decisions.
Five copilots on one shared engine. Each decision is reasoned as geometry, acted on only if it
clears the conservation gate, verified against the real outcome, and written back — so the next
decision is sharper. The copilots run one decision loop on the GAE substrate: the loop is what comes
alive (next), the substrate is what it runs on (later).
Five copilots → one Graph Attention Engine → the RGI loop (score → act/abstain → verify → write-back),
enclosed by the conservation gate α·q·V ≥ θ_min. The reasoning layer, in the open.
How RGI comes alive — the decision loop
nine moves · one loop
Nine innovations, but not a list — stations on one loop, read in the order the loop runs them.
Five moves form the cycle; four properties wrap it. The loop is the product — remove any one and the
compounding stops. GAE and the math are the substrate; the loop is what lives on it.
A great firm isn't its org chart — it's a machine: people who read the situation, a culture that says
when to act and when to escalate, a way to improve how it works without breaking what works, and institutional
memory that survives anyone leaving. RGI is that machine made explicit.
1Enrich
Universal Context Layer
Pull every system you run — ERP, SIEM, identity, process mining — into one traversable context graph. Not RAG; a reasoning substrate.
Live
2Decide / abstain
Situation Analysis
Turn context into a factor vector, score options as nearest-prototype geometry — and abstain when it hasn't earned the right.
Live
3Act
Closed-Loop Copilots
Replace a queue: execute under an approval gate, verify in the source system, log immutable evidence with KPI attribution.
Live
4Verify & write back
Judgment Memory
The verified outcome moves one centroid — the fourth memory type, the only one that compounds.
Live
5Evolve
AgentEvolver
Shadow-test and promote operational variants at runtime — base model frozen, every promotion under the gate.
Live
↻ the verified outcome reshapes the geometry — so the next decision is scored on a sharper surface.
⑥ Reify
makes the process an editable object · near
⑦ Discover
surfaces the risk nobody queried · near
⑧ Govern
never lets automation outrun trust · live
⑨ Compound
each turn leaves it better at the next
The loop is the product. GAE and the math sit underneath it as the substrate — the engine the
loop runs on, not part of the loop itself.
Where RGI separates
what it is — and is not
A category is defined by what it excludes. Three fields are reaching for the same capability; RGI
is the one that compounds and stays governed. The membership test makes the boundary exact:
The test — a system is RGI iff
(1) it reshapes the decision boundary — the surface that assigns actions — from verified outcomes of its
own decisions; and (2) that reshaping is conservation-governed, with the decision procedure an
invariant the learning cannot alter. The two clauses exclude the incumbents by construction.
rung below vs. Graph engineering — read & route
Graph engineering
A knowledge graph retrieves a cited path; a graph of agents routes work across a topology. Both are real advances — and both leave the graph as plumbing: structure the model reads or routes through. The reasoning happens once, then is discarded. Decision ten-thousand is decision one.
RGI
The graph reasons. The action is scored as geometry, and every verified outcome reshapes that geometry — so decision ten-thousand is measurably sharper than decision one, on your decisions. Read and route are structure; only reshape compounds.
the dangerous cousin vs. Recursive self-improvement (RSI / rrsi)
RSI
Recursion over the self — the system rewrites its own weights and code to get smarter. Unbounded, opaque, and the self-poisoning vector the field itself now flags. No risk owner approves automation that can silently change its own decision logic — which is why it stays in the lab.
RGI
Recursion over the judgment graph — the decision boundary — under a conservation gate. Bounded, inspectable, reversible. It deliberately does not rewrite itself; the procedure a risk owner approved is an invariant. RGI is the governed, deployable instance of recursive improvement.
the fast layer vs. Typed machine decisions (jev)
jev
A fast typed decision — a probability back in milliseconds, the model's own opinion, the same every time. Then it forgets. Stateless: decision ten-thousand is handled exactly like decision one.
RGI
The compounding memory around the fast decision: it scores against verified-outcome prototypes, gates the risky calls, and gets better. Wrap jev as the millisecond scorer if you like — RGI is the verified-outcome memory underneath it.
rung 1
Read
retrieve a cited path · grows by ingestion
rung 2
Route
dispatch work across a topology · rewired by hand
rung 3
Reshape — RGI
reason, decide, and get better from every verified outcome
And a new class of learning system: RGI updates on verified outcomes — a real-world result
checked against ground truth — not a feedback signal or a reward proxy, and only when the change clears the gate.
What RGI unlocks
six things only reshape produces
Not a feature list — six things you could not do before a graph that reshapes itself from
verified outcomes. Each runs across the five copilots on synthetic streams.
Illustrative Named scenes (Meridian Health, Halden Mfg, Kesler Capital, Brightline, Northwind) are illustrative, on synthetic streams — not customers. Only the tier-chipped numbers are measured.
1
Keep your best person's judgment after they leave
Verified decisions shape an inspectable geometry that persists across model swaps and staff turnover — judgment memory, a fourth cognitive type beyond episodic, semantic and procedural. No other memory gets better with use.
Meridian Health — the analyst quits Friday; what his 847 verified calls taught the geometry is still triaging Monday.
A fourth memory typeMeasured
2
See the factor you trust most that's actually your noisiest
A per-factor noise fingerprint (σ) surfaces signal-confidence inversion — the trust trap where the field a team relies on most is its least reliable predictor. A diagnostic from your decisions, not a generic importance score.
Kesler Capital — the desk's favorite setup turns out to be its noisiest signal. Only its own 1,800 trades could have said so.
Cross-graph attention runs over domain pairs, surfacing combinations no single query reaches — discovery, not retrieval. A signal born in one domain changes a decision in another, automatically.
Security → Procurement — a vendor credential flagged in the SOC at 07:12 holds that vendor's invoice in S2P at 2 p.m. Nobody emailed anyone.
discovery scales n^2.150Measured
4
Deploy a self-improving system that pulls back its own autonomy
A conservation gate lets it act only while verified accuracy stays above a floor — else it abstains, and reduces its own autonomy when a regime breaks. It even rejects its own bad ideas. The move no reward-maximizer can make: "not yet."
Meridian Health — it paused itself when its record dipped below the floor, and blocked 35 of 47 changes it proposed, naming the clause each failed.
9,826 gate evaluations · 0 violationsMeasured
5
Run a queue that shrinks
As the geometry learns, earned exception classes move to auto-approval and the queue stops asking about them — decision #10,000 isn't handled like #1. A read-graph's queue is the same size on day 365; this one gets smaller.
Halden Mfg — one exception class climbs 5% → 41% auto-approved, week 1 to week 8, each step earned, gate green throughout (illustrative trajectory).
decision #10,000 ≠ #1Live in SOC · roadmap elsewhere
6
Decide how hard to think — sharper and cheaper at once
A learned controller spends more investigation on hard calls, less on easy ones — effort follows stakes, and it never touches the decision. Higher decision quality at lower average cost: the one thing a fixed pipeline can't do.
Halden Mfg — a $900 utility bill gets one read; a $38K contested capex invoice gets three, where the fifth look flips the call.
+6.5–6.8pp at ~30% fewer readsMeasured
Proof it compounds
measured, on synthetic streams
The thesis is falsifiable: RGI gets measurably better at a firm's own decisions with every verified
one, and faster the longer it runs. For an investor that reframes the spend — improvement is expense; compounding
is capital. A static system's advantage is flat; this one's widens.
gate evaluations vs violations · 5 copilots · synthetic harness
It compounds across all five copilots
Routing accuracy — learned geometry vs a frozen twin, 500 verified decisions each, identical protocol. Every copilot improves; none regress.
learned geometryfrozen twin
S2P's +3pp is the high-surface-noise regime — the boundary characterized on RL-CTRL. Even there, the gate holds it at 0 regressions.
Conservation — per threat model
Detection rate, 0% false-pause on clean streams
full detectionboundary characterized
A moat that's a measurement, not a claim. Same code, a rival trained on another firm's decisions
trails by 19.6 ± 5.4pp (SOC, 0/5 seeds at parity, 5-seed synthetic) — because the geometry encodes your
verified decisions in your noise environment, and the gap widens super-linearly. You can copy the code; you
can't copy the geometry. Sustained, drift and sudden degradation are caught at full rate with zero false pauses;
the sparse-adversarial case is the measured sensitivity boundary — where the gate's reach is characterized, not assumed.
The substrate — GAE & the math
what the loop runs on
The loop comes alive on a substrate: one shared Graph Attention Engine (GAE) — ~844 parameters
of judgment geometry — and the math beneath it. Every decision is two operations, score and learn,
repeated under the conservation gate. The engine is the open-source core; the geometry is what compounds.
The two operations, made precise:
Score
a*(v) = argmin_a ‖v − μ[c,a]‖²_DK · p = softmax(−d²/τ)
the action is the nearest prototype — a point you can name
one verified outcome moves one centroid — auditable, reversible
Gate
α·q·V ≥ θ_min · θ_min = 23.53/(α·V)
act only once earned — three layers: absolute, drift, rate
Two coupled loops on one geometry: a fast loop inside a decision (reason → score → investigate
only if the margin is thin → gate) and a slow loop across decisions (each verified outcome moves one
prototype). The shared geometry is why it compounds.
Five copilots, one engine
same math · different geometry
The same engine carries a different judgment geometry per domain — ~844 parameters in all. The
verified outcome that moves it is domain-specific (a confirmed triage, an approval that cleared, a reorder
that arrived), so a lesson learned in one domain can speed convergence in another through the shared substrate.
SOC
6×4×6
Meridian Health
The alert with no precedent — it reasons where a lookup has nothing to recall.
S2P
5×5×8
Halden Mfg
The rule that kept saying no — until it read that copper rose 4.8%.
Trading
5×4×10
Kesler Capital
Your favorite setup is your worst — only your own 1,800 trades could say so.
Purchasing
5×4×7
Brightline
The GM who just started — the kitchen turns over; the judgment doesn't.
DataOps
6×5×6
Northwind
The source that lost its trust — 0.71→0.23 after 15 wrong outcomes.
What ships, and what's next
honest tiers
MeasuredShipped core: the GAE engine (score / learn / gate), the decision geometry, the three-layer conservation gate, situation analysis, the enrichment controller and cross-graph attention — run across the SDK and five copilots on synthetic streams with known ground truth.
ModeledRe-convergence after a regime break (γ ≈ 1.2) is proved and characterized in simulation; live magnitude is pilot-gated.
SyntheticDeployment trajectories (e.g. SOC auto-close 68 → 89%) are demonstrated on synthetic streams, not production data.
RoadmapProcess/ERP reification, structural self-computation, and the full cross-copilot control plane become possible on this architecture — flagged as roadmap, not claimed as shipped.
No production customers yet. Figures labelled Measured are controlled experiments on synthetic streams; magnitude on a firm's live decisions is a pilot measurement, never synthesized. The GAE engine and the mathematics are open, Apache-2.0.
See it on your own decisions
the reasoning layer, in the open
Don't take our numbers. Clone the engine, or hand us a frozen export of your decisions and we'll
show the compounding curve on your data before anything touches production. We're looking for design partners —
one per domain — and architects who want to try to break the gate.
For architects: the math layer beneath the engine — eight pure mechanisms (M1–M8), each independently
testable, under the single invariant enforced in production.
M1 centroid update · M2 scoring kernel · M3–M5 conservation gates · M6 evidence acquisition · M7
calibration · M8 cross-domain transfer — all governed by α·q·V ≥ θ_min.
