Build LangGraph workflows your team can understand, debug, and maintain.
EZGraph is the application layer for guided agentic workflows. One reusable node contract brings prompts, scoped tools, state, history, model configuration, and recovery together.
Build guided conversations, extraction workflows, and reviewed tasks—with an inspectable session document.
No EZGraph account or key. No runtime fee.
Commercial runtime license · Bring your own model provider.
Recognize intent. Validate the facts.
tools: capture_detailsCheck the result against your criteria.
tools: review_resultPublish the accepted result.
tools: confirm_resultSpend your design effort on the application.
LangGraph gives you graph execution. EZGraph supplies conventions for the application around it—so the next stage, and the next workflow, follow a structure your team already knows.
One contract across stages.
Keep a stage's prompt, tools, validation, state writes, and lifecycle hooks in an LlmNode. Read one node and know where to find the same responsibilities in another.
Give the model a focused job.
Select the tools and history that belong to the current stage. Let models handle recognition and ambiguity; let your code validate facts, enforce policy, and decide what happens next.
Explore stage controlUnderstand a saved session.
A readable document brings together the active node, business facts, histories, usage, and diagnostics. Give a developer—or an AI debugging assistant—the application record to inspect.
Explore session inspectionA stage you can read in one place.
The node says what the model should do. Its handler says what the application will accept.
- 01Declare the prompt and allowed tools.
The city collector offers
capture_city, with a schema checked before its handler runs. - 02Save facts where they become valid.
saveState()stages a write to the current node's typed channel. Shared context has an explicit home too. - 03Return an explicit outcome.
stay()supplies corrective tool feedback;go()enters the next stage. Replies and completion have their own builders.
class CityNode extends LlmNode<StarterStateType> {
getPrompt() {
return "Ask for a city, then call capture_city.";
}
defineTool(): readonly ToolDefinition[] {
return [{
name: "capture_city",
description: "Save a destination city.",
schema: z.object({ city: z.string().min(2) }),
}];
}
@Tool("capture_city")
async captureCity({ city }: { city: string }) {
const value = city.trim();
if (!/^[\p{L} .'-]+$/u.test(value)) {
return stay("Ask for a valid city name.");
}
this.saveState({ city: value });
return go(SummaryNode);
}
}Guided agents, beyond the chat window.
The same application contracts fit a conversation, a document extraction, or a task reviewed before publication.
Guide a conversation to a result.
Collect details, handle corrections, apply business rules, and ask for a clear confirmation. QuoteGraph makes this concrete with an insurance quote.
Walk through QuoteGraphTurn a document into structured data.
Attach a receipt, constrain the capture schema, and return expense JSON. ExpenseGraph demonstrates a request that finishes without a dialogue.
Explore extractionReview an answer before you publish it.
Generate a draft, evaluate it through a typed judgment, and let code publish an accepted result or a fallback. DecisionHotelGraph shows a reviewed presentation.
Explore reviewed tasksSee where the application code goes.
QuoteGraph implements a guided quote in EZGraph. QuoteLanggraph implements the same product journey directly on LangGraph.
In this example, reusable tool handling, stage transitions, and session plumbing move into the EZGraph runtime. The comparison shows the code that each application maintains.
Inspect the counts, source, and limitationsMeasured October 9, 2026. Excludes shared backend code, controllers, tests, and runtime libraries. One implementation comparison; code size does not establish development speed, reliability, or complete behavioral parity.
Give debugging a useful starting point.
Which node was active? What facts had it accepted? What history did it see? What warning accompanied the turn?
The session document gives these questions a common home, alongside model usage and decision diagnostics. Inspect the record with your own tools or provide a carefully selected excerpt to an AI debugging assistant.
- Typed node facts and graph-wide context
- Named histories and the active stage
- Usage, warnings, errors, and decisions
- Schema versions and migration hooks
Application session snapshots have a different recovery boundary from LangGraph checkpoints. See the distinction.
{
"id": "first-workflow",
"status": "completed",
"graph": {
"id": "StarterGraph",
"schemaVersion": 1,
"currentNode": "end",
"histories": {
"intake": ["…"],
"summary": ["…"]
},
"nodes": {
"CityNode": { "city": "Lisbon" },
"SummaryNode": {
"plan": "Trip to Lisbon: choose your dates, then book transport."
}
}
},
"warnings": [],
"errors": []
}Run one workflow.
Inspect what it saves.
Start locally with two nodes, two turns, and an inspectable session. Scripted model replies make the first run reproducible.
The starter exercises the real engine, graph, handlers, and in-memory persistence. It includes tests for continuation, validation, and stage-specific tools. Node.js 22.5 or later; no model credentials needed for this run.
Then connect your model provider and persistence store using the developer guide.
cd ezgraph-starter
npm install
npm start
npm testYou: Hi
EZGraph: Which city would you like to visit?
You: Lisbon
EZGraph: Trip to Lisbon: choose your dates,
then book transport.
Completed: true
Session document: { … }A clear contract has a clear scope.
EZGraph fits TypeScript applications with guided stages and explicit application policy. Assess its execution and persistence conventions against your requirements.
A useful fit when…
You are building guided conversations, structured extraction, or reviewed tasks, and want a common way to organize nodes, histories, model policy, recovery, and sessions across them.
Check the fit when…
Your design depends on native token streaming, arbitrary checkpoint continuation, or unrestricted LangGraph topology. The current default is request/response turns, a constrained graph facade, and application session snapshots.
Practical answers for developers.
How does EZGraph relate to LangGraph and LangChain?
EZGraph compiles its authoring layer to a LangGraph StateGraph. LangGraph executes it; LangChain supplies underlying components. EZGraph adds a shared application contract for nodes, tools, histories, state, models, recovery, and sessions. LangChain also supplies agent loops and middleware; compare the conventions to decide which layer fits.
Can I start without an account or model credentials?
Yes. EZGraph needs no account or license key. The downloadable starter uses scripted model replies and local memory sessions. Live models require your chosen provider's credentials, or a custom adapter for your own endpoint. Model-provider and infrastructure costs are separate.
What does the runtime license allow?
Production application use has no EZGraph runtime fee, including commercial applications and internal use. The license restricts competing hosted services and redistribution as a competing SDK, developer library, or plugin framework. Read the full license for the governing terms.
Is the runtime open source?
The public npm runtime is distributed as compiled, obfuscated JavaScript with TypeScript declarations. The example application source is public. Optional paid support includes access to private readable source and a debug package while the subscription is active. Contact PicoFlow for support details.
How should I adopt it in an existing LangGraph application?
Start with a new workflow or a small stage. Adapt its prompt, tools, state, and transitions to the node contract, then test the behavior through the turn harness. Existing applications need deliberate adaptation to EZGraph's state and session contracts. The adoption guide maps those responsibilities.
Does tool scoping make model behavior fully reliable?
Tool scoping narrows the actions available at each stage. Schema checks, validation, explicit transitions, and recovery hooks give your application more control. Your handlers still own authorization, domain validation, and side effects; models still need evaluation on real scenarios.
Give your next LangGraph application a consistent foundation.
Run the starter, inspect the session, and decide whether the node contract fits your team.