PocketFlow

PocketFlow implements a universal Graph + Shared Store model where nodes represent discrete computation units and a shared dictionary maintains mutable state across the entire workflow. Each node executes a three-phase lifecycle (prep → exec → post) with access to the shared store, enabling stateful coordination without external databases. The graph structure is language-agnostic, ported identically across Python, TypeScript, Java, C++, Go, Rust, and PHP with consistent node lifecycle semantics.

Every node in PocketFlow executes through three distinct phases: prep() prepares data and validates inputs using the shared store, exec() performs the core computation (LLM call, tool invocation, data transformation), and post() processes results and updates shared state. This lifecycle is implemented identically across all language ports, enabling predictable node behavior and clear separation of concerns. Nodes can access and mutate the shared store at any phase, with post() typically responsible for persisting results.

PocketFlow supports real-time streaming of node results and LLM token streams within workflows. Nodes can yield intermediate results as they compute, with results streamed to downstream nodes or to external consumers (web clients, logs). LLM streaming is supported for agents and generation nodes, enabling token-by-token output without waiting for full completion. Streaming is integrated with async execution, enabling non-blocking result consumption.

PocketFlow provides built-in visualization and tracing capabilities for debugging workflows and understanding agent behavior. Workflows can be visualized as directed graphs showing node dependencies and data flow. Execution traces capture per-node timing, input/output values, and shared state mutations, enabling post-mortem analysis of workflow behavior. Traces can be exported as JSON or visualized in interactive dashboards.

PocketFlow implements an Agent-to-Agent (A2A) protocol enabling agents to communicate and delegate tasks to other agents within a workflow. Agents can invoke other agents as tools, passing queries and receiving results through a standardized protocol. The A2A protocol supports hierarchical agent structures (manager agents delegating to worker agents) and peer-to-peer agent networks, with all communication mediated through the shared store.

PocketFlow supports Human-in-the-Loop (HITL) patterns where workflows pause for human input or approval at designated checkpoints. Nodes can be marked as requiring human review, pausing execution until a human provides feedback or approval. Human input is stored in shared state and accessible to downstream nodes, enabling workflows to adapt based on human decisions. HITL is integrated with async execution, enabling non-blocking human input collection.

PocketFlow's 100-line core is ported to 7 programming languages (Python, TypeScript, Java, C++, Go, Rust, PHP) with identical semantics and behavior. Each port implements the same Graph + Shared Store model and three-phase node lifecycle, enabling workflows defined in one language to be understood and modified in another. Ports maintain feature parity (agents, RAG, batch processing, async execution) while using language-native idioms and libraries.

PocketFlow provides a built-in Agent pattern that wraps LLM inference with tool calling capabilities and iterative decision-making loops. Agents use the shared store to maintain conversation history, tool results, and reasoning state across multiple LLM invocations. The pattern supports both function calling APIs (OpenAI, Anthropic) and custom tool registries, with agents automatically routing tool calls to registered handlers and feeding results back into the LLM context.

PocketFlow provides a RAG pattern that chains retrieval, ranking, and generation nodes within a single workflow graph. The pattern uses the shared store to pass retrieved documents through ranking stages and into the LLM context window. Supports vector embeddings via external providers (OpenAI, Hugging Face) and custom ranking logic, with results cached in shared state to avoid redundant retrievals across agent iterations.

PocketFlow provides a Batch Flow abstraction that implements map-reduce semantics for processing collections of items in parallel. The map phase distributes items across worker nodes, each executing the same computation independently with access to shared state for coordination. The reduce phase aggregates results back into the shared store. Supports both synchronous and asynchronous batch processing with configurable parallelism and error handling per item.

PocketFlow supports both asynchronous (async/await) and parallel (thread/process pool) execution of nodes within a workflow graph. Nodes can be marked as async, and the framework automatically manages event loop scheduling and result collection. Parallel execution uses Python's concurrent.futures for thread-based parallelism or multiprocessing for CPU-bound tasks, with shared state access coordinated through thread-safe wrappers. Async and sync nodes can be mixed in the same graph with automatic bridging.

PocketFlow enables Chain-of-Thought (CoT) reasoning by composing multiple reasoning nodes that accumulate intermediate thoughts in the shared store. Each reasoning node can prompt the LLM with previous reasoning steps, enabling iterative refinement of answers. Structured output is supported through JSON schema validation and parsing, with results stored as typed objects in shared state. The pattern supports both few-shot examples and dynamic prompt construction based on accumulated reasoning.

PocketFlow enables multi-agent systems where independent agents coordinate through a shared state dictionary rather than explicit message passing. Each agent is a node in the workflow graph with access to the shared store for reading other agents' outputs and writing results for downstream agents. Agents can be executed sequentially or in parallel, with shared state providing implicit coordination. The pattern supports agent hierarchies (manager agents coordinating worker agents) and peer-to-peer agent networks.

PocketFlow integrates with the Model Context Protocol (MCP) standard, enabling agents to call tools defined via MCP servers without custom schema definitions. MCP provides a standardized interface for tool discovery, invocation, and result handling across different LLM providers. Agents can dynamically discover available tools from MCP servers and automatically generate function calling schemas, reducing boilerplate for tool integration.

PocketFlow provides built-in support for vector embeddings and semantic search through integration with embedding providers (OpenAI, Hugging Face) and similarity search algorithms. Embeddings are computed on-demand or cached in shared state, with cosine similarity used for retrieval ranking. The pattern supports both dense embeddings (from neural models) and sparse embeddings (BM25-style), with configurable similarity thresholds and top-k retrieval.