Agent frameworks have arrived quickly, and most of them begin by wrapping a working agent for you, leaving you to edit inside their shell. This one goes the other way: it calls itself a low-level orchestration framework and runtime, and it hands control back. The front page names the trade-off it is built around — a balance between control and autonomy, for agents that have to handle complex tasks reliably.

Four things get their own chapter

Human involvement is optional but treated as a first-class concern: checkpoints inserted at key nodes let a person review, add quality checks and approve an action before the agent takes it, which the site puts bluntly as adding checkpoints so you can guide and approve. Control flow comes in three shapes — a single agent, several agents, or a hierarchy — and all three use the same low-level primitives, so the structure grows with the requirement instead of the framework being swapped when the architecture changes. Memory is built in: conversation history is kept and context survives across sessions, with the documentation splitting it into a short-term working memory and a longer-term store. Streaming is treated as a first-class concern too, with token-by-token output that exposes reasoning and actions in real time — which is really an interface for whatever front end you put on top.

Two kinds of step, one graph

The design decision that matters most is permission to mix. In the same graph, a step that has to be stable and auditable can be written as deterministic hand-rolled logic, while a step that has to improvise can be handed to a model. It sounds obvious, and in engineering terms it changes a lot: you no longer choose between fully automatic and fully scripted, you decide segment by segment where the model belongs. The documentation frames the product as a low-level orchestration framework and runtime for building, managing and deploying long-running stateful agents, and reports adoption inside large financial, mobility and banking organisations. It also draws a dependency boundary clearly: a model and a tool are enough to start, the docs lean on the sibling component ecosystem for integrations, and using this framework does not require pulling that ecosystem in.

Getting moving is genuinely light. Installation is one package, and the official hello world builds nodes on a state graph with a message state, connects start to finish, compiles and calls, returning a single model message. That snippet contains the whole worldview: nodes are steps, edges are transitions, state travels between them.

Resume points and human approval are production features

The first three benefits listed in the docs are all problems you meet only once something is live. Durable execution lets an agent recover from the point of failure instead of running the whole job again. Human involvement allows state to be inspected and changed at any moment. Combined memory keeps short-term working memory separate from the long-term store. On top sit debugging and observability through the vendor's companion product, and deployment for long-running workflows. The documentation's own table of contents shows the emphasis: persistent checkpoints, storage, fault tolerance, event streams, interrupts, time travel, subgraphs, deployment — nearly every chapter answers the question of what happens when a run gets long.

The provenance section is refreshingly plain: inspired by classic graph-processing and distributed dataflow designs, a public interface modelled on a well-known graph library, built by the team behind a widely used agent-component ecosystem, and usable without it.

Who it fits

Three groups. Engineering teams that need long-running agents, where resuming after failure, an approval gate and inspectable state are primitives rather than patches bolted on later. Teams that want granular control and refuse to be boxed into a single black-box cognitive architecture, preferring to decide segment by segment where a model is used and where fixed logic is. And anyone already inside that component ecosystem, where observability, evaluation and deployment have matching products to connect to.

A few cautions. This is a low-level framework, and less abstraction means more code: for a quick demonstration agent, starting from a higher-level wrapper is less work, and the project's own readme points at such upper-layer projects. Observability and deployment live on the vendor's cloud side, so a self-hosted setup means filling those gaps yourself. On licensing, the repository is MIT, with roughly 41.8k stars, 7.1k forks, 561 releases, 301 contributors and use across 44K projects, plus an equivalent build for the scripting languages of the web.

The value of a low-level framework is not that you write less code. It is that when the flow jams at step twenty, you have a hook within reach.