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
Automation forces a bad trade-off, and it's expensive whichever way you turn.
Drag-and-drop promises “anyone can automate.” Then citizen developers get stuck, engineers inherit the work, and you pay twice — build and maintain.
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.
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.
Same brief, same model, three targets. flopod's plain-TypeScript shape is what an agent authors reliably — even Haiku.
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.
Not a smarter model — a better substrate. Six properties turn an automation into a single artifact an agent can build, run, and keep alive.
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.
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.
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.
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.
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.
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.
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.
I/O, compute, try/catch — anything. Retries and timeouts are declared in JSDoc (@retry 3) and enforced by the runtime.
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.
fp.waitForSignal pauses the run for an approval. It survives restarts and redeploys, then resumes with the input.
// 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) } }
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 finishThe 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 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.
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.
The same artifact the agent authored is the one it repairs — because every run is a durable, replayable recording, not log soup.
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.
Intent, acceptance criteria, approvals. A fix isn't trusted because it compiles — it's trusted because it meets your stated expectation.
Implementation, debugging, and the repair loop — gated by replay every time. Full autonomy is opt-in for low-risk flows, not the default.
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.
fly auth token→
3 · provision & open
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.
Every flopod ships the full web environment: Studio for building with the agent, Operate for runs, approvals, and history. One click to open.
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.
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.
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