Known limitations

Strata is a preview. This page lists what 0.9.0-preview.1 doesn’t do yet, or does only in part, and what to do in the meantime. Before 1.0, each item is either built or dropped with a reason (see the Roadmap). The page is updated with every version.

The API can still change

While the version is 0.x, a minor version may break the API, and a preview promises nothing between previews. The changelog says what changed in each version. Pin the exact version you use (see Installation).

The checkpoint format is versioned in schema/, with compatibility rules and shared test fixtures, but its formal spec isn’t written yet. Until it is, rely on the compatibility rules in schema/README.md.

Engine

Limitation	In the meantime
Compiling a graph doesn’t check that every path can reach an end (STRATA_ERR_NO_TERMINAL isn’t built), and there is no hop limit by default.	Set a hop limit: MaxNodeHops in CompilationOptions (C#), or CompileOptions::new().with_max_node_hops(...) with compile_with (Rust). It stops a run that loops forever.
There is no ValidationGuard hook that re-checks a thread’s state when it resumes after a long pause.	Check the state in the first node after the interrupt boundary.
Checkpoint state has no field-level encryption.	Keep secrets out of state. Store them in your secret store and put only a reference in state.
Tool calls have no time limit unless you set one. No timeout middleware ships with Strata.	Set a node timeout, write a tool middleware that sets a time limit, or cancel the run.
Node names are strings, so your IDE completes state fields but not node names.	Keep node names in constants.
A signal that arrives before the thread reaches its event wait is refused, not buffered.	Send the signal again once the thread is waiting. strata thread list shows what each thread waits for.
A retry’s backoff wait is held in memory. If the process crashes during the wait, the run is lost like any other crash.	Checkpoint after every node (EveryNode), so recovery resumes from the last node that finished.
The branches of a parallel group aren’t graph nodes. They can’t have their own interrupt boundaries or recovery policies, and the group’s retry re-runs every branch.	Make branches safe to repeat. When a step needs its own boundary or retry, make it a node of its own.
A map’s child graph can’t have an interrupt boundary, so one item of a map can’t pause on its own.	Put the interrupt boundary on the map node itself, or on a node before it.

.NET

Limitation	In the meantime
The packages aren’t ready for Native AOT or trimming. Tool dispatch is generated without reflection, but argument binding uses reflection-based System.Text.Json, and nothing is AOT-annotated or AOT-tested.	Publish without AOT and trimming.
The SQLite memory store needs the sqlite-vec extension, which Datalium.Strata.Storage doesn’t bring.	Reference the sqlite-vec NuGet package yourself with ExcludeAssets="contentFiles", or give the extension’s path in SqliteMemoryOptions.Extension.
Serialization uses System.Text.Json nodes and strings, not Span<T> or ReadOnlyMemory<T>. Streaming already uses ReadOnlyMemory<char>.	Nothing to do. Keep state small.

Rust

Limitation	In the meantime
The history store returns a conversation as a whole Vec, not a stream. .NET streams it (IAsyncEnumerable).	Expect a whole conversation in memory when you read it.
#[strata_tool] needs an arguments struct, so a tool can’t take zero arguments.	Give the tool an empty arguments struct.
#[strata_tool] drops the tool’s own error. ToolExecutionFailure keeps only the tool’s name.	Log the error inside the tool before you return it.

The strata CLI

The CLI reference describes every command.

Limitation	In the meantime
Binaries are built for Linux, macOS and Windows on x86-64 only. There is no build for macOS on Apple silicon (ARM64) or Linux on ARM64, and the binaries aren’t statically linked.	Build the CLI from source.
The CLI is read-only: there is no strata thread resume.	Resume threads from your application.
strata checkpoint replay shows the state and the next node at a sequence. It doesn’t run the node or swap the model.	No workaround yet.
strata thread inspect doesn’t show token usage or a summary of the history.	Read token usage from the model-call run events or the GenAI metrics.
The CLI can’t reach Postgres or Redis over TLS, because it connects through the Rust stores (see Stores). A --storage value that isn’t a postgres://, postgresql:// or redis:// URL is opened as a SQLite file path, and the file is created if it’s missing.	Run the CLI where the database accepts connections without TLS, for example from inside its private network.

Stores

Limitation	In the meantime
Rust’s Postgres and Redis stores don’t connect over TLS: the Postgres store connects without it, and rediss:// URLs don’t work. The .NET stores do: give sslmode in a Postgres URL, or a StackExchange.Redis configuration string with ssl=true.	In Rust, for Postgres, connect a tokio_postgres::Client with your own TLS connector and pass it to PostgresCheckpointStore::from_client. That store can’t reconnect or pool. For Redis, keep it on a private network.
The Redis stores don’t support Redis Cluster or Sentinel.	Use a single Redis primary.
The Redis memory store needs the Redis Query Engine: Redis 8, or Redis Stack.	Use Redis 8 or Redis Stack, or another memory store.
A SQLite history store written by one engine can’t be read by the other: .NET writes the HistoryRecords table and Rust history_records, and they save a role differently ("User" and "user"). Checkpoints in SQLite, and history in Postgres and Redis, are shared.	Use Postgres or Redis for history that both engines read.
Retention purges checkpoints, not history.	Clean up old history in the database yourself.
Under the default Boundaries policy, a thread that paused, was resumed and then finished writes no completed checkpoint, so it stays resumed. Retention’s default states (completed and ended) and Redis’s finished-thread expiry skip it.	Add resumed to the states the purge takes, or compile the graph with EveryNode.
The Strata Cloud store is for the Strata Cloud private beta. The retention driver doesn’t run against it, and the strata CLI can’t read it.	Use a self-hosted store when you need either.
Strata doesn’t place runs on workers or coordinate a cluster.	Partition threads across workers with your own queue. Thread leases and recovery make any placement safe.

Benchmarks

Performance summarizes the results and how to run the benchmarks.

Limitation	In the meantime
The published benchmark results were measured on Windows only. CI runs the benchmarks on Linux but records nothing, and nothing fails a build when performance regresses.	Run the benchmarks on your own hardware.
The cost of tool dispatch isn’t benchmarked yet.	No workaround yet.

Packages and releases

Limitation	In the meantime
The NuGet packages and the crates aren’t signed.	Install from nuget.org and crates.io, and check the CLI binaries against SHA256SUMS.txt on the release.
Nothing checks API compatibility between versions yet.	Read the changelog before you upgrade.

Found another one?

Open an issue on GitHub.