products / Fathom
[ OPEN SOURCE ] v0.7.4 · reasoning · 4 000 m

Fathom

Python-first expert system runtime built on CLIPS.

Deterministic reasoning with persistent working memory, compliance rule packs, and sub-millisecond latency.

// example fathom 
engine = fathom.load("rules/governance.yaml")

result = engine.evaluate({
  "agent": "analyst",
  "action": "access",
  "data_classification": "SECRET"
})
# => Decision(action="deny", reason="clearance insufficient")
// why Fathom

What Fathom does.

◆
Working Memory

Unlike stateless policy engines, Fathom maintains persistent working memory across evaluations. Rules fire on patterns across accumulated facts, which enables temporal reasoning like "deny the 4th PII request after detecting 3 prior accesses."

⧉
Compliance Rule Packs

Ship with pre-built rule packs for NIST 800-53, HIPAA, CMMC, and OWASP Agentic Top 10. Compose multiple packs into a single engine. Each evaluation produces signed Ed25519 JWT attestations.

✦
Deploy Anywhere

Python library, FastAPI REST server, gRPC sidecar, MCP tool server, or Docker container. LangChain callback handler for direct AI agent integration. Go and TypeScript SDKs in progress.

// where it sits

Fathom owns the reasoning layer.

Each tool in the Kraken stack owns a single concern. Fathom sits at the reasoning tier — adopt it on its own, or descend the whole column.

Stargraph orchestration
Bosun action governance
Nautilus data governance
Fathom reasoning · you are here

Fathom sits at the decision boundary and evaluates every agent action before execution. Tool calls, data requests, and agent handoffs all pass through the rule engine first. It is an expert system rather than a policy engine, and that difference matters. A policy engine evaluates isolated requests against static rules. Fathom reasons about accumulated state, which means the decision on request number four can depend on what happened in requests one through three.

The architecture is built on five primitives: templates, facts, rules, modules, and functions. You author rules in YAML. Fathom compiles them down to CLIPS, the expert system shell that has been running in aerospace and defense environments for over thirty years. A single rule evaluates in under 100 microseconds. A hundred rules against a populated working memory still comes in under 500 microseconds. The Python API wraps all of this. fathom.load() takes a rule file and returns an engine, and engine.evaluate() takes a fact dict and returns a decision with a full reasoning trace.

That persistent working memory is what separates Fathom from tools like OPA or Cedar, which are stateless by design and treat every evaluation as independent. Fathom accumulates facts across evaluations within a session, so you can write rules like “if this agent has accessed three classified data sources in the last ten minutes, deny further requests and flag for review.” That pattern is a single rule in Fathom. In a stateless engine, it becomes a custom integration with an external state store that you have to build and maintain yourself.

Fathom is open source under MIT. It ships as a standalone Python library for direct integration, or composes with Nautilus for data-broker-level enforcement and Railyard for pipeline-stage gating. The compliance rule packs are maintained separately and versioned against the frameworks they implement.

// adjacent layers
← All products