v0.9.0 — 11 templates in three tiers, eval scaffolding

Templates: 4 → 11, in three tiers

graphx new (and the TUI's n key) now offers:

• starters — blank · agent · approval · pipeline. The agent starter now carries a function tool, so it demonstrates tool calling alongside schema validation and fallback.
• patterns — the canonical agentic workflow shapes:
  • review — evaluator-optimizer: write → fresh-context critic → bounded revise loop → publish
  • fanout — parallelization: map over items concurrently → collect → synthesize
  • triage — routing: router classifies → quick / deep / human-escalation branches
• real world — trigger- and connector-wired workflows:
  • inbox — local-model email triage: classify + draft behind a human gate
  • digest — cron + webhook triggers → API fetch → LLM summary → Slack via secret://
  • issueops — GitHub issue webhook → drafted reply → human gate → posted comment
  • watchdog — LLM-free interval health check → Slack alert only when a threshold trips

Eval scaffolding

Templates with LLM steps emit a paired NAME.eval.yaml — deterministic assertions plus a commented-out LLM-judge block — so every generated workflow starts life with an eval harness:

graphx new mybot -t review        # → mybot.yaml + mybot.eval.yaml, model auto-filled
graphx eval mybot.yaml mybot.eval.yaml

Eval bodies are validated against the eval dataset schema at render time; an existing eval file is never overwritten without --force.

Also

• graphx new prints the eval scaffold path + run hint; unknown -t values list all templates.
• README: new "Start from a template" section.

298 tests, ruff-clean.

Full changelog: v0.8.0...v0.9.0

v0.8.0 — eval/ops, self-review critic, dynamic handoffs

Three features across the harness/loop/graph layers, built to keep data / state / flow / logic cleanly separated. The engine gained exactly one additive, emit-only line.

Highlights

critic node — self-review that can't rubber-stamp

An independent judge scored against explicit criteria in a fresh context — it only ever sees the artifact + criteria, never the producing agent's conversation, so a model can't quietly grade its own work. LLM or deterministic handler: backend; the verdict routes via edges (loop to revise on fail, forward on pass), bounded by the producer's max_iterations.

Dynamic handoffs on agent

A handoffs: list adds one synthetic handoff_to_<target> tool per target; calling one transfers control (goto) and the full conversation (a state channel the target reads at <state.handoff.*>). Bounded by the existing step/iteration guards.

eval/ops — a read-only observer

A new graphx.eval package over the existing events + checkpoints tables — never touches the execution path, state, or routing.

• Per-run + per-node reports: cost, latency, retries, fallbacks, dead-letters, interventions.
• Dataset-driven eval: deterministic assertions + optional LLM judge (reuses the critic).
• Version compare: same dataset vs two graphs → outcome / metric / trace diff.
• Golden-trace normalization so behavioral regressions diff cleanly.
• CLI: runs, run-show, eval, eval-compare. TUI run browser on b.

Verification

283 tests (20 new), ruff-clean, Python 3.12+. Live-verified against a local vLLM: critic review loop, handoff, eval run, and the TUI run browser.

Examples

examples/review_loop.yaml, examples/handoff.yaml, examples/hello.eval.yaml.

Full changelog: v0.7.1...v0.8.0

graphx v0.7.1 — bug-fix release

A patch release fixing 15 verified bugs found in a parallel subsystem audit (engine, nodes/resilience/LLM, builder/export/secrets). Every finding had a concrete failure scenario and a regression test.

Highlights (HIGH severity)

• Merges no longer mishandle optional branches. A branch skipped by a when:/condition was recorded as failed (spurious merge failure), or — if pruned upstream — never arrived, so the merge and everything downstream were silently dropped while the run reported "finished." Now a 3-state arrival model (ok/failed/skipped) + a pending-merge flush make optional-branch fan-in correct.
• ${ENV} no longer breaks validate/edit. An unset environment variable made a valid workflow fail to load, breaking graphx validate and graphx edit. Unset ${VAR} is now left as a placeholder (like secret://).
• map retries transient item errors again. Re-raising inside asyncio.TaskGroup produced an ExceptionGroup that defeated the retry predicate; now unwrapped.

Also fixed (MEDIUM/LOW)

interval every:0 busy-loop · a bad cron silently killing a schedule · one malformed trigger dropping a whole file's triggers · shell BrokenPipe on unconsumed stdin · redactor substring-leak + short-value over-masking (which could corrupt resumed state) · update_node(None) backend divergence · export omitting ${ENV} names · stale export wheel · agentic add_node id/type clobber · map None-output drop · shell SIGKILL-on-cancel · daemon shutdown drain · Anthropic parallel tool_result 400.

263 tests, ruff-clean, Python 3.12+. No behavior change for correct workflows (golden-trace + resume-equivalence tests green).

graphx v0.7.0 — it runs itself, and runs anywhere

graphx crosses from "a tool you operate" to "automation that runs itself" — and any workflow is now portable to any machine.

✨ New in v0.7.0

Triggers — workflows that run themselves

triggers:
  - { type: schedule, cron: "0 7 * * *" }              # daily at 7am
  - { type: interval, every: 15m }                      # every 15 minutes
  - { type: webhook, path: "orders", input_from: body } # POST /hooks/orders → body = input

• graphx serve is now a daemon — an async scheduler fires schedule/interval triggers, POST /hooks/{path} runs a workflow with the request body as input, and GET /schedules lists everything with next-fire times.
• Or hand it to the OS — graphx schedule wf.yaml --cron "0 7 * * *" --install writes + enables a systemd user timer (cron → OnCalendar), or --crontab prints a crontab line. No daemon needed for schedule-only jobs.

Export — runs on any machine

graphx export myflow.yaml --docker → a self-contained folder: the workflow + a bundled graphx wheel + requirements.txt (auto-detected [mcp]/[postgres]/[s3] extras) + .env.example (secret names only) + run.py + optional Dockerfile. Installs graphx offline from the wheel, deps from PyPI, credentials from your .env. Verified: runs to completion in a clean venv with no graphx present.

From v0.6

Pregel engine (loops, checkpointing, resume) · natural-language builder (both engines) + point-at-any-endpoint · 12 node types · resilience · secret:// credentials that never leak · 12 connectors · discovery · OpenAPI scaffolding · Textual TUI · FastAPI + SSE.

250 tests, ruff-clean, Python 3.12+.

Install

pip install -e ".[tui,mcp,server]"
graphx tui

graphx v0.6.0 — describe it, and it builds it

The payoff release: point graphx at your local LLM by URL, describe a workflow in plain English, and it builds and runs it — offline, on your hardware.

✨ New in v0.6.0

Point at any endpoint

graphx providers --add http://192.168.1.50:8000    # probe a URL, auto-discover its model

Type an IP/URL for any OpenAI-compatible server (vLLM / llama.cpp / Ollama / LM Studio / gateway) — graphx probes it, confirms it's live, and discovers the model name. Also a TUI AddEndpointScreen.

Natural-language workflow builder

graphx generate "fetch a URL, summarize it with the local model, save to a file"
graphx edit myflow.yaml "add a Slack alert when the agent fails"

Turns a description into a valid, runnable workflow using the full node + connector set, and applies natural-language edits to existing ones. In the TUI, press g.

• Grounded by the validator — the model's output is checked by the same validator graphx run uses; errors are fed back for a bounded repair loop. Always either valid or clearly flagged for a quick fix.
• Two engines — oneshot (default; emit + repair, reliable on small local models) and --agentic (builder tools, step by step).
• Verified live on a local vLLM: generate produced a valid workflow in ~2.8k tokens that ran end to end; edit inserted a human gate.

From v0.5

Pregel-style engine (loops, checkpointing, resume) · 12 node types · resilience (retries, fallbacks, budgets, dead-letters) · secret:// credentials that never leak · 12 credential-wired connectors · LAN model discovery · templates · OpenAPI scaffolding · Textual TUI · FastAPI + SSE server.

224 tests, ruff-clean, Python 3.12+.

Install

pip install -e ".[tui,mcp,server]"
graphx tui

graphx v0.5.0

First tagged release of graphx — a TUI-native designer and runner for agentic workflows.

Highlights

• Engine — Pregel-style superstep executor: state channels with reducers, cyclic graphs with loops, parallel fan-out + barrier joins, per-superstep SQLite checkpointing with kill-and-resume, human-in-the-loop interrupts, retries / model fallbacks / validation re-asks, and four budget guards.
• Node types — agent (LLM + tools + schema-validated output), api, mcp, function, shell, condition, router, map, merge, human, wait, subworkflow.
• Design & discovery — graphx new templates, graphx scaffold-api / TUI o to build an api node from a live OpenAPI spec, and background LAN discovery of local inference servers (Ollama / vLLM / llama.cpp / LM Studio).
• Credentials — reference secrets as secret://NAME; resolved only at the point of use and never written to config, state, outputs, events, checkpoints, or the TUI (redaction net for residual leaks). graphx secret set/list/rm; TUI k manager + missing-secret prompt.
• Connectors — 12 credential-wired presets: Slack, Discord, Telegram, webhook, SendGrid, SMTP, Gmail (MCP), GitHub issues/comments, GitLab issues, Postgres, S3. graphx add <connector> or TUI i.
• Interfaces — CLI, a Textual TUI (graph canvas, live runs, palette editing), and a FastAPI server with SSE.
• Examples — hello, gpu_report (real host health report on a local model), email_triage (classify + draft replies locally, human gate).

200 tests, ruff clean. Python 3.12+.

Install

pip install -e ".[tui,mcp,server]"
graphx tui