Key facts

  • This site explains minimalist LLM orchestration as an independent educational guide, not as the official Pocket Flow project.
  • The central model is nodes, action-labeled edges, and shared state.
  • The comparison stays neutral: minimal graphs are a technique, not a framework religion.

The minimalist thesis

A large share of LLM application code is orchestration: decide which step runs next, pass context between steps, retry fragile calls, and preserve enough state to debug what happened. Pocket Flow's open-source concept argues that the durable part of that problem is not a provider wrapper or a tool catalog. It is a graph.

In the Pocket Flow model, each node owns a small unit of work. A node reads from shared state, runs compute, writes results back, and returns an action string. The flow follows that action to the next node. Agent loops, workflows, RAG pipelines, and map-reduce jobs are then different graph shapes rather than different framework universes.

"Graph + Shared Store"

Pocket Flow docs

This site is opinionated toward that clarity. It is also deliberately not a fan page. Minimal orchestration is a technique, not a religion. LangChain, LangGraph, LlamaIndex, AutoGen-style runtimes, and managed platforms exist because production systems need integrations, persistence, evaluation, deployment, data connectors, and governance. The useful question is not "which framework wins?" It is "how much framework does this system need right now?"

This is an independent guide, not the official Pocket Flow project. If you are evaluating whether to build agents without LangChain, use this site as a map of the concepts and the upstream docs as the final source of project behavior.

What to read

The node graph model Nodes, edges, actions, shared store, params, nesting, and why the graph is the framework. Minimal vs heavy Where tiny orchestration wins, where LangChain/LangGraph/LlamaIndex win, and how to choose fairly. Free tools Client-side graph design, framework overhead, and orchestration pattern tools. Flow graph designer Sketch a node graph and export JSON plus Python skeleton code. Framework overhead calculator Estimate when vanilla orchestration stops being the simplest choice. Orchestration pattern gallery Click through common LLM orchestration patterns as graphs. Patterns Agent, workflow, RAG, map-reduce, structured output, and multi-agent patterns as graphs. Build your own A from-scratch minimal orchestrator walkthrough with nodes, actions, retries, and tests. Build agents without LangChain A practical guide to building a small agent graph before adopting a larger framework. Glossary Definitions for the terms that recur in minimal LLM orchestration. Sources Primary sources, documentation, and machine-readable llms.txt files. FAQ Direct answers to common questions about minimal LLM frameworks.

Free tools

Phase 2 adds three browser-only tools: an agent graph designer, a framework overhead calculator, and an orchestration pattern gallery. They do not require signup, do not call a backend, and do not send graph or calculator data off the page.

How this site uses sources

The Pocket Flow project itself is the primary source for the node, flow, shared-store, batch, agent, workflow, RAG, and map-reduce descriptions. LangChain and LlamaIndex are cited from their own documentation rather than from third-party comparisons. Retrieval-augmented generation is grounded in the original Lewis et al. paper on arXiv.

Facts are separated from advice. When this guide says "Pocket Flow models workflows as a graph," that is attribution to the project documentation. When it says "start minimal when you are still discovering your state machine," that is this site's recommendation based on the source model.

Practical summary

  • Use a tiny graph when your team can name every state, transition, and side effect.
  • Use a heavier framework when connectors, persistence, deployment, tracing, or managed data pipelines matter more than reading the runtime in one sitting.
  • Keep provider calls, vector stores, and web search as replaceable utilities unless your framework has already earned the right to own them.
  • Design shared state before prompts. If the state contract is messy, the agent will be messy too.

Sources used on this page

  • Pocket Flow documentation The Pocket. Accessed July 6, 2026. Primary source for the 100-line claim, Graph + Shared Store abstraction, core patterns, and utility philosophy.
  • The-Pocket/PocketFlow GitHub repository GitHub. Accessed July 6, 2026. Primary repository and README for installation, license, language ports, examples, and project framing.
  • Pocket Flow Node documentation The Pocket. Accessed July 6, 2026. Primary source for prep, exec, post, retries, and fallback behavior.
  • LangChain overview LangChain. Accessed July 6, 2026. Primary source for LangChain create_agent, integrations, middleware, and LangGraph relationship.
  • LangGraph overview LangChain. Accessed July 6, 2026. Primary source for durable execution, persistence, human-in-the-loop, memory, and production orchestration claims.
  • LlamaIndex developer documentation LlamaIndex. Accessed July 6, 2026. Primary source for LlamaIndex document loading, indexing, retrieval, parsing, and extraction scope.
  • Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks arXiv / NeurIPS 2020. Submitted May 22, 2020; accessed July 6, 2026. Primary research source for RAG as parametric plus non-parametric memory for generation.
All free tools
The node graph modelNodes, edges, actions, shared store, params, nesting, and why the graph is the framework.Minimal vs heavyWhere tiny orchestration wins, where LangChain/LangGraph/LlamaIndex win, and how to choose fairly.Free toolsClient-side graph design, framework overhead, and orchestration pattern tools.Flow graph designerSketch a node graph and export JSON plus Python skeleton code.