Orchestrate AI agentslike a living network.
Celial is the workflow layer for AI. Compose agents on a visual canvas, run them with a single command, and watch them think — a simple surface over a powerful, living network.
A simple surface over a powerful network
Three movements take you from a blank canvas to running agents — the same way a forest turns scattered roots into one intelligent system.
Compose
Lay agents, inputs and outputs on a visual canvas and connect them into a DAG. Group steps, reuse sub-workflows — like growing a network of hyphae.
Run
One command — smf run — schedules every agent across stages. Independent branches execute in parallel; outputs flow downstream along the edges.
Observe
Attach to any node's live session and watch it think — or take over. Every run is inspectable, recoverable, and opens a PR when it's done.
Press run. Watch it think.
A four-agent research workflow, executing live. Independent branches run in parallel; outputs flow downstream; a PR opens when it's done.
Hover a node to see its mode and model. This is a simulation of a real smf run.
Everything you need to ship agents
The orchestration primitives production AI systems keep reinventing — one coherent, local-first toolkit.
Drag, connect, and compose agents into clear DAGs
Build workflows you can see, version, and trust. Group steps into frames and drop reusable sub-workflows in as single nodes — the network grows as you do.
One-command runs
Go from canvas to execution with a single smf run. Local-first, reproducible, easy to wire into CI.
Graph-driven parallelism
Every node whose upstreams are done launches immediately. Fan out, fan back in — no artificial concurrency limits.
Attach to any session
Agents run interactively in a terminal multiplexer. Attach to a live node to watch it think — or take over mid-run.
Gates & guardrails
Hooks enforce what agents may touch. Drop an approval gate on any node to pause for a human yes/no.
Pull request on success
SimpleFlow owns version control: it branches, commits, pushes, and opens a PR when a run succeeds — so every agent run lands as reviewable work, not a mystery diff.
Bring your own models
Pick a model per node — fast or frontier. Provider-agnostic, your keys, your stack.
Workflows you can read, version, and trust
A workflow is just a YAML DAG. Each agent node runs Claude Code interactively inplan orbuildmode; edges carry each node's output to the next as context. Commit it, diff it, run it anywhere.
- Nodes
- input · agent · output · sub-workflow
- Modes
- plan (read-only) · build (full write)
- Models
- opus · sonnet · haiku — per node
- Hand-off
- each node's output flows downstream as context
name: research-flow
nodes:
- id: task
type: input
- id: search
type: agent
mode: plan
model: sonnet
- id: synthesize
type: agent
mode: build
model: opus
- id: report
type: output
edges:
- from: task, to: search
- from: search, to: synthesize
- from: synthesize, to: report Powerful agents, fully under your control
Runs on your machine
No cloud middleman. Agents execute locally in terminal sessions you can attach to.
Your keys, your models
Provider-agnostic and BYO-credentials. Nothing routes through us.
Versioned as YAML
Workflows are plain files. Diff them, review them, commit them with your code.
Observable & recoverable
Token and cost metrics per node. Resume a failed run from the node that broke.
Agents are getting powerful faster than we're learning to coordinate them. We're building the layer that makes many agents work like one calm, reliable system — visible, local, and yours.
The Celial team
Building SimpleFlow in the open
Built for teams shipping with agents
Questions, answered
What is SimpleFlow?
A local-first AI workflow builder. Workflows are YAML DAGs of nodes connected by edges; agent nodes run Claude Code interactively, so you can attach to any node and watch — or take over — its session.
Where do the agents actually run?
On your own machine, using your own API keys. Each agent runs in an interactive terminal session inside a multiplexer (tmux on macOS/Linux, psmux on Windows) that you can attach to live.
Which models can I use?
Provider-agnostic by default. Choose a model per node — for example opus, sonnet, or haiku — matching frontier reasoning or fast throughput to each step.
How do agents pass work to each other?
Along the edges. Each node produces an output that's injected into downstream prompts as context, so a search node's findings flow into a synthesis node automatically.
Is it safe to let agents write code?
You stay in control. Plan-mode nodes are read-only, hooks restrict what build-mode agents may touch, and approval gates pause a run for a human yes/no before risky steps.
How much does it cost?
SimpleFlow is open source and local-first — you pay only for the model usage on your own keys. Hosted Celial features are coming; join the waitlist to hear first.
Be first to grow with Celial
Early access is opening soon. Join the waitlist and we'll reach out when it's your turn to build on the living network.
No spam — one email when access opens.