# GraphBit: the benchmark table has a column titled Other Frameworks

> A Rust workspace with a maturin-built Python wheel on top of it, sold on deterministic concurrent execution and a set of efficiency multiples. The measured claims are internal, the comparison set is unnamed, and the release tags describe the wheel rather than the crates, which is a reasonable shape for the project and worth understanding before you rely on any of it.

**InfinitiBit/graphbit** — GraphBit is the world’s first enterprise-grade Agentic AI framework, built on a Rust core with a Python wrapper for unmatched speed, security, and scalability. It enables reliable multi-agent workflows with minimal CPU and memory usage, making it production-ready for real-world enterprise environments.

- Repository: https://github.com/InfinitiBit/graphbit
- Website: https://graphbit.ai
- Stars: 586 · Forks: 120
- Language: Rust
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/infinitibit-graphbit

## The comparison column has no names in it

The efficiency claim is the centre of the page, and it rests on a table with one row that cannot be checked:

| Metric | GraphBit | Other Frameworks | Gain |
|:---|:---|:---|:---|
| CPU Usage | 1.0x baseline | 68.3x higher | ~68x CPU |
| Memory Footprint | 1.0x baseline | 140x higher | ~140x Memory |
| Execution Speed | equal or faster | (none) | Consistent throughput |
| Determinism | 100% success | Variable | Guaranteed reliability |

The prose around it calls the suite internal and the opponents leading Python-based agent frameworks, so no version, no configuration and no name appears. The execution speed row has no competitor figure at all, which means the one dimension where a reader might assume a like-for-like number exists has none, and the word Variable in the determinism row is doing the same work as the multiples.

The prose repeats the numbers as up to 68 times lower CPU and 140 times lower memory while maintaining equal or greater throughput, and a video demo of the benchmark is linked beneath the table.

## One named production customer, one sentence

The section headed Used in Production contains a single company. Grant Thornton Germany is described as having adopted GraphBit to move AI from permanent pilot to production without regulatory risk, as a core component of their tech stack. That is the whole of the production evidence on the page: one organisation, one sentence, no description of which parts of the framework they run.

The rest of the positioning section is written as a filter rather than a claim. It asks you to choose the framework if you need production-grade multi-agent systems that will not collapse under load, type-safe execution and reproducible outputs, real-time orchestration for hybrid or streaming applications, or Rust-level efficiency with Python-level ergonomics, and then says it is for you if you are scaling beyond prototypes or care about runtime determinism.

So the page tells you who it is for more precisely than who has used it, which is the inverse of the usual arrangement.

## The release tags describe the wheel, and the casing changed

The three newest tags all name the Python package rather than the crates:

`Graphbit_Python_v0.6.8`, `Graphbit_Python_v0.6.7`, and, before those, `GraphBit_Python_v0.6.6`. The capitalisation is not stable: the 0.6.6 tag uses GraphBit with a capital B and the two newer ones use Graphbit with a lower-case b. Any script that sorts or matches tags by name has to account for that.

The workspace underneath is larger than the tags. The root Cargo package is `graphbit-lib`, described as the agentic workflow automation framework library, and it is marked `publish = false`, while the Python side is built by maturin into a wheel named graphbit at version 0.6.8. A separate workspace member, `graphbit-core`, is pulled in with the `python` feature enabled.

So there is a Cargo workspace with several publishable crates and a Python distribution, and the release history on this page documents only the second. The dates are 2026-03-25, 2026-04-09 and 2026-06-22, and the last push to `main` is 2026-06-22.

## Link time optimization is off because a prebuilt library has no bitcode

The release profile carries a comment that explains more about the packaging than any documentation would:

```
[profile.release]
codegen-units = 1
lto = false
opt-level = 3
panic = "abort"
strip = "symbols"
```

The comment above the `lto = false` line reads that LTO is disabled because the prebuilt `libguardrail_ffi.a` has no bitcode and fat LTO would fail at link. There is a `guardrail_ffi/` directory at the repository root, so the guardrail surface depends on a prebuilt static library rather than on Rust source, and that single fact dictates the optimization settings for everything else in the release build.

A second profile, `release-python`, inherits release and drops `opt-level` to `s` with the comment that size matters for Python extensions, while keeping LTO off for the same reason. The bench profile also keeps LTO off. The crate's own `[features]` block has `default = []`, so none of that is switched on unless a consumer asks.

## No LLM SDK in the Python dependency list

The wheel's dependencies are aiofiles, aiohttp, python-dotenv, rich, typer, huggingface_hub and numpy. There is no OpenAI client, no Anthropic client and no vendor SDK among them, which is consistent with the design: the HTTP layer lives in Rust, where `reqwest` is a workspace dependency, and the Python package is a thin layer on top.

The Python dependencies each have an obvious job. aiohttp and aiofiles cover async network and file access, rich covers terminal output, typer is the command line layer, huggingface_hub points at model artefacts, and python-dotenv reads local environment files. numpy is there for the data the framework returns.

The public surface shown in the quick start matches that split: `LlmConfig`, `Executor`, `Workflow`, `Node`, `tool` and `GuardRailPolicyConfig` are imported from the top-level `graphbit` package, `LlmConfig.openai` takes a key and a model name, and tools are plain Python functions decorated with `@tool`. The example passes the description as `_description`, with a leading underscore in the keyword name, on the assumption that the decorator is what an LLM reads to choose a tool.

## Two Discord invites, thirteen translations, a placeholder comment

The housekeeping in the page header is where the drift shows. The Discord badge in the README points at `discord.com/invite/FMhgB3paMD`, while the Discord URL in the Python metadata points at `discord.com/invite/huVJwkyu`. Two different invite codes for what is meant to be one server.

The header also keeps an HTML comment that reads as an unfinished note: Added placeholders for links, fill it up when the corresponding links are available. Next to it are badge anchors with no image inside them, empty centred paragraph blocks, and a PyPI anchor that appears twice, the second time commented out. None of that breaks the rendered page, but it does mean the header was assembled from a template and left that way.

The translations are a different story. Thirteen localised READMEs are linked, covering Simplified and Traditional Chinese, Spanish, French, German, Japanese, Korean, Hindi, Arabic, Italian, Brazilian Portuguese, Russian and Bengali, and they live in a `README_Multi_Lingual_i18n_Files/` directory beside the English one.

## vendor/, javascript/ and a committed secrets baseline

The root of a Rust and Python workspace holds a few directories whose purpose is not stated anywhere on the page. `vendor/` is there, which in a project of this size means third-party code is committed rather than fetched. `javascript/` is there too, in a repository whose published surfaces are a Cargo workspace and a Python wheel, with no package manifest at the root to go with it.

Against that, the tooling configuration is unusually complete. Rust side: `clippy.toml`, `rustfmt.toml` and `tarpaulin.toml` for coverage, plus a `Cargo.lock`. Python side: `pytest.ini`, `.mypy.ini` and a `[tool.bandit]` section in the package metadata with a list of excluded directories. Repository side: `.pre-commit-config.yaml`, `.markdownlint.yaml`, `.typos.toml`, and a `.secrets.baseline`, which is a recorded fingerprint file for secret scanning. The governance files are present as well, with a code of conduct, a contributing guide and a security policy.

The examples directory is where the scope shows. Alongside a chatbot and a research paper summariser there are two guardrail examples, one financial and one phone-number shaped, plus a browser automation agent and a tasks example.

## Conclusion

GraphBit is a substantial piece of engineering with an unusually candid build configuration and an unusually vague benchmark. It suits a team that wants typed agent workflows with the network layer in Rust and is prepared to run its own measurements, because the published table is a starting hypothesis rather than evidence, and it does not suit anyone who needs a named, reproducible comparison or a crate-first release story, since the tags track the Python wheel. Before adopting it, run the same workload against the framework you would otherwise pick, read the guardrail build constraint in the release profile before you enable that surface, and treat the single named production customer as one data point rather than a track record.

## FAQ

### How do I install GraphBit and what does the Python package need?

pip install graphbit, with a virtual environment recommended. The wheel is built by maturin and requires Python 3.9 up to but not including 3.14, and it depends on aiofiles, aiohttp, python-dotenv, rich, typer, huggingface_hub and numpy. No LLM vendor SDK is among them, because the HTTP layer is in the Rust core.

### What are GraphBit's benchmark numbers measured against?

The page describes an internal benchmark suite run against leading Python-based agent frameworks, and the table labels that column Other Frameworks without naming a single one. GraphBit is set at a 1.0 baseline with the others shown as 68.3 times higher CPU and 140 times higher memory, while the execution speed row carries no competitor figure at all.

### Which model providers does GraphBit support?

The feature list names OpenAI, Azure OpenAI, Anthropic, OpenRouter, DeepSeek, Replicate, Ollama and TogetherAI among others. The quick start configures one with LlmConfig.openai, passing a key and a model name, and the environment setup exports OPENAI_API_KEY and ANTHROPIC_API_KEY.

## Sources

- [InfinitiBit/graphbit on GitHub](https://github.com/InfinitiBit/graphbit)
- [License: Apache-2.0](https://github.com/InfinitiBit/graphbit/blob/main/LICENSE)
- [Project website](https://graphbit.ai)
- [README](https://github.com/InfinitiBit/graphbit/blob/main/README.md)
- [Releases](https://github.com/InfinitiBit/graphbit/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/infinitibit-graphbit