Introduction

Datalium Strata is a type-safe, compiled, open-source, high-performance, and native agentic AI orchestration framework targeting the Rust and .NET/C# ecosystems, built for high-concurrency production workloads. Performance figures, with the method and raw data, are in benchmarks/RESULTS.md.

It provides developers with a production-grade alternative to Python-first frameworks like LangChain and LangGraph, one that integrates natively into existing enterprise backend stacks without sidecars, virtual environments, or runtime type errors.

In practice, Strata is a framework for building AI agents and other multi-step workflows as typed graphs, in C# or Rust. You describe the steps as nodes, connect them with edges, and Strata runs them. It saves the thread so it can pause for a person, survive a restart, and pick up where it stopped.

Strata runs inside your own .NET or Rust application, as a NuGet package or a crate. There is no separate orchestration service to deploy. Strata is open source under the Apache 2.0 license.

The problems it solves

An agent that does real work is more than one model call. It calls tools, branches on what it finds, waits for approval, retries when a provider is down, and runs for minutes or days. Written by hand, that logic ends up scattered across queues, database tables and retry loops.

Strata gives that logic one shape, a graph, and handles the parts that are hard to get right:

• Typed state. The data that flows between steps is a C# record or a Rust struct. A misspelled field is a compile error, not a crash halfway through a run.
• Checks before the first run. When you compile a graph, Strata rejects structural mistakes, such as a node nothing leads to, a loop in which every edge is unconditional, or an edge to a node that doesn’t exist.
• Pausing and resuming. A graph can stop and wait for a person, an event or a timer. The thread is saved to a store, and nothing runs while it waits.
• Failures. Nodes can retry with backoff, time out, or fall back to another node.

These checks cover the graph’s structure and the state’s types. A model can still give a wrong answer, so check what it returns as you would any other input.

The core ideas

Idea	What it is
Graph	Nodes (the steps) joined by edges (what runs next). You build it with a fluent API and compile it once.
State	One typed value that each node receives and returns.
Thread	One execution of a graph, named by a thread ID. A thread can span several runs: it starts, pauses, and is resumed later, even by another process. You resume, inspect and end a thread by its ID.
Checkpoint	A saved snapshot of a thread: its state and the node it runs next. By default Strata saves one when a thread pauses, and you can ask for one after every node. Checkpoints go to a store: in-memory, SQLite, Postgres or Redis.
Human-in-the-loop	An interrupt boundary pauses a thread after a node. A person approves or rejects it, can correct fields in the state, and the thread resumes.

On top of these, Strata has parallel branches, fan-out over a list of items, subgraphs, streaming output, tools whose JSON schemas are generated at compile time, model calls and agents, OpenTelemetry tracing and metrics, and a strata command-line tool for checking graphs and inspecting threads.

One model in Rust and .NET

Strata has two engines, one in Rust and one in .NET. They have the same concepts and the same API shape: AddNode in C# is add_node in Rust, Compile is compile, and so on. Every code sample in these docs shows both languages side by side.

The two engines also write the same checkpoint format. A thread that a .NET service paused in Postgres or Redis can be resumed by a Rust service, and the other way round.

How it compares with LangGraph and LangChain

If you know LangGraph, most of Strata will feel familiar. Both build a state graph of nodes and edges, save threads with a checkpointer, and pause for a human with an interrupt. LangGraph is excellent for building agents in Python. The differences:

• Language. LangGraph is for Python and JavaScript. Strata is for C# and Rust, and runs in the same process as the rest of your service.
• Types. In Strata the state is a compiled type, and the compiler checks every node against it.
• When errors show up. Strata checks the graph’s structure when you compile it, so a broken graph fails at startup or in CI, not in the middle of a run. The strata graph validate command runs the same check on an exported graph.

LangChain is a different kind of library: a large set of components for prompts, models, retrievers and integrations. Strata doesn’t try to replace that catalog. For model calls, the .NET engine works with any IChatClient from Microsoft.Extensions.AI, and the Rust engine comes with clients for OpenAI-compatible servers and for Anthropic.

When to choose Strata

Strata is a good fit when:

• Your services are written in .NET or Rust, and you want agents to run inside them.
• Your workflows run for a long time, wait for people or events, and must survive restarts.
• You want the graph’s shape and the state’s type checked before anything runs.
• You care about the engine’s own cost per step. Performance gives measured numbers, with the method and the hardware.

Strata is probably not the right choice when your team works in Python, or when you need a ready-made integration for every model, vector store and document loader.

Before you decide, read the Known limitations. It lists what this version doesn’t do yet.

Why Strata is a preview

These docs cover version 0.9.0-preview.1. The engines are built and tested in both languages, and the packages are published. The version is still a preview because three things that 0.9.0 requires aren’t done:

• A formal checkpoint schema. The checkpoint format is versioned in schema/, and migrations exist, but the spec that makes it normative, with a tested migration, isn’t written yet.
• A load report from a real application. The benchmark suite ships now. Strata was built alongside StrataOps, an autonomous SRE system built on Strata that isn’t public yet. Its large-scale load test, run against a simulator, isn’t finished.
• StrataOps building from the published packages instead of from source.

After 0.9.0, version 1.0 adds a promise of API stability, outside teams running Strata in production, and a checkpoint schema that stays stable through a release. The Roadmap has the targets.

Until then:

• The API can change between previews. A preview promises nothing about the next one. While the version starts with 0., a minor version can also break the API. The changelog lists what changed in each release and what to do when you upgrade.
• Saved data is safer. Checkpoints, exported graphs and databases have their own schema versions. A newer Strata reads everything an older one wrote, and refuses data newer than itself rather than guessing. When you upgrade, upgrade every reader before you turn on a feature that writes something new.

Next steps

• Install Strata for .NET or Rust.
• Build your first graph in the Quickstart.
• Read how Strata is put together, in Architecture.
• Browse the 29 runnable demos, in C# and in Rust.