Orchestration
Turn one-off agent runs into repeatable, reviewable workflows.
Define a workflow as a DAG of agent and exec nodes, validate it, then run it. Each run produces a run record you can watch live and review afterward. Start from a template or build it on the canvas. Everything is tenant-scoped behind row-level security.
trigger
manual / cron
agent · plan
claude-code
exec · test
npm test
agent · fix
claude-code
exec · merge
git · gate
How it works
1
Define the DAG
Lay out agent nodes (a Claude Code session with a prompt) and exec nodes (a shell command) and the edges between them.
2
Validate
The server checks the graph - no cycles, every dependency resolves - before anything runs.
3
Run it
Kick off the workflow manually or on a schedule. Each node runs in order, respecting its dependencies.
4
Watch the run
Follow the run record live in the canvas and run viewer, then review the completed run later.
Deep dives
Agent + exec nodes
An agent node is a Claude Code session driven by a prompt; an exec node is a shell command. Compose them into a DAG to chain planning, code changes, tests, and gates into one run.
Node timeouts → SIGTERM
Every node can carry a timeout. On breach the node is sent SIGTERM so a stuck agent or runaway command can't hold the run open indefinitely.
Templates & visual canvas
Start from a built-in starter template, then edit on the visual canvas. The run viewer shows each node's status as the run progresses.
Define and run a workflow
config · workflow.yaml
name: ci-triage
nodes:
- id: plan
type: agent
prompt: "triage the failing build"
timeout: 15m # SIGTERM on breach
- id: test
type: exec
run: npm test
needs: [plan]
$ synaptyx workflow run ci-triage
✓ validated DAG · 2 nodes · no cycles
run_id: wf_3c8a… · watch the run record live in the canvas
Orchestration that's auditable, not opaque.
A workflow is just a DAG you can read, version, and review. Each run is recorded, so you can see exactly which node did what - no black-box automation.
Compare
| Synaptyx | Shell scripts | Generic CI | |
|---|---|---|---|
| Agent-native nodes | yes | no | no |
| Pre-run DAG validation | cycles + deps checked | no | partial |
| Live run record | canvas + run viewer | logs only | logs only |
| Node timeout → SIGTERM | per node | manual | job-level only |
| Tenant isolation | RLS-scoped | no | shared runners |
FAQ
Two kinds today: an agent node runs a Claude Code session from a prompt, and an exec node runs a shell command. You wire them into a DAG and connect each node's output to the next via its dependencies.
Each node can declare a timeout. When it's exceeded the node is sent SIGTERM, so a stuck agent or long-running command is stopped instead of holding the whole run open.
No. There are starter templates to clone, and a visual canvas/editor to adjust the graph. You can also define a workflow as a definition and run it via the API.
No. Workflows and their runs are tenant-scoped and enforced with row-level security in Postgres, so they're only visible inside the company that owns them.
Ready to orchestrate your agents?
Request access in minutes - or talk to us about your workflow patterns.