Not a product

ELLM is the technology our products are built on. We don’t sell it, and its source isn’t public yet — we may publish it in the future. Determinism is only worth something if it can be checked, and when we publish, it will be.

The family, and how each relates to the engine:

• Guardrail — in beta. Compiles your policy into a Rete network; classifies tool calls in 15µs (p50), 0 false-ALLOW across 115 cross-ecosystem tests.
• Engram — in beta. Content-addressed frames give memory a deterministic identity and full audit trails.
• Amparo — in beta. Part of the ELLM lineage — its agent core came out of the system developed in conjunction with ELLM — and today it acts through Guardrail as its policy engine and Engram as its memory.

If you want to build something on ELLM — commercially or otherwise — we’d like to hear about it: Elai-intelligence@pm.me. That’s a conversation, not a pitch.

What it is

ELLM is a symbolic reasoning kernel — an embeddable inference engine that reasons over facts using deterministic forward-chaining rules. It’s not an LLM. It’s not probabilistic. It’s the layer of certainty underneath AI that needs to be right.

User query → NL compiler → Symbolic kernel → forward-chain to fixpoint
                                                 │
                            ┌────────────────────┼────────────────────┐
                            ▼                    ▼                    ▼
                      Direct answer       Frame-resolved          Gap / "I don't know"
                      (IS_A proof)        (rule match)            (explicit, no confabulation)

The ideas

Frames all the way down

Everything in ELLM is a frame — a (subject, relation, object, confidence) tuple. Facts, rules, conversation turns, system state, memories. All the same structure. All queryable. All auditable.

(frame Arc IS_A struct)
(frame Arc SAFE_TO_SEND Send)
(frame user WANTS to_learn_rust)
(frame (EXEC guardrail_check) YIELDS allow)

Content-addressed by design

Every entity ID is a deterministic hash of its name. No registry. No lookup table. Two kernels that independently learn the same rule produce identical frames, bit for bit. Deduplication and merge conflicts vanish. Fleet synchronization becomes a CRDT problem with known solutions.

The kernel directs the LLM — never the reverse

When the kernel reaches the limits of purely symbolic resolution, it can direct an LLM to synthesize natural language from frames the kernel has verified. The LLM is a capability the kernel uses — the same as file I/O or process spawn. It is not an oracle the system defers to.

Unknown beats wrong

Unresolved queries become explicit gaps, not confabulations. The system says “I don’t know” rather than inventing an answer. Every knowledge gap is captured, logged, and fed into the learning pipeline.

Auditable inference traces

Every answer traces back to specific rules that fired. Every rule traces to evidence sources. No opaque weights. No stochastic hallucination — deterministic derivation.

Query: "is Arc thread-safe?"
Trace:
  Step 1: Encode "Arc" → (Arc, IS_A, struct)
  Step 2: Match rule struct_rule_42
  Step 3: Fire rule → (Arc, SAFE_TO_SEND, Send)
  Step 4: IS_A traversal
  Result: (Arc, SAFE_TO_SEND, Send) with confidence=200

What it powers

Embeddable at every scale

The graduated autonomy model

As the rule base compounds through learning, LLM dependence decreases. The kernel accumulates knowledge; LLM fills gaps that shrink over time. This is a direction — not a claim about current state. But it’s the only architecture in the space designed for this trajectory.

What exists today

• CortexKernel — production forward-chaining rule engine with Rete network
• NL compiler — deterministic text-to-frames and frames-to-text
• Oracle triad — RustcOracle, SynOracle, COracle for code verification
• QEM — Quantized Engram Memory: holographic associative recall with XOR binding
• Effect system — EXEC frames gated by capability, for side effects
• Proof certificates — Ed25519-signed Fitch-style natural deduction traces
• Elonic PCLM — Lisp-style DSL for programming the kernel
• 13,500+ curated rules across 60+ domains