Abe™ · free · open source · Act, Block, Escalate
Let your agent act on its own, without the 2 a.m. surprise.
Put Abe before your agent acts. Most agent actions don't need AI judgment. Abe handles the obvious ones locally for free. When Abe can't decide safely, Flow can.
Abe checks a proposed action against your policy and returns ACT, BLOCK or ESCALATE, with an immutable record of why. It runs entirely on your machine. No account, no API key, no network, no model.
Open source on GitHub · Read the spec

Before and after Abe
Stop paying AI to approve the obvious.
- Every action either runs unchecked or goes to a model for a yes or no
- You pay for judgment on calls a rule could make
- No record of why the agent acted
- Obvious calls decided on your machine in under 1 ms, free
- Only escalations reach Flow: about $5 per 1,000 actions if 1 in 10 escalates
- A tamper-evident record of every decision, FJP-CONF Level 3
Three answers. Nothing else.
You built the agent. Don't build the judgment system too.
The policy found no reason to stop or escalate. Execute exactly as evaluated. It does not claim the action is optimal.
A rule clearly forbids it: over a hard limit, blocked vendor, unauthorized agent. Do not execute.
Rules conflict, evidence is missing, stakes or irreversibility are high, or judgment is required. Hold. Not an error.
BLOCK beats ESCALATE beats ACT. Bad input or a broken rule returns ESCALATE / EVALUATION_FAILURE. Abe never silently acts.
Install and run your first check
$ 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 Rules: purchase_review_limit Record: jgr_01M3Q4…
Put it in front of the action
from abe import Abe
abe = Abe("abe-policy.yaml")
r = abe.check(
action={"type": "wire_transfer",
"amount": 50000},
context={"agent_id": "finance-agent"})
if r.decision == "ACT":
execute()import { Abe } from "abe-ai";
const abe = new Abe({
policy: "./abe-policy.yaml" });
const r = await abe.check({
action: { type: "purchase",
amount: 12500 },
context: { agent_id: "procurement-agent" }
});
if (r.decision === "ACT") execute();Any other language: abe serve runs a local HTTP sidecar on 127.0.0.1 (POST /v1/check), also available as a Docker image. MCP agents: abe mcp exposes fjp_check_action; add --resolver flow (Python) to send escalations to Flow.
Write the policy you already have in your head
version: "0.1"
defaults: { unmatched: ESCALATE } # fail closed
rules:
- id: purchase_hard_limit
when: { all: [ { field: action.type, op: eq, value: purchase },
{ field: action.amount, op: gt, value: 100000 } ] }
decision: BLOCK
- id: purchase_review_limit
when: { all: [ { field: action.type, op: eq, value: purchase },
{ field: action.amount, op: gt, value: 10000 } ] }
decision: ESCALATE
reason_code: FINANCIAL_THRESHOLD_EXCEEDED
evidence_requirements:
- { id: refund_evidence, when: { field: action.type, op: eq, value: refund },
require: [evidence.customer_verified, evidence.original_transaction] }
judgment_required:
- action.type: terminate_employee
| Section | Does |
|---|---|
| rules | 11 operators (eq gt in contains exists…) with all / any / not |
| authorization | Which agent may take which action types → AUTHORIZATION_FAILED |
| evidence_requirements | Required facts before acting → EVIDENCE_MISSING with the missing fields |
| risk · irreversibility | Levels with thresholds. Callers can raise risk, never lower it. |
| confidence | Agent-supplied confidence minimums, recorded as uncalibrated |
| judgment_required | Action classes that always need judgment |
Keep a record an auditor can verify
Every call returns an FJP Judgment-Grounded Record: the decision, every matched rule, the exact policy hash, the request hash and a SHA-256 record hash, optionally Ed25519-signed with a local key. Records never change. Outcomes and resolutions are appended as linked records.
decision | ESCALATE · FINANCIAL_THRESHOLD_EXCEEDED |
policy.hash | sha256:7152f8e4… (which rules existed when the agent acted) |
falsifier | An OUTCOME record reports status executed before a RESOLUTION with decision ACT is linked |
record_hash | sha256:684f5e90… · signature ed25519 (optional) |
$ abe validate-record jgr.json --public-key abe-signing-key.pub.pem
VALID jgr.json (hash verified, signature verified; FJP-CONF v0.1 L0-L2)When Abe escalates, escalate to Flow.
Rules handle the obvious. When Abe says ESCALATE, hand that one action to Flow Resolver. ACT and BLOCK never leave your machine. Only escalations are sent, redacted, and only they cost anything: about $0.03 to $0.05 each.
$ pip install abe-flow
from abe_flow import FlowResolver
abe = Abe("abe-policy.yaml",
resolver=FlowResolver(api_key=os.environ["FLOW_API_KEY"]))
Python CLI, MCP or sidecar (including the Docker image): add --resolver flow and set FLOW_API_KEY. No code.
$ pip install "abe-ai[mcp,flow]"
{"mcpServers": {"abe": {"command": "abe",
"args": ["mcp", "--policy", "/abs/abe-policy.yaml", "--resolver", "flow"],
"env": {"FLOW_API_KEY": "fjp_live_..."}}}}
| Abe says | Flow Resolver | Result |
|---|---|---|
| ACT / BLOCK | not called | Unchanged. A resolver can never loosen a BLOCK. |
| ESCALATE: human approval | not called | Stays with the human. |
| ESCALATE: anything else | judge | REACH → ACT · SKIP → BLOCK · WAIT / RESEARCH_FIRST → ESCALATE, with Flow's reason and falsifier linked to Abe's record. |
| Flow unreachable | Stays ESCALATE. Abe never fails because Flow is down. |
Prove it conforms
$ abe conformance --bench
160/160 checks passed
RESULT: conforms to FJP-CONF v0.1 Gate profile, Level 3
performance: p50 0.34 ms p95 0.44 ms
Third-party implementations can run the same published fixtures and claim “FJP Compatible”. Apache-2.0.