Cruxible Core

[Cruxible]

Cruxible

[PyPI version] [Python 3.11+] [License: Apache 2.0]

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:

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:

  $ 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.

INGEST       pinned feeds -> Incident, Supplier, Product, and Shipment stateCLAIM        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 releasedRUN          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 boundaryATTESTATION  contradict incident_impacts_supplier (claim remains live)REVIEW       attestation upheld; separate adjudication rejects the claimQUERY        incident_impacted_suppliers -> []
SNAPSHOT     exact config + lock + graph state + Procedure definitions captured

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

Get Started

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:

# shell 1 — local sandbox daemonCRUXIBLE_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-radiuscruxible context connect --server-url http://127.0.0.1:8100 --instance-id <instance-id>
# deterministic ingest: preview, then commitcruxible run --workflow build_seed_state && cruxible apply --workflow build_seed_state --from-last-previewcruxible 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 recordcruxible propose --workflow propose_incident_impacts_suppliercruxible group list --status pending_reviewcruxible group resolve --group <GRP-id> --action approve \  --rationale "Confirmed against supplier geography" --expected-pending-version 1
# receipted answers through the edges you just admittedcruxible query run open_incident_impacts --jsoncruxible 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.

Guards face inward (the write boundary of live state); gates face outward (an external action holds until state agrees).

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.

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.

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