The distinction that matters
Most AI governance tooling in 2026 is a policy engine — a list of regex patterns and allow/deny rules that fire on individual requests. That works when the question is “should this specific call be allowed.” It fails the moment the question becomes “given everything this agent has done in the last hour, should it be allowed to act now.”
Expert systems — the kind built on CLIPS, Jess, and Drools — don’t evaluate rules in isolation. They maintain a working memory of facts, and rules fire based on patterns across that memory. That is the shape of the governance problem for autonomous agents.
What changes when you have working memory
Consider a simple policy: an analyst agent may request classified data, but not more than three times in a rolling ten-minute window. A rule engine can enforce this only if you encode the window logic into the rule itself — usually by querying a database, caching results, and writing fragile time-window arithmetic. An expert system treats the three recent requests as facts, and the rule is a single pattern match.
Multiply that across the full space of real governance questions — data lineage, clearance hierarchies, trust decay, tool-use budgets — and the difference compounds. Expert systems let you express the policy; rule engines force you to re-implement the substrate underneath it.
Why this isn’t well-known
Expert systems peaked in the 80s and disappeared from mainstream programming vocabulary. CLIPS, the engine Fathom is built on, was released by NASA in 1985 and is still maintained. Entire industries — aerospace diagnostics, insurance underwriting, medical decision support — never stopped using it. The tooling just stopped being fashionable.
AI agent governance is forcing a reappraisal. The problem shape matches what expert systems were built for: lots of facts, lots of conditional logic, low tolerance for incorrect decisions, requirement for explainability.
What Fathom does with this
Fathom ships the CLIPS engine as a library with a thin TypeScript API. Rules are defined in plain CLIPS syntax (IF/THEN patterns over fact templates), facts are asserted as agents act, and the engine fires deterministically at the decision boundary. The latency budget is sub-millisecond per rule evaluation — small enough to sit on every agent request without changing the user-visible experience.
The goal is boring: make governance a library call, not a vendor dependency, and let the rules be inspectable code.