YuCe MCP server
Commit Nov 16, 2026Provides a deterministic evidence control kernel that tracks AI agent claims through byte-exact quotes and a hash-chained journal.
Also known as OrganeticSphere/yuce
- Stars
- 0
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 16, 2026
- License
- Apache-2.0
What is YuCe MCP?
YuCe provides a deterministic evidence control kernel that tracks AI agent claims through byte-exact quotes and a hash-chained journal.
Summary generated from the project's README
About YuCe MCP server
Tracking the validity of AI agent claims through byte-exact quotes and a hash-chained journal is what YuCe enables for developer teams. This deterministic evidence control kernel acts as a shared environment where agents of any model can submit observations, claims, and hypotheses. It ensures that every quote provided by an agent matches the source bytes exactly within a leased document section, preventing hallucinations or inaccuracies in citations.
Users interact with the kernel via MCP to coordinate tasks among multiple agents. The system maintains a sealed, append-only journal using SHA-256 hashing to ensure that any replay of the session reaches the same roots. If a source document is withdrawn, the kernel automatically identifies and lists all conclusions that relied on those specific bytes. This allows developers to audit exactly which parts of an agent's reasoning have lost their grounding without needing to query a language model again.
What you can do with it
- 1Audit fallen claims after source withdrawalIdentify which specific agent conclusions lost their support when a source document was revoked.
- 2Verify agent reasoning without a modelCheck a published journal and its supporting evidence independently using a verification tool.
- 3Generate cryptographic proofs for conclusionsCreate a small, signed file containing a single conclusion and all the byte-exact quotes it rests upon.
- 4Ensure deterministic session replaysRestart a stopped agent run and guarantee it reaches the exact same state and roots.
Written from the project's README. Every use case is checked against a quote from it.
Configuration
SBGK_MCP_TOKEN
| Name | Description | |
|---|---|---|
| SBGK_MCP_TOKEN | — |
Automated checks
Ran Nov 15, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachableorganeticsphere/yuce is public and reachablegithub.com/organeticsphere/yuce ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-14github.com/organeticsphere/yuce ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubYuCe
A source your AI agents quoted was withdrawn. Which of their conclusions need re-checking?
YuCe answers that from the record, not by asking a model. Your agents work through it over MCP: it hands each agent one bounded task at a time, accepts a quote only when its bytes occur in the source, records which conclusions rest on which quotes, and keeps the accepted records and their grounds in a sealed, hash-chained journal. When a source is withdrawn, the kernel itself lists the conclusions that stood on it, and the others stay standing. A stopped run replays its journal to the same roots, and anyone can check a published journal without a model.
A deterministic evidence control kernel for AI agent teams: Rust, Apache-2.0, calls no model. Agents of any model are its clients. Deterministic here means that the kernel's answers follow from its inputs and a journal replays to the same roots; two runs of a team differ, in their timestamps and in what their models write. An agent sends the text of a quote, not offsets: the kernel itself finds its bytes in the section the agent was leased.
What 0.2 adds
- What fell, and why.
sbgk audit-read fallen --wal run.walnames each record that lost a ground, the quotes that went (by their bytes, not their text) and why, the quotes under it that still stand, claims on other sources that say much the same, and what to reread. - A quittance for one conclusion.
sbgk audit-proofcuts one file with a record and everything it rests on, down to its quotes, under the signed checkpoint of a seal: 7 to 24 KB in the control runs.sbgk audit-proof-verifychecks it alone, with no journal and no model. - A journal anyone can check. The server seals the journal as it goes, and the seals are signed as C2SP checkpoints (Ed25519).
sbgk audit-verifychecks a journal against a receipt or a checkpoint kept elsewhere. Checking is always free. - Nothing skipped in silence. The gap pass (
--gap-pass, off by default) hands the parts of read sections that no quote covers back to the agents as narrow tasks: record what a part states, or answer empty. - An index beside the journal.
sbgk audit-indexbuilds a SQLite file any tool reads, rebuilt from the journal at any time.
The full list is in CHANGELOG.md.
Source revoked: one minute, no model, no API key
python examples/revoke-and-replay/demo.py --bin path/to/sbgk --html inspector_report.html
path/to/sbgk is the binary of a release (see Quick start), or cargo build --release builds it and the script
finds it without --bin.
Three readers and an owner work on one page of the MCP specification through the real audit server, in six checked steps:
- A quote with one byte changed is refused, and nothing is stored.
- Two byte-exact quotes and one claim on each are accepted, with receipts.
- The owner revokes the first quote: the claim on it loses its support, the claim on the other quote keeps it.
- The server is stopped and started on the same journal: the replay reaches the same roots and the same two states.
- A copy of the journal with one letter changed is refused on start.
- Without the server,
sbgk audit-verifychecks the journal against the receipt saved before the stop: verified; the edited copy: refused.
Open inspector_report.html to see what the kernel answered at each step: the quotes found byte for byte in the section
the reader was handed, the claims before and after the revocation, and both journal checks. The page works offline and
shows only the kernel's recorded answers (examples/revoke-and-replay/).
Results
The same team of agents with the kernel (K) and without it, on native Temporal (T) and native LangGraph (L), on 22 pages of the MCP specification across five revisions. Share of correct statements, graded blind; after reading (stage 1) and after each of two source withdrawals (2A, 2B):
| Agents (grader) | Stage 1: K / T / L | 2A: K / T / L | 2B: K / T / L |
|---|---|---|---|
| Claude Haiku 5.5 (Fable 5.1) | 89.9 / 79.3 / 84.9 | 90.5 / 86.6 / 88.8 | 88.7 / 86.7 / 85.8 |
| DeepSeek Flash, series 1 (Opus 5.5) | 91.8 / 83.3 / 83.0 | 91.8 / 74.6 / 81.4 | 91.7 / 91.9 / 86.7 |
| DeepSeek Flash, series 2 (Opus 5.5) | 89.6 / 92.1 / 84.9 | 89.6 / 83.8 / 85.2 | 89.7 / 81.0 / 88.9 |
| Four makers, run 1, before the fix of 0.1.6 (Opus 5.5) | 87.8 / 86.6 / 84.0 | 83.6 / 93.7 / 67.1 | 87.0 / 92.5 / 82.3 |
| Four makers, run 2 (Opus 5.5) | 88.2 / 50.0 / 81.8 | 85.9 / 80.5 / 77.5 | 82.2 / 70.4 / 76.9 |
| Four makers, control run of 0.1.7: K new, T and L of run 2 graded again (Opus 5.5) | 82.0 / 56.9 / 86.4 | 87.1 / 87.7 / 77.5 | 82.6 / 78.2 / 83.8 |
| Four makers, control run of 0.2: K new, T and L of run 2 graded again (Fable 5.2) | 98.9 / 66.7 / 89.6 | 98.9 / 89.6 / 83.8 | 98.9 / 85.9 / 92.5 |
| The same grading, K of the control run of 0.1.7 (Fable 5.2) | 86.5 / 66.7 / 89.6 | 86.5 / 89.6 / 83.8 | 88.8 / 85.9 / 92.5 |
| Three DeepSeek Flash readers with the gap pass, 0.2, no side without the kernel (Fable 5.2) | 91.5 / – / – | 90.4 / – / – | 91.4 / – / – |
We claim no gain in answer quality. The samples are small: one corpus, one or two runs per side, 45 to 158 graded statements each. The 95% interval of a difference is about 10 to 12 points either way; on the single-model runs one difference of the 18 clears it (DeepSeek series 1, 2A, against T: +17.2), none after correcting for 18 comparisons, and they are not independent: the kernel's answers of stage 1 and 2A are the same text. The advantage of DeepSeek series 1 did not repeat in series 2. Agents of four makers show how far two runs can fall apart: the kernel's side was 10.1 points below T in 2A of run 1, and T fell by 36.6 points in stage 1 of run 2 with nothing changed on its side. In the grading of 0.2 the same four readers scored 98.9 at every stage on 0.2 and 86.5 to 88.8 on 0.1.7, a gap wider than the grader's own spread (up to 2.6 points on the same text, 5.6 between its two label orders), but each side is one run.
What the kernel adds is the record, not the score. Every accepted quote is byte-exact and every claim names what it rests on, so what a withdrawal touches is read from those links rather than asked of a model, and a journal can be checked against its receipt by anyone. On the single-model runs every grading found that the kernel's side kept both withdrawals, and the sides without it kept them fully in 10 (T) and 8 (L) of 12 gradings and partly in the rest. On four makers the grader found a real gap: a reader stored a withdrawn sentence again, three bytes wider, the kernel took it as a new record, and an answer cited it. Since 0.1.6 a withdrawal closes the bytes, and in the second run no grounded record rests on the withdrawn text. Its answer was still graded partly kept after the second withdrawal, for dropping a conclusion another page supports. T kept all 8 gradings there, L 6. In 0.1.7 the kernel names what fell: in its control run the repair took one new claim per answer and the conclusion stood. The grader marked the second withdrawal kept in one order and partly in the other, for an earlier state written as current, which the answer held before the withdrawals. In 0.2 a repair also shows the live support of what fell. In both control runs no grounded record rests on the withdrawn text after either withdrawal, and the grader found no earlier state written as current in the kernel's answers, against 8 to 12 for 0.1.7. With four makers both withdrawals were kept in both orders. With three DeepSeek readers the second was kept partly: the model read the withdrawal of one changelog line as the withdrawal of the whole revision, and its repaired answer lost the sessions conclusion that a standing page supports.
The price. 2.3 to 2.5 times the wall time and 1.4 times the cost on Haiku; 1.2 to 1.3 and 1.5 to 1.6 on DeepSeek. Its side also makes 1.8 to 2.6 times the model calls in stage 1, and no side with an equal budget of calls was run, so what the kernel adds to the answers cannot be told from the extra reading. On DeepSeek it named fewer version transitions than T (9 and 7 to 8 of 13, against 13 and 12), and on 0.2 with four makers 9 or 10 of 13, against 12 for 0.1.7 and 13 for L. It checks bytes and registered dependencies, not meaning: on correct quotes its side once gave a current rule as replaced (Haiku) and once an outdated one as current (DeepSeek, series 2). See BENCHMARKS.md and LIMITATIONS.md.
What the kernel does
The environment for agent teams is the audit server, sbgk audit-serve:
- Shared records with exact quotes. Agents submit records:
observe,claim,relation,hypothesis,question,done. Anobservemust quote its source byte for byte, inside the document range issued with the task; otherwise it is rejected. Each source document is pinned by repository, commit, path and SHA-256 of its raw bytes, as listed in a manifest, or, for your own files, by its path in a folder and the SHA-256 of its bytes. - Grounds. A claim names the quotes it is based on (
based_on), and every one of them is required. The kernel tracks whether each claim is still grounded: all its quotes must stand. A claim cannot rest on another claim here; chains of derivations belong to the engine below. - Withdrawal with cascade. The owner can withdraw an
observerecord (audit_revoke) or a text of a document, quoted or not (audit_withdraw_text). That closes those bytes in the document: every stored quote overlapping them goes with it, and a new quote overlapping them is refused. Every record whose required grounds include one of those quotes loses its support at once; since all entries ofbased_onare required, one withdrawn quote is enough. Records grounded independently of it stay available, and history is not rewritten. The report of what fell (audit_fallen, orsbgk audit-read fallenover the journal) names each record that lost a ground, the quotes that went (by their bytes, without their text), the quotes under it that still stand, and claims on other sources that say much the same. A claim in an answer also carries a time label for its reader:CURRENT_UNCERTAIN(a claim that rested on an earlier and a later report lost the later quote; the kernel opens a task on that report and warns the next summary) orLATEST_KNOWN(no later state is known to the kernel, which is not proof that the state is current). With the experimental graph, acceptedsupersedeslinks addCITES_REPLACED(its quotes include an earlier state that was replaced, and none of the replacing one) andCITES_EARLIER_AND_LATER(quotes of both). - Hash-chained journal. Each accepted transaction is one frame of an append-only journal (
sbgk-session-log/3): canonical JSON (RFC 8785), a header that names the body by its hash and the accepted records by the root of their tree, linked by SHA-256 to the previous header, written and synced before the new state is published. Reopening a journal replays it and checks that it reproduces the sameaudit_rootandengine_root. The server seals the journal from time to time: the frames so far, the roots of the state and the hashes of what stands and what rests on what. Journals of 0.1 (sbgk-session-log/2) still verify. - Coordination. Work is cut into tasks. Each task is leased to one agent at a time; an expired lease is taken back.
A retry with the same submission id returns the original receipt instead of committing twice. Readers work in circles
(reading, then answering), with roles given per task. When the run is complete, the owner closes it (
audit_close), and agents that ask for work receiveDONE. - MCP access. The server answers MCP-style JSON-RPC 2.0 (
initialize,tools/list,tools/call) over TCP. Each agent has its own token from a subjects file, and the token's role (swarm,builderorowner) decides which tools it sees and may call.sbgk mcp-bridgelets an MCP client that starts its servers as stdio child processes join the shared server.
Underneath is the engine (sbgk apply, serve, mcp-serve). It binds evidence to exact byte spans of a document
version split into content-defined chunks, keeps facts and rule derivations, withdraws conclusions whose evidence is
revoked while re-deriving those that have another valid derivation, and stores the state as a .sbgk container with a
hash-chained log and a Merkle root. The minimal example below uses the engine.
Experimental, off by default. A graph builder (--build-scope full, with a dedicated builder subject) proposes links between records of
different agents (supports, contradicts, qualifies, supersedes, depends_on, same_as, duplicate_of), each
accepted or rejected by a kernel rule, by an agent that wrote neither end, or by the owner; the dynamic ontology
(--ontology-revisions, --ontology-review) grows and revises concepts during a run. Both are measured but not the default:
see LIMITATIONS.md.
What it does not do
- It checks bytes and structure, not meaning. The kernel checks that a quote occurs in the source and that a claim names live grounds. It does not check that a claim says what its quotes say; two agents can agree on a wrong reading.
- A hash chain alone does not authenticate history. Detecting a rehashed history, or a journal cut back to a valid prefix, needs a checkpoint trusted from outside the journal.
- The bridge restricts only what it is configured to. Without
--allow-tools,mcp-bridgepasses every tool through, and the server's role check is the only filter. The agent id and the token come from the bridge's configuration. Give each agent a restricted profile:--allow-tools,--agent-idand its own token. The servers have no TLS; a non-loopback--listenaddress needs--allow-remote(and, formcp-serve,--token). - Verification costs model calls. Link checks and re-reads after a withdrawal are extra work for the agents.
- Size. Up to 8 agents at once are recommended, as measured on 0.1, and runs of a few thousand records: the cost of a commit and of reopening the journal grows with it. A real run's journal of about 3,000 records reopens in about 2 s, as does a journal of 10,000 records of quotes and claims alone.
All of them, with what was measured: LIMITATIONS.md. Reporting a vulnerability: SECURITY.md.
Three ways to use it
- On its own. Run
sbgk audit-serveon your corpus (a folder of text files, or a manifest of sources pinned by commit and SHA-256) and let your agents call its MCP tools, each with its own token, from any language or through the Python client. See An audit server on the open corpus. - With a team you run. The benchmark runner (
benchmarks/run_pilot_ac.py) drives a team of readers and a checker through the kernel on DeepSeek, on Claude through Claude Code, or on a stub model that makes no calls, and runs the same team without the kernel for comparison.python benchmarks/run_pilot_ac.py --helplists its options. - Next to the tools you use. An MCP client such as Claude Code joins as one agent through
sbgk mcp-bridge(below). An orchestrator calls the same MCP tools from its own steps: the runner's native Temporal and LangGraph sides show the same team on those frameworks (benchmarks/sbgk_bench/arm_a_temporal.py,arm_a_langgraph.py; their packages:benchmarks/requirements-baselines.txt). There is no dedicated adapter yet.
Quick start
The shortest way is a release: binaries for Linux, macOS and Windows, with SHA-256 sums, are on the
releases page. Check the sum, unpack, and run sbgk --help (or yuce --help,
the same commands). The Python client is on PyPI:
pip install organetic-yuce
One agent on your own folder
A folder of UTF-8 text files, one question, one agent (Claude Code, Cursor or any MCP client):
cat > questions.json <<'EOF'
[{"id": "q1", "text": "What do these documents say about refunds?", "about": ["refund"]}]
EOF
sbgk audit-serve --profile solo --docs ./my-docs --questions questions.json --run-id mine --wal mine.wal --listen 127.0.0.1:8787
--profile solo runs one reading agent without a graph builder. Without --subjects the server writes mine.wal.subjects.json
beside the journal with two tokens, agent for your agent and owner for you, and never prints them. Join your MCP client as
agent with the bridge entry below (--agent-id agent, its token in SBGK_MCP_TOKEN). about names the words your documents
use for the topic: if no document holds any of them, the server says so at the start and in audit_status.
The same flags fit in one file: sbgk audit-serve --settings settings.json, with relative paths taken from the file's folder.
examples/settings/ holds one you can run as it is.
The examples below are in this repository, not in the release archives. To build from source with a current stable Rust toolchain and run the tests:
cargo build --workspace --release
cargo test --workspace --release
The build puts sbgk and yuce in target/release/.
A minimal example
examples/quickstart/ holds an ontology, one policy document and a five-step JSONL stream: two exact quotes, two facts
resting on them, and one derivation.
Q=examples/quickstart
# Apply the stream: every quote must occur byte for byte in the document, or the step is refused
# (QUOTE_NOT_FOUND_IN_BYTES, with the nearest candidates from the document)
./target/release/sbgk apply --ontology $Q/ontology.json --docs $Q/docs --stream $Q/stream.jsonl --out graph.sbgk
./target/release/sbgk apply --ontology $Q/ontology.json --docs $Q/docs --stream $Q/stream_prefix.jsonl --out graph_prefix.sbgk
# Check the container: header, chunks, node table, hash chain of the log, quote anchors (exit code 1 if a check fails)
./target/release/sbgk verify graph.sbgk
# The support cone of one entity: only what its conclusions rest on
./target/release/sbgk cone graph.sbgk --entity svc_auth --out cone.json
# What differs between two states, and the state after step 3
./target/release/sbgk diff graph_prefix.sbgk graph.sbgk
./target/release/sbgk timetravel graph.sbgk --seq 3
YuCe MCP questions
How does the kernel handle withdrawn sources?
When a source is withdrawn, the kernel automatically identifies and lists all conclusions that relied on those specific quotes, while allowing independent conclusions to remain.
Can the journal be verified without an AI model?
Yes, the journal is sealed with Ed25519 signatures, allowing anyone to verify the integrity of the records and the state without needing a model.
How does the server ensure quotes are accurate?
The kernel requires that every observation quote its source byte-for-byte within the assigned document range; otherwise, the submission is rejected.
Does the kernel require an API key?
No, the kernel can operate without an API key.