ChronoFlow is live: AI nodes, runtime debugger, alerts, themes, and connector SDK

Private workflow orchestration

ChronoFlow.Run the audit-gradeworkflows you own.

Design governed workflows, run human approvals and system actions, recover live instances, and export the evidence your teams need to trust the process — inside your own environment.

Request private deployment Open workspace

Live

Workspace release

Workflow node types

AI node types

Ops

Runtime debugger

Three proof artifacts representing a governed pilot process, audit evidence, and private deployment readiness

Pilot · evidence · private deployment

First pilot

One governed process

Approval, request, incident, HR, access, vendor, or service flow.

Proof path

Run history to evidence

Structured intake, owned tasks, runtime intervention, and exportable audit trails.

Deployment posture

Private-first

Docker, Helm, air-gap bundle assets, backup scripts, and admin controls.

The lifecycle

It's no longer about drawing boxes. It's about proving operations.

ChronoFlow starts at intake, executes through a queue-backed runtime, pauses for people, recovers from failure, and preserves evidence end-to-end.

A five-stage intake to evidence workflow represented by connected glass artifacts

Intake → policy → people → recovery → evidence

Capture the request

Forms · schemas · public submissions

Public and internal forms collect validated data, files, and context before anything reaches a queue.

Route through policy

Workflow canvas · versions · templates

A versioned workflow owns branches, timers, loops, signals, joins, subprocesses, and external actions.

Pause for people

Task queues · approvals · SLA

Human tasks, approval outcomes, comments, departments, delegation, and SLA warnings stay in the runtime record.

Recover safely

Runtime control center

Operators can inspect logs, pause, resume, cancel, retry, replay checkpoints, and plan runtime modifications.

Export the proof

Evidence · audit · trust center

Audit logs, execution history, incidents, admin events, and evidence exports support compliance review.

Operating model

A live control plane for the whole workflow lifecycle.

Operators need more than a canvas screenshot. ChronoFlow brings design, execution, intervention, and evidence into a single operating model.

Instance PR-2048

Paused on finance approval

Owner

Tracked

SLA

Tracked

Evidence

Tracked

Run mode · live

Run evidence

The runtime executes human-plus-system flows through queues, timers, retries, integrations, checkpoints, and durable state.

BullMQ worker

Execution logs

Checkpoint recovery

Node catalog

A node palette built for real operations — 59 executable types across 15 categories.

Control flow, human work, integrations, data, communication, loops, events, governance — every step the PRD describes has a backing executor, schema, and runtime semantic.

Triggers · 4Control Flow · 7Human Tasks · 2Actions · 12Integrations · 12Data · 6Documents · 2Files · 1AI / Documents · 1Communication · 3Loops · 2Events · 2Other · 3Governance · 1Observability · 1

Triggers

4 nodes

Workflow entry events

Schedule TriggerConnector TriggerEmail TriggerFile Watch Trigger

Control Flow

7 nodes

Flow control nodes

StartEndConditionJoinSub-ProcessRate LimitError Boundary

Human Tasks

2 nodes

People, approvals, and SLA routing

EscalationQuorum Approval

Actions

12 nodes

Execute operations

ActionUser TaskApprovalTimerTransformDecision TableAI PromptAI ClassifierAI ExtractorAI SummarizerAI AgentAI Embedding

Integrations

12 nodes

Connect external systems

IntegrationAPI CallWebhookGeolocationDB QueryDB WriteGoogle SheetsHubSpot CRMStripe PaymentGitHub Issue/PRVirtual Object QueryVirtual Object Action

Data

6 nodes

Lookup and data operations

Lookup QueryLookup WriteFile ParserCSV ExportQueue PublishCache Get/Set

Documents

2 nodes

Document and file artifacts

PDF GenerateDocument Merge

Files

1 nodes

File storage operations

S3 File

AI / Documents

1 nodes

Document intelligence

OCR Extract

Communication

3 nodes

Send messages

EmailSMSSlack Message

Loops

2 nodes

Iteration and looping

For-EachLoop End

Events

2 nodes

Signal and message events

Signal ThrowSignal Catch

Other

3 nodes

Annotations and helpers

CommentSwimlaneAudit Log

Governance

1 nodes

Failure capture and policy records

Dead Letter

Observability

1 nodes

Operational visibility and alerting

Alert

AI Blueprint

Describe the process. Land a draft workflow with a linked form.

ChronoFlow's blueprint engine ships with provider-agnostic LLM access, organizational context gathering, streamed progress, blueprint validation, and admin-controlled rate limits.

Generate blueprints

Describe a workflow in natural language. The /ai/generate-blueprint endpoint returns a draft workflow plus optional linked form.

Streamed progress

Server-sent events emit progress through prompt prep, context gather, model generation, validation, and creation phases.

Enhance drafts

Iterate on existing or proposed blueprints with additional instructions through /ai/enhance-blueprint.

Governed providers

Admin AI settings configure provider, model, and key; sensitive values are encrypted, sanitized, and rate-limit guarded.

POST /ai/generate-blueprint/stream

streaming

prompt: "Capture vendor onboarding requests, run finance review,
          notify procurement on rejection, persist evidence."

event: prompt_prepared      ✓ system + user prompts assembled
event: context_gathered     ✓ 4 departments, 7 integrations, 12 workflows
event: model_generation     ⠋ 1.4s elapsed · streaming tokens
event: blueprint_validated  ✓ 11 nodes, 14 edges, 1 form linked
event: workflow_created     ✓ id: wf_vendor_onboarding_v1
                            ↳ requires publish review

Validation

Zod + graph rules

Provider

Configurable

Publish

Human-gated

Forms & approvals

Forms and approvals turn requests into accountable work.

Form intake and human task execution are first-class product surfaces: public submissions, linked task forms, department queues, comments, approvals, and SLA state all feed the runtime trail.

Intake · queues · approvals · evidence

Structured intake

Internal and public forms validate submissions, capture files, and attach request context before workflow execution starts.

Owned human work

Personal queues, department pools, supervisors, delegation, comments, and linked forms keep approvals accountable.

SLA-aware decisions

Due dates, warning thresholds, breach timestamps, and completion states preserve operational pressure in the record.

Evidence by default

Submitted data, task outcomes, comments, attachments, and runtime history become part of the reviewable process trail.

Runtime & External APIs

Two governed API surfaces. Both tenant-scoped and audit-logged.

The Runtime API starts, inspects, and controls instances. The External CRUD API exposes selected core entities behind feature-gated, rotatable API keys with sanitized responses.

Auth

Hashed API keys

Scope

Org-isolated

Audit

Every mutation

Runtime API

POST/api/v1/runtime/workflows/:id/startStart an instance
GET/api/v1/runtime/instances/:idFull instance detail
GET/api/v1/runtime/instances/:id/historyExecution timeline
POST/api/v1/runtime/instances/:id/pausePause running work
POST/api/v1/runtime/instances/:id/retryRetry failed node
POST/api/v1/runtime/instances/:id/replayReplay from checkpoint

External CRUD API

GET/api/v1/crud/usersList users
POST/api/v1/crud/tasksCreate task
PATCH/api/v1/crud/submissions/:idUpdate submission
DELETE/api/v1/crud/departments/:idRemove department

Integration & data

Secure ingress

Webhook triggers support public, HMAC, API key, and bearer patterns for controlled external starts.

Runtime APIs

External systems can start, inspect, pause, resume, retry, cancel, and review workflow instances through governed endpoints.

Operational data

Virtual objects, lookups, database nodes, and mapping tools give workflows durable business context.

Credential boundaries

API keys, webhook secrets, integration credentials, and provider keys are handled with sanitized surfaces.

Webhooks, APIs, and data objects plug the workflow into the rest of the estate.

ChronoFlow exposes runtime control, external CRUD, signed ingress, outbound system steps, lookups, and virtual objects so private workflows can sit inside existing enterprise systems.

Secure webhook, runtime API, virtual data object, lookup table, integration connector, and workflow event stream converging into one orchestration route

Webhook · API · data · credentials

Architecture

The architecture story matches the runtime promise.

It's more than a frontend canvas: queued execution, persistent instance state, worker processing, admin governance, evidence records, and private deployment assets — together.

App and API

Next.js 14 App Router, React 18, TypeScript, and a NestJS API form authoring, admin, runtime, and public form surfaces.

Async execution

Redis and BullMQ coordinate queued workflow execution, scheduled work, retries, delays, and worker processing.

Durable state

PostgreSQL stores workflow versions, instances, tasks, submissions, incidents, audit logs, and configuration.

Private operations

Docker, Helm, backup and restore scripts, air-gap packaging, and deployment checklists support private rollout.

Private deployment system topology with frontend, API, queue, workers, database, evidence store, and deployment kit

Next.js · NestJS · BullMQ · PostgreSQL

Personas

Built for the people who own rollout, not only the people who draw diagrams.

Six personas with clear daily surfaces — admins, designers, operations managers, task assignees, integration developers, and implementation partners.

A private workflow rollout workshop with operators reviewing workflow boards and evidence artifacts

Admins · designers · operators · assignees · integrators · partners

Organization admin

Manage users, roles, sessions, SSO, departments, API keys, audit logs, license posture, and private deployment readiness.

RBACSSOAudit logs

Workflow designer

Model processes visually, configure node behavior, link forms, validate routes, publish versions, and reuse templates.

CanvasValidationVersions

Operations manager

Monitor instances, resolve failures, reassign blocked work, replay from checkpoints, and preserve intervention history.

RuntimeRecoverySLA visibility

Task assignee

Claim, complete, approve, reject, comment, and submit linked task forms from personal and department queues.

QueuesCommentsLinked forms

Integration developer

Configure integrations, webhooks, runtime API keys, virtual objects, lookups, and data sources with sanitized credential handling.

APIsWebhooksData objects

Implementation partner

Assess legacy assets from K2/Camunda, install accelerators, prepare private deployments, and package pilot use cases.

MigrationAcceleratorsTrust kit

Capability depth

Capability depth with clear boundaries.

No inflated platform claims. Available features sit alongside roadmap separately, so regulated teams know what they can pilot now.

A modular capability matrix with available tiles and recessed roadmap tiles

Available now · roadmap separated

Authoring

Visual workflow builderAvailable

Node palette and data mappingAvailable

AI blueprint generationAvailable

Exact BPMN import parityRoadmap

Runtime

Async execution workersAvailable

Pause, resume, cancel, retryAvailable

Simulation and modification plansAvailable

Full CRDT live editingRoadmap

Human work

Approval states and commentsAvailable

Department pools and delegationAvailable

SLA warnings and breach fieldsAvailable

Preset escalation librariesRoadmap

Data and integrations

Webhook security modesAvailable

Runtime and external CRUD APIsAvailable

Virtual objects and lookupsAvailable

Public connector marketplaceRoadmap

Governance & security

Controls live next to the work they govern.

ChronoFlow ties identity, permissions, API access, runtime actions, audit logs, tenant context, and deployment operations directly to the workflow lifecycle.

A dark secure operations table with identity, key, tenant boundary, and audit control artifacts

Identity and access

JWT auth, roles, permissions, sessions, SSO configuration, password policy, and admin-only operations.

Secret-aware integrations

Integration credentials, AI provider keys, webhook secrets, and API keys are sanitized or hashed before unsafe exposure.

Tenant-aware APIs

Organization context flows through protected services, runtime APIs, external CRUD, forms, workflow execution, and API keys.

Private operations kit

Docker Compose, Helm chart, backup and restore scripts, air-gap bundle support, and deployment checklists live with the product.

Trust & evidence

Six layers of evidence — the audit story your reviewers actually ask for.

Workflow lineage, runtime trails, human actions, admin mutations, external access, and file events all write structured records tied to organization context.

Workflow lineage

Versions, publishes, restores, and change history preserve who shipped what and when.

Runtime trail

Execution logs, checkpoints, incidents, and runtime interventions are stored per instance.

Human evidence

Task actions, approvals, comments, delegations, SLA warnings, and attachments anchor accountability.

Admin audit

Settings changes, role and permission updates, API key rotation, and SSO changes write structured audit events.

External access

Runtime API and external CRUD calls record actor, target, outcome, and request context for tenant-scoped review.

File evidence

Upload, link, signed download, and delete events on attached files are audited per organization.

Authentication

JWT, SSO discovery, OAuth/OIDC start & callback, password policy.

Authorization

Role + permission guards across runtime read/pause/resume/retry/cancel.

Secret handling

Hashed API keys, signed file URLs, sanitized integration responses.

Migration factory

Move K2 and Camunda assets into a private platform without guessing.

Analyze, gap-report, preview, and persist — every migration mutation is audit-logged with coverage, readiness, bundle digest, and workflow metadata.

Legacy workflow artifacts transforming into migration manifests, readiness reports, accelerator packs, and enterprise evidence packages

K2 · Camunda · accelerators · evidence

Analyze

Parse K2 or Camunda manifests and produce inventory, coverage percentage, supported/unsupported assets, and readiness signals.

Gap report

Identify unresolved items, manual review work, and unsupported steps before a single workflow lands in the new platform.

Preview import

Compile a workflow bundle, see compatibility, readiness, and unresolved manifest output without persisting anything yet.

Persist & publish

Create workflows from approved bundles, optionally auto-publish, and audit-log every migration mutation with bundle digest.

Accelerators ship with the platform

Procurement approvalHR onboardingIT access requestIncident triage

Deployment

A private pilot path that can survive real enterprise review.

Prove one governed process before scaling: choose a workflow, map controls, run privately, export evidence, then expand through reusable patterns.

Private deployment pilot artifacts including a process folder, workflow map, server kit, and evidence package

Docker · Helm · air-gap bundle

Select the process

Pick one high-friction approval, request, incident, access, procurement, HR, vendor, or service workflow.

Map the operating model

Define intake schema, owners, task queues, runtime controls, integrations, evidence expectations, and rollout permissions.

Run in a private environment

Use the existing deployment kit to validate data ownership, admin controls, backup behavior, and operational readiness.

Prove and expand

Export evidence, review failures and bottlenecks, then turn the pilot into reusable implementation patterns.

Integration paths already in the story

Form trigger

Signed webhook

Runtime API

Virtual data object

Migration factory

Measurable outcomes

Twelve operational signals the platform already supports.

Workflow success, completion latency, SLA, retries, approval cycle time, webhook health, migration coverage, and more — derivable from shipped surfaces.

Workflow success rate

By workflow and version

Completion percentiles

Median and tail latencies

SLA warning + breach rate

Task and approval lifecycle

Retry & failure mix

Per node type

Approval cycle time

Owner, queue, decision lag

Webhook trigger health

Count and failure rate

FAQ

Conservative answers for serious buyers.

Copy stays close to the as-built PRD — strong on shipped governance and runtime controls, explicit about current product boundaries.

Due-diligence evidence folders and product boundary artifacts for enterprise workflow review

Shipped vs. boundary, made explicit

Is ChronoFlow a public SaaS automation tool?

The PRD positions ChronoFlow as private workflow orchestration for regulated operations, with a pilot-led deployment path and controls around identity, audit evidence, and runtime intervention.

Where does the audit evidence come from?

Evidence is assembled from structured form submissions, workflow versions, task actions, execution logs, incidents, runtime controls, admin mutations, and audit log filters.

Can it replace every BPMN workflow unchanged?

No. The current product is not claiming exact BPMN import/export fidelity. Migration tooling helps assess K2 and Camunda assets, produce reports, and identify manual implementation gaps.

How are external systems integrated safely?

Webhook security supports public, HMAC, API key, and bearer modes; runtime and external CRUD APIs use hashed keys with org-scoped guards and permission decorators; provider/integration secrets are sanitized at the response boundary.

What happens when a running instance gets stuck?

Operators can inspect logs, pause/resume/cancel/retry, re-execute individual nodes, jump to a node where permitted, list checkpoints, replay from a checkpoint, preview modification plans, or migrate the instance to a newer workflow version.

Is the AI generation production-ready?

AI blueprint generation assists authoring. Outputs are validated, sanitized, and still require human review and publish-gate validation before they reach a runtime version.

Start your private pilot

Bring one messy process. Leave with a governed pilot path.

Map the workflow, connect intake and approvals, test runtime controls, and generate evidence before expanding to more departments.

A messy stack of process papers turning into a clean governed workflow and evidence package

From messy process to governed pilot

Request private deployment Open workspace