Skip to main content
Glama

flow-start-recording

Start a new flow recording, resetting the target .yaml to empty and replacing any existing flow. Capture reusable device interactions for later replay.

Instructions

Start recording a new flow, resetting .argent/flows/.yaml to an empty flow and replacing any existing one. Use when you want to capture a reusable sequence of device interactions for later replay. Returns { message, flowFile, savedTo } and optionally { restarted, discardedSteps } if a live recording of the same flow was discarded. Whether this server writes that file depends on where your project is: co-located, it creates it and fails if the .argent/flows/ directory cannot be created or the file cannot be written; against a remote tool-server it writes nothing and savedTo is a directive your client applies (a null savedTo back means it did not).

Several flows can be recorded at once — each keyed by the name + project_root that every subsequent recording tool repeats — and one recording's steps never land in another's file. Steps still run LIVE, so give each concurrent recording its own device and pick a name unique to your task.

After starting, use flow-add-step to append tool calls — each step is executed LIVE so you can verify it works before it gets recorded. Read each step's message: an await-ui-element whose condition never held is still recorded (it returns success:false rather than failing), and a check that passes live can still fail once polished into an await:/assert: directive, which resolves against a different tree. flow-add-step warns about both when you record the wait DIRECTLY. A wait nested inside a recorded run-sequence gets neither warning — that tool reports its own shape — so for those, read toolResult. For a self-contained e2e flow, record a restart-app of the app under test as the FIRST step (captured as the flow's launch step); for a reusable fragment, skip that and pass executionPrerequisite instead. Use flow-add-echo to add labels, and flow-add-script to run a local .mjs file and record it as a script: step. Call flow-finish-recording when done.

If a recorded step turns out to be wrong, edit the .yaml file directly to remove or reorder steps - after flow-finish-recording, not during the recording. Against a remote client the in-memory copy is authoritative and every write serializes it over your edit; in host mode the recorder re-reads the file before each append, so a mid-recording edit renumbers the steps and costs the finish the cross-tree verdicts anchored to them.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
nameYesName for this flow (e.g. "settings-explore") — letters, digits, underscore and hyphen only.
project_rootYesAbsolute path to the project root directory (the directory that contains or should contain `.argent/flows/`). The flow file is created at `<project_root>/.argent/flows/<name>.yaml`.
executionPrerequisiteNoFragments only: the app/device state assumed on entry (e.g. "Settings app open on General page"). For a self-contained e2e flow, omit this and record a `restart-app` as the first step instead — it is captured as the flow's `launch` step. restart-app has no chromium support, so a chromium flow records as a fragment; add the `launch: { chromium: <app path> }` line to the YAML afterward, deleting the executionPrerequisite line if you passed one — a flow that starts with a launch must not declare it.

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed2 schema fields changedv0.20.0
    • changedInput schema / properties / executionPrerequisite / description
      Previous value: -"Fragments only: the app/device state assumed on entry (e.g. \"Settings app open on General page\"). For a self-contained e2e flow, omit this and record a `restart-app` as the first step instead — it is captured as the flow's `launch` step."New value: +"Fragments only: the app/device state assumed on entry (e.g. \"Settings app open on General page\"). For a self-contained e2e flow, omit this and record a `restart-app` as the first step instead — it is captured as the flow's `launch` step. restart-app has no chromium support, so a chromium flow records as a fragment; add the `launch: { chromium: <app path> }` line to the YAML afterward, deleting the executionPrerequisite line if you passed one — a flow that starts with a launch must not declare it."
    • changedInput schema / properties / name / description
      Previous value: -"Name for this flow (e.g. \"settings-explore\")"New value: +"Name for this flow (e.g. \"settings-explore\") — letters, digits, underscore and hyphen only."
  2. Changed2 schema fields changedv0.16.0
    • changedInput schema / properties / executionPrerequisite / description
      Previous value: -"Describes the required app/device state before running this flow (e.g. \"App on home screen after a fresh reload\", \"Settings app open on General page\")"New value: +"Fragments only: the app/device state assumed on entry (e.g. \"Settings app open on General page\"). For a self-contained e2e flow, omit this and record a `restart-app` as the first step instead — it is captured as the flow's `launch` step."
    • changedInput schema / required
      Previous value: -[
      -  "name",
      -  "project_root",
      -  "executionPrerequisite"
      -]New value: +[
      +  "name",
      +  "project_root"
      +]
  3. First observedv0.15.0

TDQS

A4.9/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses the return shape, the co-located vs remote tool-server file behaviors, failure conditions, concurrency isolation, and the rule that steps run LIVE. It even explains nuanced cases like recorded checks returning success:false and the consequences of mid-recording edits. This is exceptionally transparent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long but front-loaded and well-structured: purpose, return value, environment behavior, concurrency, follow-up actions, and caveats each occupy a coherent section. Every sentence adds needed operational context for a tool that starts a multi-step workflow. There is no tautology or filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no annotations and no output schema, the description covers the intent, lifecycle, parameter semantics, return envelope, failure modes, concurrent-recording behavior, and follow-up tools. Minor omissions like authentication requirements and a concrete YAML example do not prevent correct invocation. This is complete for the tool's complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful semantics beyond the schema: name + project_root key concurrent recordings, executionPrerequisite is fragment-only and must not be combined with a launch step, and project_root determines where the file is written. This extra context justifies a score above baseline.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific action, 'Start recording a new flow', and immediately states the destructive/reset semantics: 'resetting .argent/flows/<name>.yaml to an empty flow and replacing any existing one.' It clearly positions the tool in the flow-recording lifecycle, distinguishing it from siblings like flow-add-step, flow-finish-recording, and flow-execute. The purpose is unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It explicitly says 'Use when you want to capture a reusable sequence of device interactions for later replay' and offers concrete route selection: for a self-contained e2e flow 'record a restart-app... as the FIRST step', while for a reusable fragment 'pass executionPrerequisite instead.' It also names the follow-up tools and warns about live execution and concurrency, so an agent knows exactly when and how to invoke this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.