Nexss Flow connects typed actions, lazy streams, parallel branches, bounded loops, structured AI output, and fallback policies in one readable workflow language.
Flow keeps orchestration visible: the graph is the documentation, and the runtime remains responsible for execution semantics.
Use the same composition model for local actions, distributed transports, AI providers, sandboxes, and typed stream operators. Keep domain models in their own packages and connect them with explicit contracts.
A readable orchestration layer over the Nexss Kernel: typed actions, streams, parallel work, structured output, and resilient execution.
Compose existing actions without moving business logic into the DSL.
Use :typed=Verdict or :schema=Verdict at AI boundaries and keep important outputs explicit.
Parallel reviewers, merge, filter, batch, collect, and reduce with a stream boundary.
Run bounded repair loops and switch models on classified provider failures.
nflow does not replace your Go services. It names the composition: what runs, what can run in parallel, what is typed, and what happens when an external model fails.
The hard parts stay in the Kernel and adapters. The workflow stays short enough to review as a diagram and precise enough to execute.
{ goal: .goal, attempt: 1 }
(
ai.prompt:model="qwen-coder"@Propose a fix
&
ai.prompt:model="deepseek-coder"@Propose a fix
)
-> merge
-> ai.prompt:typed=Verdict@Choose the safest patch
-> { patch: .verdict.patch, approved: .verdict.approved }
-> loop( sandbox.test )
until( approved == true || attempt >= 4 )
-> ai.prompt:model="backup-model"
|| ai.prompt:model="primary-model"The unique part is not another syntax layer. It is the shared contract between Kernel actions, lazy streams, AI outputs, and the graph that connects them.
A reader can see the system's topology, fallback, loop boundary, and state projection without opening five service repositories.
Typed actions, typed stream items, and structured AI output keep the important boundaries explicit instead of turning the graph into untyped maps.
Cancellation, bounded concurrency, retries, provider fallback, and stream lifecycle belong to the runtime—not to every workflow author.
A small number of explicit stages keeps complex workflows debuggable and testable.
Reusable composition patterns for real systems.
Run several typed workers, merge their streams, deduplicate findings, and ask one judge for a structured verdict.
Gradually replacing fragile PHP, Parallel composition, or Node monoliths with high-throughput Go services using dark launches and zero downtime.
Try a primary model, classify provider errors in the kernel, and switch to a backup without breaking the pipeline.
Start with a typed action, a stream boundary, or a small .nflow example. Grow only where the execution graph proves it is needed.