Two proprietary capabilities, in order: it learns your field, then it maps the path to your goal. The second only impresses once the first lands.
Before a single question is asked, Crift builds itself into a genuine expert on your field — through three pipelines that run in sequence and hand off to each other.
The engine researches the domain on its own and surfaces what matters — the moving parts, the forces, the failure modes a practitioner knows are in play. It doesn't wait to be fed documents; it finds the shape of the field, then enriches each finding into a defined, scored piece of knowledge.
It discovers how those pieces relate — including the non-obvious links an expert sees and an outsider misses. This is the step that turns a pile of facts into a knowledge graph: a web where everything that touches everything else is wired together.
Finally it organizes the learned field so the exact right knowledge surfaces at the exact right moment, when a real problem comes in. Crift calls each living model of a field a namespace — and it shows up to your problem already expert.
Hand it a goal and it returns a full, auditable map of the way through — every step traceable to what it learned, every gap named as its own item you can act on.
The spine — the route from where you are to the goal. The word means a path in Old English; the product is named for what it does.
The forces working in your favor — the things that move the path forward.
The obstacles, the contradictions, the risks working against you. Crift surfaces these instead of hiding them — and names every gap as its own item you can act on.
The unshaped objective enters, however it arrives.
A deal memo, a matter, a goal stated in a sentence. No schema required up front — Crift takes ambiguity as its input, not its obstacle. app.intake → app.project
The engine resolves the objective into a Lode tree.
Probabilistic decomposition descends the problem seam by seam, breadth-first through bands — generate, critique, select — branching into nodes a human can reason about. 8 node types · 6 operator families
Every node is tied to evidence before it stands.
The knowledge graph and RAG substrate anchor each conclusion to source. Nothing in the tree is asserted without a trace back to where it came from. kg.* · rag.* grounding
You survey the structure and stamp it.
The dry-run gate puts the entire proposed tree in front of you before anything commits. You approve, revise, or reject — the machine never moves without your seal. dry_run → ratify
The ratified tree re-projects as a sequenced workplan.
What you approved becomes an executable playbook — owners, order, dependencies — without re-authoring a thing. Reasoning and execution share one source of truth. playbook projection
Crift wears two faces over one core — a configurable system of record your business runs on, and a reasoning engine that maps the way through any problem inside it. Same foundation, same governance, same data.
Through a three-tier ingest: it discovers the field, connects it into a knowledge graph, and organizes it for recall — building itself into an expert before the first question, in a fraction of the time a person would take.
The reasoning map: a spine of propositions (the Lode), with Crests (helping forces) and Rifts (risks) along it — each node grounded in evidence and ratified before anything commits.