ALGAL vs LangGraph

LangGraph is a framework for orchestrating agents in Python or TypeScript. ALGAL is a language and a virtual machine. They answer overlapping questions — stateful graphs, human review, long-running work — with very different machinery, and they are not really competitors. This page is about where the line actually sits.

The shortest honest summary

In LangGraph, the agent is code: nodes are functions in your process, state flows through channels you wire up, and a checkpointer serializes progress.

In ALGAL, the program is data: a typed, content-addressed manifest (algal.organism.v1) that no host code is required to inspect, hash, diff, transport, or generate. The VM executes it; the manifest itself never executes anything on its own.

That single difference — program-as-code versus program-as-data — produces almost every downstream difference on this page.

Where they differ

	LangGraph	ALGAL
The program is	host-language code (functions, decorators)	typed data — a manifest any runtime can read
Model calls	callbacks you write	declared, typed effect cells with budgets
Durable waits	`interrupt()` + checkpointer + a runner that resumes	contract-level suspension; a new process — even the other runtime — verifies and continues
Execution evidence	LangSmith traces (observability)	content-addressed receipts that replay-verify offline, no store or credentials
Authority model	whatever your code does	capabilities the host admits; cells cannot mint their own
Programs producing programs	your code writes code	`spawn` emits a manifest as data; foundry measures candidates; the host selects

Durability is the sharp edge

Temporal's own LangGraph plugin announcement makes the point cleanly: checkpoints are not durable execution. A checkpoint preserves your state; something else has to notice the crash, decide where to re-enter, and restart the run — and that "something" is an orchestration layer you either build or buy.

ALGAL's answer is stranger and smaller: the suspended run is itself data. A wait is a declared cell with bounded wake capabilities. The checkpoint is bound to the manifest digest; a later CLI invocation — a new OS process, potentially the Rust kernel instead of the TypeScript reference — verifies the recorded effects and continues. There is no resident orchestrator because there is nothing to orchestrate: the receipt plus the store are the resume state.

If your mental model is "durable workflows," ALGAL is closer to a portable, self-verifying workflow artifact than to a workflow engine. See the process VM doc for the mechanics, or the durable process spec.

The evidence layer

LangSmith gives you excellent traces: what the model saw, what it returned, how long each node took. It is observability, and it is good at it.

An ALGAL receipt is a different kind of object. It records the event order, per-cell args and outputs, and effect digests — enough that algal verify can replay the run bit-for-bit offline and algal diff can compare two executions. The receipt is a file you can hand to someone who does not trust you, your infra, or your model provider, and they can check the run themselves. It proves execution consistency — honestly, not that the model was right.

That is why the interactive diagrams on this site replay recorded event order instead of animating a simulation.

Where LangGraph is the better fit

You live in the LangChain ecosystem and want its integrations, retrievers, and tool catalog.

You want streaming UIs, an agent IDE, managed deployment, and a platform behind it.

Your agents are prototypes or moderate-complexity graphs where in-process execution plus a checkpointer is enough.

You are fine with the graph existing only as code in your repo.

Where ALGAL is the better fit

The program itself must be an artifact — handed to another host, reviewed as data, diffed against a prior version, or generated by another program.

Runs must carry verifiable evidence: receipts that replay-verify offline and survive moving the store.

Agent programs need explicit authority boundaries: typed capabilities, budgets, host-owned admission — not convention.

You want programs that can propose their successors under measurement, with lineage recorded on the receipt — the path toward habitats and selection.

The honest caveat

ALGAL is an application-VM prerelease. Packages are unsigned and unnotarized, the ecosystem is young, and there is no managed platform — you run the binary. LangGraph is a mature framework with a company and a cloud behind it. If you need that today, use it. If you want to see what agent software looks like when the program is data, take the tour or read the spec.