When an agent gets it wrong, the bill runs $1M to $15M, and nobody finds out until the damage is done. FJP fixes that. An open standard makes any agent's decisions auditable. A fifty-cent resolver call returns the judgment itself: what matters, why, what to do, and what would prove it wrong.
Every system can find information. Very few can tell you what actually matters. Today every app and every agent makes that call on its own, and they don't agree. FJP gives them one place to ask, and one consistent answer back.
Two parts: an open standard anyone can check their own system against, free to use, and a paid service that does the work. The rest of this page is the detail.
The judgment layer behind Flow's resolver has run inside our application for almost a year, serving a private cohort of founders, executives, and investors managing multiple billions in assets and leading companies that have defined technology from the web to AI.
An open-source conformance suite. It validates that your agent's output is a well-formed Judgment-Grounded Record: signal, judgment, action, falsifier. It tests the shape of the decision, not the quality. Your agent does its own judgment. CONF checks the record.
A live judgment API. Signal in, Judgment-Grounded Record out. Three tools: judge, weigh, and match. Each returns calibrated judgment with confidence, reasoning, recommended action, and a falsifier.
Any LLM can return the right JSON shape. Any developer can pass CONF. The shape isn't the hard part.
The hard part is producing disciplined judgment, not merely returning the correct JSON structure.
The Flow Resolver produces Judgment-Grounded Records through Flow's proprietary judgment system.
The implementation, models, scoring methods, calibration processes, orchestration, and underlying data remain proprietary.
FJP-CONF tests only the resulting record. It does not inspect or prescribe how the judgment was produced.
Every FJP response, whether you build your own or call the resolver, carries four components:
The references form a chain. The falsifier makes the decision checkable after the fact. An agent that emits this record can be audited. One that doesn't, can't.
Each call returns a complete Judgment-Grounded Record. One credit per call.
Every agent makes judgment calls. The question is whether anyone can tell when those calls are wrong, and what the wrong call costs. FJP costs $0.50 per call. Here's what the alternative costs.
CFO of a portfolio company sold 40% of holdings during a quiet period. The agent needs to decide: escalate to the portfolio manager now, or file it as routine.
PM reviews position, hedges before the earnings miss. Stock drops 18% the following week. The hedge saved $1.8M on a $10M position.
No hedge. The 18% drop hits the full position. $1.8M loss that was avoidable. No record of why the agent classified it as routine. No way to fix the logic.
The resolver returns ESCALATE with high confidence and a falsifier: "unless this sale is part of a pre-announced 10b5-1 plan." The falsifier is checkable in 30 seconds. The PM acts. Cost of the call: $0.50. Value created: $1.8M in avoided losses.
A well-funded competitor announced entry into the company's core market. It's one of 200 signals. The agent must rank it: decisive, material, or peripheral.
Analyst sees it first thing. Company accelerates product roadmap, locks two key customers before the competitor launches. $4M in protected ARR.
Signal buried on page 3. Team discovers it two weeks later from a customer call. Two renewals already in competitive bake-offs. $4M in ARR at risk, six months of firefighting.
The resolver returns decisive with the falsifier: "unless the competitor is targeting a different segment or geography." That's verifiable from their press release. Cost: 200 calls at $0.50 = $100/day to triage all signals. Replaces 4+ hours of manual analyst review ($600+/day).
Inbound: Series B, vertical SaaS for logistics, $30M ARR, 120% net retention. The fund's thesis is infrastructure software, $10-50M ARR, capital-efficient growth. The agent needs to decide: pass to the IC or skip.
IC reviews, recognizes the horizontal platform beneath the vertical packaging. Leads the round. Company 3x's in 18 months. $15M in fund returns on a $5M check.
Agent classifies it as "vertical, not infrastructure" and skips. Competitor fund leads. $15M in missed returns. Partners find out a year later.
The resolver returns strong relevance with the falsifier: "unless the product is a point solution with no platform extensibility." That's answerable from one technical call. The deal gets surfaced. Cost of the call: $0.50. Cost of missing it: $15M.
The math is the same every time: the cost of a wrong judgment at the decision layer is $1M to $15M+. The cost of an FJP call is fifty cents. The gap between those numbers is the entire business case.
And without the falsifier, you never find out the judgment was wrong until the damage is done. With it, someone can check before they act.
Any agent that makes a judgment call with consequences. If the wrong call costs money, customers, or compliance, the agent needs a record that explains why it acted.
The common thread: the agent's judgment has consequences, and someone other than the builder will eventually ask how it decided. FJP makes that question answerable.
Enter your email and choose a tier. Your API key arrives by email in seconds.
One credit per call. Outcome reporting is free. Top up any time.
Just verifying the API works? Run the $1 smoke test. It grants 2 credits (two live calls), and your API key arrives by email the moment payment clears.
MCP-native. Drops into any agent stack.
High volume or enterprise? Let's talk.FJP-CONF validates that your agent emits well-formed Judgment-Grounded Records. Stdlib-only Python, no dependencies. Use it whether you build your own judgment or call the resolver.
Four conformance levels:
Check your agent's conformance:
Call the resolver:
Hard stop. The API returns a 402 with a refill link. No degraded mode, no surprise charges, no grace period. You top up when you're ready.
No. Credits remain on your account until used.
Yes. CONF is free, open-source, and fully independent. Build your own judgment layer and validate its output against the spec. The resolver is a separate paid service for teams that want calibrated judgment on demand.
The resolver processes the context you submit and returns a Judgment-Grounded Record. It sees your input and the output it produces. It does not see your internal systems, your users, or anything beyond what you include in the API call.
No. Your input context is not used as training data and is never shared with other customers.
The resolver is not defined by a single model. Its implementation may use different models, methods, and orchestration over time, all of which remain proprietary. The public contract is the Judgment-Grounded Record returned by the service.
Typical judge and weigh calls return in 2 to 5 seconds. Match calls depend on the number of contexts evaluated. These are judgment calls, not lookups. The latency reflects real reasoning, not infrastructure lag.
Not at current scale. The resolver runs on dedicated infrastructure and has been reliable in daily production use. Formal SLAs are available for enterprise volume agreements. Reach out to discuss.
No. The Flow Resolver is offered as a managed service, and its implementation remains proprietary. FJP-CONF is open-source if you want to build your own judgment system and validate its output against the public standard.
Streamable HTTP (stateless). POST JSON-RPC messages to https://resolve.flowinfo.co/mcp with your API key as a bearer token. Standard MCP lifecycle: initialize, tools/list, tools/call. No SSE stream, no session state.