Machine
Drive the local machine, its shell, and the connected browser extension.
Run a shell command and capture its output, or drive the connected browser. Shell execution is powerful and unscoped, so prefer a purpose-built component wherever one exists.
The extension components run fragments of the canonical fragment library inside the connected browser. Sync pushes the library and waits for its ack, run executes a single fragment by id, and sequence runs an ordered set as one cancelable job sharing a live browser session. Fragments are always referenced by id and never inlined, so the browser only executes what its library author fixed, parameterized by workflow variables. The install component writes the browser's native messaging manifest so the bridge can be spawned on demand, and is idempotent, so a setup workflow can carry it unconditionally.
Components
Each component links to its own page with its full options and outputs.
| Name | Description |
|---|---|
machine:agent:session:create | Runs one turn of a coding agent session against a working directory and returns the session it ran, the agent's final message, the tools it called and what the turn spent. The agent runs headless through its own CLI, which has to be installed on the machine the run happens on, and reports what it does as it does it on step.progress events, each carrying a type of session, message or tool on IO.Partial. A coding agent runs commands of its own, so the step is behind the same host permission as machine:shell:exec. |
machine:agent:session:list | Lists the sessions coding agents keep on the machine the run happens on, each with its tokens, cost, models and tool calls, the subagents it spawned included. A session whose agent recorded no cost is priced from the run's price table, and stays uncosted with an empty cost_source when a model it ran is not in that table. |
machine:agent:session:read | Reads one session a coding agent keeps on the machine the run happens on, with its messages, its turns, the subagents it spawned and what each of them spent. Tool inputs and outputs are left out, since they are bulky and routinely carry whatever secrets the agent saw. |
machine:extension:advance | Acts on the control that reaches a listing's next batch. The pipeline owns the repetition, so this takes one step towards the next page and returns. Whether there is a page after that is answered by observing again, which is the workflow document's turn rather than this component's. |
machine:extension:apply | Turns one model decision into a step and performs it on the live page, then reports what the next turn needs to know. A step the loop may not write, a ref the page does not hold and a step the page refused are all ordinary outcomes here rather than component failures. Each one comes back as Error, which is the text the next prompt shows the model, because a loop that stopped on them would throw away the one thing that lets the model correct itself. A step that hands the page to the person in front of it is the one turn this does not hold to the turn timeout. It waits on them for as long as the step allows, and the turn is given back to the session's budget, so a loop is never shortened by the waiting it asked for. |
machine:extension:author | Writes a browser workflow by driving a real browser. It observes the live page, asks a model for one step, applies that step in the session, and keeps the ones that worked, so the workflow it emits is a record of a run that actually happened rather than a guess at the site's markup. A step that fails is not discarded silently. Its error goes back into the next prompt, so the model corrects against what the page did rather than against what it assumed. What the loop may write covers the whole of what a page hands over. It reads prose and it reads listings as rows, and where the thing it was sent for is a file behind a form rather than something written on the page, it re-issues that form and keeps the bytes. A wall only a person can get through is not a failure either. The loop writes a step that hands the page to whoever is in front of it, says what they have to do, and waits, and neither the time they take nor the turn it took is charged to the session. |
machine:extension:emit | Assembles the steps an authoring session accepted into a workflow, pushes it into the extension's library when asked, and saves it as a file when the run set write. It is the end of the loop rather than a part of it, so it needs no bridge unless a sync was asked for. That is what lets a session run against a browser and still hand back its fragment when the browser has gone away. |
machine:extension:list | Reads a page's repeated items as rows. It is the read half of paging through a listing. The repetition itself is never here, because a fragment is a flat list of steps and a browser that owns the loop is a browser deciding when to stop. This reads the page it is pointed at and hands the rows back, and the workflow document decides whether there is another page. |
machine:extension:observe | Reads the live page through the connected browser extension and returns its interactive elements as refs a model can name. It is the eye of the authoring loop, and it is useful on its own when a workflow needs to branch on what a page is currently showing. |
machine:extension:prompt | Renders one turn of the authoring loop as a prompt. It exists so a workflow document can run the loop step by step and still ask the model the same question the one-shot machine:extension:author component asks. Nothing about it touches the browser, so a run can render a turn and read it without a bridge. |
machine:extension:recall | Resolves the fragment held for one site and intent, so a run nobody is watching starts from what the last run worked out. An agent-driven repair carries the fragment in and takes the rewrite back out, and that caller keeps storage. A scheduled run has no such caller, so without this it authors the page from nothing every time and throws the result away at the end. Nothing stored is a miss rather than an error. The first run for an intent has nothing to find by definition, and a step that failed there would refuse the one run whose whole job is to work the page out. |
machine:extension:remember | Lands what a run worked out back on the fragment store, and writes down how the replay before it went. It is the other half of machine:extension:recall and useless without it. Recalling alone reads what the last run knew and leaves this run's repair in the outputs, where the next run cannot find it, so a page that changed is authored from nothing again on every run and the counters that would say so stay blank. A run that replayed cleanly writes no body. There is nothing new to keep, and storing the body it was just given would file a second identical revision on every run. |
machine:extension:replay | Runs an already-authored fragment and says whether to trust what it returned. Authoring a fragment costs a model call per turn and a live browser session, so a workflow that authors on every run is paying that on every run for a page it already worked out. This is the fast path. It runs what was authored, holds the result against the contract that fragment promised, and reports a miss or a break rather than failing, because the caller's answer to both is the same and it is to author. A step error is the easy failure. The one that matters is the fragment that runs clean and returns nothing, which is what a site's redesign looks like from here. Every step reports ok, the run reports ok, and the rows are gone. The contract is the only thing standing between that and a workflow that quietly reads zero rows forever. |
machine:extension:run | Runs one library fragment in the connected browser extension and blocks until its result comes back. One invocation is one workflow: the fragment is referenced by id (never inlined), so the extension only ever executes what its library author fixed, parameterized by variables. Under the hood the run travels as a single-ref sequence, the reference-only shape the trust boundary calls for. |
machine:extension:sequence | Runs an ordered list of library fragments in the connected browser extension as one logical job (one tab/session, one cancelable id) and blocks until the per-fragment results come back. Use it when fragments must share a live browser session; when they are independent, prefer chained machine:extension:run steps so the pipeline owns the control flow between them. |
machine:extension:sync | Pushes the canonical fragment library to the connected browser extension and waits for its ack, so a pipeline seeds (or replaces) the fragment set that later machine:extension:run and machine:extension:sequence steps reference by id. The fragments are plain workflow JSON files in the extension's wire schema, one workflow per file. |
machine:shell:exec | Runs an arbitrary shell command and captures its stdout, stderr and exit code |