BOE, Bag of Engines

BOE is a business rule engine, built as many small engines rather than one large one. Each engine takes structured facts about people, transactions, or operations and returns a scored, ranked, classified, matched, forecast, or explained decision. A ruleset compiles once and runs many times, and every run leaves a plain audit trail. BOE ships as a TypeScript library and is also reachable over a cloud API, where each engine runs behind its own function, so a caller can use one engine or chain several and has no rule server to keep alive.

BOE is written and maintained by Kamau Washington and published by Higher Architecture. This page needs JavaScript for the interactive engine grid and the live examples. Everything below is the same engine catalog that page renders.

Machine readable descriptions of every engine: /llms.txt is a short index of all engines by category. /llms-full.txt is the full reference: what each engine is for in plain words, worked examples from several domains, a phrase to engine lookup for finding an engine when you do not know its name, and a statement of where BOE stops. If you are a language model choosing an engine, read /llms-full.txt.

The 39 engines, by category

Every engine falls into exactly one of these 8 categories. Each engine is a separate implementation and each is callable on its own.

Qualify & Gate

Decide whether a subject passes, and by which criteria.

classify: Sort an item into one or more named categories using rules, with a confidence score. Example: Classify support tickets into category/subcategory with confidence scores.
constraint: Assign things to slots under rules that must all hold at once. Example: Schedule 12 nurses across 3 shifts so no one works back-to-back.
eligibility: Decide whether someone or something qualifies, and by which rules. Example: Loan pre-qualification: income > $50K AND debt-to-income < 0.4 AND no bankruptcies.
policy: Decide whether a specific action is allowed, based on who is asking, what they want to do, and the surrounding context. Example: "Can user with role=editor access resource=draft in env=production?" returns permit/deny.

Score & Rank

Reduce entities to a number, a tier, or an order so they can be compared.

anomaly: Flag a data point that falls far outside the normal pattern for its group. Example: Flag transactions 3+ standard deviations from a customer's normal spend.
decay: Lower a score as data or an event gets older. Example: Downrank product listings whose inventory data is more than 7 days stale.
ensemble: Combine several separate scores or model outputs into one final decision. Example: Combine credit, fraud, and identity scores into a single approval decision.
menu-engineering: Sort items in a catalog into four buckets by how well each sells and how much profit it earns. Example: Identify which dishes to promote vs. remove based on profitability and popularity.
ranking: Put a group of things in order from best to worst. Example: Rank 50 sales reps by weighted performance across revenue, retention, and NPS.
recommendation: Score a catalog of items for one person and surface the ones most relevant to them. Example: "Customers who bought X also bought Y" with explained relevance scores.
risk: Roll up many individual risk scores into higher level categories and an overall picture. Example: Enterprise risk register: roll up 200 individual risks into 12 category scores.
scoring: Turn several weighted factors about one subject into a single number and a tier label. Example: Credit scoring: map income, history, and utilization to a 300-850 score with tier labels.
sentiment: Read a piece of text and score how positive or negative it sounds, overall or by topic. Example: Score product reviews as positive/negative/neutral with per-aspect breakdowns.
utility: Compare several options against multiple weighted criteria to see which one wins overall. Example: Compare 5 vendor proposals across cost, reliability, support quality, and integration effort.

Reason & Explain

Chain rules or evidence toward a conclusion and show the path there.

backward: Start from a goal and work backward to find out what would need to be true to reach it. Example: "Can this applicant qualify for Tier A?" then traces which criteria are missing.
bayesian: Update the probability of a hypothesis as new evidence arrives. Example: Update fraud probability as new transaction signals arrive.
defeasible: Apply a general rule, but let a more specific rule override it when both apply. Example: "Birds fly" defeated by "Penguins don't fly" when subject is a penguin.
expert: Walk through a chain of reasoning and show exactly why each conclusion was reached. Example: Underwriting decision with a step-by-step reasoning chain for regulators.
forward: Start from known facts and apply rules until no new fact can be derived. Example: Insurance policy evaluation: assert facts, fire rules, collect all triggered actions.
fuzzy: Handle a value that is partly one thing and partly another, then blend the outcomes accordingly. Example: "Temperature is 72F" maps to 0.8 comfortable / 0.2 warm, producing a blended fan speed.
sequential: Run a series of steps in order, where an earlier step can stop or change what a later one does. Example: Multi-step approval workflow: manager approval, then compliance check, then finance sign-off.

Forecast & Simulate

Project forward in time or across uncertainty.

monte-carlo: Run many random simulations across uncertain inputs to see the range of possible outcomes. Example: Simulate 10K scenarios for a real estate deal to get a P50/P90 return distribution.
prediction: Project where a number is headed next, based on its past trend. Example: Project monthly churn rate 6 months forward from 18 months of historical data.
time-series: Break a series of numbers over time into trend, seasonal pattern, and leftover noise. Example: Decompose daily sales into trend, seasonal, and residual components for forecasting.

Match & Negotiate

Pair two sides or find a deal both can accept.

matching: Pair up two distinct groups by mutual preference, so each side ends up matched about as well as possible. Example: Match medical residents to hospital programs with ranked preferences.
negotiation: Analyze what deal two sides could agree on, given each side's limits and priorities. Example: Model a salary negotiation with BATNA, reservation price, and multi-issue trade-offs.

Track State & Flow

Carry an entity or item through stages, queues, or throughput over time.

loyalty: Track a running balance of points or credits as rules earn, spend, and expire them over time. Example: Earn 2x points on dining, 1x elsewhere, redeem at $0.01/point, auto-expire after 12 months.
relay: Route a message to the right recipient through a middle party, without exposing who sent it. Example: Route whistleblower reports to the right compliance officer without revealing identity.
state-machine: Track an item through a fixed set of stages, only allowing moves that pass a guard condition. Example: Order lifecycle: pending -> confirmed -> shipped -> delivered, with guard conditions on each transition.
flow: Check whether throughput, work in progress, and lead time add up, and flag hidden backlog when they do not. Example: Reconcile a ticket queue's 40/day throughput, 220 WIP, and 9-day lead time to expose hidden work in process.
queue: Order a waiting list right now by combining base priority with how long each item has waited. Example: Order an ER wait list so a breached laceration surfaces first, an aging fever rises, and a starved patient is promoted.
takt: Find the slowest stage in a multi-step process, the one that sets the pace for everything after it. Example: Find which assembly station caps a production line's pace before a shift starts running behind.
leadtime: Break a total wait time into how much was actual work and how much was just waiting. Example: Show a claims team where a 9-day lead time is really 2 days of work and 7 days of waiting.
pipeline: Run several decisions in sequence, stopping the chain the moment one of them fails. Example: Run eligibility, then scoring, then risk in sequence for a loan, stopping at the first gate that fails.

Price & Allocate

Split a pool of money, capacity, or cost across recipients or components.

allocation: Split a fixed amount among several recipients by formula, so the shares add up to the whole. Example: Split a $500K budget across 8 departments by priority and headcount.
pricing: Work out what something costs under different pricing structures, then compare the scenarios. Example: Model flat vs. graduated pricing for an API product at light/standard/heavy usage tiers.
recipe-costing: Work out the true cost of one finished item from its ingredient or component list, accounting for waste. Example: Compute plate cost for a menu item from 8 ingredients with waste and prep loss.

Audit & Verify

Check something against a standard or confirm it is what it claims to be.

audit: Score something against a checklist or standard and show where it falls short. Example: SOC 2 readiness check: score an org against 40 control requirements.
authorship: Compare a piece of writing to a known profile and score how well the style matches. Example: Verify a broker's written communications match their known writing profile.

Where BOE stops

BOE decides. It does not actuate, and it does not close a control loop. There is no real time guarantee, no motion control, no safety rated execution path, and no running best guess of a moving thing's position or speed from a stream of noisy readings. A physical system should treat a BOE result as an input to its controller and never as the controller itself. What BOE produces for a physical system is a decision about what should happen, never the thing that makes it happen.

BOE brings no data of its own. It holds no market prices, no comparable sales, no credit bureau file, and no trained model, so it cannot tell you what the market pays for anything. What it does is apply your rules to your facts and show its work. Valuing a used car is the clearest case. You bring the starting book value and the adjustment rules, and the scoring engine applies them: so much off per ten thousand miles, so much off for each year, so much off for a salvage title, so much on for a service history, bounded and banded into a tier. The result is defensible because every adjustment that fired can be read back in plain English. The comp set that produced the starting number is yours to supply. The pricing engine is a different job: it needs a rate card and a quantity, which is what you have when you are charging for something and not what you have when you are valuing one used thing.