flowwork turns your daily work into auditable, repeatable programs that drive Claude Code — combining deterministic orchestration with the generative power of agents in one durable unit.
Free tier: 3 active workflows · 10 runs/day · no credit card
workflow({
name: "AgentTriage",
version: "1",
description: "Classify a support ticket by asking the driving agent.",
initial: { ticket_id: null, subject: "", body: "" },
triggers: [apiTrigger("run")],
steps: [
step("start", { start: true, next: "triage" }, start),
agent("triage", {
prompt: "Classify support ticket {{ticket_id}}. Subject: {{subject}}. Body: {{body}}. " +
"Return JSON {category, severity} where severity is 'urgent' or 'normal'.",
resultType: "json",
context: ["ticket_id", "subject", "body"], // allowlist sent as context
resultSchema: {
type: "object",
required: ["category", "severity"],
properties: {
category: { type: "string" },
severity: { type: "string", enum: ["urgent", "normal"] },
},
},
onError: "triage_failed",
next: "route",
}, on_triage),
step("route", {
branches: [
branch("severity == 'urgent'", "urgent"),
branch("true", "normal"),
],
}, route),
step("urgent", { next: "end", label: "Escalated" }, urgent),
step("normal", { next: "end", label: "Queued" }, normal),
step("triage_failed", { next: "end", label: "Triage Failed" }, triage_failed),
],
});The flexibility of a coding agent with the guarantees of a versioned, strongly-typed workflow.
External calls execute inside the workflow. You pay the token cost once, at authoring time — not on every agent run.
Keep working in your Claude Code session while getting the predictability of versioned, strongly-typed workflows.
Skills and built-in tools are callable from a workflow. Drive Claude Code over local files, docs, devops, source code, and browsers.
Workflows are repeatable, shareable units with a full audit trail. Run the same thing twice and get the same shape of result.
Retries, exponential backoff, and greedy fallback out of the box — or author your own graceful degradation.
Develop custom applications and agents on top of flowwork. The engine is the durable substrate; you bring the product.
Because the code is prewritten, there is no sandboxing to bolt on, no AI-firewall trying to out-guess a probabilistic model, and no class of prompt-injection that turns into an arbitrary external call. Those defenses are inherently insufficient against the nondeterminism of LLMs.
Every external call is abstracted into a connector with explicit checking, retries and backoff, and a fallback you control. The model decides what to do within bounds you authored — it never decides how to reach the outside world.
Describe the workflow in words and use the 'flowwork' skill to generate a typed, versioned definition — connectors and all.
Trigger workflows from Claude, monitor execution, and handle human-in-the-loop steps as they come up.
Execute it repeatably. Every run is auditable, resumable, and shareable as one unit.
Try it free. Buy it once.
For trying it out
1-year license, includes a year of updates
The free tier allows up to 3 active workflows and 10 runs per day — enough to build something real. Upgrade to remove the limits.
Because the code is prewritten. There's nothing to sandbox at runtime and no AI-firewall guessing at a probabilistic model's intent. External calls are abstracted into vetted connectors with explicit checking.
You can — until you need retries, backoff, leases, versioning, fan-out, long timers, replay, and operator tooling. Then you've rebuilt a workflow engine. We wrote about this.
Yes. The engine runs locally against your own Postgres. The trial license checks in periodically but tolerates being offline within a grace window.
Browse the community workflow collection, watch a demo, then start your free trial.