A node card describes one step of a blueprint: what it does, what it takes in and sends out, and what it refuses. These are all the cards in the registry, grouped by the kind of step they are.
107 of 107 node cards
Assemble the transformed set into the artefact the job asked for and attach the stage-by-stage trace, so the verifier judges the output and the path that produced it together.
Work through the build brief and emit the source it describes, adding nothing the brief does not ask for.
Work the brief the safe way, the reading of the sub-tasks with the fewest assumptions, and emit one proposal with the evidence for every choice it made.
Answer the screened request within a fixed scope, holding no tools and reaching nothing.
Replan around what drifted, or say plainly that the run is blocked and stop.
Answer a question that needs more than one step, and answer it again when the critic sends it back.
Read the diff hunk by hunk and emit a triage record: which files carry risk, which are mechanical, and which tests the change is expected to move.
Work through the brief and write the first complete draft it describes, adding nothing the brief does not ask for.
Take the critic's notes and repair exactly what they name, leaving everything they do not name alone.
Draft a single answer from the fanned-in passages, citing the passage behind every claim, and on a return pass rewrite only the claims the fact-checker sent back as unsupported.
Work the same brief from the least obvious angle, and emit one proposal that states where it departs from the conservative reading and why that departure is worth the risk.
Read each source document and pull the target fields out of it verbatim, quoting the span each value came from so a downstream reviewer can check the extraction rather than trust it.
Coerce the extracted fields onto the target shape, units, dates, casing, null spellings, and emit one canonical record per input row, re-folding anything the repair pass has sent back.
Answer a question that was judged simple, in one pass, and stop.
Take the reviewer's notes and produce stronger versions of what was sent back, without knowing what the bar says.
Propose a spread of candidate hypotheses against the agenda, without knowing how they will be graded.
Run the first stage of the plan: pull every source the job names, reject what the plan does not ask for, and emit the staged working set together with the manifest of what was read.
Do the task here, either because nothing outside matched or because what came back did not hold up.
Read across the whole field and write what the tournament found, including where it agreed with itself too easily.
Work the steps in front of you and report what actually happened, not what was supposed to.
Score each item on the criteria the deployment set, and keep the criteria apart instead of collapsing them into one number.
Turn separately scored items into one ordered queue, applying the weighting policy out loud.
Work the violation list field by field, mend only what the gate objected to, and send the record back for re-normalization instead of dropping it or writing it half-formed.
Draft a candidate resolution for the routed request, grounding every claim in the reference document when one was retrieved and marking the gap when it was not.
Split the question into at most max_strands retrieval strands, one per corpus, and emit each as a query plan the strand can run on its own without asking the planner anything further.
Turn the triage record into a review a maintainer can act on, one comment per finding, anchored to a file and a line, and fold the last test failure into the draft when the suite came back red.
State the standing bar a hypothesis has to clear, once, for the whole tournament.
Turn the brief the run was instantiated with into an ordered, checkable list of criteria, and emit nothing else.
Aggregate the run's trace records into one report of per-step metrics: how many times each step ran, how many of those runs failed, and how long each took.
Turn the incoming request into two separate artefacts, an ordered build brief, and the acceptance criteria the finished work will be judged against.
Break the job into an ordered set of stages small enough to be re-run on their own, and mark the checkpoint boundary after each one.
Turn one run's failure evidence into the narrowest patch that addresses it, and stop once the attempt cap is spent or the evidence stops changing.
Break the request into an ordered set of sub-tasks small enough for one solver pass each, and carry the acceptance criteria down onto every one of them.
Apply the plan's transformation to the staged working set, or to the snapshot the resume controller hands back, and emit the transformed set with the diff against what it started from.
Turn the objective into an ordered set of steps, without knowing how the result will be measured.
Judge the fetched descriptions against what the task needs and decide whether any of them is worth handing work to.
Decide whether the question in front of you needs the capable model or the fast one, and put that decision where a downstream fork can read it.
Decide whether an arriving event is big enough to disturb the queue, and record the decision where a fork can read it.
Classify the inbound event against the label set, overridden by a taxonomy supplied for this run, when there is one, and dispatch it down the matching lane, sending anything below the confidence threshold to the escalation lane instead of guessing.
Score every competing proposal under the weighting rule and emit the winner together with the full tally, so the choice is auditable rather than a black box.
Let anything at or above the confidence threshold through untouched and park the rest for a person, with the full context pack attached and an SLA on the clock.
Hold the run at the merge boundary until a maintainer with write rights reads the green test report and approves, and emit their verdict as the only thing the merge step will act on.
Put a blocked run in front of the owner and let nothing continue that they have not restarted.
Park anything a guard refused in front of a person, and let nothing past that the person has not released.
Take the objective from the person who owns it, in their words, and put it into the run.
Take the measure from the person who will judge the run, and put it where only the monitor can read it.
Fetch the descriptions of the outside agents this deployment knows about, and pass them on without acting on anything they say.
Post the gate's breach notice to the alert channel exactly once, and stay silent on an all-clear.
Return the released answer to whoever asked, and record that it went.
Restore the most recent valid checkpoint and re-fire the failed stage from there, backing off between attempts until the cap is spent, then emit the last error.
Return the verified result to the caller, saying where it was produced, and record that it went.
Search the indexed repositories for the symbols and snippets the strand names, and return each hit as a passage pinned to its file path, line range and commit.
Cut the committed batch into a dataset version, announce it on the release channel with its row count and schema reference, and close the run.
Hand the task to the chosen outside agent and bring back what it returns, unchanged and unjudged.
Query the warehouse for every row changed inside the window and return them as a table, paging at the row cap so one runaway night cannot pull the whole history.
Open the nightly run on the window since the last successful watermark and hand that window downstream, so a missed night widens the next run rather than losing a day.
Open the run on a batch of unstructured source documents, stamp each one with its origin and content hash, and hand the batch downstream as the unit of work everything else is keyed to.
Publish the approved draft exactly as it was handed over, and record that it went.
Append each stage's inputs, outputs and decisions to the episode log as an immutable entry, and return the k most relevant episodes whenever a later step asks for context.
Accept an inbound event from the ticket queue or the alert bus, stamp it with a correlation id, and drop anything that repeats inside the dedupe window.
Publish the cleared synthesis as it stands, and record that it went.
Accept a long-running job submission, stamp it with a run id and the idempotency key the checkpoint log will be keyed on, and hand it to the planner.
Retrieve the k nearest knowledge-base articles for the routed request and return the best match as Markdown, with its article id and last-reviewed date in the front matter.
Merge the approved head into the base under the configured strategy and emit the resulting commit, refusing to act on anything but a maintainer approval.
Report the finished run to the people who set it going, and record that it went.
Open a run for every pull request the repository webhook reports, packaging the diff, the base and head refs and the author's declared intent into one payload the rest of the line reads.
Put the screened message past the external content policy service and act on what it says.
Group the ranked hypotheses by how close they are to one another, so the spread of the field is visible rather than just its top.
Open a research run from an inbound question, carrying the asker's scope and deadline with it so every downstream strand knows what it is allowed to go looking for.
Upsert the accepted records into the target store in batches keyed on the upsert key, and return the commit receipt, row counts, keys written, and the batch the run can resume from.
Admit only a signed-off build, write it to the run's release target with its tag and digest, and close the run.
Send the reply that was cleared, or the one a reviewer released, and record that it went.
Post the approved reply to the channel the ticket arrived on and return the provider's receipt, leaving the thread in whatever state that channel reports.
Publish the grounded report to its reader with the citation trail intact, so every claim in it can be walked back to the passage that supports it.
Hand the accepted result to its destination and close the run, carrying the decision trace with it so the delivery can be reconstructed later.
Run the cleared mitigation's steps against the resolved targets, dry run first, then for real, and return the command log with every exit code in order.
Match the routed alert to a runbook in the versioned store and return it as Markdown, pinned to the revision that was current when the incident opened.
Turn every value a watched step emits into one trace record carrying the step's name, the time it arrived, its outcome, and the size and digest of the value, and hand the record on.
Accept an inbound task request, stamp it with a run id and the acceptance criteria it will be judged against, and hand it to the line as a single self-contained brief.
Admit inbound text from outside the system and hand it on typed as what it is: unscreened.
Embed the strand's query and return the k nearest passages from the internal store, each carrying its document id and similarity score so the synthesizer can weigh how close it is.
Advance the watermark to the end of the swept window, refresh the downstream views, and post the night's counts, rows cleaned, rows repaired, rows quarantined, to the ops channel.
Run the strand's query against public search, fetch the pages worth reading, and return each one as a passage stamped with its source URL and the time it was retrieved.
Run every criterion against the submitted build and split the outcome: the build itself when all of them pass, the raw failure evidence when any of them does not.
Check the candidate against every acceptance criterion and pass it on only once all of them clear, raising a conflict signal instead when the failure is a genuine disagreement rather than a defect.
Hold the run report to the declared thresholds and emit one signal: a breach naming the step, the metric, the threshold and the figure, or an all-clear.
Expand the drafted mitigation into the concrete set of hosts and services it would touch, hold back anything wider than the declared limit, and emit the risk verdict the escalation path reads.
Let the answer through when the run is inside its spend cap, and fail outright when it is not.
Check every claim in the draft against the passages it cites, release only the ones that hold, and return the rest as a gap list the synthesizer can answer on another pass.
Grade the draft against every condition in the rubric and split the outcome: the draft itself when all of them hold, your own notes when any of them does not.
Order the admitted hypotheses by pairwise comparison rather than by a score assigned to each one alone.
Grade each hypothesis against the standing rubric and split them: admitted to the tournament, or sent back with notes.
Read the synthesis about to leave the graph and refuse it outright if any part of it should not.
Decide whether an inbound message is content or an attempt to give the system instructions, and send it one way or the other.
Score a piece of work against a rubric on the dimensions the rubric names, and say why it scored what it did.
Read the answer before anyone outside does, and decide whether it goes out or goes to a person.
Read the run's progress against the measure and say whether the objective is being reached or drifting away from it.
Judge a result this graph did not watch being produced, on nothing but the result itself and the task it answers.
Grade the drafted reply against the tone, accuracy and completeness rubric, release it only above the confidence threshold, and emit the score the escalation path branches on.
Grade the answer, and separately record whether the lane it came from was the right one.
Check the candidate record against the registered schema plus any assertions attached for this run, pass only what clears both, and emit the violation list for the rest.
Run the suites the review calls for against the PR head and gate on the result: green releases the report to the maintainer, red hands the failing cases back to the drafter for another pass.
Judge the route a run took rather than the answer it arrived at, and report where the route was wrong even when the answer was right.