OpenTine vs LangGraph vs Temporal vs DSPy: Which Layer Do You Need?

The short answer

Choose the layer that owns the problem you actually have:

OpenTine when you need portable, verifiable provenance around agent executions, including runs produced by other frameworks or external CLIs.
LangGraph when your application is naturally a state graph and needs checkpointed execution, interrupts, cycles, and time travel.
Temporal when durable recovery, retries, long-running business workflows, and operational orchestration are the load-bearing requirements.
DSPy when the central task is declaring an LM program and optimizing its instructions, examples, or other parameters against a metric.

This comparison was rechecked on August 25, 2026. OpenTine claims are pinned to the tagged 0.8.0 release. The other columns link to their current official documentation because those projects change independently.

They occupy different layers

Calling all four “agent runtimes” hides the most important distinction.

OpenTine 0.8.0 is primarily a provenance layer. It can call a bundled model or spawn an external harness, but its defining artifacts are portable .tine files and content-addressed repository objects. It imports existing traces, verifies recorded content, forks causal history, compares runs, and exports OpenTelemetry GenAI data.

LangGraph is an execution framework. You define state, nodes, edges, routers, interrupts, and reducers. A checkpointer persists graph state at super-step boundaries. Its official time-travel guide documents replay and forks from prior checkpoints.

Temporal is a durable workflow platform. Workflow code is reconstructed from durable event history while activities isolate side effects and retries. It is useful far beyond AI: payments, provisioning, fulfillment, data pipelines, and long-running sagas all fit its model. See Temporal's official workflow execution documentation.

DSPy is a declarative LM programming and optimization system. Signatures and modules describe the program; optimizers search for better instructions, demonstrations, or other program parameters against an explicit metric. See the official DSPy documentation.

Capability matrix

Question	OpenTine 0.8	LangGraph 1.x	Temporal	DSPy
What is the primary abstraction?	Recorded run graph and provenance object	Stateful execution graph	Durable workflow and activity history	Declarative LM program
Does it execute application control flow?	Limited model and harness capture; not a general scheduler	Yes	Yes	Executes LM modules, not durable workflow orchestration
What persists?	Portable artifacts or typed repository objects	Checkpointed graph state through a configured checkpointer	Workflow event history	Program configuration, examples, and optimization outputs
Can it branch history?	File and repository forks	Checkpoint time travel and state forks	Not a first-class exploratory fork primitive	Not its central abstraction
What does replay mean?	Cache derivation or a live harness rerun, with a verification gate	Nodes after the chosen checkpoint execute again	Workflow code rebuilds state from history; activities are not blindly repeated	Run the program again; optimization may search new candidates
Does it provide crash-safe distributed orchestration?	No	With the appropriate persistent deployment stack	Yes, this is a core purpose	No
Is the run portable outside the framework?	Yes: documented `.tine` and repository formats, plus OTel exchange	Checkpoints belong to the graph/checkpointer contract	History belongs to a Temporal deployment/export path	Saved programs are DSPy artifacts
Does it optimize prompts or programs?	No	No built-in optimizer	No	Yes
Best fit	Provenance, verification, trace exchange, branching, evaluation gates	Stateful agents and graph workflows	Durable operational workflows	Metric-driven LM program improvement

OpenTine: provenance under or around another system

OpenTine's strongest use case is not “replace your framework.” It is “give the run a portable identity and evidence trail.”

There are several on-ramps:

# Import a trace emitted elsewhere
tine import trace.json --format otel-json --save imported.tine

# Capture an external agent CLI
tine run --harness hermes --prompt "Audit this change" --save hermes.tine

# Capture one model call without writing Python
tine run --model anthropic --prompt "Explain the failure" --save model.tine

LangChain and LangGraph can be recorded live through OpenTineCallbackHandler. Serialized LangChain, LlamaIndex, AutoGen, CrewAI, and OpenAI Agents traces can be imported after the fact. OpenTelemetry GenAI is the framework-neutral path.

Once recorded, the same run can be verified, signed, forked, diffed, migrated into a v3 repository, evaluated, attested, promoted, or exported:

tine verify hermes.tine
tine fork hermes.tine --from-step 3 --save alternative.tine
tine diff hermes.tine alternative.tine --exit-code
tine export alternative.tine --output spans.json

The limitation is equally important: OpenTine does not keep a distributed worker alive, schedule a retry tomorrow, or make a side-effecting tool idempotent. Its process-harness limits are recorder guardrails, not a sandbox or workflow service.

LangGraph: explicit state and topology

LangGraph is the natural fit when the application itself is a graph:

nodes execute model, tool, or application logic;
edges and routers choose the next node;
reducers combine state;
checkpoints persist state at super-step boundaries;
interrupts pause for human input; and
cycles express refinement, review, and retry loops.

The current official docs are explicit about time travel. Nodes before a selected checkpoint keep their saved results. Nodes after it execute again, including LLM calls, API requests, and interrupts. Updating state at a checkpoint creates a branch without deleting the original history.

That is real fork and replay functionality; older claims that LangGraph had only “checkpoints” and could not fork were wrong.

Use LangGraph when graph topology is part of the application contract. Add OpenTine when you also need a standalone artifact, cross-framework trace exchange, signed provenance, or repository-level evaluation and promotion.

Temporal: durability and recovery

Temporal owns a different failure mode: processes crash, networks partition, workers restart, and workflows may wait for hours or months.

Its event history lets workflow code reconstruct its state. Side effects belong in activities, which carry retry and timeout policies. That model imposes determinism constraints on workflow code and asks teams to operate Temporal Cloud or a Temporal service.

Use Temporal when:

business state must survive worker loss;
retries and compensation are part of the product contract;
work crosses services or lasts a long time;
operational visibility and task queues matter more than a portable local artifact.

OpenTine is not a substitute for that durability. A useful composition is to run an agent step as a Temporal activity and attach a redacted, verified .tine artifact or OpenTelemetry trace to the workflow's operational record. Temporal owns execution recovery; OpenTine owns the portable agent-run evidence.

DSPy: optimize the program

DSPy starts from an outcome metric. A developer defines signatures and modules, then uses an optimizer such as MIPROv2 or GEPA to search for program configurations that score better on representative data.

Use DSPy when:

you can state and evaluate the target behavior;
prompt and demonstration selection should be systematic;
the same program will be tested across many examples; and
improving the program matters more than branching one production run.

OpenTine can record the evaluations produced during that work, but it does not perform the optimization. Conversely, DSPy can produce a better program without providing OpenTine's portable run repository, signature, or trace-interchange model.

Common combinations

These tools compose more naturally than a winner-take-all comparison suggests.

LangGraph + OpenTine

Run the state graph in LangGraph and attach OpenTineCallbackHandler. LangGraph owns nodes, edges, checkpoints, and interrupts. OpenTine records the live callback events into a portable or repository-backed provenance graph.

Temporal + OpenTine

Run model or agent work inside an activity. Store the durable business workflow in Temporal and retain an OpenTine artifact, repository run ID, or exported OTel trace as evidence for the agent operation.

DSPy + OpenTine

Use DSPy to generate and evaluate candidate programs. Record candidate runs and scores in OpenTine, then attach immutable evaluations and promote the selected run or configuration through an explicit gate.

LangGraph + Temporal

Use LangGraph inside an activity when agent-level checkpointing and workflow-level durability have different owners. This introduces two persistence models, so define which layer retries what and which side effects are idempotent.

Decision checklist

Ask these questions in order:

Do I need durable workflow recovery across workers and long waits? Start with Temporal.
Is my application control flow an explicit state graph with cycles or interrupts? Start with LangGraph.
Is my main problem optimizing an LM program against a metric? Start with DSPy.
Do I need portable, verifiable run evidence across those systems? Add OpenTine.

Then test the boundary:

Which layer owns retries?
Which layer records side effects?
Which identifier appears in logs and incident reports?
Which data can leave the execution environment?
Which verification result is required before a run is promoted?
Can a replay accidentally repeat an email, payment, deployment, or database write?

The right architecture is usually not the framework with the longest feature list. It is the one with a clearly owned state model—and an explicit bridge where another layer is genuinely needed.