$ cat ./pitch.txt

> turn your internal functions
into workflows your customers compose.

your typescript becomes a node. your customers describe the workflow in chat. the engine runs durably in your VPC — never in ours.

[ get-early-access ]

● typescript● react flow● grpc + mtls

fetch-customer-orders.tsready

// runs in your worker, your VPC, your auth context
import { defineNode } from "@flowget/sdk";
import { db } from "@/lib/db";

export const fetchCustomerOrders = defineNode({
  id: "fetch_customer_orders",
  category: "data",
  label: "Customer — Recent orders",
  fields: [
    { key: "customerId",
      type: "text", required: true },
  ],
  outputFields: [
    { key: "orders", type: "object" },
    { key: "count",  type: "number" },
  ],
  async execute({ customerId }) {
    const rows = await
      db.orders.findByCustomer(customerId);
    return { orders: rows, count: rows.length };
  },
});

$ man 1 the-wedge

your code becomes a first-class node.

Write a TypeScript function with your DB, your ORM, your auth context. Push with the CLI — the node shows up in the builder, and the AI agent can compose with it.

// your worker, your VPC
export const chargeCustomer = defineNode({
  id: "charge_customer",
  category: "payments",
  decorators: [withRetry({ attempts: 3 })],
  async execute({ amount, customerId }) {
    return stripe.charges.create({ … });
  },
});

customer — recent orders

fetch_customer_orders

LIVE

customerIdtext · req

Out

ordersobject[]

countnumber

no marshalling. no HTTP boundary. the node runs in your worker, in your VPC, with the same auth context as the rest of your app.

$ ai authoring · grounded in your catalog

your customers don't want to draw graphs.
they want to solve problems.

Your customer describes the outcome. The agent composes the graph from real catalog nodes — no hallucinated steps, no made-up fields. They review it, authorize, and ship — all without leaving the chat.

$ embedded-chat · acme.exampleAI · gpt-4 · 8k

live · ai builds the workflow● REC

waiting for the agent to compose…

the graph will render when the chat lands

no hallucinated steps.the agent composes only from the catalog you declared, and every generated workflow is validated against your types before it's saved.

$ recordings/ai-authoring.gifreal product

real builder · screenshot pending

16:9 · gif / mp4 / webm · swap in RealBuilderSlot.tsx

the same flow, recorded in the real builder — your customer types, the agent composes from the catalog, the graph snaps in. swap to see the actual UI once we ship the recording.

catalog-grounded

the AI can only compose from your declared nodes. made-up steps don't make it past validation.

always a draft

generated workflows land disabled. review the graph, test in sandbox, then enable. no silent prod changes.

conversation, not commands

refine in chat — "change the filter to less than 700". the agent updates the graph; you review the diff.

ai SDK, your chat UI

we run the model orchestration, prompts, safety, and billing — you embed the SDK into your existing chat. brand it your way. no iframe, no vendor chrome.

honest FAQ

"then can you read my customers' chats?"

no. the agent runs inside your worker — the same BYO-worker boundarythat protects your domain data extends to the AI. we orchestrate; we don't see plaintext.

BYO LLM key

plug in your own OpenAI key, or self-host. calls go worker → provider direct. we never see the bytes.

chats live in your DB

every message and draft persists only in your tenant database. our control plane stores catalog manifests + decisions taken — never message content.

auditable boundary

the agent code is open. inspect exactly what crosses our line: metadata (which tools fired, validation results, cost), not content.

$ cat ./billing.md

your customer knows exactly what they're spending.

no hidden costs. no fine print. no surprise invoice at the end of the month. every workflow execution is itemized down to the node — the customer sees what they paid for, you charge for what they actually used.

per-node cost, per execution

every node reports its own USD cost — LLM tokens, external API calls, storage, compute. aggregated up to the workflow, rolled up to the customer.

pass-through billing

define how each node is priced. we compute, attribute, and expose it. plug into your existing billing system — Stripe metered, Lago, Orb — without writing accounting code.

no fine print

customer dashboards show: how many runs, what each cost, why. if a number changes, the breakdown changes with it. trust by default.

…or keep it hidden — your call

don't want to expose costs to your customer? flip a config flag and the entire breakdown disappears from their view. show all, show totals, or show nothing — no-code, plug-and-play, no rewrite.

the principle

whether the customer sees the bill or not is your decision — but if you do show it, it has to be the truth.

execution breakdown · weekly-summary-2026-W21ok

LLM Call · resumo executivo

llm_call-summary01

$0.0421

3.4s

Create Report · PDF

create_report-pdf01

$0.0184

8.1s

HTTP Request · webhook

http_request-webhook01

$0.0024

877ms

HITL · approve

human_in_the_loop-approve01

$0.0002

16.6s

Cache · weekly-summary-llm

cache-llmcache01

HIT

$0.000028

38ms

Trigger · schedule

schedule-trig01

$0.0000

0ms

Admin Notification

create_admin_notification-ok01

$0.0000

124ms

cost compositionrun #4827 · 29.1s elapsed

LLM 68%compute 20%storage 8%HITL 4%

subtotal · 7 nodes$0.0631pass-through margin · 15%$0.0095customer pays$0.0726

$ ls -la ./workflows

workflows are code. the graph is the debugger.

every workflow is a JSON document. track it in your git repo when engineers own it (PR review, CI deploy, rollback like code), or persist it in your database when your customers author it through the AI agent. either way, the JSON is yours — we never lock it inside our cloud.

PR #143 · workflows/credit-risk.json+12 / −4

  {    "id": "wf_credit_risk_v3",    "executionPolicy": "reject_if_running",    "graph": {      "nodes": [        { "id": "trigger", ... },-       { "id": "score_check", "nodeTypeId": "if_else",-         "config": { "operator": "<", "right": 600 } },+       { "id": "score_check", "nodeTypeId": "if_else",+         "config": { "operator": "<", "right": 700 } },+       { "id": "hitl_approve",+         "nodeTypeId": "human_in_the_loop",+         "config": { "timeoutSeconds": 86400 } },        ...      ],      "edges": [ ... ]    }  }

~/repo/acmezsh

$ flowget push workflows/credit-risk.json
✓ validated against catalog
✓ uploaded as v3 (was v2)
✓ schedule reconciled

$ flowget test wf_credit_risk_v3 --trigger schedule \
      --mock fixtures/credit-low.json
→ executing... cache miss... LLM call... HITL pending
⏸ waiting on approval (auto-approve in dev mode)
✓ done in 4.2s · $0.0423

JSON contract

stable, documented schema. lint it, generate it from a script, store it wherever your stack puts artifacts.

git-native

engineer-owned workflows live in your repo. PR review, code-owners, branch protection — all the discipline you already have.

db-native

customer-authored workflows live in your database, same row-level security as the rest of your tenant data. no vendor lock.

CLI + SDK

push, test, promote workflows from the terminal. CI/CD-ready, or call the SDK from your control plane.

$ cat ./architecture.md

your data never leaves your infra.

your nodes run in a worker process inside your VPC, connected outbound to the Flowget orchestrator. payloads are encrypted at the worker edge — our cluster orchestrates without ever decrypting your data.

control plane · we run it

flowget saas

multi-tenant orchestration. visual builder, AI authoring, audit history, billing primitives.

durable orchestrator (per-tenant namespace)
workflow interpreter
catalog db · workflow versions · executions
builder UI + AI authoring agent

sees: ciphertext payloads, workflow metadata, decisions taken. never sees: your raw domain data.

encrypted

gRPC · mTLS

outbound · 1-way

execution plane · you run it

your worker, your VPC

a single worker process running our SDK. registers your nodes, polls outbound, executes alongside your app.

@flowget/sdk worker process
direct access to your DB · ORM · secrets
payload codec (encrypt before send)
scales with your existing infra

sees: everything. domain data, secrets, business logic — all stays on this side of the line.

data residency

your data stays under your control. our cluster acts as a processor of metadata only — your VPC stays the boundary for everything else.

regulator-friendly

GDPR, HIPAA, SOC 2, PCI, regional regulators — they all care where data lives. with BYO worker, you can answer: in your VPC.

audit-ready

every workflow execution is replayable from history. the codec lets you decide which fields go in clear vs. ciphertext.

$ trace ./one-execution

one workflow, end to end — under the hood.

watch a scheduled weekly report run, step by step. every byte crossing our cluster is encrypted at your worker edge with a tenant-scoped key. we orchestrate; you hold the plaintext.

the workflow

Schedule trigger
schedule
Fetch customer orders
fetch
Aggregate metrics
aggregate
Build PDF
pdf
Send email
email

on the wiregRPC · TLS 1.3 · payload codec

cost

$0.0000

elapsed

0.00s

encrypted pkts

Cloud

orchestrator

ciphertext only

Worker

your VPC

holds the key

idle. click [ run end-to-end ] to start.

the codec is opt-in per tenant — leave it off for non-sensitive workloads, flip it on for compliance-bound ones. same SDK on both sides.

$ ls ./features

code what matters to you. we handle the rest.

Skip the orchestrator, the queue, the state machine, the retry math, the cost accounting, the audit trail, the visual builder. We've already shipped them.

domain-native nodes

TypeScript functions in your codebase. Same auth context, same DB pool, same secrets. Zero HTTP marshalling, zero vendor egress.

durable execution, native

Workflows survive deploys, crashes, and 7-day human approvals. We operate the orchestrator; you write business logic.

decorators for free

Cache, retry, rate-limit, audit — attached to any node as stickers. Author them once; reuse across the catalog.

human-in-the-loop

Pause a workflow for hours or days waiting on approval. Resume on click, with full audit trail of who said what and when.

workflow-as-json

The graph is a versioned artifact. Diff in PR, lint in CI, roll back like code. Visual builder is debug, not source of truth.

replayable executions

Every run produces a deterministic history. Re-render the graph at any past moment, click a node, inspect its inputs.

$ sign-me-up --early

ship your customers' workflows. not their integration platform.

ten teams a month into the beta cohort. tell us what we're building together and we'll start the conversation.

[ request-access ] $ see-use-cases

✓ single-tenant cloudsoon on-prem on enterprisesoon soc 2 type II

> turn your internal functionsinto workflows your customers compose.

your code becomes a first-class node.

your customers don't want to draw graphs.they want to solve problems.

your customer knows exactly what they're spending.

workflows are code. the graph is the debugger.

your data never leaves your infra.

one workflow, end to end — under the hood.

code what matters to you. we handle the rest.

domain-native nodes

durable execution, native

decorators for free

human-in-the-loop

workflow-as-json

replayable executions

ship your customers' workflows. not their integration platform.

> turn your internal functions
into workflows your customers compose.

your customers don't want to draw graphs.
they want to solve problems.