JSPM

A low-level utility for matching a string against a directed acyclic graph of regexes.

A topologically ordered map of key/value pairs with a simple API for adding constraints.

Directed acyclic graph functions for graphology.

Typescript implementation of the IPLD dag-jose format

Layout algorithms for visualizing directed acyclic graphs.

Complete WASM toolkit for edge AI: vector search, graph DB, neural networks, DAG workflows, SQL/SPARQL/Cypher, and ONNX inference - all running in browser

Directed graphs analyzer for parallel traversals

WebGL Node-based Graph for React

Graph visualization for angular

toposort using modern ecma script data structures

Efficiently sort interdependent tasks into a sequence of concurrently-executable batches.

A user-empowering data visualization Vue 3 components library for eloquent data storytelling

Calculate packages required to rebuild when a given package changes

Utility functions for the dag-jose ipld codec

Lossless Context Management plugin for OpenClaw — DAG-based conversation summarization with threshold compaction

TypeScript/JavaScript client for the nedbd HTTP API (nedb-engine)

Type-agnostic directed acyclic graph (DAG) & graph operations

Core workflow execution engine for CascadeFlow with dependency-aware parallel task execution

Live deck of Claude Code and Codex agents — watch parallel subagents fork, call tools, and return on one calm canvas. Also available as npx ccdeck and npx agent-dag.

LLM-backed worox-graph DAG composer and studio preflight: graph authoring actions, graph-entry patches, skill invoke analysis (analyzeTaskNodeRunTaskRequest), llmCall/reasoningEffort orchestrator contract — OpenRouter via @x12i/funcx; catalog rows from @x

Utilities for working with graphs in javascript.

TypeScript SDK for signing data transactions on Constellation data metagraphs built with metakit

CLI tool for structured software specifications. Validate .dog files, compile .dag graphs, query via MCP.

A tiny (~315B) utility that executes a dependency graph of async functions as concurrently as possible.

Symbiote provider UI, Web Components, themes, manifests, schemas, graph layout helpers, WebMCP metadata, and SSR-safe UI contracts.

JSONata embedded in JSON

Compose backtest-kit computations as a typed directed acyclic graph. Define source nodes that fetch market data and output nodes that compute derived values — then resolve the whole graph in topological order.

Sparse & bitwise adjacency matrices, lists and selected traversal algorithms for directed & undirected graphs

Pi extension. Chain skills into typed multi-stage workflows with audited JSONL state, predicate routing, and per-stage output validation. Skill-agnostic — bring your own skills.

Directed acyclic graph

A lightweight workflow engine

A TypeScript-first graph library with plain JSON-serializable objects

@gobing-ai/ts-dual-workflow-engine — State-machine and transition-flow workflow runtime.

DAG resolution of vanilla objects & arrays with internally linked values

Atlas by Synthetic Sciences - research map CLI and skills.

A powerful Workflow Orchestration Engine with simple declarative YAML API. Zero-dependency, single binary for Linux, macOS, and Windows.

Unified WebAssembly bindings for 18+ attention mechanisms: Neural, DAG, Graph, and Mamba SSM

Multi-agent YAML workflow engine — 216 AI roles, auto DAG parallelism, zero code. One sentence → multiple AI roles collaborate → complete plan in minutes. 10 LLM providers, 7 need no API key.

DSL to define shader code in TypeScript and cross-compile to GLSL, JS and other targets

PostgreSQL schema-aware deployment control — idempotent SQL migrations with CI-enforced integrity checks, expand/contract migration orchestration, schema drift detection, and unified gating across database, application, and infrastructure rollouts

Parser, validator, expression engine, DAG resolver, and reasoning compiler for the LOGIC.md specification

Run multi-step prompt chains on local CLI models, defined in one YAML file.

Skill library, DAG workflow orchestration, and E2E browser testing powered by Claude

Worldline-first WARP graph over Git: deterministic multi-writer causal history, readings, and tooling.

A logic orchestration engine utilizing topological scheduling and watermark control to resolve asynchronous race conditions in complex dependency linkages.

Directed acyclic graph (DAG) builder for Vue.js

Directed acyclic graph (DAG) based solver.

ARCS — DAG-based task orchestration for AI agents. Persistent workflow continuity via graph-structured context.

Pattern execution engine — runtime-neutral core (Web-standard APIs only).

Universal node-based execution engine. Domain-agnostic graph runtime.

Live deck of Claude Code and Codex agents — watch parallel subagents fork, call tools, and return on one calm canvas. Also available as npx ccdeck and npx agent-dag.

JavaScript implementation of the Knish.IO SDK to consume Knish.IO GraphQL APIs.

A layout and rendering engine for graphs

a toolkit for composing tangle reducing strategies

reduce tangles into their current state

A drop-in visual workflow editor for any web application. You own the backend. You own the data. You own the orchestration.

An Angular service for managing directed acyclic graphs

Julia 3.0 - AI Orchestrator with RTK compression, Auto-DAG parallelism, and 84% token economy

Minimal and explicit dependency-injection & lifecycle container for stateful app components

Robust async, stream-first Git plumbing for Node, Bun, and Deno.

Adaptive dev orchestration CLI — task DAG, content caching, runtime detection

A layout and rendering engine for graphs

TypeScript SDK for ottochain metagraph operations - signing, encoding, and network interactions

A layout and rendering engine for graphs

Host-neutral engine for declarative, verifiable task-DAG orchestration — the runtime, DSL, cache, and verification shared by pi-taskflow, codex-taskflow, claude-taskflow, and opencode-taskflow.

a helper for building + updating traverseable tangle graphs

Chain promises declaratively using high-level graphs. Tiny, portable, dependency-free.

Configuration-driven dynamic form engine — types, DAG, conditions, validation, stepper

Detach monorepo packages from normal linking

A framework for building type-safe, DAG-based workflows with optional Temporal integration.

Agentic engine core (release candidate) — descriptor registry, 9-phase execution pipeline, prompt assembler, task scheduler, safety & observability modules, with built-in direct-answer and tool-use (agentic loop) sub-flows.

[](https://www.npmjs.com/package/@ebay/nice-dag-core) [](https://www.npmjs.com/package/@ebay/nice-dag-core) [![Demo](https://img

Graph visualization for angular

Composable AI safety pipeline framework with industry compliance packs (HIPAA, SOX, GDPR, FedRAMP)

Deterministic rails for agentic workflows. Declare steps and dependencies; the engine guarantees order, redoes what changes invalidate, and stops what keeps failing — instead of hoping the agent follows through.

Manifesto Lineage - decorator runtime for seal-aware continuity, history, and restore

TypeScript implementation of the Knish.IO SDK to consume Knish.IO GraphQL APIs with enhanced type safety.

Run a topology consisting of a directed acyclic graph

Core kernel for the Constellation metagraph SDK: hashing, canonical serialization, and signing primitives. Generic and offline.

Execute tasks from task files/PRD's using DAG-based dependency resolution with persistent progress tracking

Run a topology created with topology-runner using nats-jobs

Never lose context again. Long Context Manager (LCM) compresses Claude Code sessions into searchable memory — every message preserved, every insight remembered.

Reactive-graph inspector for @zakkster/lite-signal. Non-perturbing introspection (peek + enumerator walks, never adds an observer), full auto-discovered DAG with diamond/convergence dedupe, live lifecycle feed, leak detector, DOT/tree renderers, and diff(

[](https://www.npmjs.com/package/@ebay/nice-dag-react) [](https://www.npmjs.com/package/@ebay/nice-dag-react) [![Demo](https:/

Keeps a directed acyclic graph topologically sorted each time you add an edge or vertex to check for cycles.

DAG-based deterministic context compiler for AI coding agents

Seeding data using DAGs

Agent-owned, self-evolving DAG+FSM state: durable memory, policy and intuition in one event-sourced store, with soft/hard transition enforcement.

Directed acyclic graph utility in TypeScript

Dependency-aware todo manager — tasks as a DAG, topological sort tells you what to do next

Work item store with dependency graph helpers for mu.

A minimalist, dbt-like SQL transformation tool for Node.js — compile SQL models, build a dependency DAG, and materialize them on any supported SQL database.

Trembus Tier-2 node-link visualizations (Tree, Lineage, SystemMap, ClassDiagram, Strata) — the same 3-jobs contract spine as @trembus/ui's Tier-1 viz, with a layout engine (d3-hierarchy for trees, dagre for DAGs), drill-down C4 architecture maps, UML clas

@xyflow/svelte wrappers — node editors, DAG helpers, canvas utilities

A graph-based task management system with CLI and web UI for atomic, verifiable tasks

Durable DAG workflow engine: Zod-typed steps over Postgres + pg-boss, with an optional AI add-on (token/cost/quota). Layered single package.

Zero-cost data provenance tracking

Multi-agent YAML workflow engine — 211 AI roles, auto DAG parallelism, zero code. One sentence → multiple AI roles collaborate → complete plan in minutes. 10 LLM providers, 7 need no API key.

A wrapper over webrtc-tree to build DAG AI topologies like Lego blocks.

TypeScript SDK for PMS (Planetary Monetary System) — wallet management, transactions, NFTs, and DAG interactions

DAG-based task runner CLI with Ink TUI

Library for working with autonomous agent events

Open-source DAG engine from ArcPX — pluggable node executor, parallel workflows, GraphEngine({ llm }) for Bedrock/OpenAI

[](https://www.npmjs.com/package/@ebay/nice-dag-vue3) [](https://www.npmjs.com/package/@ebay/nice-dag-vue3) [![Demo](https://img

In-page visual debugger for @zakkster/lite-signal reactive graphs. A pure consumer of @zakkster/lite-devtools: live layered DAG view (SVG), node inspector, engine stats, lifecycle log, and DOT export. Non-self-instrumenting -- it never creates a signal, s

React component for workflow DAG visualization

World-class CLI for modern web development with enterprise-grade features: plugins, recipes, and DAG task engine

A lightweight, type-safe, and domain-agnostic task orchestration engine. It resolves a Directed Acyclic Graph (DAG) of steps, executes independent tasks in parallel, and manages a shared context across the pipeline.

Interactive workflow DAG visualizer (WASM + Canvas)

Lossless m3mory Claw — DAG-based context management with m3mory long-term memory integration for OpenClaw

This is a base implementation of wrapping jsplumb with react + redux to be more usable in a react based environment

A Directed Acyclic Graph (DAG) library with online cycle detection and topological ordering.

Workflow execution engine and cron scheduler for consensus-tools

DAG based computation graph

PipeSafe Manifold - DAG composition and orchestration layer for @pipesafe/core

基于Vue3的DAG流程图组件。

TypeScript library for working with directed graphs

QuDAG - Quantum-Resistant Distributed Communication Platform

Dependency-free logic + a thin React view for browsing a DAG (polyhierarchy) as a collapsible tree, de-duplicating nodes that appear under multiple parents.

Conductor Workflow IDE — a visual workflow designer built with React 19, ReactFlow and Zustand for editing, validating and monitoring Netflix Conductor workflows.

Syncable large scale database built on IPLD

A library-first async agent system for building autonomous workflows

See and debug your GitHub Actions workflow as a graph before you push.

Lightweight DAG workflow engine for orchestrating code in Docker containers via light-run.

Task decomposition, planning, and multi-agent orchestration for KATASHIRO

Crash-safe, non-blocking, modular job processing framework for Node.js

AI 算法编排可视化工作流编辑器组件库

Alias for agents-deck — live deck of Claude Code and Codex agents. Run with: npx ccdeck

Local Workflow Engine - Pure, deterministic workflow executor

High-performance graph database with native Cypher support and pluggable storage

Workflow engine for SWEny — composable DAG-based agentic workflows

Pay-per-call API SDK & CLI for APINow.fun — endpoints + workflows, wraps x402 so you don't have to

Provider-neutral agent runtime for coding workflows. Verified DAG execution with evidence gates, worktree isolation, and local graph memory.

Local deterministic proof relationship graph for Totem Edge — indexes proofs, identities, manifests, and subjects into a queryable content-addressed DAG

Durable workflow engine for Node.js — type-safe, fault-tolerant task orchestration

MMCP — Multi-Model Context Protocol. Intelligent AI model routing with MCP server for Claude Desktop & Codex CLI. Auto-routes tasks to Claude, GPT, Gemini, DeepSeek, Llama with RL-based smart routing and cost optimization.

Interactive flowchart and node-graph engine for Alpine.js — drag-and-drop nodes, edges, animations, collaboration, and layout algorithms.

The official logger plugin for MeshFlow

React component to create interactive D3 directed acyclic graphs (DAGs)

A powerful Workflow Orchestration Engine with simple declarative YAML API. Zero-dependency, single binary for Linux, macOS, and Windows.

Advanced cognitive thinking MCP with DAG-based thought graph, 10 reasoning strategies, node aliases, session persistence, structured responses, auto strategy selection, and 17 tools with help & conclude

Dagify is a JavaScript library designed for building and managing reactive dependency graphs. It enables developers to create dynamic, interconnected data flows with support for computed nodes, shallow reactive nodes, manual execution, and network synchro

N-API bindings for QuDAG quantum-resistant DAG and cryptography

Immutable, type-safe directed acyclic graph (DAG) with a fluent class API and a tree-shakeable pure-function core: topological sort, cycle detection, and traversals.

Local-first LLM state branching, debugging & context offloading. Treat AI context windows like a Git repo — capture, branch, and archive context as encrypted DAG capsules.

External cryptographic step ledger for long-running multi-agent orchestration

Runtime-neutral, durable, file-driven DAG orchestration controller for multi-stage agent workflows (agent-team, shell, sdtk-cli, external lifecycle adapters, Hermes Kanban dry-run).

Vue components to create svg interactive graphs, diagrams or node visual tools.

Mermaid flowchart renderer for @orcish/dag: a pure DagRaw to string function with no DOM and no runtime dependencies.

Generate interactive, credential-free documentation for Dataform projects (dependency graph, column-aware search, assertion linkage).

A Directec Acyclic Graph visualization for angular!

DAG workflow engine with AI-powered nodes — design, run, and deploy workflows from CLI, UI, or code

Configuration-driven visual graph editor for Angular 19+

LLM-backed worox-graph DAG composer: create, modify, explain, suggestConceptObjective, reviewConcept, catalog resolution/creation, scoping need match and scoping map creation plans, plus optional orchestrator — OpenRouter via @x12i/funcx; catalog rows fro

A 'reactive' React node and edge generator

Headless DAG (Directed Acyclic Graph) manager for node-based visual programming

Graph visualization for angular

A2R Workflow Engine - Visual workflow orchestration with DAG support

TypeScript types + JSON Schema + parser/validator for the OpenExpertise experience.yaml format.

BlueSky firehose/WebSocket and CAR in plain JavaScript

Portable workflow DAG schema, validation, and interpreter for SkillsRegistry

```sh $ npm install $ cd examples $ node balance.js ```

Headless, framework-agnostic, high-performance 2D flow visualization engine (Pure Canvas2D)

Multi-agent YAML workflow engine — 211 AI roles, auto DAG parallelism, zero code. One sentence → multiple AI roles collaborate → complete plan in minutes. 10 LLM providers, 7 need no API key.

Modify the ngx-chart version is used

Node JS utils and methods to interact with rchain's rnode api and proto interfaces

StepFlow graph for ASL-like state machine workflows with scope validation

Scheduler, dispatcher registry, event bus, and SQLite-backed state store — the OpenExpertise runtime.

Never lose context again. lossless-claude compresses Claude Code sessions into searchable memory — every message preserved, every insight remembered.

DAG-specific validation and rules for @cook-step/graph with cycle detection and multiplicity constraints

Core models, parser, validator, graph, and planning engine for COOP.

Éditeur de formation (domaine headless) : arbre Formation/Activity (10 kinds), dépendances DAG + détection de cycle, validation par kind, snapshots versionnés. DÉCOUPLÉ du média (mediaRef opaque). Extraction iquesta.

A GEDCOM parser, which translates GEDCOM (.ged) files into D3 capable JSON. This package is specifically designed to prepare data for use in https://github.com/oh-kay-blanket/blood-lines

Provide math operators for the computeTS package

a merkle trie implemention that if focused on being generic and fast

Filesystem-first context store — typed shared memory for agent phases, with content-addressable records and a DAG of provenance

OpenCode plugin: orchestrate ephemeral adversarial agent teams for software development

Personal modify

Any-file to Markdown importer (MarkItDown bridge) with content-addressed conversion cache for Makedown.

A dependency based service graph controller library

The official rendering gateway plugin for MeshFlow

Execution kernel (compiler, node-runner, registry, binding resolver) and built-in IF/LLM nodes for OpenPipeline.

Dependency-graph execution planner using Kahn's Algorithm with priority-aware batching

A library for creating visualizations of undirected and directed graphs with the help of AI.

distributed decentralized app-scale ledger

Generic DAG scheduling core: adjacency, cycle detection, topological sort, parallel waves, and failure-cascade propagation

Dispatcher for `tool` nodes — runs deterministic JavaScript/TypeScript impl files.

Visual DAG builder for OpenPipeline as a controlled React component library (ReactFlow + Zustand).

A SolidJS component library for graph visualization, powered by @antv/g6

OpenAI-compatible LLMClient implementation for OpenExpertise — wraps any OpenAI-API endpoint (OpenAI, Azure, self-hosted).

Simplify Asynchronous Operations in JavaScript

A powerful workflow engine that supports DAG (Directed Acyclic Graph) task scheduling with conditional branching, parallel execution, and context management.

Dispatcher for `dataset` nodes — loads file/sqlite/http/MCP-resource data into state.

Easy, simple, data workflows

Dispatcher for `experience` nodes — nests one OpenExpertise experience inside another.

Shared domain types and zod schemas for Makedown.

Spec-driven, test-first, graph-based workflow engine for Claude Code

Lossless Context Management for Pi — DAG-based summarization with full history recovery

Framework-agnostic execution kernel and interface contracts for OpenPipeline.

Invisible events. Replayable graphs. AxionGraph is an append-only execution-graph event model and deterministic reducer — provider-agnostic, storage is a port.

Reflow is a modular flow-based programming runtime that executes actor-model DAGs for data pipelines, real-time media, visual tooling, and optional ML/CV workloads. This package is the official Node.js SDK.

Reflow is a modular flow-based programming runtime that executes actor-model DAGs for data pipelines, real-time media, visual tooling, and optional ML/CV workloads. This package is the official Node.js SDK.

Provide number operators for the computeTS package

Git-backed work graphs for constraint-driven planning.

Safe math evaluator with variables, dependencies, and precision

Dispatcher for `skill` nodes — invokes Anthropic-style SKILL.md packages as graph steps.

A lighweight swrm client for browser.

Dispatcher for `cli-agent` nodes — delegates work to Claude Code, Codex, or Gemini CLI subprocesses with timeout/retry.

Fast DAG (Directed Acyclic Graph) library with Rust/WASM. Topological sort, critical path, task scheduling, dependency resolution, workflow optimization. Self-learning ML attention. Browser & Node.js with auto-persistence.

Reflow is a modular flow-based programming runtime that executes actor-model DAGs for data pipelines, real-time media, visual tooling, and optional ML/CV workloads. This package is the official Node.js SDK.

Provide boolean operators for the computeTS package

Reflow is a modular flow-based programming runtime that executes actor-model DAGs for data pipelines, real-time media, visual tooling, and optional ML/CV workloads. This package is the official Node.js SDK.

Command-line interface for QuDAG quantum-resistant DAG operations

Advisor that reads a run's events+state and proposes graph upgrades as git-apply-ready diffs.

Hierarchical Knowledge Graph Visualization System

SDK for AINetwork MerkleDAG gRPC service

Node JS utils and methods to interact with rchain's rnode api and proto interfaces

`oe-mcp` MCP server — exposes 6 OpenExpertise tools so external MCP-aware agents can run experiences.

SDK for tool-planning agents - generate and execute DAG execution plans from natural language

Core package for libraries creation

Blueprint-Style DAG Workflow Orchestrator for n8n

Task queue for Node.js. TypeScript-first, Celery-inspired, batteries-included.

Reflow is a modular flow-based programming runtime that executes actor-model DAGs for data pipelines, real-time media, visual tooling, and optional ML/CV workloads. This package is the official Node.js SDK.

WebGL Node-based Graph for React

The `oe` command-line interface — run, resume, inspect, evolve, validate experiences.

Ink-based terminal UI for `oe run --tui` — live phases, node status, token stream, activity feed.

Shared interactive libraries for @lincle

TypeScript client for the workflow-graph REST API

Makedown build engine: DAG, content-addressed store, hashing, provenance, sandboxing.

Declarative skill chaining for Claude Code workflows

Reflow is a modular flow-based programming runtime that executes actor-model DAGs for data pipelines, real-time media, visual tooling, and optional ML/CV workloads. This package is the official Node.js SDK.

Dispatcher for `agent` nodes — calls an LLM with structured-output schema, writes validated keys to state.

<p align="center"> <a href="https://vue-data-ui.graphieros.com/"><img width="500" src="https://github.com/user-attachments/assets/19d4334d-679c-4c19-bc4f-6050810afa05"></a> <br> <a href="https://vue-data-ui.graphieros.com/"><img width="100%

ローカル完結型自律開発フレームワーク - Miyabi AX

Shared library for @lincle

Anthropic SKILL.md package that teaches an LLM how to author OpenExpertise experiences.

Unified WebAssembly bindings for 18+ attention mechanisms: Neural, DAG, Graph, and Mamba SSM

Git Chat SDK - A Git-like conversation SDK for managing chat histories with branching support

A 'reactive' React node and edge generator

Compatibility OpenClawBrain package for older OpenClaw plugin installs; canonical front door is @openclawbrain/openclaw.

Horizontally Scalable EventEmitter powered by a Merkle DAG

Orchestrate agent workflows with natural language. Natural language in, executable DAG out.

Logical observability plugin for MeshFlow. High-fidelity epoch-based tracing and causal monitoring.

Zero-dependency TypeScript DAG utilities: topological sort, parallel batches, cycle detection. Port of Python graphlib / Go gonum graph.

A local-first CLI for recording intent and binding it to git commits/diffs

dag-builder-js is a simple-to-use Javascript DAG library with support to N:N vertices/edges. It supports validating that no cycle can be created in real-time, import/export states and it's built on SVG so you can render graphs pretty much anywhere.

A 'reactive' React node and edge generator

Interactive CLI for Cloud Composer DAG deployment

Simple, Type-safe, Observable, & Concurrent pipeline framework. Best for IO bottlenecked workflows.

viewer for directed acyclic graph