fathom-rules 0.2.0

Deterministic reasoning runtime for AI agents, built on CLIPS via clipspy

Fathom

A modern Python-first expert system runtime built on CLIPS. Define rules in YAML. Evaluate in microseconds. Zero hallucinations.

Status: Design Draft License: MIT Language: Python 3.14+ Package Manager: uv

---

Why Fathom?

Every AI agent framework lets agents decide what to do by guessing. For most tasks, that's fine.

For some tasks, guessing is unacceptable:

• Policy enforcement — "Is this agent allowed to do this?" can't be a maybe.
• Data routing — "Which databases should this query hit?" can't hallucinate a source.
• Compliance — "Did this fleet operate within NIST 800-53 controls?" needs a provable answer.
• Classification — "What clearance level does this data require?" is not a prompt engineering problem.

Fathom provides deterministic, explainable, auditable reasoning using CLIPS — a battle-tested expert system — wrapped in a modern Python library with YAML-first rule authoring.

Quick Start

uv add fathom-rules

from fathom import Engine

engine = Engine()
engine.load_templates("templates/")
engine.load_rules("rules/")

engine.assert_fact("agent", {
    "id": "agent-alpha",
    "clearance": "secret",
    "purpose": "threat-analysis",
    "session_id": "sess-001"
})

engine.assert_fact("data_request", {
    "agent_id": "agent-alpha",
    "target": "hr_records",
    "classification": "top-secret",
    "action": "read"
})

result = engine.evaluate()
print(result.decision)   # "deny"
print(result.reason)     # "Agent clearance 'secret' insufficient for 'top-secret' data"
print(result.duration_us)  # 47

Core Primitives

Primitive	Purpose	CLIPS Construct
Templates	Define fact schemas with typed slots	deftemplate
Facts	Typed instances asserted into working memory	working memory
Rules	Pattern-matching logic with conditions and actions	defrule
Modules	Namespace rules with controlled execution order	defmodule
Functions	Reusable logic for conditions and actions	deffunction

Key Differentiator: Working Memory

Unlike stateless policy engines (OPA, Cedar), Fathom maintains working memory across evaluations within a session:

• Cumulative reasoning — "This agent accessed PII from 3 sources — deny the 4th."
• Temporal patterns — "Denial rate spiked 400% in 10 minutes — escalate."
• Cross-fact inference — "Agent A passed data to Agent B, who is requesting external access — violation."

Integration

As a library:

from fathom import Engine
engine = Engine.from_rules("rules/")
result = engine.evaluate()

As a sidecar:

docker run -p 8080:8080 -v ./rules:/rules kraken/fathom:latest
curl -X POST localhost:8080/v1/evaluate -d '{"facts": [...], "ruleset": "access-control"}'

As an MCP tool:

from fathom.integrations.mcp import FathomMCPServer
server = FathomMCPServer(engine)
server.serve()

Rule Packs

Pre-built rule collections (planned):

• fathom-owasp-agentic — OWASP Agentic Top 10 mitigations
• fathom-nist-800-53 — Access control, audit, information flow
• fathom-hipaa — PHI handling, minimum necessary, breach triggers
• fathom-cmmc — CMMC Level 2+ controls

Performance Targets

Operation	Target
Single rule evaluation	< 100µs
100-rule evaluation	< 500µs
Fact assertion	< 10µs
YAML compilation	< 50ms

Related Projects

• Bosun — Agent governance built on Fathom (fleet analysis, compliance attestation)
• Nautilus — Intelligent data broker built on Fathom (multi-source routing, classification-aware scoping)

Development

git clone <repo-url>
cd fathom
uv sync
uv run pytest

See design.md for the full specification and roadmap.

License

MIT — see LICENSE for details.

---

Maintained by Kraken Networks