Lock-free atomic execution
No synchronisation bottleneck and O(1) resource acquisition. Thousands of agents execute concurrently without blocking each other.
GraphBit · The execution engineThe model reasons.
The model reasons.
It never routes.
GraphBit is a Rust-core execution engine for AI workflows that have to survive an audit. Deterministic control flow, model reasoning inside hard guardrails, and a reproducible record of every step.
01ingest → parse_transaction0.4 ms
02resolve_jurisdiction → DE0.2 ms
03graph_lookup → subgraph @ 2025-11-041.1 ms
04llm_reason → characterisation8.9 ms
05constraint_check → within guardrail0.7 ms
06emit_verdict + derivation0.6 ms
run 0001 … run 1000identical path · identical output
entry 01the problem with agent frameworks
The model is not the risk. The orchestration is.
In a conventional agent framework, a language model decides which tool to call, which branch to take, and when the work is finished. Those are control-flow decisions made probabilistically.
The result is a class of failure that has nothing to do with model quality: the framework routes to the wrong step and produces a confident, well-formed, wrong answer. We call it framework-induced hallucination, and it is why AI stalls at the pilot stage in regulated workflows.
GraphBit removes the model from control flow entirely. A Rust-core DAG governs every step, route and tool call. The model interprets context inside hard guardrails — it can read a contract, but it can never guess a rule.
entry 02architecture
Three layers. Only one is probabilistic — and it is fenced.
Ground truth
The knowledge graph
Legal and regulatory text is constructed into a versioned, effective-dated graph — per jurisdiction, per domain. Not a hand-written rulebase and not a vector index of documents: a structured representation of the source text, with provisions and their relationships addressable at evaluation time. Specialised agents traverse the subgraph that applied on the transaction date.
Cognition
Isolated model reasoning
Language models do the work only they can do — reading contracts, delivery notes, CRM records and free-text descriptions, and mapping messy reality onto the graph's vocabulary. They are called in isolation, with a bounded task and a bounded context. They hold no state and make no routing decision.
Control
The deterministic Rust DAG
Every step, route, tool call and termination condition is fixed in the graph and executed by the Rust core. The same input traverses the same path every time. Every node emits a record: what was evaluated, against which provision, at which version, with what result.
The consequence: zero framework-induced hallucination. Not a lower error rate — a class of error removed by construction. That is what makes the output signable.
entry 03engine
Determinism is a runtime property, not a prompt.
Python orchestration frameworks inherit the GIL, garbage-collection pauses and serialisation overhead at every hop. GraphBit's core is Rust; Python and TypeScript are interfaces to it, not the runtime.
Bidirectional dependency caching
Graph traversal collapses from O(V+E) to O(1) lookups. Routing is resolved structurally, never inferred.
Zero-copy across languages
Rust core with Python and TypeScript bindings via PyO3. No serialisation cost at the boundary, no penalty for a familiar developer surface.
No GC pauses
Rust's ownership model removes garbage collection from the hot path, so latency stays flat under sustained load.
Async by default
An async runtime carries long-running, IO-bound agent work without thread-per-task overhead.
Immutable step log
Every node execution is written with a timestamp, the inputs it saw and the graph version it read. Any past run can be reproduced exactly.
entry 04measured
100% routing reliability.
0% framework-induced hallucination.
GAIA benchmark, 68 real-world agentic tasks, identical models and identical task set across all five frameworks. The difference measured is the orchestration layer, not the model.
| Framework | Routing reliability | Framework-induced hallucination | Latency | Memory |
|---|---|---|---|---|
| LangChain | 58.8% | 41.2% | 36.1 ms | 234 MB |
| LangGraph | 52.9% | 47.1% | 31.5 ms | 208 MB |
| CrewAI | 66.2% | 14.3% | 31.0 ms | 202 MB |
| Pydantic AI | 85.7% | 0.0% | 18.3 ms | 167 MB |
| GraphBit | 100.0% | 0.0% | 11.9 ms | 126 MB |
0%framework-induced hallucination
100%routing reliability
3×throughput vs. best baseline
7.1×fewer tokens consumed
Source: GraphBit, submitted to EMNLP 2026 (Budapest) — under review. Co-authored with Dr. Shafiq Joty, Senior Research Director, Salesforce AI.
entry 05why it improves
Your automation rate rises with use.
A static rulebase decays from the day it ships — the vendor updates on their cadence, and your team absorbs the gap. GraphBit works the other way: every edge case your experts resolve is written back into your graph, and the next transaction of that shape is handled automatically.
The ceiling is not fixed
The share of your load the engine settles without human touch grows month over month — measurably, in your own numbers, not in a roadmap.
Inside your environment
The resolved logic accretes into your own graph, in your own deployment. It reflects how your business actually transacts — and it stays yours.
Run
The engine validates the bulk of the load against the graph and returns a verdict with its derivation.
Flag
What cannot be verified against the law is flagged — never waved through, never silently decided.
Resolve
An expert rules on the edge case once, in their normal review workflow.
Absorb
The resolved logic is written back into the graph, versioned and dated.
The next transaction of that shape is handled automatically.
entry 06where it runs
One engine, applied where being wrong is expensive.
Product
Tax Solutions
Substantive validation of every indirect-tax transaction, transfer pricing local files, customs classification, audit working papers. Grounded in the legal text, defensible years later.
Explore Tax Solutions →ProductDocument Intelligence
Requirements extracted from specifications, tenders and standards into structured, traceable form — then validated against the source, clause by clause.
Explore Document Intelligence →In production at a top-10 audit and advisory firm and at industrial manufacturers across automotive and process engineering.
entry 07next step
Two hours. Your data. You leave with findings.
The working session: we run a sample of your real cases through the engine, live. No slideware — you leave with verdicts and the derivation behind each one.
Certified and assessed
ISO/IEC 27001TISAXPatent pendingEU AI Act — Art. 12 / 14 / 15
Deployable inside your environment. Sensitive data is tokenised before any external model contact, so client data does not leave your compliance perimeter.