NodeFox
Patterns

Start from a working step,
not a blank canvas.

A useful workflow contains steps worth repeating: extracting a record, checking a requirement, preparing a decision. Compose these into reusable networks with explicit inputs and outputs, then adapt the connections and rules to the next process.

Illustrated workflow composition. See the recorded demo for actual application footage.

Plan a reusable step

See what can come next.

Choose the next component by its input contract. Check what the current network produces, which fields the next step needs and what it will return.

Ready

Its required inputs are available and compatible. Check the schema and connection before execution.

Starts here

An intake step reads a configured file, API or other source and establishes the first data contract.

Not yet

A required input or permission is missing. Add the prerequisite rather than letting the workflow guess.
Shared vocabulary

Steps that connect by what they carry.

Define the data a component consumes and produces—ticket in, checked response out. Explicit routes connect those interfaces. A Network node lets a larger workflow call a reusable sub-network.
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 workflow can combine a ticket parser, a source-grounded answer, an escalation decision and an engineering handoff. Configure each interface and test the resulting chain against routine and exceptional tickets.

How a pattern is made

Written once. Only the values change.

Document reusable work in three parts: purpose, configurable values and execution structure. The example below illustrates that design; it is not an importable product schema.

The card

A name, purpose, required inputs and expected outputs make the component understandable to its next user.

The form

Separate values that change between deployments: a policy, provider, field mapping or output destination.

The graph

Keep the nodes, routes, activation conditions and output schemas explicit. Test this structure before reusing it in a consequential process.
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}}")
AI-assisted construction

Use AI to help build. Inspect what it changes.

Give AI a bounded task: draft a prompt, modify code, or update a network through supported MCP operations. Review the result against the component’s input and output contract.

Set a goal

State the operational result, available inputs and permitted actions.

Choose a component

Reuse a tested network or define a small step with clear inputs and outputs.

Correct it in plain words

Ask for a specific prompt, code or network change, then inspect its proposed behavior.

Validate and run

Inspect the graph and test representative inputs before authorizing consequential actions. Agent writes depend on the bridge permissions you configure.
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 ↵

Illustrative component configuration. Review AI-generated connections, code and values before running the workflow.

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 model evaluates a draft against a rubric. Bound the revision loop and route unresolved cases to a person; a model score is not proof of correctness.
Critique Then Revise

Check before posting.

Validate required fields and exact transaction rules. Route ambiguous classifications to a person before the authorized ledger write.
Categorise Transaction

Review the supporting evidence.

A model can flag statements that appear unsupported. Preserve source references, cap retries and retain human review where correctness matters.
Grounded Synthesis Loop
AI throughout

Build, change and run with AI.

Use AI assistance for prompts, code and structured content, or connect an authorized external agent through the supported MCP bridge.

In NodeFox

AI suggestion controls help draft and edit supported text, code and JSON fields. Verify their outputs before use.

From your own agent

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

A reusable workflow retains the integration logic, checks and execution structure across runs. Measure model usage, elapsed time and review effort for your process rather than assuming a universal cost or latency advantage.

Yours to tune

Give reusable logic an owner.

Maintain shared sub-networks with explicit interfaces and a change policy. Test affected parent workflows when rules, prompts, models or schemas change.

A copied graph and a referenced sub-network have different maintenance implications. Choose deliberately, document the dependency and validate changes before rollout.

Questions about patterns

Are patterns templates?

A pattern describes a recurring execution structure. You can implement it with nodes and reuse a network as a component in another workflow.

If a pattern changes, do my networks change?

Copied nodes remain separate. Referenced sub-networks are dependencies, so manage their changes and retest the workflows that call them.

Which models do patterns use?

Configure supported providers and models for the task. Check input formats, credentials and output schemas rather than assuming every model is interchangeable.

Does AI decide what runs?

The graph defines execution. AI can propose changes or invoke supported operations when authorized; inspect those changes and configure bridge write/run permissions explicitly.

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. Build and test a network with a clear input/output contract, then compose it into a larger workflow using a Network node.

Build one step you can reuse.

Choose a recurring check or transformation. Define its contract, test it and reuse it in the next workflow.