One self-contained platform · author · run · maintain

The automation is the code. The code is the diagram.

flopod is one platform where an AI agent authors your automations in plain TypeScript — faster and more reliably than any low-code builder — and a bounded set of ~10 node types renders that same code as a live graph anyone can watch, replay, and trust. Durable by replay. And when day ninety comes, it heals itself.

$ one account · sign-in provisions your environment on demand

invoice-sync run #1847 Running
↓ invoices ·3 fetchInvoices PARALLEL invoices ×3 enrich[0] enrich[1] enrich[2] → out ·1 → out ·1 → out ·1 report
#1+0msRunStarted entry src/invoice-sync.ts
The problem

Two audiences, opposite needs — and no single platform serves both.

Automation forces a bad trade-off, and it's expensive whichever way you turn.

Go low-code
Hits a wall

Drag-and-drop promises “anyone can automate.” Then citizen developers get stuck, engineers inherit the work, and you pay twice — build and maintain.

Go code-first
Loses the picture

Author workflows as code and non-technical users lose the visual view they need — and durability means bolting on something like Temporal: slow to set up, hard for an agent to write.

Add AI on top
Barely moves

Existing platforms bolt AI onto legacy XML/JSON. Agents are brilliant at real code (TS/JS) and weak at those formats — so the AI hardly moves the needle.

Citizen developers want a guided, managed experience. Engineers want their own IDE, LLM, and tools with no lock-in. flopod is the one platform that serves both.

The proof

20 web automations, AI-authored and run.

Same brief, same model, three targets. flopod's plain-TypeScript shape is what an agent authors reliably — even Haiku.

flopodplain TypeScript, agent-authored
20 / 20
Low-code, Python-codedhand-written functions
12 / 20
Low-code, XML activitiesthe legacy format
11 / 20

Roughly 1.7× more working automations than the best alternative — nearly 2× the legacy format.

Because the target is code an agent is genuinely good at — not a format it has to fight.

How it works

One model: code an agent authors, that everyone can read.

Not a smarter model — a better substrate. Six properties turn an automation into a single artifact an agent can build, run, and keep alive.

01

Code, not formats

An automation is plain TypeScript. Agents author it brilliantly; engineers debug it with their own tools — no lock-in, no XML/JSON. Even Haiku writes it reliably.

02

The code is the diagram

A bounded, closed algebra of ~10 node types — steps, branches, loops, parallelism, waits — auto-renders a live graph. Non-technical users watch it run and scrub and replay in time. One artifact, both audiences.

03

Two-tier authoring

Leaves do the real work; the branch only directs. You write plain functions and the compiler wires them into an observable, checkpointed workflow — you never hand-write durable primitives.

04

Durable by replay

Event-sourced runs save their state and resume exactly after a restart. Long-running and human-in-the-loop workflows just work — no always-on process, no worker fleet.

05

Self-healing when it breaks

When day ninety comes, the agent runs reproduce → localize → repair → verify — every fix gated by deterministic replay and your approval before it ships. The model proposes; the gates decide.

06

One self-contained flopod

Authoring, runtime, orchestrator, and scheduler in a single Docker — the electric engine, not AI bolted on. npx to start, deploy anywhere, or use the hosted studio.

The shape an agent authors

Plain TypeScript, two tiers. That's the whole trick.

This bounded shape is exactly what makes the agent reliable — activities do the work, the root directs it, and the compiler turns it into durable, checkpointed primitives you never write yourself. The same source renders as the live graph above.

Activities do real work

I/O, compute, try/catch — anything. Retries and timeouts are declared in JSDoc (@retry 3) and enforced by the runtime.

The root only directs

Order, conditionals, fp.parallel fan-out, durable sleeps and waits. No hidden state, no side effects — which is why it can be replayed and rendered as a graph.

Humans in the loop, durably

fp.waitForSignal pauses the run for an approval. It survives restarts and redeploys, then resumes with the input.

src/invoice-sync.ts✓ compiles · 4 activities
// Activities do the real work — I/O, compute, retries
/** @retry 3  @backoff exponential */
async function fetchInvoices(since: string): Promise<Invoice[]> {  }
async function enrich(inv: Invoice): Promise<Entry> {  }
async function buildReport(entries: Entry[]): Promise<Report> {  }
async function postToLedger(r: Report): Promise<void> {  }

// The root only directs — order, fan-out, waits
export default async function main() {
  const invoices = await fetchInvoices('yesterday')

  // parallel fan-out, one durable checkpoint per item
  const entries = await fp.parallel(...invoices.map(i => enrich(i)))
  const report = await buildReport(entries)

  // pauses here — survives restarts, resumes with input
  const { approved } = await fp.waitForSignal('approve')
  if (approved) {
    await postToLedger(report)
  }
}
waits survive restarts and redeploys one shared vocabulary — human, agent, runtime, graph one Docker container per automation — no scheduler, no worker fleet
Today, in your terminal

It’s just TypeScript. Run it, it works.

No infra, no server, no ceremony. fp.parallel, fp.sleep, and the rest are a real library, so the file executes under plain tsx and does exactly what it reads like it does.

  • $ tsx src/invoice-sync.ts — runs start to finish
  • real fetches, real output, nothing to stand up
  • readable, testable, git-diffable — it’s code
same file
Shipped, without a rewrite

…and a durable workflow system, for free.

The compiler lowers that same file into checkpointed primitives. Durability isn’t something you code — it’s an enhancement the compiler adds to the code you already ran.

  • every step checkpointed — crash-safe, resumes from where it stopped
  • deterministic replay of any run, exactly
  • a live graph — fan-out, waits, retries, dataflow
  • waits & sleeps survive restarts and redeploys
Why flopod

One platform does what no single tool does.

Every other option makes you pick: agent-friendly code or a visual diagram, durable or simple, build help or maintenance. flopod refuses the trade-off — it's all one artifact.

Capability Low-codevisual builders Code + durability libe.g. Temporal flopodone artifact
Agent-friendly code (an LLM writes it)
Visual diagram of the workflow
Code + visual = one artifact
Durable suspend / resume
Replay / time-travel debugging
Agent self-healing maintenance
Self-contained (no cloud orchestrator)

Faster, more reliable authoring than any low-code tool — and, uniquely, the agent also owns maintenance, the cost everyone else ignores.

One honest objection

“Just let the AI run it.” No.

A good company doesn't run because a room of geniuses improvises every order — it runs on good procedures. Automations are the same. You don't want a model re-deciding your invoice reconciliation on every run; you want it to execute the same way, every time, and to prove it did.

Deterministic workflows aren't the thing AI replaces — they're the thing AI should build, run, and keep alive. flopod keeps the run deterministic and replayable, and puts the agent everywhere the work actually is: authoring the workflow, and repairing it when it breaks.

And when it breaks

Day ninety comes. It heals itself.

The same artifact the agent authored is the one it repairs — because every run is a durable, replayable recording, not log soup.

observe ✗ reproduce localize repair verify ✓

An API changes overnight and run #1847 fails mid-flight. The agent replays the run to the exact moment it broke, localizes the break to one named activity, and patches it in an isolated draft. The fix must pass the compile gate and the replay + expectation gate before it ships — then the run resumes from its checkpoint.

The model proposes; the gates decide. You own intent and acceptance; the agent owns the repair.

✓ run #1847 repaired & resumed from checkpoint · 0 humans paged
You own

Intent, acceptance criteria, approvals. A fix isn't trusted because it compiles — it's trusted because it meets your stated expectation.

The agent owns

Implementation, debugging, and the repair loop — gated by replay every time. Full autonomy is opt-in for low-risk flows, not the default.

https://invoice-sync.flopod.app/#/studio
Studio: draft banner, the live graph beside its TypeScript source, compile status, and the agent dock repairing an activity
The console

From sign-in to a running automation environment in one click.

The flopod console is the cloud entry point. Sign in, connect your deploy provider, and provision flopods — self-contained automation environments, each one click to open. Keep up to three per account; delete one to make room for another.

1 · sign in 2 · connect your provider — fly auth token 3 · provision & open

Self-contained flopods

Each flopod is its own deployed environment — own app, own machine, own durable data. Deploy is one Docker container per automation; all state lives in the database.

Author + operate, built in

Every flopod ships the full web environment: Studio for building with the agent, Operate for runs, approvals, and history. One click to open.

Your infrastructure

Connect your deploy provider with a Fly.io token and provision on your own account. No proprietary scheduler, no worker fleet to babysit.

Your flopods run in your own infrastructure — flopod never holds your production data.

Yes, about the name
flopod
/ˈflɒp.pɒd/ · noun · a flow that survives its own flops
  • 1.a self-contained pod where your automations are free to flop — because a run that can fail safely, be reproduced exactly, and resume from a checkpoint is worth more than one that merely promises never to break.
  • 2.the honest half of flow. Every automation flops eventually — an API bumps a version, a column gets renamed, a page restructures. Here the flop is a non-event: the agent notices, repairs behind gates, and picks up where it left off.

We considered “Flow Pod.” But flows that never flop don’t exist, and we didn’t want to lie to you on the homepage. The flop is the point — watch the hero again: run → flop → heal.

Get started

One platform. Author, run, and maintain.

Sign in, connect a provider, provision a flopod. Describe an automation and let the agent build it — or bring your own IDE and LLM. It's just TypeScript either way.

$ sign in → connect provider → provision