[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"project-92236":3},{"id":4,"name":5,"fullName":6,"owner":7,"repo":5,"description":8,"homepage":9,"htmlUrl":10,"language":11,"languages":10,"totalLinesOfCode":10,"stars":12,"forks":13,"watchers":14,"openIssues":15,"contributorsCount":13,"subscribersCount":13,"size":13,"stars1d":13,"stars7d":13,"stars30d":16,"stars90d":13,"forks30d":13,"starsTrendScore":13,"compositeScore":17,"rankGlobal":10,"rankLanguage":10,"license":18,"archived":19,"fork":19,"defaultBranch":20,"hasWiki":21,"hasPages":19,"topics":22,"createdAt":10,"pushedAt":10,"updatedAt":23,"readmeContent":24,"aiSummary":25,"trendingCount":13,"starSnapshotCount":13,"syncStatus":15,"lastSyncTime":26,"discoverSource":27},92236,"PiFlow","blueif16\u002FPiFlow","blueif16","Self-designing, durable, self-improving agent orchestration: describe a goal — an agent designs the graph, a fleet of sealed full-agent nodes runs it, and a learning loop makes it better every run.","https:\u002F\u002Fpiflow.sh",null,"JavaScript",66,0,52,2,8,40.8,"MIT License",false,"main",true,[],"2026-07-22 04:02:05","\u003Cp align=\"center\">\n  \u003Cimg src=\"docs\u002Fassets\u002Ftui-hero.png\" width=\"820\" alt=\"Pi Flow's terminal monitor: a fusion workflow (plan → three parallel drafts → harden → publish) running one pi agent per node, with per-node stage, model, token count, and verified on-disk outputs.\">\n\u003C\u002Fp>\n\n\u003Ch1 align=\"center\">Pi Flow\u003C\u002Fh1>\n\n\u003Cp align=\"center\">\u003Cb>Describe a goal. An agent designs the graph, a fleet of sealed full-agent nodes runs it, and a learning loop makes it better every run.\u003C\u002Fb>\u003C\u002Fp>\n\n\u003Cp align=\"center\">\n  \u003Ca href=\"https:\u002F\u002Fgithub.com\u002Fblueif16\u002FPiFlow\u002Fstargazers\">\u003Cimg src=\"https:\u002F\u002Fimg.shields.io\u002Fgithub\u002Fstars\u002Fblueif16\u002FPiFlow?style=flat&color=111111\" alt=\"GitHub stars\">\u003C\u002Fa> ·\n  \u003Cimg src=\"https:\u002F\u002Fimg.shields.io\u002Fbadge\u002Fstatus-v0.1_early-orange\" alt=\"Status: v0.1, early\"> ·\n  \u003Cimg src=\"https:\u002F\u002Fimg.shields.io\u002Fbadge\u002Fruntime-pi-111111\" alt=\"Runs on the pi agent runtime\"> ·\n  \u003Cimg src=\"https:\u002F\u002Fimg.shields.io\u002Fbadge\u002Flicense-MIT-blue\" alt=\"MIT license\"> ·\n  \u003Ca href=\"https:\u002F\u002Fpiflow.sh\">piflow.sh\u003C\u002Fa>\n\u003C\u002Fp>\n\nPi Flow is an open-source **orchestration substrate for agentic workflows**. Every node in the graph is a **full, sealed `pi` agent** — not a thin model call. The graph is **designed from a goal**, not drawn on a canvas. And a **Hermes-style memory** makes proven flows improve each run. You build it once on Claude Code (`ultracode`); the fleet carries it from there, and you steer the whole thing from your terminal.\n\n## What is Pi Flow?\n\nThree things, stacked, that no single tool gives you together:\n\n- **Self-designing** — hand it a goal; an agent decomposes the work, discovers the right tools for each piece, infers the edges (you don't draw them), and parallelizes by default into a runnable DAG.\n- **Durable & sealed** — each node is a complete agent in its own sandbox with exactly the tools and files you grant it. Nodes hand off through the filesystem; plain code owns the graph, so the model never decides control flow.\n- **Self-improving** — a background control plane watches every run, fixes a stalled node, gates on a failed check, and writes down what worked — so the next run starts ahead.\n\nIt sits in a slot the incumbents don't: **agentic · self-designing · self-improving · long-horizon · production.** Temporal\u002FDBOS are durable but not self-designing; LangGraph is a typed graph for *fixed* flows; CrewAI is role-prototyping; ADAS\u002FAFlow\u002FGEPA design agents *offline*. Pi Flow is the intersection — online, durable, and built on full-agent nodes.\n\n> [!NOTE]\n> Pi Flow runs **on top of [`pi`](https:\u002F\u002Fpi.dev)** (`earendil-works\u002Fpi`) — the headless agent each node spawns. It's an external prerequisite, installed and credentialed once via `~\u002F.pi\u002F`, not bundled. That's what keeps `@piflow\u002Fcore` product-agnostic logic.\n\n## The three layers\n\nThe product is three layers you can reach for independently — **the agent, the workflow, the memory.**\n\n### P1 · Agents — every node is a full agent in a sealed box\n\nA node is a complete `pi` agent, isolated, holding exactly what you grant it.\n\n| | What you get |\n| --- | --- |\n| **Node** | A full Pi agent you scope and equip — set its read\u002Fwrite scope, declare its tools and skills, install any MCP or OpenClaw plugin, connect to any MCP server. |\n| **Hooks** | Programmatic pre\u002Fpost checks around every node — the seam where the gate and policy are applied. |\n| **Sandbox** | Isolated execution with file-based hand-off. Set a sandbox per workflow, per run, or per node; git-tracked; local, any OS, or a cloud provider. |\n| **Telemetry** | See and debug the runtime live — agent-native CLI commands trace every tool call and every sync, with docker-style streaming modes. |\n| **Composability** | Snap base agent types + skills + their tools together like Lego; each node grows into exactly the specialist its task needs. |\n\n### P2 · Workflow — hand it a goal, it designs the graph\n\nThe DAG that runs the agents — designed, adaptive, and promotable.\n\n| | What you get |\n| --- | --- |\n| **Compose** | An agent breaks your goal into the work that does it, finds each piece's tools, and wires them into a flow. Independent steps run side by side; dependencies become the edges. |\n| **Adaptivity** | Designs that adapt to any DAG change — copy a pre-built, skill-system workflow and migrate in one click; the full monitoring interface visualizes every part of a running flow (watch a model fusion expand the graph in one click). |\n| **Cloud** | Promote the whole DAG, a single node, or the rest of a run to a cloud VM with a Kubernetes-style control plane — one click, or a message to an agent — then monitor and control it remotely through the GUI. |\n\n### P3 · Memory — proven flows get better each run\n\nA Hermes-style memory captured *as the agent works*, so corrections compound.\n\n| | What you get |\n| --- | --- |\n| **Lessons** | Self-correcting memory that records what changed and why — a git-backed collection holds the exact update history; a `memory.md` per node and per workflow turns past corrections into durable guidance. |\n| **Functionality** | An optional built-in open code graph indexes the codebase and maintains a slicing of function records, so a `code-map.md` per node carries an exact understanding of how its work gets done. |\n\n## How it works\n\nA Claude Code agent owns the whole loop through the **`@piflow\u002Fcore` SDK + the `piflowctl` CLI**: it designs the DAG, spawns the fleet, monitors every node, and improves the flow between runs.\n\n```\n  COMPOSE ──designs──►  RUN  (one `pi` per node · parallel stages · filesystem state)\n     ▲                    │\n     │ re-compose         ├─ observe ─► ONE stream ─► GUI · TUI · watch   (monitor-only)\n     │ (next phase)       │\n     └──────  control plane  ◄── debug → Hermes ──► edit skill \u002F memory\n                          (the learning loop = the gradient across runs)\n```\n\nThat closed loop — **design → run → observe + debug\u002FHermes → edit skill or re-compose → rerun** — *is* the substrate. The driver owns stage order, parallel lanes, and halt-on-failure; each node ends with one fenced ` ```json ` block the driver verifies against disk (`ok` ⇒ the files exist). Hot-edits land at the **seams, between runs** — never mid-run.\n\n## The two monitors\n\nThe GUI and the TUI are **monitor-only twins** — their one job is a clear picture of what's running right now: which nodes are live, their context\u002Fcost, the warnings, the shape of the DAG. Both read the same single stream off disk; neither reimplements run state.\n\n\u003Cp align=\"center\">\n  \u003Cimg src=\"docs\u002Fassets\u002Fgui-canvas.png\" width=\"720\" alt=\"Pi Flow's GUI canvas: a research → build workflow rendered as a box-and-arrow DAG, each node showing its agent, status, and produced files, with a run switcher and view-mode overlays (Status · Model · Artifacts · Basis · Fusion · Compose · Chat).\">\n\u003C\u002Fp>\n\n```bash\npiflowctl gui                 # the canvas (box-and-arrow DAG, view-mode overlays)\npiflow-tui  \u003Crundir>          # the terminal monitor (above)\npiflowctl watch \u003Crundir>      # a silent sentinel: one line on done \u002F fail\npiflowctl logs  \u003Crun> -f      # docker-logs-for-a-run: follow every node's event stream\n```\n\n## Quickstart\n\n```bash\n# 1 · Prerequisite: the pi agent runtime on your PATH, and a model wired up\npi --list-models cp\n\n# 2 · Install the plugin (3 Claude Code skills) + the piflowctl CLI\ngit clone https:\u002F\u002Fgithub.com\u002Fblueif16\u002FPiFlow.git && cd PiFlow\nfor s in piflow-init piflow-enhance piflow-start; do\n  ln -sfn \"$(pwd)\u002F.claude\u002Fskills\u002F$s\" ~\u002F.claude\u002Fskills\u002F$s\ndone\nnpm --prefix packages\u002Fcli link        # → the global `piflowctl` bin\n\n# 3 · Dry-run a workflow (free — prints stages, per-node tools\u002Fhooks, the pi command),\n#     then go live on the fleet (run it in the background and watch)\npiflowctl run \u003CtemplateDir> --provider cp --thinking low --sandbox local --dry-run\npiflowctl run \u003CtemplateDir> --provider cp --thinking low --sandbox local\n```\n\nThen steer from the terminal: Claude Code surfaces **`piflow-init`** to design or port a workflow, **`piflow-start`** to run and monitor one, and **`piflow-enhance`** to improve one. You never wire a node on a canvas, click *Run*, or configure a run on a screen — at most you drop in an API key.\n\n> [!TIP]\n> The bin links as **`piflowctl`** (bare `piflow` collides with the unrelated `@arche-sh\u002Fpiflow`). If `piflow` is free on your machine: `alias piflow=piflowctl`.\n\n## What's shipping today\n\n**Running now — the agent layer (P1) and the run engine:** sealed per-node sandboxes (`local` · `seatbelt` · `worktree` · `daytona`), declarative per-node tools (MCP + OpenClaw), pre\u002Fpost hooks, verified-not-trusted contracts; **true parallel stages** with deterministic stage-barrier promotion; the **one-stream observability** (GUI · TUI · `watch` · `logs`); and fusion nodes.\n\n**In flight — the rest of the loop:** **Compose (P2)**, the design-from-a-goal planner (the `WorkflowSpec` → `compile` boundary is built; the planner is landing); the **Memory layer (P3)**, Hermes lessons + the code graph (designed, mechanism in progress); and the **control plane**, the self-improvement and cloud-promotion loops. These reuse the same node primitive — a control node is just a node with intelligence on a seam — so they're mostly *composition*, not new machinery. See [`ROADMAP.md`](ROADMAP.md).\n\n## The pieces\n\n| Piece | Package \u002F bin | Role |\n|---|---|---|\n| **Engine (SDK)** | `@piflow\u002Fcore` | the node-envelope schema, the DAG compiler, the runner, the tool\u002Fsandbox plane, and the `observe` stream |\n| **CLI** | `@piflow\u002Fcli` → `piflowctl` | the front door: `run` · `inspect` · `extract` · `status` · `watch` · `logs` · `gui` |\n| **Monitor** | `@piflow\u002Ftui` → `piflow-tui` + the GUI canvas (`piflowctl gui`) | monitor-only twins on the **one** `observe` stream |\n| **Runtime** | `pi` — external prerequisite | the headless agent each node spawns; credentialed once via `~\u002F.pi\u002F`, kept external so `@piflow\u002Fcore` stays product-agnostic logic only |\n\n## Documentation\n\n- **[`docs\u002FINDEX.md`](docs\u002FINDEX.md)** — start here: the reading map + the vocabulary.\n- **[`docs\u002FARCHITECTURE.md`](docs\u002FARCHITECTURE.md)** — the buildable mechanism + what's built today vs the gaps.\n- **[`docs\u002Fdesign\u002Fl1-node-envelope.md`](docs\u002Fdesign\u002Fl1-node-envelope.md)** — the node-envelope schema canon (the frozen spine).\n- **[`docs\u002Fdesign\u002Fl2-l3-boundary-map.md`](docs\u002Fdesign\u002Fl2-l3-boundary-map.md)** — Compose, the control plane, and the closed loop.\n- **[`ROADMAP.md`](ROADMAP.md)** — the build order, framework shape, and guardrails.\n- **[piflow.sh\u002Fdocs](https:\u002F\u002Fpiflow.sh\u002Fdocs)** — the hosted docs.\n\n## Security\n\nNo secrets ship in this repo. `.env.example` and `models.json.example` contain only placeholders (`sk-REPLACE_ME`, `your-provider.example.com`); the bundled `.gitignore` excludes the real files. Set the credential **once** in pi's own global config (`~\u002F.pi\u002Fagent\u002Fmodels.json`, `chmod 600`). Never commit a filled-in credential.\n\n## License\n\nMIT\n","Pi Flow 是一个面向智能体工作流的自设计、持久化与自优化编排框架。它支持用户仅描述目标，由智能体自动构建可执行的有向无环图（DAG），每个节点为隔离的完整智能体（基于 pi 运行时），通过文件系统传递数据，并依托 Hermes 风格记忆机制实现运行间持续改进。技术上强调控制流由代码定义而非模型决策，节点沙箱化、工具与权限显式声明，且依赖外部 pi 代理运行时。适用于需长期演进、高可靠性保障与目标驱动自动化的复杂任务场景，如多阶段内容生成、自动化研究流程或闭环式工程验证。","2026-07-08 04:29:55","CREATED_QUERY"]