io.github.cruxible-ai/cruxible-core MCP Server

This MCP server exposes a deterministic decision engine that uses receipts. It lets users define rules in YAML, query a graph, and obtain proof. The project is described with topics spanning AI agents, governance, ontology, provenance, state-management (including hard-state), and local-first workflows, with SQLite and Python mentioned.

🛠️ Key Features

Deterministic decision engine
Receipts for outcomes
YAML-based rule definitions
Graph queries
Proof generation

🚀 Use Cases

AI agents and multi-agent systems
AI governance and agent governance
Knowledge-as-code workflows
Ontology-driven reasoning with provenance tracking
State management using hard-state concepts

⚡ Developer Benefits

Integrates with Model Context Protocol (MCP)
Works with Python (3.11+ indicated)
Supports graph querying and proof-oriented results
Uses SQLite for data handling (as indicated by topics)

⚠️ Limitations

No tool count or specific MCP tools are provided in the available data
Implementation details beyond YAML rules, graph queries, and proof are not described in the provided excerpt

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.

What agent platforms are missing — state management, reviewed reflection, shared knowledge artifacts — and the Crux that answers them: typed claims and procedures with a review lifecycle, outcome contracts and gates, versioned and receipted

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:

yaml

entity_types:
  Incident:
    id: incident_id
    properties:
      title: string indexed
  Supplier:
    id: supplier_id
    properties:
      name: string indexed

relationships:
  - incident_impacts_supplier: Incident -> Supplier
    write_policy: proposal_only        # judgment call: enters only through review

named_queries:
  incident_impacted_suppliers:
    mode: traversal
    entry_point: Incident
    returns: Supplier
    traverse:
      - relationship: incident_impacts_supplier
        direction: outgoing

Now the policy is part of the runtime. The direct write is refused, review admits the judgment, and a query computes its consequence:

diff

  $ cruxible relationship add incident_impacts_supplier \
      Incident INC-TW-RAIL-2026-07 Supplier S-CN-DG-HARNESS
- Error: DirectWriteRefusedError: Direct write to relationship
- 'incident_impacts_supplier' is refused (write_policy=proposal_only).
- Use 'group propose' to stage a governed proposal. (receipt: RCP-…)

  $ cruxible propose --workflow propose_incident_impacts_supplier
  $ cruxible group resolve --group <GRP-id> --action approve \
      --rationale "Confirmed against supplier geography"

  $ cruxible query run incident_impacted_suppliers \
      --param incident_id=INC-TW-RAIL-2026-07 --json
+ { "items": [ { "entity_type": "Supplier", "entity_id": "S-CN-DG-HARNESS" } ],
+   "receipt_id": "RCP-2f61a90c84d3" }

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:

text

INGEST       pinned feeds -> Incident, Supplier, Product, and Shipment state
CLAIM        incident_impacts_supplier: pending -> live (evidence + reviewer)
QUERY        incident_impacted_suppliers -> [S-CN-DG-HARNESS]

PROCEDURE    hold_exposed_shipments v1: pending -> live (config + lock pinned)
DECISION     hold exposed shipments; success = zero exposed shipments released
RUN          bounded provider calls complete -> receipt RCP-run-...
OUTCOME      pinned query at check time -> satisfied -> receipt RCP-outcome-...

OBSERVATION  new evidence says the supplier was outside the incident boundary
ATTESTATION  contradict incident_impacts_supplier (claim remains live)
REVIEW       attestation upheld; separate adjudication rejects the claim
QUERY        incident_impacted_suppliers -> []

SNAPSHOT     exact config + lock + graph state + Procedure definitions captured

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_policy chooses 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

bash

pip install cruxible

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:

bash

# shell 1 — local sandbox daemon
CRUXIBLE_SERVER_STATE_DIR="$HOME/.cruxible/sandbox" cruxible server start

# shell 2 — kit bundles are fetched from the release and digest-verified
# (agent-operation is the optional agent-ops layer; domain-only works too)
cruxible --server-url http://127.0.0.1:8100 init --kit agent-operation --kit supply-chain-blast-radius
cruxible context connect --server-url http://127.0.0.1:8100 --instance-id <instance-id>

# deterministic ingest: preview, then commit
cruxible run --workflow build_seed_state && cruxible apply --workflow build_seed_state --from-last-preview
cruxible run --workflow ingest_incidents && cruxible apply --workflow ingest_incidents --from-last-preview

# the incident feed can only PROPOSE impact edges; the judgment is yours, on the record
cruxible propose --workflow propose_incident_impacts_supplier
cruxible group list --status pending_review
cruxible group resolve --group <GRP-id> --action approve \
  --rationale "Confirmed against supplier geography" --expected-pending-version 1

# receipted answers through the edges you just admitted
cruxible query run open_incident_impacts --json
cruxible query run incident_impacted_suppliers --param incident_id=INC-TW-RAIL-2026-07 --json

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

yaml

gates:
  merge-review:
    kind: git-pre-push
    entity_type: ReviewRequest
    match_property: change_head
    condition: {status: approved}
    adapter: {branch_pattern: refs/heads/main}

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.

Cruxible review group page: signal matrix, proposed edges each carrying matching evidence, and a provenance rail with workflow, receipts, and provider traces

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

io.github.cruxible-ai/cruxible-core