Introducing Hope Workflow Engine

Hope

A CLI-first, self-hosted workflow engine where GPT-5.5, Claude Opus 4.8, or your local LLM can learn your systems, design workflows, wire cloud and programmatic events, mock tools, test paths, and validate automations end to end.

Request early access -> See how it works

Chat when it is fastest Describe the business problem and let an LLM draft, test, and refine the workflow.

Code when it matters Use a modern CLI for dev workflows, debugging, automation, and local runs.

Visual when it helps Review and adjust n8n-style graphs with operators, analysts, and business teams.

Durable by design Record execution history so completed steps are not repeated after crashes.

Workflow automation has split into two worlds.

No-code tools are fast but fragile. Durable execution platforms are reliable but developer-heavy. Hope is designed to keep the speed of visual automation while giving the runtime a real execution history.

Problem 01

Automations disappear into process memory.

Many workflow tools can run a graph, but recovery after worker crashes is still an afterthought. Hope treats the event log as the source of truth.

Problem 02

AI workflows repeat expensive or risky side effects.

LLM calls, HTTP requests, approvals, and tool results should be recorded once and reused during replay. Hope models those calls as durable activities.

Problem 03

Workflow creation still starts from a blank canvas.

Most tools make users manually translate business intent into nodes. Hope starts from chat: the agent learns your registry, drafts the graph, mocks services, and proves it works.

Problem 04

Business users and developers get different tools.

Hope gives developers a CLI-first engine and gives business users a visual editor over the same workflow definition, not a separate product.

Built for private, agentic operations.

Hope is for teams that want an LLM to understand their ecosystem, turn business intent into executable workflows, connect cloud and application events, test them with mocks, and deploy them on private infrastructure.

Agentic workflow design

Chat with GPT-5.5, Claude Opus 4.8, or a local model to discover requirements, map systems, and draft a valid workflow graph.

Mock, test, and validate

Generate mocks for tools, APIs, approvals, and LLM responses, then run end-to-end validation before a workflow is activated.

CLI-first workflow engine

Initialize projects, validate graphs, run workflows, inspect history, and resume executions from the terminal.

Durable replay and checkpoints

Execution history records completed work so a restarted worker can continue without duplicating side effects.

Common node and tool schema

Define triggers, actions, LLM providers, schemas, credentials, and UI metadata in one registry.

Cloud and programmatic events

Trigger workflows from AWS, GCP, other cloud event buses, webhooks, schedules, queues, or your own application code.

BYO LLMs and private tools

Connect OpenAI-compatible APIs, local models, MCP-style tools, internal HTTP services, and self-hosted providers.

Visual editor as a projection

The eventual desktop UI edits the same engine-owned workflow definition that the CLI runs.

$ hope init ops-automation
created hope.yaml
created workflows/
created registries/

$ hope chat "build onboarding for enterprise leads"
agent learned crm, slack, email, approval policy
agent drafted workflow and generated tool mocks

$ hope trigger sync aws.eventbridge gcp.pubsub
ok cloud events mapped to typed workflow triggers

$ hope validate workflows/customer-onboarding.json
graph 8 nodes, 10 edges, 2 triggers
ok stable ids, schemas, ports

$ hope test customer-onboarding --mock
ok happy path, rejection path, retry path

$ hope run customer-onboarding --watch
execution ex_01J...
manual.trigger       completed   12ms
crm.lookup           completed   184ms
llm.classify         completed   1.8s
approval.wait        waiting     human signal

$ hope history ex_01J... --json
replay-safe completed activities will not rerun

The engine owns execution. The UI owns editing.

The design borrows the right lessons: visual graph ergonomics from automation tools, event history from durable execution systems, and a local-first CLI loop from developer infrastructure.

Definition Versioned workflow graph, stable node IDs, typed ports, trigger contracts, retry policies, mocks, and secret references.

Event ingress Cloud events, webhooks, schedules, queues, and programmatic application events enter through typed trigger adapters.

Agent loop An LLM reads the registry, asks clarifying questions, drafts workflows, creates mocks, and validates behavior.

Event history Append-only facts: started, scheduled, completed, failed, timer created, signal received.

Replay state A deterministic reducer rebuilds state from history before the engine decides what to do next.

Commands The engine emits intents: schedule task, wait for signal, start timer, complete execution.

Workers Local or self-hosted workers execute nodes, tools, LLM calls, and human workflow steps.

Planned in disciplined layers.

Hope starts with the durable core before chasing the node library or desktop editor. The first milestone is simple: make replay, retries, timers, and inspection boringly reliable.

Core engine

C++ runtime, workflow IR, SQLite event store, replay reducer, local task runner, CLI inspection.

Node registry

Business logic nodes, tool schemas, cloud triggers, LLM providers, mocks, credentials, and deterministic validation.

Self-hosted runtime

Workers, leases, Postgres adapter, control API, event stream, observability, and Docker deploys.

Desktop editor

Figma-like workflow canvas, node palette, execution timeline, replay viewer, and business-user flows.

Build workflows that survive reality.

Hope is being built for teams that want to chat with an LLM, teach it their ecosystem, generate tested workflows, and run them on a durable self-hosted engine.

Talk to Anpu ->