Cruxible Core README
The full upstream README, mirrored here for reference. Install config, tool schemas, adoption signals, and an original overview live on the Cruxible Core listing page.
Cruxible
cruxible.ai · quickstart · docs · kits · skills
Cruxible is a governed state engine for AI agents. It produces a Crux: an executable artifact of your domain knowledge with a code-like lifecycle — typed, reviewed, versioned, auditable, and tested against outcomes.
The problem. Code is typed, reviewed, and versioned; it executes deterministically, and tests verify it in seconds. The judgments, observations, reusable actions, and decisions agents produce land in prose — which doesn't execute, has no governed path from proposed to trusted, and puts no bounds on what gets repeated. Real decisions resolve over weeks or months, long after anything is still tracking them. And prose can't serve as shared ground: an organization running many agents needs them all acting on the same current claims, rules, and reviewed ways of acting, not on each agent's own reading of the documents.
How it works. You declare the domain ontology and its rules in YAML. Reproducible pipelines turn trusted source data into typed state. When an agent or human makes a judgment, Cruxible can require evidence and review before the claim becomes live. When an agent learns a way of acting that works, it can propose that too: a Procedure passes through the same review cycle as a claim and runs only within its declared inputs, preconditions, and limits. A decision can be required to declare, before it is accepted, what result will count as success; the outcome contract comes due on its own schedule and records what reality said. Queries and actions run against the same live state, and invalid changes are refused. No LLM runs inside the engine.
Why use it. Every agent works against the same live claims and can invoke the same reviewed, bounded Procedures. Invalid writes and actions are refused, contradictions remain visible until resolved, decisions can be checked against what happened, and computed answers, mutations, and action runs carry receipts that explain them. Snapshots capture exact config, lock, graph state, and procedure definitions at a revision for comparison, branching, and transfer; backups preserve the complete audit stores for recovery. The whole artifact outlives any single session or model.
One small example: a supplier inventory and incident feed build entities from pinned sources. An agent concludes that an incident impacts a supplier, but the relationship is declared a judgment call:
Now the policy is part of the runtime. The direct write is refused, review admits the judgment, and a query computes its consequence:
The source facts came through deterministic ingest; the inferred edge entered through review. Queries can now traverse its consequences, guards and gates can act on it, and later observations can contradict it without silently rewriting history.
Continue through a learned action, measured outcome, and correction
The complete lifecycle, abbreviated:
The Procedure is immutable once accepted and can call only capabilities the operator exported, within its reviewed preconditions and budgets. The outcome contract is declared before the decision becomes live and pins how success will be measured. The attestation is an append-only observation: resolving it does not silently change the claim, so the subsequent rejection is a separate, receipted decision. The old claim, observation, and reasoning remain available after live query results change.
Cruxible uses the same boundary itself: this repository refuses a push to main until state pins an approved review (how).
pip install cruxible— the Quickstart goes install to first query; Get Started below runs the seeded demo world in ~3 minutes, with no model calls or API keys.
Inside a Crux
Model — declare the world and the rules that govern it
- Entity types, relationships, enums, contracts, queries, guards, and gates live in one Terraform-like config
- Kits package a reusable model with its policies, workflows, and providers; overlay kits compose domain and operating models without copying them
- Authoring skills help draft the ontology from source systems and artifacts; the operator reviews the contract the runtime will enforce (Modeling State)
Settle — turn evidence and judgment into live operational state
- Sources remain content-hashed artifacts; claims cite exact source locations instead of copying the corpus into the graph
- Deterministic facts can be built through previewed, lock-pinned workflows; judgment enters as an evidence-backed proposal
- Per-type
write_policychooses direct, proposal-only, or mint-only admission; guards enforce evidence, transitions, and co-writes at one chokepoint (Concepts) - Judgment calls land in review groups carrying their matching evidence; review mints attributed state with the rationale on record
- Four cumulative permission tiers per credential; a guard can require the reviewing actor differs from the creating actor, anchored on receipts (Auth And Agent Roles)
Compute — derive exact answers from the same live state
- Named traversals compute blast radius, dependencies, eligibility, and other recurring answers outside the model
- Query receipts identify the state revision and graph paths used; truncation and pagination are explicit rather than silently incomplete
- Compact output profiles, bounded neighborhoods, graph-shaped results, and a local read working set keep agent context proportional to the question
Act — execute learned procedures without granting arbitrary code
- Procedures are agent-proposable compositions of capabilities explicitly exported by the operator, with declared preconditions and execution budgets (Concepts)
- Independent acceptance pins an immutable Procedure to the reviewed config and lock; stale pins fail closed and revisions supersede rather than mutate it
- Every run is bounded and receipted. Guards protect state writes; gates hold external actions such as merges or deploys until live state permits them
Observe — connect action back to evidence without silent self-modification
- Attestations append dated support, contradiction, or uncertainty to an exact claim without changing its live status; reviewers resolve the discrepancy
- Outcome contracts declare the success criterion and pinned measurement before a decision is accepted, then record what reality said when the check comes due
- Corrections, rejections, and supersession remain explicit governed events. Outcomes inform the next revision; they do not rewrite state automatically (Concepts)
Operate — one daemon, many interfaces, state you own
- MCP server, CLI, and Python client against the same daemon, credentials, and tiers; agent setup is one MCP config block
- Snapshots, backups, state publishing, and an inspection UI over a SQLite file, portable as one artifact (Isolated Deployment)
Get Started
Build your own Crux with the
authoring skills
and Modeling State,
or run the demo — a seeded supply-chain world, ~3 minutes, with no model
calls or API keys. Sandbox writes attribute to a built-in operator
identity:
When agents join, identity turns on: restart with CRUXIBLE_SERVER_AUTH=true,
claim the bootstrap credential, and mint each agent its own token — every
write is attributed. Details, permission tiers, and hardening:
Quickstart ·
Runtime Auth And Agent Roles.
The Rules Run
Cruxible never asks a model to follow the rules, because the rules run as code. A rule declared in config runs at the write chokepoint on every mutation, and there is no code path around the chokepoint.
| Prompted | Enforced |
|---|---|
| "The agent knows an exposure can't be closed while unremediated" | The write chokepoint refuses the transition until the remediation claim, with its evidence, is linked |
| "The model says these sources support the claim" | The write is refused unless every reference dereferences to a content-hash-verified source chunk |
| "The agent was told not to accept claims it proposed itself" | The guard compares the acting actor against the creation receipt's recorded actor and refuses, including create-as-accepted |
| "The agent learned a reusable action sequence" | A Procedure may call only exported providers, within declared preconditions and budgets; independent acceptance pins it to the reviewed config and lock, and every run leaves a receipt |
Guards face inward (the write boundary of live state); gates face outward (an external action holds until state agrees).
A declared gate, wired into git pre-push
This repository runs on that gate: it refused our own 0.2.2 release push until the review record was corrected in state. We fixed the state, not the hook.
The Full Walkthrough
The deep dive builds one governed truth end to end: a single
reviewed judgment lets a query walk a recursive bill of materials and
name every exposed shipment five typed hops downstream, with a receipt
you can explain.
The screenshot is the review seat in the inspection UI: each proposed edge carries the evidence that matched it, with a provenance rail back to workflows, receipts, and traces.
Where Cruxible Fits
Cruxible does not replace source systems, documents, or retrieval. Those layers help agents find and interpret evidence. Cruxible holds the smaller set of commitments that the rest of the system must query consistently, enforce, or act through.
| Layer | Job |
|---|---|
| Source systems, artifacts, and retrieval | Preserve and find the evidence |
| Agents and humans | Interpret evidence, propose claims and Procedures, review judgment |
| Cruxible | Maintain claim lifecycle, execute exact reads and bounded actions, enforce policy, and attach receipts and outcomes |
If information is only useful to read, leave it in the artifact or retrieval layer. When agents across sessions must rely on it as current, traverse its consequences, enforce it, or act through it, compile that knowledge into a Crux.
Kits
A kit is a reusable template for a Crux: it packages an ontology with its governance, queries, workflows, and providers as one versioned, composable unit. Per-kit guides run each end to end.
| Kit | Kind | What it models |
|---|---|---|
| agent-operation | Agent operating state | Work items, review requests, decisions, risks, open questions, state notes, actors, lifecycle, and dependency context. |
| project-domain | Domain overlay state | Roadmap items, milestones, release lines, and product areas composed over the agent-operation base — the project state Cruxible itself runs on. |
| agent-release | Domain overlay state | Agent systems, versions, eval suites and runs, with governed certification and promotion gates. |
| kev-reference | Domain reference state | Public known-exploited vulnerability reference data. Consumed as a published state release (state create-overlay); init the kit itself only to build offline or publish your own. |
| kev-triage | Domain overlay state | Local asset exposure, service impact, controls, incidents, findings, remediation, and governed vulnerability triage. |
| supply-chain-blast-radius | Domain state | Suppliers, components, assemblies, products, shipments, and incident blast radius. |
| case-law-monitoring | Domain state | Matter-centered case-law monitoring and authority impact. |
Documentation
- Quickstart — install to first query
- Concepts — architecture and primitives
- Deep Dive — a governed domain end to end
- Modeling State — designing an ontology
- Config Reference — the YAML config schema
- CLI Reference · MCP Tools · AI Agent Guide
- Kit guides — KEV, supply chain, case law, agent operation — plus deployment, auth, backups, and publishing, all under
docs/; agent skills for authoring state from your data
Technology
Cruxible uses Pydantic for validation, NetworkX for in-memory graph operations, Polars for data operations, SQLite for local durable state, FastAPI for the daemon, and FastMCP for MCP tools.
Contributing
Contributions welcome — see CONTRIBUTING.md. If governed agent state is a problem you're working on, star the repo or open an issue with your use case.
License
Apache 2.0