graphbit 0.6.1

GraphBit - Advanced workflow automation and AI agent orchestration library

GraphBit - High Performance Agentic Framework

Website | Docs | Discord

Type-Safe AI Agent Workflows with Rust Performance

---

Read this in other languages: 🇨🇳 简体中文 | 🇨🇳 繁體中文 | 🇪🇸 Español | 🇫🇷 Français | 🇩🇪 Deutsch | 🇯🇵 日本語 | 🇰🇷 한국어 | 🇮🇳 हिन्दी | 🇸🇦 العربية | 🇮🇹 Italiano | 🇧🇷 Português | 🇷🇺 Русский | 🇧🇩 বাংলা

---

What is GraphBit?

GraphBit is a source-available agentic AI framework for developers who need deterministic, concurrent, and low-overhead execution.

Built with a Rust core and a minimal Python layer, GraphBit delivers up to 68× lower CPU usage and 140× lower memory footprint than other frameworks, while maintaining equal or greater throughput.

It powers multi-agent workflows that run in parallel, persist memory across steps, self-recover from failures, and ensure 100% task reliability. GraphBit is built for production workloads, from enterprise AI systems to low-resource edge deployments.

---

Why GraphBit?

Efficiency decides who scales. GraphBit is built for developers who need deterministic, concurrent, and ultra-efficient AI execution without the overhead.

• Rust-Powered Performance - Maximum speed and memory safety at the core
• Production-Ready - Circuit breakers, retry policies, and fault recovery built-in
• Resource Efficient - Run on enterprise servers or low-resource edge devices
• Multi-Agent Ready - Parallel execution with shared memory across workflow steps
• Observable - Built-in tracing, structured logs, and performance metrics

---

Benchmark

GraphBit was built for efficiency at scale—not theoretical claims, but measured results.

Our internal benchmark suite compared GraphBit to leading Python-based agent frameworks across identical workloads.

Metric	GraphBit	Other Frameworks	Gain
CPU Usage	1.0× baseline	68.3× higher	~68× CPU
Memory Footprint	1.0× baseline	140× higher	~140× Memory
Execution Speed	≈ equal / faster	—	Consistent throughput
Determinism	100% success	Variable	Guaranteed reliability

GraphBit consistently delivers production-grade efficiency across LLM calls, tool invocations, and multi-agent chains.

View Full Benchmark Report for detailed methodology, test scenarios, and complete results.

Watch Benchmark Demo Video to see GraphBit's performance in action.

---

When to Use GraphBit

Choose GraphBit if you need:

• Production-grade multi-agent systems that won't collapse under load
• Type-safe execution and reproducible outputs
• Real-time orchestration for hybrid or streaming AI applications
• Rust-level efficiency with Python-level ergonomics

If you're scaling beyond prototypes or care about runtime determinism, GraphBit is for you.

---

Key Features

• Tool Selection - LLMs intelligently choose tools based on descriptions
• Type Safety - Strong typing through every execution layer
• Reliability - Circuit breakers, retry policies, error handling and fault recovery
• Multi-LLM Support - OpenAI, Azure OpenAI, Anthropic, OpenRouter, DeepSeek, Replicate, Ollama, TogetherAI and more
• Resource Management - Concurrency controls and memory optimization
• Observability - Built-in tracing, structured logs, and performance metrics

---

Quick Start

Installation

Recommended to use virtual environment.

pip install graphbit

Environment Setup

Set up API keys you want to use in your project:

# OpenAI (optional – required if using OpenAI models)
export OPENAI_API_KEY=your_openai_api_key_here

# Anthropic (optional – required if using Anthropic models)
export ANTHROPIC_API_KEY=your_anthropic_api_key_here

Security Note: Never commit API keys to version control. Always use environment variables or secure secret management.

Basic Usage

import os

from graphbit import LlmConfig, Executor, Workflow, Node, tool

# Initialize and configure
config = LlmConfig.openai(os.getenv("OPENAI_API_KEY"), "gpt-4o-mini")

# Create executor
executor = Executor(config)

# Create tools with clear descriptions for LLM selection
@tool(_description="Get current weather information for any city")
def get_weather(location: str) -> dict:
    return {"location": location, "temperature": 22, "condition": "sunny"}

@tool(_description="Perform mathematical calculations and return results")
def calculate(expression: str) -> str:
    return f"Result: {eval(expression)}"

# Build workflow
workflow = Workflow("Analysis Pipeline")

# Create agent nodes
smart_agent = Node.agent(
    name="Smart Agent",
    prompt="What's the weather in Paris and calculate 15 + 27?",
    system_prompt="You are an assistant skilled in weather lookup and math calculations. Use tools to answer queries accurately.",
    tools=[get_weather, calculate]
)

processor = Node.agent(
    name="Data Processor",
    prompt="Process the results obtained from Smart Agent.",
    system_prompt="""You process and organize results from other agents.

    - Summarize and clarify key points
    - Structure your output for easy reading
    - Focus on actionable insights
    """
)

# Connect and execute
id1 = workflow.add_node(smart_agent)
id2 = workflow.add_node(processor)
workflow.connect(id1, id2)

result = executor.execute(workflow)
print(f"Workflow completed: {result.is_success()}")
print("\nSmart Agent Output: \n", result.get_node_output("Smart Agent"))
print("\nData Processor Output: \n", result.get_node_output("Data Processor"))

Watch Quick Start Video Tutorial - Complete walkthrough: Install GraphBit via PyPI, setup, and run your first workflow

Watch: Building Your First Agent Workflow - Advanced tutorial on creating multi-agent workflows with GraphBit

---

High-Level Architecture

Three-tier design for reliability and performance:

• Rust Core - Workflow engine, agents, and LLM providers
• Orchestration Layer - Project management and execution
• Python API - PyO3 bindings with async support

---

Python API Integrations

GraphBit provides a rich Python API for building and integrating agentic workflows:

• LLM Clients - Multi-provider integrations (OpenAI, Anthropic, Azure, and more)
• Workflows - Define and manage multi-agent workflow graphs with state management
• Nodes - Agent nodes, tool nodes, and custom workflow components
• Executors - Workflow execution engine with configuration management
• Tool System - Function decorators, registry, and execution framework
• Embeddings - Vector embeddings for semantic search and retrieval
• Document Loaders - Load and parse documents (PDF, DOCX, TXT, JSON, CSV, XML, HTML)
• Text Splitters - Split documents into chunks (character, token, sentence, recursive)

For the complete list of classes, methods, and usage examples, see the Python API Reference.

Watch: GraphBit Observability & Tracing - Learn how to monitor and trace your AI workflows

---

Contributing to GraphBit

We welcome contributions. To get started, please see the Contributing file for development setup and guidelines.

GraphBit is built by a wonderful community of researchers and engineers.

---

Security

GraphBit is committed to maintaining security standards for our agentic framework. We recommend:

• Using environment variables for API keys
• Keeping GraphBit updated to the latest version
• Using proper secret management for production environments

If you discover a security vulnerability, please report it responsibly through GitHub Security or via email rather than creating a public issue.

For detailed reporting procedures and response timelines, see our Security Policy.

---

License

GraphBit is licensed under a three-tier model:

Model	Users	Terms
Model A (Free Use)	Individuals, academic institutions, small teams (≤10 users)	Free for non-commercial use
Model B (Free Trial)	Enterprise evaluation	30-day free trial
Model C (Enterprise)	Commercial/production use	Paid license required

Note: Redistribution is prohibited under all models without an explicit Enterprise License.

For complete terms and conditions, see the Full License.

---

Copyright © 2023–2026 InfinitiBit GmbH. All rights reserved.