Keep the runtime.
Choose the application contract.
LangGraph executes the graph. EZGraph supplies a TypeScript application layer around it. The choice is which conventions your team wants to adopt and which it wants to design.
What your application team owns.
LangGraph's maintainers describe it as a low-level orchestration runtime that leaves prompts and application architecture open. That flexibility gives teams room to define their own conventions. LangGraph overview ↗
| Concern | EZGraph supplies | Direct LangGraph / LangChain composition |
|---|---|---|
| Stage structure | LlmNode groups prompt, tools, state, and lifecycle hooks. | Organize node functions, agents, subgraphs, and shared helpers to fit the application. |
| Model/tool rounds | A shared loop integrated with node outcomes, validation, histories, and diagnostics. | Use LangChain agents and middleware, or construct a custom loop and its surrounding contracts. |
| Tool scope and validation | Node tool definitions, bound handlers, schema feedback, and explicit application outcomes. | Bind selected tools and schemas, then choose middleware and application validation policy. |
| Model policy | Graph defaults, node overrides, catalog validation, and recovery configuration. | Compose model configuration and override rules with available model and agent APIs. |
| History and business facts | Named history spaces, typed node channels, graph context, and staged writes. | Design state schemas, reducers, stores, and the memory each stage receives. |
| User turns and sessions | An engine-managed turn boundary with application session documents. | Compose invocation, checkpointing, application records, and session policy. |
| Recovery and testing | Node recovery with graph fallback; scripted providers and a turn harness. | Combine runtime capabilities, middleware, mocks, and application-specific tests. |
| Execution controls | A validated graph facade that compiles to LangGraph. | Direct access to LangGraph topology, channels, streaming, and checkpoint controls. |
LangChain supplies agent loops and middleware for tool selection, retries, fallbacks, and guardrails. Those agents can be composed inside a larger LangGraph workflow. EZGraph differentiates through its integrated application contract. LangChain middleware and composition ↗
A domain record you can inspect.
EZGraph stores accepted facts in typed node channels and shared graph context. Named histories specify which conversation each node sees. A session document records the active stage, application state, usage, and diagnostics.
The engine restores and persists that application record around turns. Schema versions, migration hooks, and restore policy provide common places for evolving sessions.
Read the persistence contractLangGraph checkpointers save execution state and support their own continuation and inspection features. EZGraph's normal engine path uses application session snapshots and compiles without a native checkpointer by default. Its saved session does not promise arbitrary mid-node resume or LangGraph checkpoint history. LangGraph persistence ↗
Make continuation a decision you can read.
A tool result expresses the application's next action. The same builders can handle collection, correction, review, a direct reply, or completion.
| Outcome | Application meaning |
|---|---|
stay(feedback) | Return corrective tool feedback and continue model work in the current node. |
go(NextNode) | Enter another registered node in the current turn. |
direct(content) | Return exact content from code; the current node stays active for the next turn. |
directTo(NextNode, content) | Reply now and select where the next user turn resumes. |
finish(content) | Complete the graph with an application-owned result. |
fanout(Child1, Child2) | Route concurrent branches with an explicitly declared join and state ownership. |
For caller-owned internal work, typed runNode() results let a parent decide what to merge and publish. See the execution ownership contract and topology guide for supported modes.
Choose the layer that fits the work.
EZGraph is a useful fit when…
Your team builds guided TypeScript workflows and wants shared conventions for stages, tools, models, history, recovery, and readable application sessions. You prefer adapting a supplied contract to designing that contract across several applications.
Direct composition is a useful fit when…
You already have an application platform, want to choose each surrounding convention, or need execution controls outside EZGraph's facade. Validate requirements for native streaming, checkpoint continuation, and custom graph topology before adopting a layer.
Adoption means adapting nodes, state, and sessions deliberately. Start with the small runnable workflow, then compare the contract against a real requirement.
See one application implemented both waysGive your next LangGraph application a consistent foundation.
Run the starter, inspect the session, and decide whether the node contract fits your team.