workflow_creation
Build a new Rome **workflow app** — one action whose body is a single async function that implements its control flow in plain TypeScript (`await`, `if`, `for`, `Promise.all`) and calls existing actions (including `system:summon`). Use whenever the user describes a multi-step automation OR asks an LLM to produce something from inputs: "read X then do Y", "pull from A, B, C and combine", "monitor … and notify me", "for each item, if … then …", "turn my X into Y", "write/draft/summarize me a … from …". Generative work — writing, drafting, summarizing, judging — belongs HERE as a `system:summon` call, not a separate app with its own agent. A specialization of `coding:app_creation`; reuses its scaffold/build/pack/install mechanics and adds the workflow shell. Build a plain app (`coding:app_creation`) instead only when the thing needs a user-edited data model, multiple distinct operations, or a conversational agent.
rome-os · Static checks on file
Installation
Read the source and dependencies before running a command. Copying does not install or execute anything.
npx skills add rome-os/rome --skill workflow_creationAbout this skill
name: workflow_creation
description: Build a new Rome workflow app — one action whose body is a single async function that implements its control flow in plain TypeScript (await, if, for, Promise.all) and calls existing actions (including system:summon). Use whenever the user describes a multi-step automation OR asks an LLM to produce something from inputs: "read X then do Y", "pull from A, B, C and combine", "monitor … and notify me", "for each item, if … then …", "turn my X into Y", "write/draft/summarize me a … from …". Generative work — writing, drafting, summarizing, judging — belongs HERE as a system:summon call, not a separate app with its own agent. A specialization of coding:app_creation; reuses its scaffold/build/pack/install mechanics and adds the workflow shell. Build a plain app (coding:app_creation) instead only when the thing needs a user-edited data model, multiple distinct operations, or a conversational agent.
tools: [Read, Edit, Bash]
Workflow Creation
A workflow is a single Rome action whose body is plain author-written code: one async function, runWorkflow(input, ctx), that transforms the value flowing in and implements its own control flow — sequencing, concurrency, conditionals, fan-out — directly in TypeScript. The run action calls runWorkflow directly, and the function reaches reusable work through ctx.runAction(canonicalId, args), which can invoke any registered action — system:send_message, a SaaS API via connector:connector_proxy, or system:summon (hand a piece of work to an LLM agent).
Each workflow is its own Rome app, scaffolded from the bundled workflow template. The template ships the entire shell — run action, trigger API, web page, run-history table — already wired and buildable. You write the one thing that differs per workflow: the body of runWorkflow().
Artifact identity — never use bare names
The scaffold is formatVersion: 2. Definitions use app-local names (name: run);
every reference and runtime call uses <app-id>:<local-name>, even for an action
owned by this workflow. Never emit a bare artifact name or self:<name>.
Use the real canonical ids for shared platform artifacts:
- LLM work:
ctx.runAction("system:summon", { agentName: "assistant:assistant", prompt }) - Connected provider API:
ctx.runAction("connector:connector_proxy", args) - Messaging:
ctx.runAction("system:send_message", args) - Routine creation:
ctx.runAction("system:create_routine", { actionName: "<workflow-app-id>:run", ... }) - Core orchestrator, only when the workflow explicitly needs it:
core:main
Three principles that decide most of the design
These come up on nearly every workflow, so internalize them before writing anything — the rest of the skill assumes them.
-
Generative work is a
system:summoncall, never a bespoke agent or action. When the request is "write me a recap / draft replies / summarize these / decide what matters," the tempting move is to stand up a custom writer agent plus agenerateaction plus a DB of past results. Resist it — that whole apparatus collapses to one line:await ctx.runAction("system:summon", { agentName: "assistant:assistant", prompt }). Put the voice, persona, and instructions in the prompt, not a custom agent. A hand-writtenaction.yaml/agent.yamlis also an error surface: one wrong field fails the whole app to load, and the run then throws "action not found."system:summonis the agent entry point. -
External APIs go through
connector:connector_proxy, grounded in a supported toolkit. The connector holds the credential and injects it into a raw HTTP call to the provider's own API. Reach for it first; call an API directly from code only when no connector can broker its toolkit. The endpoint must be the provider's real, documented REST/GraphQL endpoint — not invented — on a toolkit from the catalog in your context. Whether the guardian has connected that toolkit is a post-build step, not a precondition for writing the code: build first, then ask them to connect what's needed. (Full procedure: Connector steps.) -
Run history is the shell's job — don't add your own
db:table. The template ships arunstable and a "Recent runs" list, and the run action records every run (status, input, result, timing) for you. Even a one-shot "gather → write" task needs no results table of its own.
Reach for coding:app_creation instead of this skill only when the thing needs a user-edited data model, multiple distinct operations, or a conversational agent (see its litmus).
Out of scope here: scheduling and live run visualization. The workflow runs on demand (a "Run now" button / its run action) and returns its result. When it fires (a routine bound to the run action) and a richer run UI (structure diagram, per-node progress) are separate follow-ups the platform will provide. Build the workflow as if it runs on demand: don't put scheduling in
runWorkflow, and don't invent acroncall.
What you author (the template ships everything else)
| Per-workflow (you edit) | Shell (template ships it; don't touch) |
|---|---|
src/workflow/definition.ts — the runWorkflow(input, ctx) function | src/workflow/context.ts — the WorkflowContext/Json types the app owns |
app.yaml description, tagline, web nav labels | src/actions/run/ — the run action (calls runWorkflow) |
.rome_store/rome_store.yaml + README.md store listing copy | src/api/index.ts — the POST /run trigger + GET /runs history feed |
src/web/App.tsx COPY block (title + run-button copy) | src/web/App.tsx body (incl. "Recent runs") + styles.css |
src/assets/icon.svg — replace the placeholder | src/db/ — the runs history table, migrations, and repository |
The template scaffolds with a starter definition.ts (one trivial line) so it builds and runs immediately. If your only chang