Application · Visual workflow editor · v0.4.0

AbstractFlow

Draw multi-agent systems: agents and model calls wired together with plain Python code, branches, loops, subflows and human approvals. Publish a workflow to your AbstractGateway and it becomes a versioned executable you run like an endpoint: as the agent of a chat in AbstractCode or AbstractAssistant, once from AbstractObserver, on a schedule as an automation, or from any program with one API call.

# Gateway console: Apps > Flow Editor > Open
# (served at /apps/flow/, already signed in)

# Or on its own: http://127.0.0.1:3003/
npx @abstractframework/flow --gateway-url http://127.0.0.1:8080

Draw it, publish it, share it, use it

AbstractFlow is a web app (@abstractframework/flow): a browser editor plus a small Node server that forwards /api/* to the gateway. It ships no Python package and no execution host: the gateway stores your workflows and AbstractRuntime compiles and runs them durably, with a ledger of every step.

The next step after skills. A skill (SKILL.md, see AbstractSkill) tells an agent in prose what to do. A workflow says it formally and visually: it orchestrates model calls, agents and deterministic code in one graph that you can read, test, version and share, and that runs durably on the gateway.

1. Draw

Wire agent, LLM, tool, code, control, media, file and memory nodes on a canvas. Declare the interface the workflow implements, such as abstractcode.agent.v1, so agent clients know how to call it.

2. Publish

Publish packs a new .flow workflow bundle version (the workflow, its subflows and metadata in one file) and installs it on the gateway. Earlier versions are kept; leave the version empty and it is bumped for you.

3. Run it

As the agent of a chat (/workflow in the AbstractCode terminal, the Workflow list in AbstractCode web), once from the Observer's Launch page, as the target of an automation, or with one API call. Leave model pickers on Auto (Gateway default) and the gateway's defaults choose the model at run time.

4. Make it the default agent

An admin makes it the gateway's default workflow for an interface. Every chat that follows Gateway default in AbstractCode, the Assistant or your own client runs it from its next turn; a turn never changes workflow while it runs.

Made to be shared · Workflows are made to be shared between gateways and the people who use them.

1. Export

Download one version as a single .flow file, exactly as it runs.

2. Install it elsewhere

An admin imports the file on another gateway, and it runs there the same way.

3. Promote to the shared catalog

Users of that gateway can then pick it: the Assistant and AbstractCode web list the shared catalog.

Loop engineering, graph engineering

The loop, the verifier, the deterministic checks and the approval step are nodes you can see. Change one, publish again, and the next run uses it. The workflows the gateway ships open in the editor like any other.

AbstractFlow editor with the coding-agent workflow: a builder loop with verification gates and delivery branches, minimap at the bottom right
The shipped coding-agent workflow (35 nodes): a builder loop with verification gates and delivery branches.
AbstractFlow editor: node palette on the left (Essentials, Core, Control Flow, Events & Time, Variables, Data & Text, Values & Schema, Files & Artifacts, Media, Memory) and the basic-agent workflow: Receiving prompt, Thinking, Agentic loop, Agentic loop done and Answering nodes with their typed pins wired
The shipped basic-agent workflow, the default chat agent, with the node palette.
AbstractFlow editor with the deep-research workflow fit to the canvas: 64 nodes in a long pipeline with fan-out branches
The shipped deep-research workflow (64 nodes), fit to view: a long pipeline with fan-out branches.

One published workflow, many clients

A client starts a workflow in one of two ways: by name (bundle_id, optionally a version and a flow_id), or as "the gateway's default for this interface" (flow_id: "@default" plus interface), which the gateway resolves at every new turn.

ClientWhere you choose the workflowWhat it lists
AbstractCode terminal/workflow (alias /agent) in a session, or --workflow default | coding-agent:coder | <bundle_id>[@version][:<flow_id>]Published workflows that declare abstractcode.agent.v1, Gateway default first; the choice is kept in ~/.abstractcode/prefs.json
AbstractCode webThe Workflow list in the toolbarThe coding agents published on your gateway, Gateway default first; Show all workflows adds schema-driven workflows
AbstractAssistantSettings → Models → WorkflowGateway default and the shared catalog's workflows that declare abstractassistant.agent.v1 (an admin promotes a published bundle to the catalog)
AbstractObserverLaunch → Run once: pick a workflow, fill its inputs, Launch nowAny bundle on the gateway (its latest version) and the default agent; one run per launch
AutomationsThe automation's target: a published workflow, or the default agent of an interfaceWorkflows of the gateway's own registry
Your appPOST /api/gateway/runs/startGET /api/gateway/bundles, GET /api/gateway/workflow-catalog

Start a workflow by name

# <token>: <data dir>/auth/bootstrap-admin-token, or the console's one-time link (abstractgateway docs/configuration.md:120, v0.7.2)

# Start a run of a shipped workflow (flow_id omitted: the bundle's default entrypoint)
RUN_ID=$(curl -sS -H "Authorization: Bearer <token>" -H "Content-Type: application/json" \
  -d '{"bundle_id":"basic-agent","input_data":{"prompt":"How long should I steep green tea?"}}' \
  "http://127.0.0.1:8080/api/gateway/runs/start" | python3 -c 'import json,sys; print(json.load(sys.stdin)["run_id"])')

Or the gateway's default agent

curl -sS -H "Authorization: Bearer <token>" -H "Content-Type: application/json" \
  -d '{"flow_id":"@default","interface":"abstractcode.agent.v1","input_data":{"prompt":"Hello"}}' \
  "http://127.0.0.1:8080/api/gateway/runs/start"

Every start answers with the run id and the exact workflow version that runs it (resolved_workflow). Inside a chat, the workflow is the chat's driver: every turn is a run of the selected workflow on the same session_id, and the client can switch workflow between turns. The run's ledger records every step, and any client can load it and follow it live.

Make it the default agent of a client

A client that runs an agent names an interface rather than a fixed workflow, and the gateway setting agents.default_workflow.<interface> decides which workflow answers. With nothing saved, AbstractCode (abstractcode.agent.v1) runs the shipped basic-agent and the Assistant (abstractassistant.agent.v1) runs its built-in orchestrator. An admin changes it in the web console (Workflows → Make agent default), in the terminal console (Runtimes → Runtime knobs → Edit default agent workflows) or from the command line; the change is audit-logged. A saved workflow must declare the interface, and a default that no longer resolves is refused rather than replaced.

abstractgateway config set agents.default_workflow.abstractcode.agent.v1 coding-agent:coder

Agentic steps and deterministic code in one graph

The palette groups nodes by family. Every media node runs through a capability the gateway advertises, and the editor shows a control only where the gateway supports it.

Agents and models

Agent runs a ReAct agent that calls tools; LLM Call, Tool Calls and Subflow (another saved workflow) complete the set. A Reasoning control (Auto, or off to xhigh) and an MTP depth setting each take a run-scoped override; response schemas are built on the resp_schema pin.

Deterministic code

Code runs a Python transform(_input) body in the runtime's sandbox, and data input pins take small Python expressions (RestrictedPython), with a Functions drawer of named helpers shared across a flow. Array, string, object, JSON and math nodes cover the rest.

Control flow

If/Else, Switch, Compare and boolean logic; ForEach, For and While loops; Parallel and Sequence; variables that carry state between iterations.

People and events

Ask User pauses the run for a free-text answer or a choice, Answer User replies. On Flow Start and On Flow End; On Event, On Schedule, Wait Event and Delay wait inside a run that has already started.

Media

Voice: Generate Voice, Transcribe Audio, Listen Voice. Music: Generate Music. Vision: Generate Image, Edit Image, Restore / Upscale Image, Generate Video, Image To Video, Analyze Media. Camera: Camera Open, Capture Photo, Capture Video, Camera Close. Vision nodes take a batch count, ordered seeds and LoRA stacks where the model supports them.

Files, memory and entities

Read File, Write File, Read PDF, Write PDF, Write DOCX and Write Chart; knowledge-graph and memory nodes (KG Assert, KG Query, Memorize, Recall); and an Entity Mind family (memory recall and formation, diary read and write, consolidation) for entity workflows.

Workflow Authoring Assistant. The star in the toolbar opens an assistant that writes or refines a whole workflow from your description, using the gateway's default text model. The editor applies only validated edits to your draft; Save, Publish and Run stay your decisions.

The contract a client calls

A workflow lists the interfaces it implements (Flow Library → Interfaces). The editor adds each interface's required pins to On Flow Start and On Flow End; the client sends inputs to the start pins and reads results from the end pins. The gateway checks that a workflow declares the interface a client asks for.

InterfaceOn Flow Start outputsOn Flow End inputs
abstractcode.agent.v1provider, model, promptresponse, success, meta
abstractassistant.agent.v1provider, model, promptresponse, success, meta
abstractcode.coding.v1requestreport, passed
abstractreview.adversarial.v1artifactfindings, verdict
abstractextract.structured.v1source_text, fields_specdata, valid
abstractbatch.mapreduce.v1itemsresults, synthesis

The full list, with pin types, is in VisualFlow format.

From draft to a workflow others can run

Save and publish

The editor stores drafts on the gateway (/api/gateway/visualflows/*). Publish installs a bundle version in the gateway's registry, which is shared by every user of that gateway, so publishing there needs an admin.

Automation Defaults

In the Flow Library, a runnable workflow's Automation row stores what an automation created from it starts with: the trigger (Schedule or Manual), its settings (a fixed UTC interval, no cron), Independent or Growing context, a title and default inputs. Publishing carries them into the bundle.

Run and watch

Run in the editor publishes a draft version and starts it, and you follow each step with previews of generated voice, music, images and video. You create and manage automations in AbstractObserver, AbstractAssistant or AbstractCode; see Automations.

Share a workflow

A published workflow is one portable .flow file: the manifest, the root flow and its subflows in a single zip. Workflows are made to be shared between gateways and the people who use them.

1. Export

In the web console's Workflows tab, Export downloads the latest version as a .flow file (a version's own Export gives that version); in the terminal console, press e. The file is byte-identical to what runs on the gateway.

GET /api/gateway/bundles/{bundle_id}/download?bundle_version=…

2. Install it elsewhere

On the other gateway, an admin clicks Import… in the Workflows tab and picks one or more .flow files, or presses i in the terminal console. Files up to 75 MB by default.

POST /api/gateway/bundles/upload

3. Promote to the shared catalog

An admin promotes an installed version to the gateway's shared catalog, optionally as its default and with access rules; catalog versions are immutable. The Assistant and AbstractCode web list the catalog. Promotion is available from the API today, not from a console button.

POST /api/gateway/admin/workflow-catalog/promote

curl -sS -H "Authorization: Bearer <token>" \
  -F "file=@./my-bundle@0.1.0.flow" \
  -F "overwrite=false" \
  -F "reload=true" \
  "http://127.0.0.1:8080/api/gateway/bundles/upload"

Packing a bundle from Python

Outside the editor, AbstractRuntime packs a bundle from VisualFlow JSON files. Upload the result as above, or place it in the directory named by ABSTRACTGATEWAY_FLOWS_DIR.

from abstractruntime.workflow_bundle import pack_workflow_bundle

pack_workflow_bundle(
    root_flow_json="/path/to/root.json",
    out_path="/path/to/bundles/my-bundle@0.1.0.flow",
    bundle_id="my-bundle",
    bundle_version="0.1.0",
    flows_dir="/path/to/flows",
)
The shipped workflows are editable. The gateway serves basic-agent (the default chat agent), coding-agent (a builder agent and a verifier that runs gates every round), deep-research, co-scientist and the Assistant's orchestrator out of the box, as VisualFlow JSON files in this repository. Shipped workflow sources maps each bundle to its files, so you can open one in the editor, change it and publish it under your own bundle id.

Open the editor

You need a running AbstractGateway (abstractgateway serve, or the installer).

# Gateway console: Apps > Flow Editor > Install, then Open
# or from a terminal:
abstractgateway apps install flow --launch

# The editor is at <gateway address>/apps/flow/ and opens signed in
npx @abstractframework/flow --gateway-url http://127.0.0.1:8080 --port 3003

# or install the command
npm install -g @abstractframework/flow
abstractflow-editor --gateway-url http://127.0.0.1:8080

# open http://127.0.0.1:3003/ and sign in with a gateway user id and token
FlagMeaning
--gateway-url <url>The gateway to talk to (aliases --gateway, --url). Without it: the saved login, then the gateway installed on this computer (~/.abstractframework/gateway.json), then http://127.0.0.1:8080. A gateway found this way is followed when it moves to another port.
--port <n>The port to listen on (default 3003).
--host <addr>The address to listen on (default 127.0.0.1). Use 0.0.0.0 only when other computers must reach this server directly; through the gateway no change is needed.

Each browser signs in with a gateway user id and that user's token. The editor exchanges the token for a gateway session kept in HTTP-only cookies and does not keep the token. Serving at /apps/flow/ needs AbstractGateway 0.7.0 or later.