NodeFox
Patterns

Start from a working step,
not a blank canvas.

A pattern is a reusable piece of a NodeFox workflow: the prompts, settings, schemas and wiring for one job, already written. Build with patterns using AI, then change and run the workflow from NodeFox or from your own agent.

Start buildingBuild with AI
The Patterns panel

See what can come next.

The panel reads the network you have open and sorts the pattern library against it, so you choose from steps that fit rather than searching a catalog.

Ready

Every input the pattern needs is already produced somewhere on your canvas. It can continue what you have.

Starts here

The pattern takes no inputs — it reads a file, a recording or a web page — so it can begin a new chain.

Not yet

The pattern is one step away. The panel shows the input it is missing and which ready pattern would produce it.
Shared vocabulary

Steps that connect by what they carry.

Every pattern declares the labelled ports it consumes and produces — transcript in, action items out. Placing one wires it to the node that already emits the label it needs, and writes its own output labels onto the canvas so the next pattern knows where to connect.
Parse Ticketsupport
Turn a raw inbound ticket into a record of customer, product, issue, steps already tried, urgency and sentiment.
? (text)→Ticket (Ticket)text (text)
Answer From Knowledge Basesupport
Answer a ticket using only the knowledge base on the second port, with the passages used, and say so plainly when the answer is not there.
Ticket (Ticket)kb (text)→answer (text)gap (text)sources (json)
Escalation Decisionsupport
Decide whether the desk can close a ticket itself or must escalate it, and send it down the matching lane with a written reason.
needs answer · from Answer From Knowledge Base
Ticket (Ticket)answer (text)→Ticket (Ticket)Escalate (Ticket)Reason (Escalation)
Write Handoffsupport
Turn an escalated ticket into the internal note an engineer needs: summary, reproduction steps, environment, expected versus actual.
needs Escalate and Reason · from Escalation Decision
Escalate (Ticket)Reason (Escalation)→Handoff (Handoff)text (text)

A support lead can place a ticket parser, a knowledge-grounded answer, an escalation decision and an engineering handoff in sequence. Each block already knows how to read the previous block's output and emits a typed record that downstream tools can use.

How a pattern is made

Written once. Only the values change.

Each pattern is one JSON record in three layers. The graph is authored with care once; a placement supplies the values.

The card

A name, a one-line purpose and the labelled ports it consumes and produces. It is what the panel ranks and what you scan.

The form

A longer description plus the handful of settings a person or the suggest agent can change: the tone of a reply, the review framework, the file to write to.

The graph

The node graph in the NodeFox scripting language, with holes where the settings drop in, and the structured output schemas its nodes rely on. A compatible schema already in your workspace is reused instead of duplicated.
meetings.jsonextract_action_items
// Card
"name": "Extract Action Items",
"short": "Pull every commitment out of a transcript with its owner, due date and the quote that proves it.",
"in": [{ "label": "transcript", "type": "text" }],
"out": [
  { "label": "action_items", "type": "json" },
  { "label": "action_table", "type": "text" }
],

// Form
"variables": [{
  "name": "context", "kind": "text", "required": false,
  "hint": "Anything the transcript assumes: the team, the project, the quarter…"
}],

// Graph — excerpt
net.Conversation("extract").label("Extract Action Items")
  .schema("ActionItems")
  .system("You extract action items from a meeting transcript. … {{context|raw}}")
Suggest agent

Say what the workflow is for. AI does the fitting.

A pattern gives AI a narrow, well-defined job: connect a step that is already written, configure it for your goal and name what it produces. You keep the final say on every placement.

Set a goal

One sentence on what the workflow should do. Every suggestion reads it, along with a running note of what each earlier step does.

Choose a pattern

From the panel, or press ⌘P on the canvas. The suggest agent picks the output that feeds each input, writes a value for every setting and names the new outputs.

Correct it in plain words

“Take the summary, not the notes.” The card fills again with your change applied.

Place it

Nothing lands on the canvas until you confirm. The running note grows by one sentence, so the next suggestion knows what this step does.
Escalation Decisionsupport
adds Escalation Decision → Escalation Fields → Escalation Gate · Escalation (reused)
Reading the canvas…Filled from the canvas
Ticket ←Parse Ticket · ticketanswer ←Answer From KB · answer· 3 settings
place / escalation-decision
Place ↵

Suggestions are model output. Check the connections and values before you place a pattern.

Loops and gates

Where a process holds its standard.

Patterns compose into loops and gates, so a step is repeated or held back until it meets the bar you set.

Revise until it passes.

A separate critic grades the draft against a rubric, and the draft is revised until its total clears the threshold.
Critique Then Revise

Post only what is certain.

A transaction is written to the ledger when categorisation clears the confidence threshold. Doubtful ones go to review instead.
Categorise Transaction

Send it back until it is grounded.

A critic lists every statement the sources do not support, and the synthesis is rewritten until the list is empty.
Grounded Synthesis Loop
AI throughout

Build, change and run with AI.

Work with the suggest agent inside NodeFox, or bring your own coding agent over MCP.

In NodeFox

The suggest agent fills and connects the patterns you choose, and reworks any step you ask it to change.

From your own agent

Claude Code, Codex or Cursor can build, change and run the same workflows through the NodeFox MCP server.

On repeat work, a workflow runs steps that are already defined instead of an agent reworking the task each time, so task for task it typically costs less and finishes sooner than a conversational agent.

Yours to tune

Change the pattern, not every copy of it.

Prompts and schemas live in editable files, not inside the app. Adjust a pattern to your voice, policies and systems, validate the folder, and every future placement uses the change.

Networks you have already built keep the nodes they were placed with. A placement copies the pattern into your network; it does not stay linked to the file.

Questions about patterns

Are patterns templates?

Not in the usual sense. A template is a whole workflow you copy. A pattern is one step — a few nodes doing one job — designed to connect to what is already on your canvas.

If a pattern changes, do my networks change?

No. Edits to a pattern apply to future placements. Nodes you have already placed stay as they are, and you can edit them like any others.

Which models do patterns use?

Steps that name no provider use your workspace's default model. A few name one where the task needs it — transcribing a recording uses Gemini because it takes the audio as input.

Does AI decide what runs?

No. The suggest agent proposes connections, values and edits, and nothing is placed until you confirm. Over MCP, an agent can only reach workspaces you have opened to it, and it can only start runs where you have allowed agent runs.

Which agents work over MCP?

MCP clients such as Claude Code, Codex and Cursor. The server connects to the NodeFox app running on your machine through the local gateway.

Do patterns guarantee good output?

No. They give a step a considered structure, prompt and schema. Model output still varies, so test with representative inputs and keep review where the work needs it.

Can we write our own?

Yes. A pattern is a JSON record with a card, a form and a graph. Validate the folder before use so a wrong setting fails there instead of on the canvas.

Place your first pattern.

Start from a step that already knows its inputs, outputs and prompt, and build the rest around it — by hand, with the suggest agent or from your own agent.

Start buildingSee how NodeFox works

NodeFox is in beta.