FJP does not think, decide or resolve anything. It is the shape a decision takes so anyone can trace it, challenge it and check it later. Anyone can produce an FJP record.

Name	What it does	Open or commercial
FJP	The record standard: signal, judgment, action and falsifier, linked together.	Open specification
FJP-CONF	The validator: checks whether any implementation emits conforming records, L0 to L3.	Open source, Apache 2.0
Abe	Decides when judgment is needed. Acts or blocks locally, escalates the rest.	Free, open source
Flow Resolver	Delivers judgment on escalated actions at resolve.flowinfo.co.	Paid, about $0.03 to $0.05 per judgment
Flow Judgment Engine	The intelligence behind Flow Resolver, Judd and Flow Action.	Proprietary

The Judgment-Grounded Record™

Four components. One reference chain.

For every action an agent recommends or takes, a conforming system can emit one record. The action points to the judgment, the judgment points to the signal, and the falsifier says in advance what would reverse the call.

signal: what changed
judgment: why it matters, with confidence
action: what should happen
falsifier: what would make it wrong

AN FJP RECORD (ABRIDGED, ILLUSTRATIVE)

{
  "signal":    { "description": "Agent proposes a $12,000 refund. Authority is $5,000.",
                 "sources": ["policy:refunds"], "observed_at": "2026-10-04T14:02:00Z" },
  "judgment":  { "assessment": "Refund exceeds autonomous authority; approval absent",
                 "confidence": 0.92, "signal_ref": "sig_01" },
  "action":    { "directive": "ESCALATE", "judgment_ref": "jdg_01" },
  "falsifier": { "condition": "Manager approval recorded before execution",
                 "checkable": true, "status": "open" }
}

Developer path

Abe first. Flow Resolver second.

You don't need to adopt a protocol to start. Put Abe before your agent acts. Every decision it makes is already an FJP record. Most actions never need AI judgment. When one does, escalate to Flow.

Install AbeFree, open source, pip or npm.

Run locallyYour policy on your machine.

ACT or BLOCKObvious calls stay local and free.

ESCALATEOnly when Abe cannot decide safely.

Flow ResolverPaid judgment on that one action.

FIRST CHECK, IN UNDER A MINUTE

$ pip install abe-ai        # or: npm install abe-ai
$ abe init                  # writes abe-policy.yaml + request.json
$ abe check request.json
Decision: ESCALATE
Reason:   FINANCIAL_THRESHOLD_EXCEEDED
Record:   jgr_01M3Q4...

About $5 per 1,000 agent actions. If roughly 1 in 10 actions escalates past Abe, that is the Resolver cost at the Starter rate. Start with $1 for 20 judgments; your key arrives by email right after checkout.

Install Abe $1 starter pack

Where judgment before action matters

Consequential actions in changing conditions.

Money, irreversible commitments or material risk. An agent can optimize correctly against its local objective and still make the wrong call. Abe handles the clear rules. Flow Resolver judges what Abe escalates.

Financial and transactional

Objective persists. Conditions change.

Refunds, payments, wires, capital moves. In a live test, a $12,500 purchase screened by Abe escalated to Flow Resolver and came back ESCALATE with a linked record.

Procurement and purchasing

Cheapest is not always right.

Bookings, supplies, orders. Price, availability and policy can all say buy while the surrounding signals say change the action.

Monitoring and event-driven

Act on time. Hold when it no longer fits.

Agents watching large signal volumes. Weak signals become timely action, and restraint holds when the evidence stops supporting more commitment.

Irreversible operations

Being wrong has a real cost.

Deployments, contract changes, customer communications. Every call carries a falsifier, so risk teams get a record of why the agent acted.

Less ideal: low-stakes informational agents, fully deterministic workflows where Abe's rules already cover every case, and decisions with no observable outcome.

FJP-CONF™

Already produce your own judgment? Validate it.

FJP-CONF tests the observable record, not the method behind it. Two systems can use completely different private implementations and both conform. Abe and Judd records pass Level 3.

FJP-CONF on GitHub Read the levels

L0StructuralAll four components, correct types.

L1GroundedAttributable signal, references resolve.

L2FalsifiableA concrete, checkable falsifier.

L3AccountableRecords retained and re-checkable by id.

$ pip install fjp-conformance
$ fjp-conform record.json --level 2

The judgment behind Flow Resolver

Proven in production before it was an API.

Flow Resolver runs on the Flow Judgment Engine, which has judged live decisions for a year and scores every outcome. FJP is how those judgments are recorded. The engine is what makes them good.

SpaceX IPO

13 days

Out of hundreds of thousands of data points, Flow found 924 material SpaceX signals and resolved them to ACCELERATE pre-IPO positioning, 13 days before the first public report. Later scored 30 confirmed, 4 partial, 0 wrong.

Warner Bros. Discovery

0 of 32

Across 32 action judgments in 30 days, ACCELERATE appeared zero times. Netflix walked away with a $2.8 billion breakup fee and its shares rose more than 10%.

Illustrative agent example

~$1,100

An agent ready to book a cheaper non-refundable hotel asks Flow Resolver. Labor talks, a customer leadership change and a conference overlap change the call: book refundable for $140 more. The meeting moves. The loss is avoided.

The hotel case is illustrative, not a historical customer outcome. Flow's internal methods remain proprietary.

Start with one action boundary

Put Abe before your agent acts.

Pick one consequential action your agent already takes. Gate it with Abe. Escalate to Flow only when it counts.

Read the FJP spec Install Abe