FUSE

FUSE is an open-source workflow engine built on the ergo actor model. Each workflow step runs as an isolated actor with message passing, supervision, and fault tolerance — designed for AI workflows, agentic orchestration, and event-driven automation.

Built and maintained by Uranus Technologies.

Features

• Graph-based workflows — Define automation pipelines as directed graphs of nodes and edges
• Actor-per-node execution — Each node runs as an independent ergo actor with supervision and fault isolation
• Control flow — Conditional branching (expr-lang), parallel execution, join/merge strategies, graph-level loops, sub-workflows
• Resilience — Configurable retries with backoff, per-node and workflow-level timeouts, error edges for recovery paths
• Durable execution — Journal-based state persistence, crash recovery, and resume from last checkpoint
• Async nodes — External completion via HTTP callback for human-in-the-loop and long-running steps
• Awakeables — Durable sleep and wait-for-event primitives
• Schema versioning — Version, activate, and rollback workflow definitions
• High availability — Multi-node clustering with ergo, claim-based workflow distribution, etcd or static peer discovery
• Helm chart — Production-ready Kubernetes deployment (standalone or clustered StatefulSet)

Architecture

How it works

1. Define a workflow schema as a JSON graph of nodes and edges
2. Register function packages that nodes reference (internal Go functions or external HTTP services)
3. Trigger a workflow instance via the REST API
4. The engine walks the graph: each node spawns as an actor, executes its function, and routes output along edges
5. Conditional edges evaluate expressions (expr-lang) to choose the next path
6. Parallel branches fan out to concurrent actors, then merge at join nodes
7. Failed nodes retry or route through error edges to recovery paths
8. Async nodes pause execution and resume when an external system calls back

Quick start

Prerequisites: Go 1.26+, Make

# Clone
git clone https://github.com/open-source-cloud/fuse.git
cd fuse

# Build and run
make build
make run        # Starts server on port 9090 with debug logging

The API is available at http://localhost:9090. Interactive Swagger docs at http://localhost:9090/docs.

Run with infrastructure

For PostgreSQL, S3 (rustfs), and etcd:

make infra-up   # Start PG + S3 + etcd
make run        # Run FUSE on host against local infra

Docker

make dkb        # Build image (fuse-app:dev)
make dkx        # Run container on port 9090

HA cluster (3 nodes)

make ha-up      # Build + start 3 FUSE nodes + PG + S3 + etcd
make ha-down    # Tear down

API

Method	Path	Description
GET	/health	Health check
POST	/v1/workflows/trigger	Start a workflow instance
PUT	/v1/schemas/{schemaID}	Create or update a workflow schema
GET	/v1/schemas/{schemaID}	Get a workflow schema
GET	/v1/packages	List function packages
GET	/v1/packages/{packageID}	Get a package
PUT	/v1/packages/{packageID}	Register or update a package
POST	/v1/workflows/{workflowID}/execs/{execID}	Submit async function result

Full API documentation: docs/API.md | Swagger UI: http://localhost:9090/docs

Example: trigger a workflow

# 1. Upload a schema
curl -X PUT http://localhost:9090/v1/schemas/my-workflow \
  -H "Content-Type: application/json" \
  -d @examples/workflows/small-test.json

# 2. Trigger execution
curl -X POST http://localhost:9090/v1/workflows/trigger \
  -H "Content-Type: application/json" \
  -d '{"schemaID": "my-workflow"}'

See examples/workflows/ for more schema examples including conditional branching, parallel execution, retries, error edges, timeouts, sub-workflows, and awakeables.

Workflow execution

Testing

FUSE has a comprehensive 4-layer test strategy:

Layer	Scope	What it validates
Unit	100 test files across pkg/ and internal/	Table-driven tests, Arrange-Act-Assert pattern
Functional	Contract tests against real PostgreSQL	Repository behavior, SQL migrations, data integrity
E2E fast	Full stack (3 FUSE nodes + PG + S3 + etcd)	Workflow execution, resilience, orchestration
E2E slow	Long-running scenarios (main branch only)	Persistence, integration, stress testing

make test               # Unit tests
make test-functional    # Functional tests (requires PostgreSQL)
make test-benchmark     # Benchmark tests
make e2e-local          # Full E2E suite (builds Docker, starts infra)

CI/CD Pipeline

Container images are published to Docker Hub uranustechnologies/fuse on every release. The Helm chart is published separately as OCI uranustechnologies/fuse-chart so the image repo is not overwritten by chart pushes.

Deployment

FUSE ships with a Helm chart for Kubernetes. Supports standalone (Deployment) and cluster (StatefulSet with ergo clustering) modes.

helm install fuse ./deploy/helm/fuse \
  --namespace fuse --create-namespace \
  --set image.tag=latest

Full deployment guide: docs/DEPLOYMENT.md

Tech stack

Component	Technology
Language	Go 1.26
Actor model	ergo.services
Dependency injection	uber-go/fx
CLI	cobra
HTTP routing	gorilla/mux
Database	PostgreSQL 17 (pluggable, in-memory for dev)
Object store	S3-compatible (pluggable, in-memory for dev)
Service discovery	etcd (for cluster mode)
Logging	zerolog
API docs	swag (Swagger 2.0)
Testing	testify, gotestsum
Linting	golangci-lint v2
Container	Distroless (gcr.io/distroless/static-debian12)

Project structure

cmd/fuse/                  CLI entrypoint (server, workflow, mermaid, migrate, seed)
internal/
  app/config/              Configuration (env vars with struct tags)
  app/di/                  Dependency injection modules (uber-go/fx)
  actors/                  ergo actor implementations
  handlers/                HTTP handlers (WebWorker pattern)
  services/                Business logic layer
  repositories/            Data access (interfaces + PostgreSQL/memory implementations)
  workflow/                Core workflow engine (graph, nodes, edges, execution)
  packages/                Function package registry
  messaging/               Actor message types
  dtos/                    Data transfer objects
pkg/                       Public libraries (workflow types, transport, uuid, http, store)
tests/
  e2e/                     End-to-end test suites
  functional/              Contract tests (PostgreSQL)
deploy/helm/fuse/          Helm chart for Kubernetes
examples/workflows/        Example workflow schemas

Contributing

See docs/CONTRIBUTE.md for guidelines.

Quality gate before every commit:

make lint && make build && make test

License

Copyright 2026 Uranus Technologies

Licensed under the Apache License, Version 2.0. See LICENSE for details.