Core Concepts

These six concepts explain the Hyphen runtime.

They are the execution-facing building blocks that sit underneath:

  • guided authoring in Process Studio
  • advanced drafting via AI workflow generation
  • embedded delivery through the gateway and SDK
graph LR W["Workflow"] --> P["Primitives"] W --> A["Actions"] P --> C["Context"] A --> C C --> AG["Agents"] AG --> R["Runs"] P --> R

1. Workflows

A workflow is a structured process definition.

It contains:

  • an optional top-level condition
  • an ordered set of steps
  • optional scheduling metadata
json
{
  "name": "invoice_reconciliation",
  "definition": {
    "condition": { "greaterThan": ["@input.invoices.length", 0] },
    "actions": [
      { "type": "matcher", "properties": { ... } },
      { "type": "loop", "properties": { "mode": "react", ... } },
      { "type": "PbotApproval", "properties": { ... } }
    ]
  }
}

You can create workflows directly through the API, generate them from natural language, or publish them through Process Studio.

2. Actions

Actions are reusable capabilities you register once and call from workflows or agents.

Kind What it does
http Calls external APIs
llm Runs model-backed text or extraction tasks
db Executes external database queries
matcher Wraps reusable matching logic
custom-table Performs table operations

Actions are how Hyphen connects to the rest of your system.

3. Primitives

Primitives are built-in workflow steps. They handle the core orchestration patterns in the runtime.

Primitive Purpose
Matcher Compares records and datasets
Loop Handles iteration or ReAct-style agent reasoning
PbotApproval Pauses for human review
PbotForm Pauses for external input
Custom Table Stores durable tenant-scoped data

If workflows are the process definition, primitives are the built-in control structures inside that process.

4. Context

Context is how data moves through a run.

Every step can read from the accumulated context and write new outputs back into it.

Common references include:

Path Meaning
@input.field Data passed at execution time
@item Current item inside a foreach loop
@__run_id Current run ID
@__approved Result from an approval step
doc:doc_xxx Uploaded document content

Context is one of the main reasons the runtime remains inspectable. Every later step can be traced back to the data available at that moment in execution.

5. Agents

Agents in Hyphen are bounded ReAct loops.

They can:

  • reason about a task
  • call declared tools
  • observe results
  • iterate toward an answer
  • escalate to a human when needed

They cannot:

  • invent capabilities that were not declared
  • run forever
  • bypass the workflow or runtime boundaries around them

This is the runtime model behind:

  • agent-as-step
  • agent-as-trigger
  • agent-as-orchestrator

6. Runs

A run is a single execution of a workflow.

A run captures:

  • input payloads
  • step outputs
  • agent traces
  • approval decisions
  • timestamps
  • final state

Runs are the durable execution record of the system.

How these concepts fit together

A common path looks like this:

  1. register actions that connect to your systems
  2. define or publish a workflow
  3. execute the workflow with input data
  4. let primitives and agents move the process forward
  5. inspect the run and the resulting audit trail

The important distinction

These are runtime concepts, not the entire product surface.

Hyphen also includes:

  • design layers such as Process Studio and AI-assisted drafting
  • delivery layers such as the gateway and SDK

But all of those sit on top of the same execution model described here.

Next pages