Graph Attention —
The Reasoning Engine That Takes Agents Off-Script

The whole loop in one command: the engine scores a decision, learns from a verified outcome, and declines to learn from one it can't trust. That refusal is the gate — the thing that makes the top of the ladder deployable.

$ pip install graph-attention-engine
$ python examples/minimal_domain/run_example.py

decision #1    → ESCALATE     nearest prototype, d=0.21   gate GREEN
   verified correct (+1)   μ[escalate] ← μ + η·(v−μ)   # it learns
decision #438  # injected fault: a mis-verified outcome
   α·q·V = 0.071  <  θ_min = 0.118   → REJECTED, centroid unchanged
   # a learning engine declining to learn — the point

>>> from gae import compute_theta_min
>>> compute_theta_min(alpha, V)   # θ_min = 23.53/(α·V), the floor, in your code

The relationship under the whole ladder. Both layers reason — about different things — and the one that decides what to do is kept separate from the one that makes it real. That separation is why unscripted action is safe to run.

The same split holds whether the change is a decision or the system improving itself. Decide what (ACCP) → operationalize how (GAE), with the gate between intent and effect — so nothing takes hold that can't clear the floor.

A fast layer picks among options you gave it and forgets the moment it answers. GAE reasons: an input becomes a factor vector, the action is the nearest centroid prototype under an L2 distance — a point you can put your finger on — and a verified outcome moves that geometry.

If that sounds like online k-means: k-means has no gate, no abstain, no record of which outcome moved which centroid, no rollback, and no transfer across domains. The classifier is the cheap part; the reasoning loop around it is the engine.

And it reasons about the situation before it scores. The Situation-Analyzer reads the context graph, classifies the situation, and forms the intent from it — which is the honest meaning of "unscripted": the action is generated from the situation, not selected from a human-enumerated list. It's what catches the access that's authorized and well-formed but wrong for this caller, right now — the case a signature-matcher waves through. A 4% price variance on copper in Q3 is not the same event as 4% on steel in Q1: a heuristic router returns the same output either way; situation analysis reads what it means in context. That graph-mediated enrichment lifts Day-1 accuracy +5.9pp before any learning — the graph's reasoning adds measurable value to the score. Situation → typed intent runs in the SDK and in the SOC and S2P copilots, on synthetic data.

Rung 4 removes the script: the agent acts on an intent it formed, with no pre-written response per case. The reason that's a feature and not a liability is the conservation gate — every action must clear the same floor before it takes effect, or it escalates. Autonomy you can deploy, because it knows when to stop. It's also the honest line against "self-improving agents" that drift: here the thing that learns and the thing that decides are separate code, and every change clears the floor.

The question we'd most like to be proven wrong on, as an open issue: does the gate hold under an adversarially corrupted verification stream? Replying there is a lower bar than emailing a founder. Honest tier: reasoning and the gate ship; situation→intent runs in the SDK and two copilots; general unscripted, cross-copilot autonomy is roadmap — becomes possible, not shipped.

jev (a System-1 decision API) is good at rung 2: a typed question, a probability back in milliseconds, stateless. Two of its own use cases, and what moving them up the ladder adds:

jev chooses fast among the options you script; RGI reasons, learns, and — with ACCP — forms the action from the situation, gated. Wrap jev as the millisecond scorer inside the mesh if you like, with GAE as the verified-outcome memory underneath. That's the rung jev hasn't climbed.

Where it goes (roadmap): the full ACCP control plane — a control tower routing formed intents across many copilots on one audited plane; reification, so a change reaches your ERP processes, not just GAE's internals. The sibling blocks run on this engine: AgentEvolver (runtime config change, live in SOC), RL-CTRL · Judgment Memory (effort, and the versioned judgment it carries).

Pull it: engine first, on its own. Clone it, run the example, read the judgment state, and check the one thing that matters — after a thousand decisions, show the parameter that moved.