Skip to content
OpenAgentSkill
Browsing is open · Catalog captured 2026-11-21 · Automatic updates and account services are paused.
Development

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_creation

About 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.

  1. Generative work is a system:summon call, 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 a generate action 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-written action.yaml/agent.yaml is also an error surface: one wrong field fails the whole app to load, and the run then throws "action not found." system:summon is the agent entry point.

  2. 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.)

  3. Run history is the shell's job — don't add your own db: table. The template ships a runs table 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 a cron call.

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) functionsrc/workflow/context.ts — the WorkflowContext/Json types the app owns
app.yaml description, tagline, web nav labelssrc/actions/run/ — the run action (calls runWorkflow)
.rome_store/rome_store.yaml + README.md store listing copysrc/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 placeholdersrc/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

Read the complete source ↗