Cadenya
Freemium
Developers building agentic workflows
Cruxible
FreeOpen SourceSelf-Hosted
Agent outputs that can't be audited, replayed, or verified against a known state are a liability — the kind that surfaces in a postmortem. Cruxible is a typed, verifiable state layer built specifically to give that guarantee back.
Similar tools
CadenyaFreemiumCadenya is an agent runtime built around a layered model: tools connect once through MCP…
WorldsFreemiumWorlds spins up a sealed twin of the external systems your agent touches — Stripe and Zendesk…
JevProxyFreemiumThe proxy sits in front of your Cursor or Claude Code agent fleet and classifies incoming tool…
Brain MemoryFreeBrain Memory stores agent decisions as Markdown files with YAML frontmatter, organized in a…
Get This Tool
License: Apache-2.0 Any use incl. commercial
Local-run terms: Install via pip and run under the Apache-2.0 license, which permits commercial use, modification, and distribution.
Screenshots 2
Pricing
- Model
- Free
Summary
Cruxible treats agent-written state as something that must be proposed, reviewed, and evidence-linked before it counts — not just logged after the fact. Every claim carries a receipt, every query can be reproduced, and every write goes through a structured proposal workflow rather than landing directly. The model fits audit-heavy domains where 'the agent said so' is not an acceptable answer. The ceiling appears when you need the tool to decide what to do next: Cruxible is a state layer and workflow runtime, not a planner, so you bring the decision logic yourself. Teams with existing data exports can convert them into structured state, but anything requiring dynamic planning or autonomous tool use sits outside this tool's scope.
Bottom line: Reach for Cruxible when your agents need a verifiable paper trail and governance over every write — and look elsewhere when you need the tool itself to plan the next action.
Find your fit
Before you choose Cruxible
More options in Agent Frameworks. Compare pricing, platforms, and features side by side.
Brain Memory
Free · Open source
Long-term continuity in multi-session coding projects
Pros
- Evidence-linked state claims, so every agent output can be traced back to its source rather than accepted on faith — which means audit requests become a query, not a forensic investigation.
- Proposal-and-review write governance, so no agent output modifies shared state without a structured approval step — which means you stay in the loop on consequential writes without wiring that control yourself.
- Reproducible query receipts, so a query over accumulated state can be re-run and verified — which means 'what did the agent know when it said that' has a deterministic answer rather than a shrug.
- Self-hostable under Apache-2.0, so the state layer and all evidence it holds stays inside your infrastructure — which means no vendor dependency on the component that carries your compliance-sensitive data.
- Existing knowledge base import via the wiki-import path the repository describes, so converting prior data exports into governed structured state does not require rebuilding from scratch.
Cons
- Cruxible contains no planner and no autonomous tool-use loop. Any agent behavior that requires deciding what step runs next — branching based on a prior result, retrying on failure, choosing between tools — must be implemented in the layer above it. Teams building anything beyond a linear deterministic workflow end up maintaining a separate planning runtime alongside Cruxible, which doubles the operational surface.
- The repository shows early community traction. With no prior related tools listed in the ecosystem and a small commit and star count at scrape time, there is no established community to pull patterns from when the docs run out. Teams that hit undocumented edge cases are filing issues against a project that has not yet accumulated that institutional knowledge — teams with a shorter runway on exploration abandon it for a more documented state management approach.
- The tool is Python-only based on the repository structure and pip installation model. Teams running agent infrastructure in Go, TypeScript, or other runtimes face a cross-language integration boundary at the state layer — a boundary that typically means either a sidecar process or abandoning the tool entirely for something that compiles into their existing stack.
About
- Platforms
- Python
- API Available
- No
- Self-Hosted
- Yes
- Last Updated
- July 9, 2026
Best For
Who it's for
- Teams building verifiable agent systems
- Domains requiring evidence-linked claims and audit trails
- Deterministic workflow execution over state
- Integrating agent outputs with existing data exports
What it does well
- Maintaining verified multi-agent state with evidence links
- Governing writes via proposal and review workflows
- Reproducing queries over accumulated state with receipts
- Converting existing knowledge bases into structured state
Frequently Asked Questions
- Is Cruxible free?
- Cruxible offers a free option. Hosting, model usage, or optional services may have separate costs; check the pricing details and official terms.
- Is Cruxible open source?
- Yes. Cruxible is open source.
- Can I self-host Cruxible?
- Yes. Cruxible supports self-hosting on your own infrastructure.
- What platforms does Cruxible support?
- Cruxible is available on: Python.
Curated lists that include this category
Agent systems fail quietly. State accumulates without attribution, queries return results that can’t be traced to their source, and writes land without any human review step in the path. Cruxible addresses exactly that failure surface: it is a typed, verifiable state layer where agents and humans operate together over shared, governed state. The core workflow is a proposal-and-review cycle — agents propose writes, reviews gate acceptance, and every accepted claim carries an evidence link so the state can be audited or replayed at any point.
The differentiating feature is the receipt model. The docs describe state queries as reproducible: you can re-run a query over accumulated state and get the same result with a traceable chain of evidence. For teams operating in regulated domains, compliance workflows, or any context where ‘show your work’ is a requirement rather than a courtesy, this architectural property is the reason to choose Cruxible over a generic memory store or vector database.
Cruxible fits as the state and governance layer underneath an agent system, not as the agent system itself. It is non-agentic by design — the vendor describes it as a deterministic workflow runtime, meaning the planning and decision logic lives in whatever orchestrates Cruxible, not inside it. Teams with existing knowledge bases can import them using the wiki-import path the repository describes. Where Cruxible breaks: if your use case requires autonomous planning, branching tool-use loops, or the runtime deciding which step runs next, you are building that logic yourself and wiring it to the state layer.
The repository is Apache-2.0 licensed, installable via pip, and self-hostable. It exposes a client package and a core package separately, and the repository includes a skills layer and kits structure for extending behavior. Community activity is early-stage — the vendor states 172 commits and 7 stars at the time of scraping — so teams adopting this tool are effectively building alongside the codebase rather than against a stabilized production API.
Contribute
- Work on Cruxible? Claim this listing.
- Embed a badge for your README or site.
Sign in to rate this tool or suggest an edit.